@rtrvr-ai/rover 1.3.1 → 1.3.2

package/dist/rover.js

@@ -11385,10 +11385,9 @@ var Bridge = class {
       }
       const clickTargetUrl = this.getClickTargetUrl(args);
       if (clickTargetUrl) {
-        this.notifyAgentNavigation(clickTargetUrl);
-        this.notifyCrossHostNavigation(clickTargetUrl);
-      } else {
-        this.notifyAgentNavigation(window.location.href);
+        const intent = this.buildNavigationIntent(clickTargetUrl);
+        this.notifyAgentNavigation(intent);
+        this.notifyCrossHostNavigation(intent);
       }
     }
     if (toolName === SystemToolNames.describe_images) {
@@ -11527,8 +11526,9 @@ var Bridge = class {
           }
           return this.domainScopeBlockedResponse(targetUrl, reason);
         }
-        this.notifyAgentNavigation(targetUrl);
-        this.notifyCrossHostNavigation(targetUrl);
+        const intent = this.buildNavigationIntent(targetUrl);
+        this.notifyAgentNavigation(intent);
+        this.notifyCrossHostNavigation(intent);
         window.location.href = targetUrl;
         return { success: true, output: { url: targetUrl, navigation: "same_tab" } };
       }
@@ -11557,23 +11557,24 @@ var Bridge = class {
           }
           return this.domainScopeBlockedResponse(targetUrl, reason);
         }
-        this.notifyAgentNavigation(targetUrl);
-        this.notifyCrossHostNavigation(targetUrl);
+        const intent = this.buildNavigationIntent(targetUrl);
+        this.notifyAgentNavigation(intent);
+        this.notifyCrossHostNavigation(intent);
         window.location.href = targetUrl;
         return { success: true, output: { url: targetUrl, navigation: "same_tab" } };
       }
       case SystemToolNames.go_back: {
-        this.notifyAgentNavigation(window.location.href);
+        this.notifyAgentNavigation(this.buildNavigationIntent(window.location.href, { isCrossHost: false }));
         window.history.back();
         return { success: true };
       }
       case SystemToolNames.go_forward: {
-        this.notifyAgentNavigation(window.location.href);
+        this.notifyAgentNavigation(this.buildNavigationIntent(window.location.href, { isCrossHost: false }));
         window.history.forward();
         return { success: true };
       }
       case SystemToolNames.refresh_page: {
-        this.notifyAgentNavigation(window.location.href);
+        this.notifyAgentNavigation(this.buildNavigationIntent(window.location.href, { isCrossHost: false }));
         window.location.reload();
         return { success: true };
       }
@@ -11585,8 +11586,9 @@ var Bridge = class {
         if (!targetUrl)
           return { success: false, error: `open_new_tab: invalid url "${rawUrl}"`, allowFallback: true };
         if (this.shouldConvertOpenNewTabToSameTab(targetUrl)) {
-          this.notifyAgentNavigation(targetUrl);
-          this.notifyCrossHostNavigation(targetUrl);
+          const intent = this.buildNavigationIntent(targetUrl);
+          this.notifyAgentNavigation(intent);
+          this.notifyCrossHostNavigation(intent);
           window.location.assign(targetUrl);
           return {
             success: true,
@@ -11681,16 +11683,33 @@ var Bridge = class {
       return false;
     return isUrlAllowedByDomains(targetUrl, this.allowedDomains);
   }
-  notifyAgentNavigation(targetUrl) {
+  buildNavigationIntent(targetUrl, options) {
+    let handoffId = "";
     try {
-      this.onBeforeAgentNavigation?.(targetUrl);
+      handoffId = crypto.randomUUID();
     } catch {
+      handoffId = `handoff_${Date.now()}_${Math.floor(Math.random() * 1e5)}`;
     }
+    return {
+      handoffId,
+      targetUrl,
+      sourceRuntimeId: this.runtimeId,
+      sourceLogicalTabId: this.actionGateContext.localLogicalTabId,
+      runId: options?.runId,
+      isCrossHost: options?.isCrossHost ?? this.isCrossHostInScopeNavigation(targetUrl),
+      ts: Date.now()
+    };
   }
-  notifyCrossHostNavigation(targetUrl) {
-    if (this.isCrossHostInScopeNavigation(targetUrl)) {
+  notifyAgentNavigation(event) {
+    try {
+      this.onBeforeAgentNavigation?.(event);
+    } catch {
+    }
+  }
+  notifyCrossHostNavigation(event) {
+    if (event.isCrossHost) {
       try {
-        this.onBeforeCrossHostNavigation?.(targetUrl);
+        this.onBeforeCrossHostNavigation?.(event);
       } catch {
       }
     }
@@ -14084,12 +14103,29 @@ function mountWidget(opts) {
       display: flex;
       justify-content: flex-end;
       align-items: center;
+      gap: 8px;
       position: sticky;
       bottom: 0;
       padding-top: 2px;
       background: linear-gradient(to bottom, rgba(255, 247, 242, 0), rgba(255, 247, 242, 0.94) 40%);
     }
 
+    .questionPromptCancel {
+      border: 1px solid var(--rv-border-strong);
+      background: rgba(255, 255, 255, 0.88);
+      color: var(--rv-text-secondary);
+      border-radius: var(--rv-radius-sm);
+      font-size: 12px;
+      font-weight: 700;
+      letter-spacing: 0.01em;
+      padding: 6px 10px;
+      cursor: pointer;
+    }
+
+    .questionPromptCancel:hover {
+      background: rgba(242, 246, 250, 0.95);
+    }
+
     .questionPromptSubmit {
       border: 1px solid var(--rv-accent-border);
       background: var(--rv-accent-soft);
@@ -14860,6 +14896,11 @@ function mountWidget(opts) {
   questionPromptForm.appendChild(questionPromptList);
   const questionPromptActions = document.createElement("div");
   questionPromptActions.className = "questionPromptActions";
+  const questionPromptCancel = document.createElement("button");
+  questionPromptCancel.type = "button";
+  questionPromptCancel.className = "questionPromptCancel";
+  questionPromptCancel.textContent = "Cancel";
+  questionPromptActions.appendChild(questionPromptCancel);
   const questionPromptSubmit = document.createElement("button");
   questionPromptSubmit.type = "submit";
   questionPromptSubmit.className = "questionPromptSubmit";
@@ -15219,6 +15260,7 @@ function mountWidget(opts) {
   function syncComposerDisabledState() {
     const disabled = currentMode2 === "observer" && !canComposeInObserver;
     inputEl.disabled = disabled;
+    questionPromptCancel.disabled = disabled;
     questionPromptSubmit.disabled = disabled;
     for (const node of Array.from(questionPromptForm.querySelectorAll(".questionPromptInput"))) {
       node.disabled = disabled;
@@ -15616,6 +15658,7 @@ function mountWidget(opts) {
       if (!value) {
         input.classList.remove("invalid");
         delete questionDraftAnswers[question.key];
+        rawLines.push(`${question.key}: (no answer provided)`);
         continue;
       }
       input.classList.remove("invalid");
@@ -15628,7 +15671,7 @@ function mountWidget(opts) {
       return;
     }
     const keys = currentQuestionPrompt.questions.map((question) => question.key);
-    const rawText = rawLines.join("\n");
+    const rawText = rawLines.length ? rawLines.join("\n") : keys.map((key) => `${key}: (no answer provided)`).join("\n");
     opts.onSend(rawText, {
       askUserAnswers: {
         answersByKey,
@@ -15636,7 +15679,15 @@ function mountWidget(opts) {
         keys
       }
     });
-    setQuestionPrompt(void 0);
+  });
+  questionPromptCancel.addEventListener("click", () => {
+    if (inputEl.disabled)
+      return;
+    if (opts.onCancelQuestionFlow) {
+      opts.onCancelQuestionFlow();
+      return;
+    }
+    opts.onCancelRun?.();
   });
   inputEl.addEventListener("keydown", (e) => {
     if (e.key === "Enter" && !e.shiftKey && !e.isComposing) {
@@ -15751,7 +15802,9 @@ 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_DETACHED_TAB_MS = 9e4;
+var STALE_NAVIGATION_HANDOFF_TAB_MS = 45e3;
+var STALE_PENDING_ATTACH_TAB_MS = 2e4;
 var STALE_RUNTIME_TAB_MS = 45e3;
 function now() {
   return Date.now();
@@ -15773,13 +15826,6 @@ function normalizeUrl2(raw) {
     return text;
   }
 }
-function extractHostname2(url) {
-  try {
-    return new URL(url).hostname.toLowerCase();
-  } catch {
-    return "";
-  }
-}
 function sanitizeSharedTask(raw) {
   if (!raw || typeof raw !== "object")
     return void 0;
@@ -15866,6 +15912,12 @@ function sanitizeSharedWorkerContext(raw) {
       choices: Array.isArray(question?.choices) ? question.choices : void 0
     };
   }).filter((question) => !!question).slice(0, 6) : [];
+  const pendingStepRefRaw = raw.pendingAskUser?.stepRef;
+  const pendingStepRef = pendingStepRefRaw && Number.isFinite(Number(pendingStepRefRaw.stepIndex)) && Number(pendingStepRefRaw.stepIndex) >= 0 && Number.isFinite(Number(pendingStepRefRaw.functionIndex)) && Number(pendingStepRefRaw.functionIndex) >= 0 ? {
+    stepIndex: Number(pendingStepRefRaw.stepIndex),
+    functionIndex: Number(pendingStepRefRaw.functionIndex),
+    ...typeof pendingStepRefRaw.accTreeId === "string" && pendingStepRefRaw.accTreeId.trim() ? { accTreeId: pendingStepRefRaw.accTreeId.trim() } : {}
+  } : void 0;
   const normalizeEntries = (items) => items.slice(-80).map((item) => ({
     role: typeof item?.role === "string" ? item.role : "assistant",
     content: typeof item?.content === "string" ? item.content : ""
@@ -15873,15 +15925,20 @@ function sanitizeSharedWorkerContext(raw) {
   const history2 = Array.isArray(raw.history) ? normalizeEntries(raw.history) : [];
   const plannerHistory = cloneUnknownArrayTail(raw.plannerHistory, 40);
   const agentPrevSteps = cloneUnknownArrayTail(raw.agentPrevSteps, 80);
+  const rootUserInput = typeof raw.rootUserInput === "string" ? raw.rootUserInput.trim() : "";
   return {
     trajectoryId: typeof raw.trajectoryId === "string" ? raw.trajectoryId : void 0,
+    taskBoundaryId: typeof raw.taskBoundaryId === "string" && raw.taskBoundaryId.trim() ? raw.taskBoundaryId.trim() : void 0,
+    rootUserInput: rootUserInput || void 0,
     history: history2,
     plannerHistory,
     agentPrevSteps,
     pendingAskUser: pendingQuestions.length ? {
       questions: pendingQuestions,
       source: raw.pendingAskUser?.source === "planner" ? "planner" : "act",
-      askedAt: Number(raw.pendingAskUser?.askedAt) || now()
+      askedAt: Number(raw.pendingAskUser?.askedAt) || now(),
+      boundaryId: typeof raw.pendingAskUser?.boundaryId === "string" && raw.pendingAskUser.boundaryId.trim() ? raw.pendingAskUser.boundaryId.trim() : void 0,
+      ...pendingStepRef ? { stepRef: pendingStepRef } : {}
     } : void 0,
     updatedAt: Number(raw.updatedAt) || now()
   };
@@ -15926,7 +15983,13 @@ function sanitizeSharedState(raw, siteId, sessionId) {
       openedAt: Number(entry?.openedAt) || now(),
       updatedAt: Number(entry?.updatedAt) || now(),
       external: !!entry?.external,
-      openerRuntimeId: typeof entry?.openerRuntimeId === "string" ? entry.openerRuntimeId : void 0
+      openerRuntimeId: typeof entry?.openerRuntimeId === "string" ? entry.openerRuntimeId : void 0,
+      detachedAt: Number(entry?.detachedAt) || void 0,
+      detachedReason: entry?.detachedReason === "navigation_handoff" || entry?.detachedReason === "tab_close" || entry?.detachedReason === "opened_pending_attach" || entry?.detachedReason === "unknown" ? entry.detachedReason : void 0,
+      handoffId: typeof entry?.handoffId === "string" ? entry.handoffId : void 0,
+      handoffRunId: typeof entry?.handoffRunId === "string" ? entry.handoffRunId : void 0,
+      handoffTargetUrl: typeof entry?.handoffTargetUrl === "string" ? entry.handoffTargetUrl : void 0,
+      handoffCreatedAt: Number(entry?.handoffCreatedAt) || void 0
     })).filter((entry) => !!entry.logicalTabId) : [],
     nextLogicalTabId: Math.max(1, Number(raw.nextLogicalTabId) || 1),
     activeLogicalTabId: Number(raw.activeLogicalTabId) || void 0,
@@ -16012,35 +16075,176 @@ var SessionCoordinator = class _SessionCoordinator {
   lastNotifiedRole;
   roleChangeTimer = null;
   static ROLE_CHANGE_DEBOUNCE_MS = 200;
+  tabFreshnessTs(tab) {
+    return Math.max(Number(tab.updatedAt) || 0, Number(tab.openedAt) || 0, Number(tab.detachedAt) || 0);
+  }
+  isBetterTabCandidate(next, current) {
+    if (!current)
+      return true;
+    const nextFreshness = this.tabFreshnessTs(next);
+    const currentFreshness = this.tabFreshnessTs(current);
+    if (nextFreshness !== currentFreshness)
+      return nextFreshness > currentFreshness;
+    if (!!next.runtimeId !== !!current.runtimeId)
+      return !!next.runtimeId;
+    return next.logicalTabId < current.logicalTabId;
+  }
+  isRuntimeTabFresh(tab, nowMs2) {
+    if (!tab.runtimeId)
+      return false;
+    if (tab.runtimeId === this.runtimeId)
+      return true;
+    return nowMs2 - this.tabFreshnessTs(tab) <= STALE_RUNTIME_TAB_MS;
+  }
+  isTabVisibleInScope(tab, nowMs2, scope) {
+    if (tab.runtimeId) {
+      return this.isRuntimeTabFresh(tab, nowMs2);
+    }
+    if (tab.external) {
+      return nowMs2 - this.tabFreshnessTs(tab) <= STALE_DETACHED_EXTERNAL_TAB_MS;
+    }
+    if (tab.detachedReason === "opened_pending_attach") {
+      return nowMs2 - this.tabFreshnessTs(tab) <= STALE_PENDING_ATTACH_TAB_MS;
+    }
+    if (scope === "context") {
+      return false;
+    }
+    if (tab.detachedReason === "navigation_handoff") {
+      return nowMs2 - this.tabFreshnessTs(tab) <= STALE_NAVIGATION_HANDOFF_TAB_MS;
+    }
+    return nowMs2 - this.tabFreshnessTs(tab) <= STALE_DETACHED_TAB_MS;
+  }
+  normalizeDraftTabs(draft) {
+    const byLogicalTabId = /* @__PURE__ */ new Map();
+    for (const tab of draft.tabs) {
+      if (!Number.isFinite(Number(tab.logicalTabId)) || Number(tab.logicalTabId) <= 0)
+        continue;
+      const existing = byLogicalTabId.get(tab.logicalTabId);
+      if (this.isBetterTabCandidate(tab, existing)) {
+        byLogicalTabId.set(tab.logicalTabId, tab);
+      }
+    }
+    const dedupedByLogical = [];
+    const emittedLogical = /* @__PURE__ */ new Set();
+    for (const tab of draft.tabs) {
+      if (emittedLogical.has(tab.logicalTabId))
+        continue;
+      const chosen = byLogicalTabId.get(tab.logicalTabId);
+      if (!chosen)
+        continue;
+      if (chosen === tab) {
+        dedupedByLogical.push(chosen);
+        emittedLogical.add(chosen.logicalTabId);
+      }
+    }
+    for (const [logicalTabId, tab] of byLogicalTabId.entries()) {
+      if (emittedLogical.has(logicalTabId))
+        continue;
+      dedupedByLogical.push(tab);
+      emittedLogical.add(logicalTabId);
+    }
+    const byRuntimeId = /* @__PURE__ */ new Map();
+    for (const tab of dedupedByLogical) {
+      if (!tab.runtimeId)
+        continue;
+      const existing = byRuntimeId.get(tab.runtimeId);
+      if (this.isBetterTabCandidate(tab, existing)) {
+        byRuntimeId.set(tab.runtimeId, tab);
+      }
+    }
+    draft.tabs = dedupedByLogical.filter((tab) => !tab.runtimeId || byRuntimeId.get(tab.runtimeId) === tab).sort((a, b) => a.logicalTabId - b.logicalTabId);
+    if (!draft.tabs.length) {
+      draft.activeLogicalTabId = void 0;
+      draft.nextLogicalTabId = 1;
+      return;
+    }
+    const nowMs2 = now();
+    const currentActive = draft.activeLogicalTabId ? draft.tabs.find((tab) => tab.logicalTabId === draft.activeLogicalTabId) : void 0;
+    const localAttached = draft.tabs.find((tab) => tab.runtimeId === this.runtimeId);
+    const liveTabs = draft.tabs.filter((tab) => this.isRuntimeTabFresh(tab, nowMs2));
+    const freshestLiveTab = [...liveTabs].sort((a, b) => this.tabFreshnessTs(b) - this.tabFreshnessTs(a))[0];
+    let nextActiveLogicalTabId = currentActive?.logicalTabId;
+    if (!currentActive) {
+      nextActiveLogicalTabId = localAttached?.logicalTabId || freshestLiveTab?.logicalTabId || draft.tabs[0]?.logicalTabId;
+    } else if (!currentActive.runtimeId || !this.isRuntimeTabFresh(currentActive, nowMs2)) {
+      nextActiveLogicalTabId = localAttached?.logicalTabId || freshestLiveTab?.logicalTabId || currentActive.logicalTabId;
+    }
+    draft.activeLogicalTabId = nextActiveLogicalTabId;
+    const maxLogicalTabId = draft.tabs.reduce((max, tab) => Math.max(max, tab.logicalTabId), 0);
+    draft.nextLogicalTabId = Math.max(Number(draft.nextLogicalTabId) || 1, maxLogicalTabId + 1);
+  }
   pruneDetachedTabs(draft, options) {
     const dropRuntimeDetached = !!options?.dropRuntimeDetached;
     const dropAllDetachedExternal = !!options?.dropAllDetachedExternal;
+    const keepOnlyActiveLiveTab = !!options?.keepOnlyActiveLiveTab;
+    const keepRecentExternalPlaceholders = !!options?.keepRecentExternalPlaceholders;
     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;
+        return this.isRuntimeTabFresh(tab, nowMs2);
       }
-      if (dropRuntimeDetached && tab.openerRuntimeId === this.runtimeId) {
+      if (dropRuntimeDetached && !tab.external && 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 - this.tabFreshnessTs(tab) <= 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;
+      const ageMs = nowMs2 - this.tabFreshnessTs(tab);
+      if (tab.detachedReason === "navigation_handoff") {
+        return ageMs <= STALE_NAVIGATION_HANDOFF_TAB_MS;
       }
-      if (draft.nextLogicalTabId <= (draft.tabs.at(-1)?.logicalTabId ?? 0)) {
-        draft.nextLogicalTabId = draft.tabs.reduce((max, tab) => Math.max(max, tab.logicalTabId), 0) + 1;
+      if (tab.detachedReason === "opened_pending_attach") {
+        return ageMs <= STALE_PENDING_ATTACH_TAB_MS;
       }
+      return ageMs <= STALE_DETACHED_TAB_MS;
+    });
+    if (keepOnlyActiveLiveTab) {
+      this.normalizeDraftTabs(draft);
+      const liveTabs = draft.tabs.filter((tab) => this.isRuntimeTabFresh(tab, nowMs2));
+      const activeLiveTab = liveTabs.find((tab) => tab.logicalTabId === draft.activeLogicalTabId);
+      const localLiveTab = liveTabs.find((tab) => tab.runtimeId === this.runtimeId);
+      const fallbackLiveTab = [...liveTabs].sort((a, b) => this.tabFreshnessTs(b) - this.tabFreshnessTs(a))[0];
+      const keepLiveTabId = activeLiveTab?.logicalTabId || localLiveTab?.logicalTabId || fallbackLiveTab?.logicalTabId;
+      draft.tabs = draft.tabs.filter((tab) => {
+        if (tab.runtimeId) {
+          return !!keepLiveTabId && tab.logicalTabId === keepLiveTabId;
+        }
+        if (tab.external) {
+          return keepRecentExternalPlaceholders && nowMs2 - this.tabFreshnessTs(tab) <= STALE_DETACHED_EXTERNAL_TAB_MS;
+        }
+        return false;
+      });
+      draft.activeLogicalTabId = keepLiveTabId || draft.tabs.find((tab) => tab.runtimeId)?.logicalTabId || draft.tabs[0]?.logicalTabId;
     }
+    this.normalizeDraftTabs(draft);
+  }
+  resetDraftToSingleCurrentTab(draft, url, title) {
+    const nowTs = now();
+    const normalizedUrl = normalizeUrl2(url);
+    const existingLocal = draft.tabs.find((tab) => tab.runtimeId === this.runtimeId);
+    const openedAt = Number(existingLocal?.openedAt) || nowTs;
+    draft.tabs = [
+      {
+        logicalTabId: 1,
+        runtimeId: this.runtimeId,
+        url: normalizedUrl || existingLocal?.url || "",
+        title: title || existingLocal?.title,
+        openedAt,
+        updatedAt: nowTs,
+        external: false,
+        detachedAt: void 0,
+        detachedReason: void 0
+      }
+    ];
+    draft.activeLogicalTabId = 1;
+    draft.nextLogicalTabId = 2;
+    draft.lease = {
+      holderRuntimeId: this.runtimeId,
+      expiresAt: nowTs + this.leaseMs,
+      updatedAt: nowTs
+    };
   }
   constructor(options) {
     this.siteId = options.siteId;
@@ -16056,15 +16260,16 @@ var SessionCoordinator = class _SessionCoordinator {
     this.key = `${SHARED_KEY_PREFIX}${this.siteId}:${this.sessionId}`;
     this.channelName = `${SHARED_CHANNEL_PREFIX}${this.siteId}:${this.sessionId}`;
     this.state = this.loadState();
+    this.normalizeDraftTabs(this.state);
   }
-  start() {
+  start(initialHandoff) {
     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.registerCurrentTab(window.location.href, document.title || void 0, initialHandoff);
     this.claimLease(false);
     if (!this.state.task) {
       this.mutate("local", (draft) => {
@@ -16227,25 +16432,23 @@ var SessionCoordinator = class _SessionCoordinator {
     }
     return true;
   }
-  listTabs() {
+  listTabs(options) {
+    const scope = options?.scope === "all" ? "all" : "context";
     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;
-    });
+    return this.state.tabs.filter((tab) => this.isTabVisibleInScope(tab, nowMs2, scope));
   }
   pruneTabs(options) {
     this.mutate("local", (draft) => {
       this.pruneDetachedTabs(draft, options);
     });
   }
+  resetTabsToCurrent(url, title) {
+    this.mutate("local", (draft) => {
+      this.resetDraftToSingleCurrentTab(draft, url, title);
+    });
+    this.notifyRoleChange();
+    return this.localLogicalTabId || 1;
+  }
   startNewTask(task) {
     const startedAt = Number(task.startedAt) || now();
     const nextTask = {
@@ -16265,7 +16468,7 @@ var SessionCoordinator = class _SessionCoordinator {
       draft.uiStatus = void 0;
       draft.activeRun = void 0;
       draft.workerContext = void 0;
-      this.pruneDetachedTabs(draft, { dropAllDetachedExternal: true });
+      this.resetDraftToSingleCurrentTab(draft, window.location.href, document.title || void 0);
     });
     return nextTask;
   }
@@ -16405,28 +16608,56 @@ var SessionCoordinator = class _SessionCoordinator {
   requestControl() {
     return this.claimLease(true);
   }
-  registerCurrentTab(url, title) {
+  registerCurrentTab(url, title, handoff) {
     const normalizedUrl = normalizeUrl2(url);
+    const handoffId = typeof handoff?.handoffId === "string" ? handoff.handoffId.trim() : "";
+    const handoffTabId = Number(handoff?.sourceLogicalTabId);
     let nextLocalTabId;
     this.mutate("local", (draft) => {
+      const nowTs = now();
+      const leaseValid = !!(draft.lease && draft.lease.expiresAt > nowTs);
+      const controllerRuntimeId = leaseValid ? draft.lease?.holderRuntimeId : void 0;
+      const shouldPreferLocalAsActive = !controllerRuntimeId || controllerRuntimeId === this.runtimeId;
       const existing = draft.tabs.find((tab) => tab.runtimeId === this.runtimeId);
       if (existing) {
         existing.url = normalizedUrl || existing.url;
         existing.title = title || existing.title;
-        existing.updatedAt = now();
+        existing.updatedAt = nowTs;
+        existing.detachedAt = void 0;
+        existing.detachedReason = void 0;
+        existing.handoffId = void 0;
+        existing.handoffRunId = void 0;
+        existing.handoffTargetUrl = void 0;
+        existing.handoffCreatedAt = void 0;
         nextLocalTabId = existing.logicalTabId;
       } else {
-        let adopted = draft.tabs.find((tab) => !tab.runtimeId && tab.url === normalizedUrl && now() - tab.openedAt < 18e4);
+        let adopted;
+        if (handoffId) {
+          adopted = draft.tabs.find((tab) => {
+            if (tab.runtimeId)
+              return false;
+            if (String(tab.handoffId || "").trim() !== handoffId)
+              return false;
+            if (Number.isFinite(handoffTabId) && handoffTabId > 0 && tab.logicalTabId !== handoffTabId)
+              return false;
+            const ageMs = nowTs - Number(tab.handoffCreatedAt || tab.updatedAt || tab.openedAt || 0);
+            return ageMs >= 0 && ageMs <= 3e4;
+          });
+        }
         if (!adopted) {
-          const currentHost = extractHostname2(normalizedUrl);
-          const candidates = draft.tabs.filter((tab) => !tab.runtimeId && currentHost && extractHostname2(tab.url) === currentHost && now() - tab.updatedAt < 1e4).sort((a, b) => b.updatedAt - a.updatedAt);
-          adopted = candidates[0];
+          adopted = draft.tabs.find((tab) => !tab.runtimeId && !tab.external && tab.url === normalizedUrl && nowTs - tab.openedAt < 18e4);
         }
         if (adopted) {
           adopted.runtimeId = this.runtimeId;
           adopted.url = normalizedUrl || adopted.url;
           adopted.title = title || adopted.title;
-          adopted.updatedAt = now();
+          adopted.updatedAt = nowTs;
+          adopted.detachedAt = void 0;
+          adopted.detachedReason = void 0;
+          adopted.handoffId = void 0;
+          adopted.handoffRunId = void 0;
+          adopted.handoffTargetUrl = void 0;
+          adopted.handoffCreatedAt = void 0;
           nextLocalTabId = adopted.logicalTabId;
         } else {
           const logicalTabId = draft.nextLogicalTabId++;
@@ -16435,14 +16666,17 @@ var SessionCoordinator = class _SessionCoordinator {
             runtimeId: this.runtimeId,
             url: normalizedUrl,
             title,
-            openedAt: now(),
-            updatedAt: now(),
-            external: false
+            openedAt: nowTs,
+            updatedAt: nowTs,
+            external: false,
+            detachedAt: void 0,
+            detachedReason: void 0
           });
           nextLocalTabId = logicalTabId;
         }
       }
-      if (!draft.activeLogicalTabId) {
+      const activeEntry = draft.activeLogicalTabId ? draft.tabs.find((tab) => tab.logicalTabId === draft.activeLogicalTabId) : void 0;
+      if (!activeEntry || !activeEntry.runtimeId || activeEntry.logicalTabId === nextLocalTabId || shouldPreferLocalAsActive) {
         draft.activeLogicalTabId = nextLocalTabId;
       }
     });
@@ -16453,11 +16687,14 @@ var SessionCoordinator = class _SessionCoordinator {
     const normalizedUrl = normalizeUrl2(payload.url);
     let logicalTabId = 0;
     this.mutate("local", (draft) => {
+      const nowTs = now();
       const existing = draft.tabs.find((tab) => !tab.runtimeId && !!tab.external === !!payload.external && tab.url === normalizedUrl);
       if (existing) {
         existing.title = payload.title || existing.title;
-        existing.updatedAt = now();
+        existing.updatedAt = nowTs;
         existing.openerRuntimeId = payload.openerRuntimeId || existing.openerRuntimeId;
+        existing.detachedAt = existing.detachedAt || nowTs;
+        existing.detachedReason = "opened_pending_attach";
         logicalTabId = existing.logicalTabId;
         return;
       }
@@ -16467,10 +16704,12 @@ var SessionCoordinator = class _SessionCoordinator {
         runtimeId: void 0,
         url: normalizedUrl,
         title: payload.title,
-        openedAt: now(),
-        updatedAt: now(),
+        openedAt: nowTs,
+        updatedAt: nowTs,
         external: !!payload.external,
-        openerRuntimeId: payload.openerRuntimeId
+        openerRuntimeId: payload.openerRuntimeId,
+        detachedAt: nowTs,
+        detachedReason: "opened_pending_attach"
       });
     });
     return { logicalTabId };
@@ -16554,21 +16793,32 @@ var SessionCoordinator = class _SessionCoordinator {
       title
     });
   }
-  broadcastClosing() {
+  broadcastClosing(handoff) {
     this.closing = true;
-    if (!this.channel)
-      return;
     this.mutate("local", (draft) => {
+      const nowTs = now();
       const localTab = draft.tabs.find((t) => t.runtimeId === this.runtimeId);
       if (localTab) {
         localTab.runtimeId = void 0;
-        localTab.updatedAt = now();
+        localTab.updatedAt = nowTs;
+        localTab.detachedAt = nowTs;
+        localTab.detachedReason = handoff ? "navigation_handoff" : "tab_close";
+        localTab.handoffId = typeof handoff?.handoffId === "string" ? handoff.handoffId : void 0;
+        localTab.handoffRunId = typeof handoff?.runId === "string" ? handoff.runId : void 0;
+        localTab.handoffTargetUrl = typeof handoff?.targetUrl === "string" ? handoff.targetUrl : void 0;
+        localTab.handoffCreatedAt = Number(handoff?.ts) || nowTs;
+      }
+      if (draft.lease?.holderRuntimeId === this.runtimeId) {
+        draft.lease = void 0;
       }
     });
+    if (!this.channel)
+      return;
     this.channel.postMessage({
       type: "tab_closing",
       runtimeId: this.runtimeId,
-      logicalTabId: this.localLogicalTabId
+      logicalTabId: this.localLogicalTabId,
+      handoff
     });
   }
   isTabAlive(logicalTabId) {
@@ -16694,8 +16944,24 @@ var SessionCoordinator = class _SessionCoordinator {
   }
   handleRemoteTabClosing(payload) {
     const { runtimeId: closingRuntimeId } = payload;
+    const handoff = payload?.handoff;
+    const handoffId = typeof handoff?.handoffId === "string" && handoff.handoffId.trim() ? handoff.handoffId.trim() : void 0;
+    const handoffRunId = typeof handoff?.runId === "string" && handoff.runId.trim() ? handoff.runId.trim() : void 0;
+    const handoffTargetUrl = typeof handoff?.targetUrl === "string" && handoff.targetUrl.trim() ? handoff.targetUrl.trim() : void 0;
+    const handoffCreatedAt = Number(handoff?.ts) || now();
     this.mutate("local", (draft) => {
-      draft.tabs = draft.tabs.filter((t) => t.runtimeId !== closingRuntimeId);
+      const nowTs = now();
+      const tab = draft.tabs.find((t) => t.runtimeId === closingRuntimeId);
+      if (tab) {
+        tab.runtimeId = void 0;
+        tab.updatedAt = nowTs;
+        tab.detachedAt = nowTs;
+        tab.detachedReason = handoffId ? "navigation_handoff" : "tab_close";
+        tab.handoffId = handoffId;
+        tab.handoffRunId = handoffRunId;
+        tab.handoffTargetUrl = handoffTargetUrl;
+        tab.handoffCreatedAt = handoffCreatedAt;
+      }
       if (draft.lease?.holderRuntimeId === closingRuntimeId) {
         draft.lease = void 0;
       }
@@ -16706,7 +16972,7 @@ var SessionCoordinator = class _SessionCoordinator {
         draft.activeRun = void 0;
       }
       if (draft.activeLogicalTabId && !draft.tabs.some((t) => t.logicalTabId === draft.activeLogicalTabId)) {
-        draft.activeLogicalTabId = void 0;
+        draft.activeLogicalTabId = this.localLogicalTabId || draft.tabs[0]?.logicalTabId;
       }
     });
     this.notifyRoleChange();
@@ -16722,21 +16988,32 @@ var SessionCoordinator = class _SessionCoordinator {
         currentTab.url = currentUrl || currentTab.url;
         currentTab.title = currentTitle || currentTab.title;
         currentTab.updatedAt = now();
+        currentTab.detachedAt = void 0;
+        currentTab.detachedReason = void 0;
       } else {
+        const nowTs = now();
         const logicalTabId = draft.nextLogicalTabId++;
         draft.tabs.push({
           logicalTabId,
           runtimeId: this.runtimeId,
           url: currentUrl,
           title: currentTitle,
-          openedAt: now(),
-          updatedAt: now(),
-          external: false
+          openedAt: nowTs,
+          updatedAt: nowTs,
+          external: false,
+          detachedAt: void 0,
+          detachedReason: void 0
         });
       }
       const lease = draft.lease;
       const leaseExpired = !lease || lease.expiresAt <= now();
-      if (leaseExpired || lease?.holderRuntimeId === this.runtimeId) {
+      const remoteHolderRuntimeId = lease && lease.holderRuntimeId !== this.runtimeId && lease.expiresAt > now() ? lease.holderRuntimeId : void 0;
+      const remoteHolderTab = remoteHolderRuntimeId ? draft.tabs.find((tab) => tab.runtimeId === remoteHolderRuntimeId) : void 0;
+      const remoteHolderAlive = !!(remoteHolderTab && remoteHolderTab.updatedAt > now() - 2 * this.heartbeatMs);
+      const hasRemoteActiveRun2 = !!(draft.activeRun?.runtimeId && draft.activeRun.runtimeId !== this.runtimeId);
+      const hasRemoteWorkflowLock = !!(draft.workflowLock && draft.workflowLock.runtimeId !== this.runtimeId && draft.workflowLock.expiresAt > now());
+      const shouldReclaimFromObserver = !!(remoteHolderRuntimeId && !remoteHolderAlive && !hasRemoteActiveRun2 && !hasRemoteWorkflowLock);
+      if (leaseExpired || lease?.holderRuntimeId === this.runtimeId || shouldReclaimFromObserver) {
         draft.lease = {
           holderRuntimeId: this.runtimeId,
           expiresAt: now() + this.leaseMs,
@@ -16755,6 +17032,7 @@ var SessionCoordinator = class _SessionCoordinator {
   }
   reloadFromStorage() {
     const fresh = this.loadState();
+    this.normalizeDraftTabs(fresh);
     if (fresh.seq > this.state.seq || fresh.seq === this.state.seq && fresh.updatedAt > this.state.updatedAt) {
       this.state = fresh;
       this.syncLocalLogicalTabId();
@@ -16822,6 +17100,7 @@ var SessionCoordinator = class _SessionCoordinator {
     }
     const draft = sanitizeSharedState(this.state, this.siteId, this.sessionId);
     updater(draft);
+    this.normalizeDraftTabs(draft);
     draft.seq = Math.max(1, Number(draft.seq) || 1) + (source === "local" ? 1 : 0);
     draft.updatedAt = now();
     this.state = draft;
@@ -16842,6 +17121,7 @@ var SessionCoordinator = class _SessionCoordinator {
     if (incoming.seq === this.state.seq && incoming.updatedAt <= this.state.updatedAt)
       return;
     this.pruneDetachedTabs(incoming);
+    this.normalizeDraftTabs(incoming);
     this.state = incoming;
     this.syncLocalLogicalTabId();
     this.onStateChange?.(this.state, "remote");
@@ -17340,6 +17620,47 @@ function clearCrossDomainResumeCookie(siteId) {
   }
 }
 
+// dist/taskBoundaryGuards.js
+function normalizeTaskBoundaryId(input) {
+  const normalized = String(input || "").trim();
+  return normalized || void 0;
+}
+function shouldAdoptIncomingBoundary(params) {
+  const incoming = normalizeTaskBoundaryId(params.incomingBoundaryId);
+  const current = normalizeTaskBoundaryId(params.currentBoundaryId);
+  if (!incoming)
+    return false;
+  if (incoming === current)
+    return false;
+  if (!current)
+    return params.allowBootstrapAdoption !== false;
+  if (params.taskEpochAdvanced === true && params.hasPendingRun !== true) {
+    return true;
+  }
+  return false;
+}
+function shouldAcceptWorkerSnapshot(params) {
+  const incoming = normalizeTaskBoundaryId(params.incomingBoundaryId);
+  const current = normalizeTaskBoundaryId(params.currentBoundaryId);
+  if (incoming && current && incoming === current) {
+    return { accept: true, reason: "match" };
+  }
+  if (!incoming) {
+    if (!current && params.allowBootstrapAdoption !== false) {
+      return { accept: true, reason: "bootstrap_adopt" };
+    }
+    return { accept: false, reason: "missing_incoming" };
+  }
+  if (shouldAdoptIncomingBoundary(params)) {
+    return {
+      accept: true,
+      adoptedBoundaryId: incoming,
+      reason: current ? "epoch_adopt" : "bootstrap_adopt"
+    };
+  }
+  return { accept: false, reason: "mismatch" };
+}
+
 // dist/taskLifecycleGuards.js
 function shouldStartFreshTask(taskStatus) {
   return taskStatus === "completed" || taskStatus === "ended";
@@ -17368,7 +17689,13 @@ function shouldClearPendingFromSharedState(params) {
   return false;
 }
 function shouldIgnoreRunScopedMessage(params) {
-  const { type, messageRunId, pendingRunId, sharedActiveRunId, taskStatus, ignoredRunIds: ignoredRunIds2 } = params;
+  const { type, messageRunId, messageTaskBoundaryId, currentTaskBoundaryId: currentTaskBoundaryId2, pendingRunId, sharedActiveRunId, taskStatus, ignoredRunIds: ignoredRunIds2 } = params;
+  const currentBoundary = normalizeTaskBoundaryId(currentTaskBoundaryId2);
+  const messageBoundary = normalizeTaskBoundaryId(messageTaskBoundaryId);
+  if ((type === "run_started" || type === "run_completed") && currentBoundary) {
+    if (!messageBoundary || messageBoundary !== currentBoundary)
+      return true;
+  }
   if (!messageRunId && type !== "run_started")
     return false;
   if (messageRunId && ignoredRunIds2?.has(messageRunId))
@@ -17451,6 +17778,8 @@ var suppressCheckpointSync = false;
 var currentMode = "controller";
 var workerReady = false;
 var autoResumeAttempted = false;
+var agentNavigationPending = false;
+var currentTaskBoundaryId = "";
 var runSafetyTimer = null;
 var unloadHandlerInstalled = false;
 var pendingTaskSuggestion = null;
@@ -17503,6 +17832,106 @@ function createId2(prefix) {
     return `${prefix}-${Date.now()}-${Math.floor(Math.random() * 1e5)}`;
   }
 }
+function createTaskBoundaryId() {
+  return createId2("task-boundary");
+}
+function sanitizeNavigationHandoff(input) {
+  if (!input || typeof input !== "object")
+    return void 0;
+  const handoffId = typeof input.handoffId === "string" ? input.handoffId.trim() : "";
+  const targetUrl = typeof input.targetUrl === "string" ? input.targetUrl.trim() : "";
+  if (!handoffId || !targetUrl)
+    return void 0;
+  const sourceLogicalTabId = Number(input.sourceLogicalTabId);
+  return {
+    handoffId,
+    targetUrl,
+    sourceLogicalTabId: Number.isFinite(sourceLogicalTabId) && sourceLogicalTabId > 0 ? sourceLogicalTabId : void 0,
+    runId: typeof input.runId === "string" && input.runId.trim() ? input.runId.trim() : void 0,
+    createdAt: Number(input.createdAt) || Date.now(),
+    consumed: input.consumed === true
+  };
+}
+function toSharedNavigationHandoff(input) {
+  if (!input)
+    return void 0;
+  return {
+    handoffId: input.handoffId,
+    targetUrl: input.targetUrl,
+    sourceLogicalTabId: input.sourceLogicalTabId,
+    runId: input.runId,
+    ts: input.createdAt
+  };
+}
+function toPersistedNavigationHandoff(intent) {
+  return {
+    handoffId: intent.handoffId,
+    targetUrl: intent.targetUrl,
+    sourceLogicalTabId: intent.sourceLogicalTabId,
+    runId: intent.runId,
+    createdAt: Number(intent.ts) || Date.now(),
+    consumed: false
+  };
+}
+function resolveExistingTaskBoundaryIdFromState(state) {
+  const pendingCandidate = typeof state?.pendingRun?.taskBoundaryId === "string" ? state.pendingRun.taskBoundaryId : void 0;
+  if (pendingCandidate)
+    return normalizeTaskBoundaryId(pendingCandidate);
+  const workerCandidate = typeof state?.workerState?.taskBoundaryId === "string" ? state.workerState.taskBoundaryId : void 0;
+  if (workerCandidate)
+    return normalizeTaskBoundaryId(workerCandidate);
+  return void 0;
+}
+function resolveTaskBoundaryIdFromState(state) {
+  const existing = resolveExistingTaskBoundaryIdFromState(state);
+  if (existing)
+    return existing;
+  return createTaskBoundaryId();
+}
+function resolveCurrentTaskBoundaryCandidate() {
+  return normalizeTaskBoundaryId(currentTaskBoundaryId) || resolveExistingTaskBoundaryIdFromState(runtimeState);
+}
+function shouldAcceptIncomingWorkerBoundary(params) {
+  const decision = shouldAcceptWorkerSnapshot({
+    source: params.source,
+    incomingBoundaryId: params.incomingBoundaryId,
+    currentBoundaryId: resolveCurrentTaskBoundaryCandidate(),
+    taskEpochAdvanced: params.taskEpochAdvanced,
+    hasPendingRun: !!runtimeState?.pendingRun,
+    taskStatus: runtimeState?.activeTask?.status,
+    allowBootstrapAdoption: params.allowBootstrapAdoption
+  });
+  if (!decision.accept)
+    return false;
+  if (decision.adoptedBoundaryId) {
+    currentTaskBoundaryId = decision.adoptedBoundaryId;
+  }
+  return true;
+}
+function getUnconsumedNavigationHandoff(maxAgeMs = 12e4) {
+  const handoff = sanitizeNavigationHandoff(runtimeState?.lastNavigationHandoff);
+  if (!handoff || handoff.consumed === true)
+    return void 0;
+  const ageMs = Date.now() - Number(handoff.createdAt || 0);
+  if (!Number.isFinite(ageMs) || ageMs < -5e3 || ageMs > maxAgeMs)
+    return void 0;
+  return handoff;
+}
+function syncCurrentTaskBoundaryId(options) {
+  const pendingBoundary = sanitizePendingRun(runtimeState?.pendingRun)?.taskBoundaryId;
+  if (pendingBoundary) {
+    currentTaskBoundaryId = pendingBoundary;
+    return;
+  }
+  const workerBoundary = sanitizeWorkerState(runtimeState?.workerState)?.taskBoundaryId;
+  if (workerBoundary) {
+    currentTaskBoundaryId = workerBoundary;
+    return;
+  }
+  if (!currentTaskBoundaryId || options?.rotateIfMissing) {
+    currentTaskBoundaryId = createTaskBoundaryId();
+  }
+}
 function getOrCreateRuntimeId(siteId) {
   const key = `${RUNTIME_ID_PREFIX}${siteId}`;
   try {
@@ -17673,6 +18102,7 @@ function createDefaultRuntimeState(sessionId, rid) {
     executionMode: "controller",
     workerState: void 0,
     pendingRun: void 0,
+    lastNavigationHandoff: void 0,
     taskEpoch: 1,
     activeTask: createDefaultTaskState(),
     lastRoutingDecision: void 0,
@@ -18054,9 +18484,12 @@ function shouldIgnoreRunScopedWorkerMessage(msg) {
   if (!RUN_SCOPED_WORKER_MESSAGE_TYPES.has(type))
     return false;
   const messageRunId = typeof msg?.runId === "string" && msg.runId ? msg.runId : void 0;
+  const messageTaskBoundaryId = typeof msg?.taskBoundaryId === "string" && msg.taskBoundaryId ? msg.taskBoundaryId : void 0;
   return shouldIgnoreRunScopedMessage({
     type,
     messageRunId,
+    messageTaskBoundaryId,
+    currentTaskBoundaryId: resolveCurrentTaskBoundaryCandidate(),
     pendingRunId: getPendingRunId(),
     sharedActiveRunId: sessionCoordinator?.getState()?.activeRun?.runId,
     taskStatus: runtimeState?.activeTask?.status,
@@ -18097,14 +18530,66 @@ function normalizeAskUserQuestions(input) {
   }
   return out.slice(0, 6);
 }
+function buildAskUserDispatchText(text, askUserAnswers) {
+  const trimmed = String(text || "").trim();
+  if (trimmed)
+    return trimmed;
+  if (!askUserAnswers || typeof askUserAnswers !== "object")
+    return "";
+  const answersByKey = askUserAnswers.answersByKey && typeof askUserAnswers.answersByKey === "object" ? askUserAnswers.answersByKey : {};
+  const pendingQuestions = normalizeAskUserQuestions(runtimeState?.workerState?.pendingAskUser?.questions);
+  const rawKeys = Array.isArray(askUserAnswers.keys) ? askUserAnswers.keys : [];
+  const resolvedKeys = rawKeys.map((key) => String(key || "").trim()).filter(Boolean);
+  if (resolvedKeys.length === 0) {
+    for (const question of pendingQuestions) {
+      const key = String(question.key || "").trim();
+      if (key)
+        resolvedKeys.push(key);
+    }
+  }
+  if (resolvedKeys.length === 0) {
+    for (const key of Object.keys(answersByKey)) {
+      const normalizedKey = String(key || "").trim();
+      if (normalizedKey)
+        resolvedKeys.push(normalizedKey);
+    }
+  }
+  const lines = [];
+  const seen = /* @__PURE__ */ new Set();
+  for (const key of resolvedKeys) {
+    const normalizedKey = String(key || "").trim();
+    if (!normalizedKey || seen.has(normalizedKey))
+      continue;
+    seen.add(normalizedKey);
+    const value = String(answersByKey[normalizedKey] || "").trim();
+    lines.push(`${normalizedKey}: ${value || "(no answer provided)"}`);
+  }
+  if (lines.length > 0) {
+    return lines.join("\n");
+  }
+  return String(askUserAnswers.rawText || "").trim();
+}
 function normalizeRunCompletionState(msg) {
   if (!msg || typeof msg !== "object") {
-    return { taskComplete: false, needsUserInput: false };
+    return {
+      taskComplete: false,
+      needsUserInput: false,
+      terminalState: "in_progress",
+      contextResetRecommended: false
+    };
   }
+  const incomingTerminal = String(msg.terminalState || "").trim().toLowerCase();
   const needsUserInput = msg.needsUserInput === true;
-  const taskComplete = msg.taskComplete === true && !needsUserInput;
+  const inferredTerminalState = incomingTerminal === "waiting_input" || incomingTerminal === "in_progress" || incomingTerminal === "completed" || incomingTerminal === "failed" ? incomingTerminal : needsUserInput ? "waiting_input" : msg.taskComplete === true ? "completed" : msg.ok === false ? "failed" : "in_progress";
+  const taskComplete = inferredTerminalState === "completed" || msg.taskComplete === true && inferredTerminalState !== "waiting_input";
   const questions = normalizeAskUserQuestions(msg.questions);
-  return { taskComplete, needsUserInput, ...questions.length ? { questions } : {} };
+  return {
+    taskComplete,
+    needsUserInput: inferredTerminalState === "waiting_input" || needsUserInput,
+    terminalState: inferredTerminalState,
+    contextResetRecommended: msg.contextResetRecommended === true || inferredTerminalState === "completed",
+    ...questions.length ? { questions } : {}
+  };
 }
 function getLatestAssistantText(runId) {
   if (runId && latestAssistantByRunId.has(runId)) {
@@ -18318,6 +18803,7 @@ function sanitizeTimelineEvents(input) {
 function sanitizeWorkerState(input) {
   if (!input || typeof input !== "object")
     return void 0;
+  const taskBoundaryIdCandidate = String(input.taskBoundaryId || "").trim();
   const historyRaw = Array.isArray(input.history) ? input.history : [];
   const plannerRaw = Array.isArray(input.plannerHistory) ? input.plannerHistory : [];
   const agentPrevStepsRaw = Array.isArray(input.agentPrevSteps) ? input.agentPrevSteps : Array.isArray(input.lastToolPreviousSteps) ? input.lastToolPreviousSteps : [];
@@ -18325,13 +18811,24 @@ function sanitizeWorkerState(input) {
   const plannerHistory = cloneUnknownArrayTail2(plannerRaw, MAX_WORKER_STEPS);
   const agentPrevSteps = cloneUnknownArrayTail2(agentPrevStepsRaw, MAX_WORKER_STEPS * 2);
   const pendingQuestions = normalizeAskUserQuestions(input?.pendingAskUser?.questions);
+  const pendingStepRefRaw = input?.pendingAskUser?.stepRef;
+  const pendingStepRef = pendingStepRefRaw && Number.isFinite(Number(pendingStepRefRaw.stepIndex)) && Number(pendingStepRefRaw.stepIndex) >= 0 && Number.isFinite(Number(pendingStepRefRaw.functionIndex)) && Number(pendingStepRefRaw.functionIndex) >= 0 ? {
+    stepIndex: Number(pendingStepRefRaw.stepIndex),
+    functionIndex: Number(pendingStepRefRaw.functionIndex),
+    ...typeof pendingStepRefRaw.accTreeId === "string" && pendingStepRefRaw.accTreeId.trim() ? { accTreeId: pendingStepRefRaw.accTreeId.trim() } : {}
+  } : void 0;
   const pendingAskUser = pendingQuestions.length ? {
     questions: pendingQuestions,
     source: input?.pendingAskUser?.source === "planner" ? "planner" : "act",
-    askedAt: Number(input?.pendingAskUser?.askedAt) || Date.now()
+    askedAt: Number(input?.pendingAskUser?.askedAt) || Date.now(),
+    boundaryId: typeof input?.pendingAskUser?.boundaryId === "string" && input.pendingAskUser.boundaryId.trim() ? input.pendingAskUser.boundaryId.trim() : void 0,
+    ...pendingStepRef ? { stepRef: pendingStepRef } : {}
   } : void 0;
+  const rootUserInput = typeof input.rootUserInput === "string" ? input.rootUserInput.trim() : "";
   return {
     trajectoryId: typeof input.trajectoryId === "string" ? input.trajectoryId : void 0,
+    taskBoundaryId: taskBoundaryIdCandidate || void 0,
+    rootUserInput: rootUserInput || void 0,
     history: history2,
     plannerHistory,
     agentPrevSteps,
@@ -18360,6 +18857,7 @@ function normalizePersistedState(raw, sessionId, rid) {
     executionMode: raw.executionMode === "observer" || raw.executionMode === "controller" ? raw.executionMode : "controller",
     workerState: sanitizeWorkerState(raw.workerState),
     pendingRun,
+    lastNavigationHandoff: sanitizeNavigationHandoff(raw.lastNavigationHandoff),
     taskEpoch: Math.max(1, Number(raw.taskEpoch) || 1),
     activeTask: parsedTask,
     lastRoutingDecision: raw.lastRoutingDecision && (raw.lastRoutingDecision.mode === "act" || raw.lastRoutingDecision.mode === "planner") ? {
@@ -18395,13 +18893,23 @@ function toSharedWorkerContext(state) {
   const pendingQuestions = normalizeAskUserQuestions(state.pendingAskUser?.questions);
   return {
     trajectoryId: state.trajectoryId,
+    taskBoundaryId: typeof state.taskBoundaryId === "string" ? state.taskBoundaryId : void 0,
+    rootUserInput: typeof state.rootUserInput === "string" ? state.rootUserInput : void 0,
     history: Array.isArray(state.history) ? state.history.slice(-MAX_WORKER_HISTORY).map((message) => toWorkerHistoryEntry(message)).filter((message) => !!message) : [],
     plannerHistory: cloneUnknownArrayTail2(state.plannerHistory, MAX_WORKER_STEPS),
     agentPrevSteps: cloneUnknownArrayTail2(state.agentPrevSteps, MAX_WORKER_STEPS * 2),
     pendingAskUser: pendingQuestions.length ? {
       questions: pendingQuestions,
       source: state.pendingAskUser?.source === "planner" ? "planner" : "act",
-      askedAt: Number(state.pendingAskUser?.askedAt) || Date.now()
+      askedAt: Number(state.pendingAskUser?.askedAt) || Date.now(),
+      boundaryId: typeof state.pendingAskUser?.boundaryId === "string" && state.pendingAskUser.boundaryId.trim() ? state.pendingAskUser.boundaryId.trim() : void 0,
+      ...state.pendingAskUser?.stepRef && Number.isFinite(Number(state.pendingAskUser.stepRef.stepIndex)) && Number(state.pendingAskUser.stepRef.stepIndex) >= 0 && Number.isFinite(Number(state.pendingAskUser.stepRef.functionIndex)) && Number(state.pendingAskUser.stepRef.functionIndex) >= 0 ? {
+        stepRef: {
+          stepIndex: Number(state.pendingAskUser.stepRef.stepIndex),
+          functionIndex: Number(state.pendingAskUser.stepRef.functionIndex),
+          ...typeof state.pendingAskUser.stepRef.accTreeId === "string" && state.pendingAskUser.stepRef.accTreeId.trim() ? { accTreeId: state.pendingAskUser.stepRef.accTreeId.trim() } : {}
+        }
+      } : {}
     } : void 0,
     updatedAt: Number(state.updatedAt) || Date.now()
   };
@@ -18411,6 +18919,7 @@ function sanitizePendingRun(input) {
     return void 0;
   const id = typeof input.id === "string" && input.id.trim() ? input.id.trim() : void 0;
   const text = typeof input.text === "string" ? input.text.trim() : "";
+  const taskBoundaryId = typeof input.taskBoundaryId === "string" && input.taskBoundaryId.trim() ? input.taskBoundaryId.trim() : void 0;
   if (!id || !text)
     return void 0;
   return {
@@ -18419,6 +18928,7 @@ function sanitizePendingRun(input) {
     startedAt: Number(input.startedAt) || Date.now(),
     attempts: Math.max(0, Number(input.attempts) || 0),
     autoResume: input.autoResume !== false,
+    taskBoundaryId,
     resumeRequired: input.resumeRequired === true,
     resumeReason: input.resumeReason === "cross_host_navigation" || input.resumeReason === "agent_navigation" || input.resumeReason === "handoff" || input.resumeReason === "page_reload" ? input.resumeReason : void 0
   };
@@ -18441,17 +18951,19 @@ function ensureUnloadHandler() {
   unloadHandlerInstalled = true;
   const onPageHide = () => {
     if (runtimeState?.pendingRun?.autoResume) {
+      const effectiveReason = runtimeState.pendingRun.resumeReason || (agentNavigationPending ? "agent_navigation" : "page_reload");
       const markedPending = sanitizePendingRun({
         ...runtimeState.pendingRun,
         resumeRequired: true,
-        resumeReason: runtimeState.pendingRun.resumeReason || "page_reload"
+        resumeReason: effectiveReason
       });
       runtimeState.pendingRun = markedPending;
       if (markedPending) {
         sessionCoordinator?.clearActiveRunRuntimeId(markedPending.id);
       }
     }
-    sessionCoordinator?.broadcastClosing();
+    const pendingHandoff = getUnconsumedNavigationHandoff();
+    sessionCoordinator?.broadcastClosing(toSharedNavigationHandoff(pendingHandoff));
     if (runtimeState?.pendingRun) {
       sessionCoordinator?.releaseWorkflowLock(runtimeState.pendingRun.id);
     }
@@ -18463,8 +18975,16 @@ function ensureUnloadHandler() {
           id: runtimeState.pendingRun.id,
           text: runtimeState.pendingRun.text,
           startedAt: runtimeState.pendingRun.startedAt,
-          attempts: runtimeState.pendingRun.attempts
+          attempts: runtimeState.pendingRun.attempts,
+          taskBoundaryId: runtimeState.pendingRun.taskBoundaryId || currentTaskBoundaryId
         },
+        handoff: pendingHandoff ? {
+          handoffId: pendingHandoff.handoffId,
+          sourceLogicalTabId: pendingHandoff.sourceLogicalTabId,
+          runId: pendingHandoff.runId,
+          targetUrl: pendingHandoff.targetUrl,
+          createdAt: pendingHandoff.createdAt
+        } : void 0,
         activeTask: runtimeState.activeTask ? { taskId: runtimeState.activeTask.taskId, status: runtimeState.activeTask.status } : void 0,
         taskEpoch: runtimeState.taskEpoch,
         timestamp: Date.now()
@@ -18732,7 +19252,20 @@ function setExecutionMode(mode, info) {
 function setPendingRun(next) {
   if (!runtimeState)
     return;
-  runtimeState.pendingRun = next;
+  if (next) {
+    runtimeState.pendingRun = sanitizePendingRun({
+      ...next,
+      taskBoundaryId: next.taskBoundaryId || currentTaskBoundaryId
+    });
+  } else {
+    runtimeState.pendingRun = void 0;
+  }
+  persistRuntimeState();
+}
+function setLatestNavigationHandoff(next) {
+  if (!runtimeState)
+    return;
+  runtimeState.lastNavigationHandoff = sanitizeNavigationHandoff(next);
   persistRuntimeState();
 }
 function postRun(text, options) {
@@ -18762,12 +19295,15 @@ function postRun(text, options) {
     appendUiMessage("user", trimmed, true);
   }
   const previousAttempts = runtimeState?.pendingRun?.id === runId ? runtimeState.pendingRun.attempts : 0;
+  const boundaryForRun = runtimeState?.pendingRun?.id === runId ? runtimeState.pendingRun.taskBoundaryId || currentTaskBoundaryId : currentTaskBoundaryId;
+  agentNavigationPending = false;
   setPendingRun({
     id: runId,
     text: trimmed,
     startedAt: Date.now(),
     attempts: resume ? previousAttempts + 1 : 0,
     autoResume: options?.autoResume !== false,
+    taskBoundaryId: boundaryForRun,
     resumeRequired: false,
     resumeReason: void 0
   });
@@ -18800,15 +19336,18 @@ function postRun(text, options) {
   }, 5 * 6e4);
 }
 function dispatchUserPrompt(text, options) {
-  const trimmed = String(text || "").trim();
+  const trimmed = buildAskUserDispatchText(text, options?.askUserAnswers);
   if (!trimmed)
     return;
   maybeClearStalePendingRun();
   const activeTaskStatus = runtimeState?.activeTask?.status;
   const shouldStartFreshTask2 = !!options?.startNewTask || shouldStartFreshTask(activeTaskStatus);
-  sessionCoordinator?.pruneTabs({
+  sessionCoordinator?.pruneTabs(shouldStartFreshTask2 ? {
     dropRuntimeDetached: true,
-    dropAllDetachedExternal: shouldStartFreshTask2
+    keepOnlyActiveLiveTab: true,
+    keepRecentExternalPlaceholders: true
+  } : {
+    dropRuntimeDetached: true
   });
   if (shouldStartFreshTask2) {
     const autoReason = options?.reason || (activeTaskStatus === "completed" ? "auto_after_task_complete" : "auto_after_task_end");
@@ -18914,12 +19453,24 @@ async function applyAsyncRuntimeStateHydration(key) {
   const incomingUpdatedAt = Number(normalized.updatedAt) || 0;
   if (incomingUpdatedAt <= localUpdatedAt + 200)
     return;
+  const localTaskEpoch = Math.max(1, Number(runtimeState.taskEpoch) || 1);
+  const incomingTaskEpoch = Math.max(1, Number(normalized.taskEpoch) || 1);
+  const incomingBoundaryId = resolveExistingTaskBoundaryIdFromState(normalized);
+  if (!shouldAcceptIncomingWorkerBoundary({
+    source: "indexeddb_checkpoint",
+    incomingBoundaryId,
+    taskEpochAdvanced: incomingTaskEpoch > localTaskEpoch,
+    allowBootstrapAdoption: true
+  })) {
+    return;
+  }
   runtimeState = normalizePersistedState({
     ...runtimeState,
     ...normalized,
     sessionId: runtimeState.sessionId,
     runtimeId
   }, runtimeState.sessionId, runtimeId);
+  syncCurrentTaskBoundaryId({ rotateIfMissing: !currentTaskBoundaryId });
   persistRuntimeState();
   if (ui) {
     ui.clearMessages();
@@ -18939,6 +19490,9 @@ async function applyAsyncRuntimeStateHydration(key) {
         ui.close();
     }
   }
+  if (workerReady && worker) {
+    worker.postMessage({ type: "update_config", config: { taskBoundaryId: currentTaskBoundaryId } });
+  }
   if (workerReady && worker && runtimeState.workerState && currentMode === "controller") {
     worker.postMessage({ type: "hydrate_state", state: runtimeState.workerState });
     emit("context_restored", { source: "indexeddb_checkpoint", ts: Date.now() });
@@ -18959,6 +19513,9 @@ function applyCoordinatorState(state, source) {
       runtimeState.timeline = [];
       clearTaskUiState();
       setPendingRun(void 0);
+      runtimeState.workerState = void 0;
+      currentTaskBoundaryId = createTaskBoundaryId();
+      worker?.postMessage({ type: "update_config", config: { taskBoundaryId: currentTaskBoundaryId } });
       hideTaskSuggestion();
     }
     const incomingMessages = sanitizeUiMessages(state.uiMessages);
@@ -19024,7 +19581,8 @@ function applyCoordinatorState(state, source) {
         text: state.activeRun.text,
         startedAt: state.activeRun.startedAt,
         attempts: runtimeState.pendingRun?.attempts || 0,
-        autoResume: true
+        autoResume: true,
+        resumeReason: runtimeState.pendingRun?.resumeReason
       }));
     } else {
       const shouldClearPending = shouldClearPendingFromSharedState({
@@ -19051,9 +19609,16 @@ function applyCoordinatorState(state, source) {
       const incomingWorker = sanitizeWorkerState(state.workerContext);
       const localUpdatedAt = Number(runtimeState.workerState?.updatedAt) || 0;
       const incomingUpdatedAt = Number(incomingWorker?.updatedAt) || 0;
-      if (incomingWorker && incomingUpdatedAt > localUpdatedAt + 100) {
+      if (incomingWorker && incomingUpdatedAt > localUpdatedAt + 100 && shouldAcceptIncomingWorkerBoundary({
+        source: "shared_worker_context",
+        incomingBoundaryId: incomingWorker.taskBoundaryId,
+        taskEpochAdvanced,
+        allowBootstrapAdoption: true
+      })) {
         runtimeState.workerState = incomingWorker;
+        syncCurrentTaskBoundaryId();
         if (workerReady && worker && currentMode === "controller") {
+          worker.postMessage({ type: "update_config", config: { taskBoundaryId: currentTaskBoundaryId } });
           worker.postMessage({ type: "hydrate_state", state: incomingWorker });
           emit("context_restored", { source: "shared_session", ts: Date.now() });
         }
@@ -19063,6 +19628,7 @@ function applyCoordinatorState(state, source) {
   runtimeState.uiMessages = sanitizeUiMessages(runtimeState.uiMessages);
   runtimeState.timeline = sanitizeTimelineEvents(runtimeState.timeline);
   runtimeState.workerState = sanitizeWorkerState(runtimeState.workerState);
+  syncCurrentTaskBoundaryId();
   syncQuestionPromptFromWorkerState();
   runtimeState.activeTask = sanitizeTask(runtimeState.activeTask, createDefaultTaskState("implicit"));
   persistRuntimeState();
@@ -19081,6 +19647,7 @@ function cloneRuntimeStateForCheckpoint(state) {
     executionMode: state.executionMode === "observer" || state.executionMode === "controller" ? state.executionMode : "controller",
     workerState: sanitizeWorkerState(state.workerState),
     pendingRun: sanitizePendingRun(state.pendingRun),
+    lastNavigationHandoff: sanitizeNavigationHandoff(state.lastNavigationHandoff),
     taskEpoch: Math.max(1, Number(state.taskEpoch) || 1),
     activeTask: sanitizeTask(state.activeTask, fallbackTask),
     lastRoutingDecision: state.lastRoutingDecision && (state.lastRoutingDecision.mode === "act" || state.lastRoutingDecision.mode === "planner") ? {
@@ -19135,7 +19702,10 @@ function applyCloudCheckpointPayload(payload) {
       runtimeState.sessionId = remoteSessionId;
       currentConfig = { ...currentConfig, sessionId: remoteSessionId };
       setupSessionCoordinator(currentConfig);
-      worker?.postMessage({ type: "update_config", config: { sessionId: remoteSessionId } });
+      worker?.postMessage({
+        type: "update_config",
+        config: { sessionId: remoteSessionId, taskBoundaryId: currentTaskBoundaryId }
+      });
     }
     if (payload.sharedState && sessionCoordinator) {
       const hydrated = sessionCoordinator.hydrateExternalState(payload.sharedState);
@@ -19157,12 +19727,24 @@ function applyCloudCheckpointPayload(payload) {
       const localUpdatedAt = Number(runtimeState.updatedAt) || 0;
       const incomingUpdatedAt = Number(incomingState.updatedAt) || 0;
       if (incomingUpdatedAt > localUpdatedAt + 200) {
+        const localTaskEpoch = Math.max(1, Number(runtimeState.taskEpoch) || 1);
+        const incomingTaskEpoch = Math.max(1, Number(incomingState.taskEpoch) || 1);
+        const incomingBoundaryId = resolveExistingTaskBoundaryIdFromState(incomingState);
+        if (!shouldAcceptIncomingWorkerBoundary({
+          source: "cloud_checkpoint",
+          incomingBoundaryId,
+          taskEpochAdvanced: incomingTaskEpoch > localTaskEpoch,
+          allowBootstrapAdoption: true
+        })) {
+          return;
+        }
         runtimeState = normalizePersistedState({
           ...runtimeState,
           ...incomingState,
           sessionId: remoteSessionId,
           runtimeId
         }, remoteSessionId, runtimeId);
+        syncCurrentTaskBoundaryId();
         persistRuntimeState();
         if (runtimeState.uiStatus) {
           ui?.setStatus(runtimeState.uiStatus);
@@ -19176,6 +19758,9 @@ function applyCloudCheckpointPayload(payload) {
           else
             ui?.close();
         }
+        if (workerReady) {
+          worker?.postMessage({ type: "update_config", config: { taskBoundaryId: currentTaskBoundaryId } });
+        }
         if (workerReady && runtimeState.workerState) {
           worker?.postMessage({ type: "hydrate_state", state: runtimeState.workerState });
           emit("context_restored", { source: "cloud_checkpoint", ts: Date.now() });
@@ -19285,12 +19870,18 @@ function setupSessionCoordinator(cfg) {
           const incomingWorker = sanitizeWorkerState(sharedWorkerContext);
           const localUpdatedAt = Number(runtimeState?.workerState?.updatedAt) || 0;
           const incomingUpdatedAt = Number(incomingWorker?.updatedAt) || 0;
-          if (incomingWorker && incomingUpdatedAt > localUpdatedAt + 100) {
+          if (incomingWorker && incomingUpdatedAt > localUpdatedAt + 100 && shouldAcceptIncomingWorkerBoundary({
+            source: "controller_handoff",
+            incomingBoundaryId: incomingWorker.taskBoundaryId,
+            allowBootstrapAdoption: true
+          })) {
             if (runtimeState) {
               runtimeState.workerState = incomingWorker;
+              syncCurrentTaskBoundaryId();
               persistRuntimeState();
             }
             if (workerReady && worker) {
+              worker.postMessage({ type: "update_config", config: { taskBoundaryId: currentTaskBoundaryId } });
               worker.postMessage({ type: "hydrate_state", state: incomingWorker });
               emit("context_restored", { source: "controller_handoff", ts: Date.now() });
             }
@@ -19313,7 +19904,15 @@ function setupSessionCoordinator(cfg) {
       }
     }
   });
-  sessionCoordinator.start();
+  const startupHandoff = getUnconsumedNavigationHandoff();
+  sessionCoordinator.start(toSharedNavigationHandoff(startupHandoff));
+  if (runtimeState?.lastNavigationHandoff && startupHandoff) {
+    runtimeState.lastNavigationHandoff = sanitizeNavigationHandoff({
+      ...runtimeState.lastNavigationHandoff,
+      consumed: true
+    });
+    persistRuntimeState();
+  }
   sessionCoordinator.setRpcRequestHandler(async (request) => {
     if (!bridge)
       throw new Error("Bridge not available");
@@ -19460,10 +20059,18 @@ function handleWorkerMessage(msg) {
   }
   if (msg.type === "state_snapshot") {
     if (runtimeState) {
-      runtimeState.workerState = sanitizeWorkerState({
+      const incomingWorkerState = sanitizeWorkerState({
         ...msg.state || {},
         updatedAt: Date.now()
       });
+      if (!incomingWorkerState || !shouldAcceptIncomingWorkerBoundary({
+        source: "worker_snapshot",
+        incomingBoundaryId: incomingWorkerState.taskBoundaryId,
+        allowBootstrapAdoption: true
+      })) {
+        return;
+      }
+      runtimeState.workerState = incomingWorkerState;
       const activeRunId = typeof msg?.activeRun?.runId === "string" && msg.activeRun.runId ? msg.activeRun.runId : void 0;
       const activeRunText = typeof msg?.activeRun?.text === "string" ? msg.activeRun.text : void 0;
       const canAdoptActiveRun = shouldAdoptSnapshotActiveRun({
@@ -19516,6 +20123,7 @@ function handleWorkerMessage(msg) {
       return;
     }
     const existing = runtimeState?.pendingRun;
+    const messageTaskBoundaryId = typeof msg?.taskBoundaryId === "string" ? normalizeTaskBoundaryId(msg.taskBoundaryId) : void 0;
     if (typeof msg.runId === "string" && msg.runId) {
       removeIgnoredRunId(msg.runId);
     }
@@ -19524,7 +20132,10 @@ function handleWorkerMessage(msg) {
       text: msg.text,
       startedAt: existing?.startedAt || Date.now(),
       attempts: existing?.attempts || 0,
-      autoResume: existing?.autoResume !== false
+      autoResume: existing?.autoResume !== false,
+      taskBoundaryId: messageTaskBoundaryId || existing?.taskBoundaryId || currentTaskBoundaryId,
+      resumeReason: existing?.resumeReason,
+      resumeRequired: existing?.resumeRequired
     }));
     sessionCoordinator?.setActiveRun({ runId: msg.runId, text: String(msg.text || "") });
     ui?.setRunning(true);
@@ -19576,9 +20187,16 @@ function handleWorkerMessage(msg) {
       if (!isTaskRunning()) {
         return;
       }
+      const completionState = normalizeRunCompletionState(msg);
       ui?.setQuestionPrompt(void 0);
-      markTaskRunning("worker_run_failed");
-      setUiStatus(`Task failed: ${String(msg.error)}`);
+      if (completionState.contextResetRecommended) {
+        markTaskCompleted("worker_run_failed_terminal");
+        sessionCoordinator?.resetTabsToCurrent(window.location.href, document.title || void 0);
+        setUiStatus(`Task failed: ${String(msg.error)}. Start a new task to continue.`);
+      } else {
+        markTaskRunning("worker_run_failed");
+        setUiStatus(`Task failed: ${String(msg.error)}`);
+      }
       if (completedRunId) {
         latestAssistantByRunId.delete(completedRunId);
       }
@@ -19595,20 +20213,39 @@ function handleWorkerMessage(msg) {
       const completionState = normalizeRunCompletionState(msg);
       const taskComplete = completionState.taskComplete;
       const needsUserInput = completionState.needsUserInput;
-      const questions = completionState.questions || normalizeAskUserQuestions(msg.questions);
-      if (taskComplete) {
+      const terminalState = completionState.terminalState;
+      const completionQuestions = completionState.questions || normalizeAskUserQuestions(msg.questions);
+      const pendingStateQuestions = normalizeAskUserQuestions(runtimeState?.workerState?.pendingAskUser?.questions);
+      const questions = completionQuestions.length ? completionQuestions : needsUserInput ? pendingStateQuestions : [];
+      if (terminalState === "failed") {
         ui?.setQuestionPrompt(void 0);
-        markTaskCompleted("worker_task_complete");
-        sessionCoordinator?.pruneTabs({
-          dropRuntimeDetached: true,
-          dropAllDetachedExternal: true
+        if (completionState.contextResetRecommended) {
+          markTaskCompleted("worker_run_failed_terminal");
+          sessionCoordinator?.resetTabsToCurrent(window.location.href, document.title || void 0);
+          setUiStatus("Task failed. Start a new task to continue.");
+        } else {
+          markTaskRunning("worker_run_failed");
+          setUiStatus("Task failed.");
+        }
+        appendTimelineEvent({
+          kind: "error",
+          title: "Run failed",
+          detail: typeof msg.error === "string" ? msg.error : "Run reported failure state.",
+          status: "error"
         });
+      } else if (taskComplete || terminalState === "completed") {
+        ui?.setQuestionPrompt(void 0);
+        markTaskCompleted("worker_task_complete");
+        sessionCoordinator?.resetTabsToCurrent(window.location.href, document.title || void 0);
         setUiStatus("Task completed");
         finalizeSuccessfulRunTimeline(typeof msg.runId === "string" ? msg.runId : void 0);
       } else {
-        markTaskRunning(needsUserInput ? "worker_waiting_for_input" : "worker_continuation");
+        const nextReason = needsUserInput ? "worker_waiting_for_input" : terminalState === "in_progress" ? "worker_continuation" : "worker_task_active";
+        markTaskRunning(nextReason);
         if (needsUserInput && questions.length > 0) {
           ui?.setQuestionPrompt({ questions });
+        } else if (needsUserInput) {
+          syncQuestionPromptFromWorkerState();
         } else {
           ui?.setQuestionPrompt(void 0);
         }
@@ -19631,13 +20268,29 @@ function handleWorkerMessage(msg) {
       loadAndMergeShortcuts(currentConfig);
     }
     const sharedWorkerContext = sessionCoordinator?.getWorkerContext();
-    const sharedWorkerState = sanitizeWorkerState(sharedWorkerContext);
-    const localUpdatedAt = Number(runtimeState?.workerState?.updatedAt) || 0;
+    const sharedWorkerStateCandidate = sanitizeWorkerState(sharedWorkerContext);
+    const sharedWorkerState = sharedWorkerStateCandidate && shouldAcceptIncomingWorkerBoundary({
+      source: "ready_hydrate",
+      incomingBoundaryId: sharedWorkerStateCandidate.taskBoundaryId,
+      allowBootstrapAdoption: true
+    }) ? sharedWorkerStateCandidate : void 0;
+    const localWorkerStateCandidate = sanitizeWorkerState(runtimeState?.workerState);
+    const localWorkerState = localWorkerStateCandidate && shouldAcceptIncomingWorkerBoundary({
+      source: "ready_hydrate",
+      incomingBoundaryId: localWorkerStateCandidate.taskBoundaryId,
+      allowBootstrapAdoption: true
+    }) ? localWorkerStateCandidate : void 0;
+    const localUpdatedAt = Number(localWorkerState?.updatedAt) || 0;
     const sharedUpdatedAt = Number(sharedWorkerState?.updatedAt) || 0;
-    const stateToHydrate = sharedWorkerState && sharedUpdatedAt > localUpdatedAt + 100 ? sharedWorkerState : runtimeState?.workerState;
-    if (runtimeState && stateToHydrate && stateToHydrate !== runtimeState.workerState) {
-      runtimeState.workerState = stateToHydrate;
-      persistRuntimeState();
+    const stateToHydrate = sharedWorkerState && sharedUpdatedAt > localUpdatedAt + 100 ? sharedWorkerState : localWorkerState;
+    if (runtimeState) {
+      if (stateToHydrate && stateToHydrate !== runtimeState.workerState) {
+        runtimeState.workerState = stateToHydrate;
+        persistRuntimeState();
+      } else if (!stateToHydrate && runtimeState.workerState) {
+        runtimeState.workerState = void 0;
+        persistRuntimeState();
+      }
     }
     if (stateToHydrate) {
       worker?.postMessage({ type: "hydrate_state", state: stateToHydrate });
@@ -20008,26 +20661,33 @@ function createRuntime(cfg) {
         status: "info"
       });
     },
-    onBeforeAgentNavigation: (_targetUrl) => {
-      if (!runtimeState?.pendingRun)
+    onBeforeAgentNavigation: (intent) => {
+      agentNavigationPending = true;
+      if (!runtimeState)
+        return;
+      setLatestNavigationHandoff(toPersistedNavigationHandoff(intent));
+      if (!runtimeState.pendingRun)
         return;
-      const currentHost = new URL(window.location.href).hostname;
-      const targetHost = new URL(_targetUrl, window.location.href).hostname;
-      if (currentHost === targetHost) {
+      if (!intent.isCrossHost) {
         runtimeState.pendingRun = sanitizePendingRun({
           ...runtimeState.pendingRun,
+          taskBoundaryId: runtimeState.pendingRun.taskBoundaryId || currentTaskBoundaryId,
           resumeRequired: true,
           resumeReason: "agent_navigation"
         });
         persistRuntimeState();
       }
     },
-    onBeforeCrossHostNavigation: (_targetUrl) => {
+    onBeforeCrossHostNavigation: (intent) => {
+      agentNavigationPending = true;
       if (!runtimeState || !currentConfig)
         return;
+      setLatestNavigationHandoff(toPersistedNavigationHandoff(intent));
+      const handoffForCookie = getUnconsumedNavigationHandoff();
       if (runtimeState.pendingRun) {
         runtimeState.pendingRun = sanitizePendingRun({
           ...runtimeState.pendingRun,
+          taskBoundaryId: runtimeState.pendingRun.taskBoundaryId || currentTaskBoundaryId,
           resumeRequired: true,
           resumeReason: "cross_host_navigation"
         });
@@ -20038,7 +20698,15 @@ function createRuntime(cfg) {
           id: runtimeState.pendingRun.id,
           text: runtimeState.pendingRun.text,
           startedAt: runtimeState.pendingRun.startedAt,
-          attempts: runtimeState.pendingRun.attempts
+          attempts: runtimeState.pendingRun.attempts,
+          taskBoundaryId: runtimeState.pendingRun.taskBoundaryId || currentTaskBoundaryId
+        } : void 0,
+        handoff: handoffForCookie ? {
+          handoffId: handoffForCookie.handoffId,
+          sourceLogicalTabId: handoffForCookie.sourceLogicalTabId,
+          runId: handoffForCookie.runId,
+          targetUrl: handoffForCookie.targetUrl,
+          createdAt: handoffForCookie.createdAt
         } : void 0,
         activeTask: runtimeState.activeTask ? {
           taskId: runtimeState.activeTask.taskId,
@@ -20137,7 +20805,7 @@ function createRuntime(cfg) {
         title: document.title
       };
     },
-    listSessionTabs: () => sessionCoordinator?.listTabs() || []
+    listSessionTabs: () => sessionCoordinator?.listTabs({ scope: "context" }) || []
   });
   channel.port1.start?.();
   const workerUrl = cfg.workerUrl ? cfg.workerUrl : new URL("./worker/worker.js", import.meta.url).toString();
@@ -20152,7 +20820,77 @@ function createRuntime(cfg) {
   } catch (_e) {
   }
   worker = new Worker(effectiveWorkerUrl, { type: "module" });
-  worker.postMessage({ type: "init", config: cfg, port: channel.port2 }, [channel.port2]);
+  worker.postMessage({
+    type: "init",
+    config: {
+      ...cfg,
+      taskBoundaryId: currentTaskBoundaryId
+    },
+    port: channel.port2
+  }, [channel.port2]);
+  const cancelCurrentFlow = (reason = "manual_cancel_task") => {
+    if (!runtimeState)
+      return;
+    const pendingRun = runtimeState.pendingRun;
+    if (pendingRun) {
+      addIgnoredRunId(pendingRun.id);
+      worker?.postMessage({ type: "cancel_run", runId: pendingRun.id });
+      sessionCoordinator?.releaseWorkflowLock(pendingRun.id);
+      sessionCoordinator?.setActiveRun(void 0);
+      setPendingRun(void 0);
+      runtimeState.workerState = void 0;
+      sessionCoordinator?.setWorkerContext(void 0);
+      currentTaskBoundaryId = createTaskBoundaryId();
+      worker?.postMessage({ type: "update_config", config: { taskBoundaryId: currentTaskBoundaryId } });
+      if (runSafetyTimer) {
+        clearTimeout(runSafetyTimer);
+        runSafetyTimer = null;
+      }
+      ui?.setRunning(false);
+      ui?.setQuestionPrompt(void 0);
+      setUiStatus("Task cancelled.");
+      appendUiMessage("system", "Task cancelled.", true);
+      appendTimelineEvent({
+        kind: "info",
+        title: "Run cancelled",
+        status: "info"
+      });
+      persistRuntimeState();
+      return;
+    }
+    const hasPendingQuestions = normalizeAskUserQuestions(runtimeState.workerState?.pendingAskUser?.questions).length > 0;
+    const activeStatus = runtimeState.activeTask?.status;
+    if (!hasPendingQuestions && activeStatus !== "running") {
+      return;
+    }
+    currentTaskBoundaryId = createTaskBoundaryId();
+    runtimeState.workerState = void 0;
+    worker?.postMessage({ type: "update_config", config: { taskBoundaryId: currentTaskBoundaryId } });
+    if (runSafetyTimer) {
+      clearTimeout(runSafetyTimer);
+      runSafetyTimer = null;
+    }
+    ui?.setRunning(false);
+    ui?.setQuestionPrompt(void 0);
+    hideTaskSuggestion();
+    setPendingRun(void 0);
+    const task = ensureActiveTask(reason);
+    if (task) {
+      task.status = "ended";
+      task.endedAt = Date.now();
+      task.boundaryReason = reason;
+    }
+    sessionCoordinator?.endTask(reason);
+    sessionCoordinator?.setActiveRun(void 0);
+    sessionCoordinator?.setWorkerContext(void 0);
+    setUiStatus(reason === "question_prompt_cancel" ? "Input request cancelled." : "Task cancelled.");
+    appendTimelineEvent({
+      kind: "info",
+      title: reason === "question_prompt_cancel" ? "Input request cancelled" : "Task cancelled",
+      status: "info"
+    });
+    persistRuntimeState();
+  };
   ui = mountWidget({
     shortcuts: getRenderableShortcuts(sanitizeShortcutList(cfg.ui?.shortcuts || [])),
     greeting: resolveEffectiveGreetingConfig(cfg),
@@ -20182,26 +20920,10 @@ function createRuntime(cfg) {
       }
     },
     onCancelRun: () => {
-      if (runtimeState?.pendingRun) {
-        addIgnoredRunId(runtimeState.pendingRun.id);
-        worker?.postMessage({ type: "cancel_run", runId: runtimeState.pendingRun.id });
-        sessionCoordinator?.releaseWorkflowLock(runtimeState.pendingRun.id);
-        sessionCoordinator?.setActiveRun(void 0);
-        setPendingRun(void 0);
-        if (runSafetyTimer) {
-          clearTimeout(runSafetyTimer);
-          runSafetyTimer = null;
-        }
-        ui?.setRunning(false);
-        ui?.setQuestionPrompt(void 0);
-        setUiStatus("Task cancelled.");
-        appendUiMessage("system", "Task cancelled.", true);
-        appendTimelineEvent({
-          kind: "info",
-          title: "Run cancelled",
-          status: "info"
-        });
-      }
+      cancelCurrentFlow("manual_cancel_task");
+    },
+    onCancelQuestionFlow: () => {
+      cancelCurrentFlow("question_prompt_cancel");
     },
     onNewTask: () => {
       newTask({ reason: "manual_new_task", clearUi: true });
@@ -20377,10 +21099,17 @@ function boot(cfg) {
       seeded.pendingRun = sanitizePendingRun({
         ...crossDomainResume.pendingRun,
         autoResume: true,
+        taskBoundaryId: crossDomainResume.pendingRun.taskBoundaryId,
         resumeRequired: true,
         resumeReason: "cross_host_navigation"
       });
     }
+    if (crossDomainResume.handoff) {
+      seeded.lastNavigationHandoff = sanitizeNavigationHandoff({
+        ...crossDomainResume.handoff,
+        createdAt: crossDomainResume.handoff.createdAt
+      });
+    }
     if (crossDomainResume.activeTask) {
       seeded.activeTask = {
         ...createDefaultTaskState("cross_domain_resume"),
@@ -20396,6 +21125,19 @@ function boot(cfg) {
   if (desiredSessionId && runtimeState.sessionId !== desiredSessionId) {
     runtimeState = createDefaultRuntimeState(desiredSessionId, runtimeId);
   }
+  currentTaskBoundaryId = resolveTaskBoundaryIdFromState(runtimeState);
+  if (runtimeState.pendingRun && !runtimeState.pendingRun.taskBoundaryId) {
+    runtimeState.pendingRun = sanitizePendingRun({
+      ...runtimeState.pendingRun,
+      taskBoundaryId: currentTaskBoundaryId
+    });
+  }
+  if (runtimeState.workerState && !runtimeState.workerState.taskBoundaryId) {
+    runtimeState.workerState = sanitizeWorkerState({
+      ...runtimeState.workerState,
+      taskBoundaryId: currentTaskBoundaryId
+    });
+  }
   currentConfig = {
     ...cfg,
     visitorId: resolvedVisitorId || cfg.visitorId,
@@ -20547,7 +21289,13 @@ function update(cfg) {
       });
     }
   }
-  worker.postMessage({ type: "update_config", config: cfg });
+  worker.postMessage({
+    type: "update_config",
+    config: {
+      ...cfg,
+      taskBoundaryId: currentTaskBoundaryId
+    }
+  });
   applyEffectiveSiteConfig(currentConfig);
   if (shouldReloadRemoteSiteConfig) {
     loadAndMergeShortcuts(currentConfig);
@@ -20583,6 +21331,8 @@ function shutdown() {
   currentConfig = null;
   workerReady = false;
   autoResumeAttempted = false;
+  agentNavigationPending = false;
+  currentTaskBoundaryId = "";
   runtimeId = "";
   resolvedVisitorId = void 0;
   resolvedVisitor = void 0;
@@ -20657,6 +21407,7 @@ function newTask(options) {
   ui?.setRunning(false);
   ui?.setQuestionPrompt(void 0);
   autoResumeAttempted = false;
+  currentTaskBoundaryId = createTaskBoundaryId();
   runtimeState.taskEpoch = taskEpoch;
   runtimeState.activeTask = nextTask;
   setPendingRun(void 0);
@@ -20679,7 +21430,7 @@ function newTask(options) {
   sessionCoordinator?.setWorkerContext(void 0);
   setUiStatus("New task started.");
   persistRuntimeState();
-  worker?.postMessage({ type: "start_new_task", taskId: nextTask.taskId });
+  worker?.postMessage({ type: "start_new_task", taskId: nextTask.taskId, taskBoundaryId: currentTaskBoundaryId });
   emit("task_started", {
     taskId: nextTask.taskId,
     reason,
@@ -20702,7 +21453,9 @@ function endTask(options) {
     sessionCoordinator?.releaseWorkflowLock(runtimeState.pendingRun.id);
   }
   setPendingRun(void 0);
+  currentTaskBoundaryId = createTaskBoundaryId();
   runtimeState.workerState = void 0;
+  worker?.postMessage({ type: "update_config", config: { taskBoundaryId: currentTaskBoundaryId } });
   if (runSafetyTimer) {
     clearTimeout(runSafetyTimer);
     runSafetyTimer = null;