viveworker 0.8.9 → 0.9.0

package/web/i18n.js

@@ -22,6 +22,7 @@ const translations = {
     "common.logOut": "Log out",
     "common.actionable": "Actionable",
     "common.actionNeeded": "Action needed",
+    "common.inProgress": "In progress",
     "common.completed": "Completed",
     "common.clear": "Clear",
     "common.cancel": "Cancel",
@@ -76,10 +77,10 @@ const translations = {
     "tab.pending.label": "Pending",
     "tab.pending.eyebrow": "Action queue",
     "tab.pending.description": "Items that need attention right now.",
-    "tab.inbox.title": "Tasks",
-    "tab.inbox.label": "Tasks",
-    "tab.inbox.eyebrow": "Work items",
-    "tab.inbox.description": "Switch between items that need action now and recent completed results.",
+    "tab.inbox.title": "Today",
+    "tab.inbox.label": "Today",
+    "tab.inbox.eyebrow": "Work today",
+    "tab.inbox.description": "See what needs you, what is running, and what finished today.",
     "tab.timeline.title": "Timeline",
     "tab.timeline.label": "Timeline",
     "tab.timeline.eyebrow": "Recent activity",
@@ -257,6 +258,7 @@ const translations = {
     "summary.fileEvent": "Review the files {provider} checked or updated in this step.",
     "summary.commandEvent": "Review the command {provider} ran in this step.",
     "summary.diffThread": "Review the file changes for this thread.",
+    "summary.inProgress": "{provider} is working on this now.",
     "summary.default": "Open the item to review its details.",
     "intent.approval": "Approve or reject this request.",
     "intent.plan": "Review this plan before {provider} continues.",
@@ -269,10 +271,25 @@ const translations = {
     "intent.userMessage": "Open this message again.",
     "intent.assistantCommentary": "Read the latest working update.",
     "intent.assistantFinal": "Read {provider}'s final reply for this turn.",
+    "intent.inProgress": "{provider} is working on this now.",
+    "intent.draftReview": "Review and approve this draft.",
+    "intent.delegationReview": "Review this delegated task before it runs.",
+    "intent.handoffReview": "Review this handoff before it is sent.",
     "timeline.allThreads": "All",
     "timeline.unknownThread": "Unknown thread",
-    "inbox.subtab.pending": "Pending",
+    "inbox.subtab.today": "Today",
+    "inbox.subtab.pending": "Needs you",
     "inbox.subtab.completed": "Completed",
+    "work.section.needsAction": "Needs you",
+    "work.section.inProgress": "In progress",
+    "work.section.completedToday": "Completed today",
+    "work.today.caughtUp": "Nothing needs your attention right now",
+    "work.today.emptyTitle": "You're caught up",
+    "work.today.emptyCopy": "New decisions and active work will appear here.",
+    "work.today.viewAllCompleted": "View all completed ({count} more)",
+    "work.health.title": "Connection needs attention",
+    "work.health.connectionRequired": "{provider} is not connected. Pending actions may not be delivered.",
+    "work.health.degraded": "A work source is temporarily unavailable.",
     "timeline.filterLabel": "Thread filter",
     "timeline.status.approved": "Approved",
     "timeline.status.rejected": "Rejected",
@@ -1153,6 +1170,7 @@ const translations = {
     "common.logOut": "ログアウト",
     "common.actionable": "対応が必要",
     "common.actionNeeded": "対応が必要",
+    "common.inProgress": "進行中",
     "common.completed": "完了",
     "common.clear": "クリア",
     "common.cancel": "キャンセル",
@@ -1201,10 +1219,10 @@ const translations = {
     "tab.pending.label": "未対応",
     "tab.pending.eyebrow": "対応待ち",
     "tab.pending.description": "いま対応が必要な項目です。",
-    "tab.inbox.title": "タスク",
-    "tab.inbox.label": "タスク",
-    "tab.inbox.eyebrow": "作業一覧",
-    "tab.inbox.description": "未対応の項目と、最近の完了結果を切り替えて確認できます。",
+    "tab.inbox.title": "今日",
+    "tab.inbox.label": "今日",
+    "tab.inbox.eyebrow": "今日の仕事",
+    "tab.inbox.description": "要対応、進行中、今日完了した仕事をまとめて確認できます。",
     "tab.timeline.title": "タイムライン",
     "tab.timeline.label": "タイムライン",
     "tab.timeline.eyebrow": "最近の動き",
@@ -1378,6 +1396,7 @@ const translations = {
     "summary.fileEvent": "このステップで触れたファイルを確認します。",
     "summary.commandEvent": "このステップで実行したコマンドを確認します。",
     "summary.diffThread": "このスレッドのファイル変更を確認します。",
+    "summary.inProgress": "{provider} が現在この作業を進めています。",
     "summary.default": "項目を開いて詳細を確認します。",
     "intent.approval": "このリクエストを承認するか拒否します。",
     "intent.plan": "{provider} が続行する前にこのプランを確認します。",
@@ -1390,10 +1409,25 @@ const translations = {
     "intent.userMessage": "このメッセージを開き直します。",
     "intent.assistantCommentary": "最新の途中経過を確認します。",
     "intent.assistantFinal": "このターンの {provider} の最終回答を確認します。",
+    "intent.inProgress": "{provider} が現在この作業を進めています。",
+    "intent.draftReview": "この下書きを確認して承認します。",
+    "intent.delegationReview": "委任されたタスクを実行前に確認します。",
+    "intent.handoffReview": "送信前にこの引き継ぎ内容を確認します。",
     "timeline.allThreads": "すべて",
     "timeline.unknownThread": "不明なスレッド",
-    "inbox.subtab.pending": "未対応",
+    "inbox.subtab.today": "今日",
+    "inbox.subtab.pending": "要対応",
     "inbox.subtab.completed": "完了済み",
+    "work.section.needsAction": "要対応",
+    "work.section.inProgress": "進行中",
+    "work.section.completedToday": "今日の完了",
+    "work.today.caughtUp": "現在、対応が必要な項目はありません",
+    "work.today.emptyTitle": "対応はありません",
+    "work.today.emptyCopy": "新しい判断や進行中の仕事がここに表示されます。",
+    "work.today.viewAllCompleted": "完了済みをすべて表示（ほか {count} 件）",
+    "work.health.title": "接続の確認が必要です",
+    "work.health.connectionRequired": "{provider} に接続されていません。保留中の操作を送信できない可能性があります。",
+    "work.health.degraded": "一部の接続先を一時的に利用できません。",
     "timeline.filterLabel": "スレッドフィルター",
     "timeline.status.approved": "承認済み",
     "timeline.status.rejected": "拒否済み",

package/web/remote-pairing/api-router.js

@@ -105,6 +105,11 @@ const AUTO_STICKY_LAN_PROBE_TIMEOUT_MS = 900;
 const LAN_REACHABILITY_PROBE_TIMEOUT_MS = 700;
 const LAN_REACHABILITY_PROBE_PATH = "/health";
 const RECENT_LAN_OK_GRACE_MS = 60_000;
+const RECENT_LAN_RESTART_RECOVERY_MS = 5_000;
+const RECENT_LAN_RESTART_PROBE_INTERVAL_MS = 500;
+const COLD_LAN_RECOVERY_MS = 35_000;
+const COLD_LAN_RECOVERY_PROBE_INTERVAL_MS = 250;
+const COLD_LAN_RECOVERY_PROBE_TIMEOUT_MS = 1_500;
 const TRANSIENT_LAN_FAILURE_STICKY_MS = 8_000;
 const TRANSIENT_LAN_FAILURE_THRESHOLD = 2;
 // If LAN was healthy moments ago, a single timed-out local request is more
@@ -118,6 +123,7 @@ const RELAY_CIRCUIT_BREAKER_MS = 60_000;
 const PAIRING_STATE_STORAGE_KEY = "viveworker.remote-pairing.state";
 const PAIRING_STATE_SCHEMA_VERSION = 2;
 const PAIRING_STATE_LEGACY_SCHEMA_VERSION = 1;
+const LAN_SUCCESS_STORAGE_KEY = "viveworker.remote-pairing.last-lan-ok-at-ms";
 const ROUTING_STATUS_EVENT = "viveworker:remote-routing-status";
 
 // ---------------------------------------------------------------------------
@@ -148,6 +154,12 @@ let _lastSuccessfulRoute = null;
 /** Last time a LAN request completed successfully. */
 let _lastLanOkAtMs = 0;
 
+/** Whether a recent LAN success was restored after this PWA module loaded. */
+let _lastLanOkRestoredFromStorage = false;
+
+/** A bridge-restart recovery loop should run at most once per PWA module. */
+let _recentLanRestartRecoveryAttempted = false;
+
 /** Last time we tried a LAN probe while sticky relay was active. */
 let _lastStickyLanProbeAtMs = 0;
 
@@ -174,6 +186,49 @@ function newTelemetry() {
   };
 }
 
+function lanSuccessStorage(opts = {}) {
+  if (opts.lanSuccessStorage) {
+    return opts.lanSuccessStorage;
+  }
+  try {
+    return globalThis.localStorage ?? null;
+  } catch {
+    return null;
+  }
+}
+
+function restoreRecentLanSuccess(opts = {}, now = nowMs(opts)) {
+  if (_lastLanOkAtMs > 0 || _recentLanRestartRecoveryAttempted) {
+    return;
+  }
+  const storage = lanSuccessStorage(opts);
+  if (!storage) return;
+
+  try {
+    const atMs = Number(storage.getItem(LAN_SUCCESS_STORAGE_KEY));
+    if (!Number.isFinite(atMs) || atMs <= 0 || atMs > now || now - atMs > RECENT_LAN_OK_GRACE_MS) {
+      storage.removeItem?.(LAN_SUCCESS_STORAGE_KEY);
+      return;
+    }
+    _lastLanOkAtMs = atMs;
+    _lastLanOkRestoredFromStorage = true;
+  } catch {
+    // Storage is only a restart hint; routing remains correct without it.
+  }
+}
+
+function rememberLanSuccess(atMs, opts = {}) {
+  _lastLanOkAtMs = atMs;
+  _lastLanOkRestoredFromStorage = false;
+  const storage = lanSuccessStorage(opts);
+  if (!storage) return;
+  try {
+    storage.setItem(LAN_SUCCESS_STORAGE_KEY, String(atMs));
+  } catch {
+    // Private browsing or a full storage quota should not affect LAN routing.
+  }
+}
+
 function emitRoutingStatus(phase, opts = {}, detail = {}) {
   if (opts.suppressRoutingStatus === true) {
     return;
@@ -601,13 +656,15 @@ async function attemptLanFetch(url, init, opts) {
       ? await Promise.race([fetchPromise, timeoutPromise])
       : await fetchPromise;
     _telemetry.lanOk++;
-    _lastLanOkAtMs = nowMs(opts);
+    rememberLanSuccess(nowMs(opts), opts);
     _consecutiveLanFailures = 0;
     _lastSuccessfulRoute = "lan";
     _stickyRelayUntilMs = 0;
     _lastStickyLanProbeAtMs = 0;
     resetRelayFailureCircuit();
-    closeRelayClient("lan connected");
+    if (opts.keepRelayClientOnLanSuccess !== true) {
+      closeRelayClient("lan connected");
+    }
     emitRoutingStatus("lan-connected", opts, { url: String(url || "") });
     return { ok: true, response };
   } catch (err) {
@@ -670,16 +727,19 @@ function shouldConfirmLanReachability(now, opts = {}) {
   if (opts.confirmLanReachabilityBeforeRelay === false) {
     return false;
   }
+  if (opts.confirmLanReachabilityBeforeRelay === true) {
+    return true;
+  }
   return _lastLanOkAtMs > 0 && now - _lastLanOkAtMs <= RECENT_LAN_OK_GRACE_MS;
 }
 
-async function confirmLanUnavailableBeforeRelay(url, err, opts = {}) {
+async function recoverLanBeforeRelay(url, init, err, opts = {}) {
   if (!shouldConfirmLanReachability(nowMs(opts), opts)) {
-    return false;
+    return { recovered: false, suppressRelay: false };
   }
   const path = urlToRelayPath(url);
   if (path === LAN_REACHABILITY_PROBE_PATH) {
-    return false;
+    return { recovered: false, suppressRelay: false };
   }
 
   const probe = await attemptLanFetch(LAN_REACHABILITY_PROBE_PATH, {
@@ -691,12 +751,251 @@ async function confirmLanUnavailableBeforeRelay(url, err, opts = {}) {
     lanTimeoutMs: opts.lanReachabilityProbeTimeoutMs ?? LAN_REACHABILITY_PROBE_TIMEOUT_MS,
   });
   if (!probe.ok) {
-    return false;
+    return { recovered: false, suppressRelay: false };
+  }
+
+  if (opts.retryLanAfterReachabilityProbe === true) {
+    const retry = await attemptLanFetch(url, init, {
+      ...opts,
+      lanTimeoutMs: opts.lanRecoveryTimeoutMs ?? opts.lanTimeoutMs ?? DEFAULT_LAN_TIMEOUT_MS,
+    });
+    if (retry.ok) {
+      return { recovered: true, response: retry.response, suppressRelay: true };
+    }
   }
 
   _telemetry.lanReachableAfterFailure++;
   suppressRelayAfterRecentLanFailure(url, err, opts);
-  return true;
+  return { recovered: false, suppressRelay: true };
+}
+
+function shouldRecoverRecentLanAfterRestart(now, opts = {}) {
+  if (opts.recoverRecentLanAfterRestart === false) return false;
+  if (!_lastLanOkRestoredFromStorage || _recentLanRestartRecoveryAttempted) return false;
+  return _lastLanOkAtMs > 0 && now - _lastLanOkAtMs <= RECENT_LAN_OK_GRACE_MS;
+}
+
+function waitForLanRecoveryDelay(ms, signal) {
+  const delayMs = Math.max(0, Number(ms) || 0);
+  if (signal?.aborted) {
+    return Promise.reject(abortError(signal));
+  }
+  return new Promise((resolve, reject) => {
+    let timer = null;
+    const onAbort = () => {
+      if (timer) clearTimeout(timer);
+      signal?.removeEventListener?.("abort", onAbort);
+      reject(abortError(signal));
+    };
+    timer = setTimeout(() => {
+      signal?.removeEventListener?.("abort", onAbort);
+      resolve();
+    }, delayMs);
+    signal?.addEventListener?.("abort", onAbort, { once: true });
+  });
+}
+
+async function recoverRecentLanAfterRestart(url, init, opts = {}) {
+  const startedAtMs = nowMs(opts);
+  if (!shouldRecoverRecentLanAfterRestart(startedAtMs, opts)) {
+    return { recovered: false };
+  }
+  _recentLanRestartRecoveryAttempted = true;
+
+  const recoveryWindowMs = Math.max(
+    0,
+    Number(opts.recentLanRestartRecoveryMs ?? RECENT_LAN_RESTART_RECOVERY_MS) || 0,
+  );
+  const deadlineMs = startedAtMs + recoveryWindowMs;
+  const path = urlToRelayPath(url);
+
+  while (true) {
+    const probe = await attemptLanFetch(LAN_REACHABILITY_PROBE_PATH, {
+      cache: "no-store",
+      credentials: "same-origin",
+      headers: { Accept: "application/json" },
+    }, {
+      ...opts,
+      lanTimeoutMs: opts.lanReachabilityProbeTimeoutMs ?? LAN_REACHABILITY_PROBE_TIMEOUT_MS,
+    });
+    if (probe.ok) {
+      if (path === LAN_REACHABILITY_PROBE_PATH) {
+        return { recovered: true, response: probe.response };
+      }
+      const retry = await attemptLanFetch(url, init, {
+        ...opts,
+        lanTimeoutMs: opts.lanRecoveryTimeoutMs ?? opts.lanTimeoutMs ?? DEFAULT_LAN_TIMEOUT_MS,
+      });
+      if (retry.ok) {
+        return { recovered: true, response: retry.response };
+      }
+    }
+
+    const remainingMs = deadlineMs - nowMs(opts);
+    if (remainingMs <= 0) {
+      return { recovered: false };
+    }
+    await waitForLanRecoveryDelay(
+      Math.min(RECENT_LAN_RESTART_PROBE_INTERVAL_MS, remainingMs),
+      init.signal,
+    );
+  }
+}
+
+function createLinkedAbortScope(parentSignal) {
+  if (typeof AbortController === "undefined") {
+    return {
+      signal: parentSignal,
+      abort() {},
+      cleanup() {},
+    };
+  }
+
+  const controller = new AbortController();
+  const onParentAbort = () => controller.abort(parentSignal?.reason);
+  if (parentSignal?.aborted) {
+    onParentAbort();
+  } else {
+    parentSignal?.addEventListener?.("abort", onParentAbort, { once: true });
+  }
+  return {
+    signal: controller.signal,
+    abort(reason) {
+      if (!controller.signal.aborted) controller.abort(reason);
+    },
+    cleanup() {
+      parentSignal?.removeEventListener?.("abort", onParentAbort);
+    },
+  };
+}
+
+function routeWinnerAbortError() {
+  const err = new Error("alternate route connected");
+  err.name = "AbortError";
+  return err;
+}
+
+async function settleRouteAttempt(route, promise) {
+  try {
+    return { route, ...(await promise) };
+  } catch (err) {
+    return { route, ok: false, err };
+  }
+}
+
+async function recoverColdLanWhileRelayConnects(url, init, initialErr, opts = {}) {
+  const startedAtMs = nowMs(opts);
+  const recoveryWindowMs = Math.max(
+    0,
+    Number(opts.coldLanRecoveryMs ?? COLD_LAN_RECOVERY_MS) || 0,
+  );
+  const deadlineMs = startedAtMs + recoveryWindowMs;
+  const path = urlToRelayPath(url);
+  let lastErr = initialErr;
+
+  while (true) {
+    const probe = await attemptLanFetch(LAN_REACHABILITY_PROBE_PATH, {
+      cache: "no-store",
+      credentials: "same-origin",
+      headers: { Accept: "application/json" },
+      signal: init.signal,
+    }, {
+      ...opts,
+      keepRelayClientOnLanSuccess: true,
+      lanTimeoutMs: opts.lanReachabilityProbeTimeoutMs ?? COLD_LAN_RECOVERY_PROBE_TIMEOUT_MS,
+    });
+    if (probe.ok) {
+      if (path === LAN_REACHABILITY_PROBE_PATH) {
+        return { ok: true, response: probe.response };
+      }
+      const retry = await attemptLanFetch(url, init, {
+        ...opts,
+        lanTimeoutMs: opts.lanRecoveryTimeoutMs ?? opts.lanTimeoutMs ?? DEFAULT_LAN_TIMEOUT_MS,
+      });
+      if (retry.ok) {
+        return { ok: true, response: retry.response };
+      }
+      lastErr = retry.err;
+    } else {
+      lastErr = probe.err;
+    }
+
+    const remainingMs = deadlineMs - nowMs(opts);
+    if (remainingMs <= 0) {
+      return { ok: false, err: lastErr };
+    }
+    await waitForLanRecoveryDelay(
+      Math.min(
+        Math.max(0, Number(opts.coldLanRecoveryProbeIntervalMs ?? COLD_LAN_RECOVERY_PROBE_INTERVAL_MS) || 0),
+        remainingMs,
+      ),
+      init.signal,
+    );
+  }
+}
+
+async function raceRelayWithColdLanRecovery(url, init, initialLanErr, opts = {}) {
+  const lanScope = createLinkedAbortScope(init.signal);
+  const relayScope = createLinkedAbortScope(init.signal);
+  const lanInit = { ...init, signal: lanScope.signal };
+  const relayInit = { ...init, signal: relayScope.signal };
+  let lanResult = null;
+  let relayResult = null;
+
+  try {
+    const lanPromise = settleRouteAttempt(
+      "lan",
+      recoverColdLanWhileRelayConnects(url, lanInit, initialLanErr, opts),
+    );
+    emitRoutingStatus("remote-switching", opts, { url: String(url || ""), sticky: false });
+    const relayPromise = settleRouteAttempt("relay", attemptRelayFetch(url, relayInit, opts));
+    const first = await Promise.race([lanPromise, relayPromise]);
+
+    if (first.route === "lan") lanResult = first;
+    else relayResult = first;
+
+    if (first.ok) {
+      if (first.route === "lan") {
+        relayScope.abort(routeWinnerAbortError());
+        closeRelayClient("LAN recovery won route race");
+      } else {
+        lanScope.abort(routeWinnerAbortError());
+      }
+      return { ok: true, response: first.response, route: first.route };
+    }
+
+    const second = await (first.route === "lan" ? relayPromise : lanPromise);
+    if (second.route === "lan") lanResult = second;
+    else relayResult = second;
+    if (second.ok) {
+      if (second.route === "lan") {
+        relayScope.abort(routeWinnerAbortError());
+        closeRelayClient("LAN recovery won route race");
+      } else {
+        lanScope.abort(routeWinnerAbortError());
+      }
+      return { ok: true, response: second.response, route: second.route };
+    }
+
+    return {
+      ok: false,
+      lanErr: lanResult?.err || initialLanErr,
+      relayErr: relayResult?.err || null,
+    };
+  } finally {
+    lanScope.cleanup();
+    relayScope.cleanup();
+  }
+}
+
+function throwRouteRaceFailure(result, opts = {}) {
+  if (isRemotePairingEnrollmentRequiredError(result.relayErr)) {
+    throw result.relayErr;
+  }
+  if (opts.preferRelayError && result.relayErr) {
+    throw result.relayErr;
+  }
+  throw result.lanErr || result.relayErr || new TypeError("LAN and relay unavailable");
 }
 
 async function attemptStickyLanProbe(url, init, opts) {
@@ -980,8 +1279,17 @@ function nowMs(opts) {
  *   autoProbeLanWhileSticky?: boolean,
  *   delayRelayAfterRecentLanFailure?: boolean,
  *   confirmLanReachabilityBeforeRelay?: boolean,
+ *   retryLanAfterReachabilityProbe?: boolean,
+ *   lanRecoveryTimeoutMs?: number,
+ *   lanAfterRelayFailureTimeoutMs?: number,
  *   stickyLanProbeTimeoutMs?: number,
  *   lanReachabilityProbeTimeoutMs?: number,
+ *   recoverRecentLanAfterRestart?: boolean,
+ *   recentLanRestartRecoveryMs?: number,
+ *   raceLanRecoveryWithRelay?: boolean,
+ *   coldLanRecoveryMs?: number,
+ *   coldLanRecoveryProbeIntervalMs?: number,
+ *   lanSuccessStorage?: Storage,
  * }} [opts]
  * @returns {Promise<{
  *   ok: boolean,
@@ -994,17 +1302,31 @@ function nowMs(opts) {
  */
 export async function routedFetch(url, init = {}, opts = {}) {
   const t = nowMs(opts);
+  restoreRecentLanSuccess(opts, t);
 
   // Sticky-relay path: LAN just failed, prefer relay for a while.
   if (_stickyRelayUntilMs > t) {
+    if (opts.raceLanRecoveryWithRelay === true) {
+      const lan = await attemptLanFetch(url, init, opts);
+      if (lan.ok) return lan.response;
+      const recovery = await recoverLanBeforeRelay(url, init, lan.err, opts);
+      if (recovery.recovered) return recovery.response;
+      const raced = await raceRelayWithColdLanRecovery(url, init, lan.err, opts);
+      if (raced.ok) return raced.response;
+      return throwRouteRaceFailure(raced, opts);
+    }
     if (shouldDelayRelayAfterRecentLanFailure(t, opts)) {
       const lan = await attemptLanFetch(url, init, opts);
       if (lan.ok) return lan.response;
+      const restartRecovery = await recoverRecentLanAfterRestart(url, init, opts);
+      if (restartRecovery.recovered) return restartRecovery.response;
       if (shouldDelayRelayAfterRecentLanFailure(nowMs(opts), opts)) {
         suppressRelayAfterRecentLanFailure(url, lan.err, opts);
         throw lan.err;
       }
-      if (await confirmLanUnavailableBeforeRelay(url, lan.err, opts)) {
+      const recovery = await recoverLanBeforeRelay(url, init, lan.err, opts);
+      if (recovery.recovered) return recovery.response;
+      if (recovery.suppressRelay) {
         throw lan.err;
       }
     }
@@ -1012,7 +1334,9 @@ export async function routedFetch(url, init = {}, opts = {}) {
     if (opts.probeLanWhileSticky === true || autoProbe) {
       const lan = await attemptStickyLanProbe(url, init, stickyLanProbeOpts(opts, autoProbe));
       if (lan.ok) return lan.response;
-      if (await confirmLanUnavailableBeforeRelay(url, lan.err, opts)) {
+      const recovery = await recoverLanBeforeRelay(url, init, lan.err, opts);
+      if (recovery.recovered) return recovery.response;
+      if (recovery.suppressRelay) {
         throw lan.err;
       }
     }
@@ -1034,11 +1358,22 @@ export async function routedFetch(url, init = {}, opts = {}) {
   // Happy path: LAN first.
   const lan = await attemptLanFetch(url, init, opts);
   if (lan.ok) return lan.response;
+  if (opts.raceLanRecoveryWithRelay === true) {
+    const recovery = await recoverLanBeforeRelay(url, init, lan.err, opts);
+    if (recovery.recovered) return recovery.response;
+    const raced = await raceRelayWithColdLanRecovery(url, init, lan.err, opts);
+    if (raced.ok) return raced.response;
+    return throwRouteRaceFailure(raced, opts);
+  }
+  const restartRecovery = await recoverRecentLanAfterRestart(url, init, opts);
+  if (restartRecovery.recovered) return restartRecovery.response;
   if (shouldDelayRelayAfterRecentLanFailure(nowMs(opts), opts)) {
     suppressRelayAfterRecentLanFailure(url, lan.err, opts);
     throw lan.err;
   }
-  if (await confirmLanUnavailableBeforeRelay(url, lan.err, opts)) {
+  const recovery = await recoverLanBeforeRelay(url, init, lan.err, opts);
+  if (recovery.recovered) return recovery.response;
+  if (recovery.suppressRelay) {
     throw lan.err;
   }
 
@@ -1046,10 +1381,18 @@ export async function routedFetch(url, init = {}, opts = {}) {
   emitRoutingStatus("remote-switching", opts, { url: String(url || ""), sticky: false });
   const r = await attemptRelayFetch(url, init, opts);
   if (r.ok) return r.response;
+  // The bridge may have finished restarting while the relay handshake was
+  // failing. Give the direct LAN route one final chance before surfacing an
+  // off-LAN error, even when this request prefers relay diagnostics.
+  const lanAfterRelay = await attemptLanFetch(url, init, {
+    ...opts,
+    lanTimeoutMs: opts.lanAfterRelayFailureTimeoutMs ?? opts.lanRecoveryTimeoutMs ?? DEFAULT_LAN_TIMEOUT_MS,
+  });
+  if (lanAfterRelay.ok) return lanAfterRelay.response;
   if (isRemotePairingEnrollmentRequiredError(r.err)) throw r.err;
   if (opts.preferRelayError && r.err) throw r.err;
 
-  throw lan.err;
+  throw lanAfterRelay.err;
 }
 
 /**
@@ -1094,6 +1437,8 @@ export function __resetForTest() {
   _lastPairingStateStatus = null;
   _lastSuccessfulRoute = null;
   _lastLanOkAtMs = 0;
+  _lastLanOkRestoredFromStorage = false;
+  _recentLanRestartRecoveryAttempted = false;
   _lastStickyLanProbeAtMs = 0;
   _consecutiveLanFailures = 0;
   _relayFailureAtMs = [];

package/web/remote-pairing/transport.js

@@ -539,7 +539,10 @@ export class RemotePairingTransport {
     if (this._closed) return;          // user-initiated; close() already settled
     if (this._state === STATE.FAILED) return; // already terminal
 
+    const stateBeforeClose = this._state;
     const isRelayReset = Number(evt?.code) === CLOSE_RELAY_RESET_SESSION;
+    const relayResetDuringNegotiation =
+      isRelayReset && (stateBeforeClose === STATE.HANDSHAKING || stateBeforeClose === STATE.RESUMING);
     if (isRelayReset) {
       this._log.debug?.(`relay requested fresh handshake reason=${evt?.reason || ""}`);
       this._dropNoiseState();
@@ -547,7 +550,10 @@ export class RemotePairingTransport {
 
     this._log.debug?.(`ws closed code=${evt?.code} reason=${evt?.reason}`);
     this._setState(STATE.DISCONNECTED, { code: evt?.code, reason: evt?.reason });
-    if (Number(evt?.code) !== CLOSE_NORMAL) {
+    // A 4004 while handshaking/resuming is the relay coordinating a normal
+    // state reset after one peer restarted. Counting it towards the reconnect
+    // circuit turns two expected reset hops into minutes of needless outage.
+    if (Number(evt?.code) !== CLOSE_NORMAL && !relayResetDuringNegotiation) {
       this._recordReconnectFailure({
         code: Number(evt?.code) || 0,
         reason: String(evt?.reason || ""),