@agent-native/core 0.90.9 → 0.90.11

package/corpus/templates/clips/desktop/src/app.tsx

@@ -81,7 +81,14 @@ import {
   saveBool,
   saveString,
 } from "./lib/storage";
-import { installAndRestart, isUpdatePendingRestart } from "./lib/updater";
+import {
+  canCheckForUpdates,
+  installAndRestart,
+  isUpdatePendingRestart,
+  retryUpdateCheck,
+  useUpdateStatus,
+  type UpdateStatus,
+} from "./lib/updater";
 import { normalizeServerUrl } from "./lib/url";
 import {
   installDesktopVoiceDictation,
@@ -3521,6 +3528,25 @@ function formatStorageBytes(bytes: number): string {
   return `${Math.max(1, Math.round(mb))} MB`;
 }
 
+function desktopUpdateStatusText(status: UpdateStatus): string {
+  switch (status.state) {
+    case "idle":
+      return "Clips checks automatically after launch and every 4 hours.";
+    case "checking":
+      return "Checking for updates...";
+    case "not-available":
+      return "Clips is up to date.";
+    case "available":
+      return `Update ${status.version} found. Downloading now...`;
+    case "downloading":
+      return `Downloading update ${status.version}... ${status.percent}%`;
+    case "downloaded":
+      return `Update ${status.version} is ready. Restart to install it.`;
+    case "error":
+      return `Update check failed: ${status.message}`;
+  }
+}
+
 function Setup({
   initial,
   serverUrl,
@@ -3568,8 +3594,8 @@ function Setup({
 }) {
   const [url, setUrl] = useState(initial ?? DEFAULT_URL);
   const [readinessOpen, setReadinessOpen] = useState(false);
-  const inputRef = useRef<HTMLInputElement | null>(null);
   const featureConfig = useFeatureConfig();
+  const updateStatus = useUpdateStatus();
   const voiceEnabled = featureConfig?.voiceEnabled !== false;
   const meetingsEnabled = featureConfig?.meetingsEnabled !== false;
   const launchAtLoginEnabled = featureConfig?.launchAtLoginEnabled !== false;
@@ -3868,10 +3894,6 @@ function Setup({
     );
   }
 
-  useEffect(() => {
-    inputRef.current?.focus();
-  }, []);
-
   useEffect(() => {
     let cancelled = false;
     const refresh = () => {
@@ -4134,6 +4156,32 @@ function Setup({
     if (providerStatus[byokProvider]) return null;
     return `${keyForByokProvider(byokProvider)} is not set — cleanup will fail until configured.`;
   })();
+  const updateChecksSupported = canCheckForUpdates();
+  const updateBusy =
+    updateStatus.state === "checking" ||
+    updateStatus.state === "available" ||
+    updateStatus.state === "downloading";
+  const updateReady = updateStatus.state === "downloaded";
+  const updateStatusClass =
+    updateStatus.state === "error"
+      ? "setup-warning"
+      : updateStatus.state === "downloaded" ||
+          updateStatus.state === "not-available"
+        ? "setup-success"
+        : "setup-hint";
+  const updateCheckLabel = !updateChecksSupported
+    ? "Release builds only"
+    : updateStatus.state === "checking"
+      ? "Checking..."
+      : updateStatus.state === "downloading"
+        ? `Downloading ${updateStatus.percent}%`
+        : "Check now";
+
+  function checkForDesktopUpdate() {
+    retryUpdateCheck().catch((err) => {
+      console.error("[clips-updater] manual check failed:", err);
+    });
+  }
 
   return (
     <form className="setup" onSubmit={handleSubmit}>
@@ -4161,13 +4209,12 @@ function Setup({
         />
         <input
           id="clips-url"
-          ref={inputRef}
           type="url"
           value={url}
           onChange={(e) => setUrl(e.target.value)}
           placeholder="http://localhost:8080"
         />
-        <button className="primary" type="submit">
+        <button className="secondary setup-connect-button" type="submit">
           Connect
         </button>
       </div>
@@ -4214,6 +4261,46 @@ function Setup({
         </div>
       </div>
 
+      <div className="setup-section">
+        <SettingLabel
+          label="Desktop updates"
+          hint="Check the signed Clips desktop release channel and download any available update."
+        />
+        <div className="setup-button-row">
+          <button
+            type="button"
+            className="secondary"
+            onClick={checkForDesktopUpdate}
+            disabled={!updateChecksSupported || updateBusy || updateReady}
+          >
+            <IconRefresh
+              size={15}
+              stroke={1.9}
+              className={updateBusy ? "update-spinner" : undefined}
+            />
+            {updateCheckLabel}
+          </button>
+          {updateReady ? (
+            <button
+              type="button"
+              className="secondary"
+              onClick={() => {
+                installAndRestart().catch((err) => {
+                  console.error("[clips-updater] relaunch failed:", err);
+                });
+              }}
+            >
+              Restart to install
+            </button>
+          ) : null}
+        </div>
+        <p className={updateStatusClass}>
+          {updateChecksSupported
+            ? desktopUpdateStatusText(updateStatus)
+            : "Update checks are available in signed release builds."}
+        </p>
+      </div>
+
       <div className="setup-section-heading">Permissions</div>
 
       <div className="setup-section">

package/corpus/templates/clips/desktop/src/lib/updater.ts

@@ -26,6 +26,13 @@ let cachedStatus: UpdateStatus = { state: "idle" };
 let pendingUpdate: Update | null = null;
 const listeners = new Set<StatusListener>();
 let started = false;
+let checkInFlight: Promise<void> | null = null;
+
+function canRunUpdateChecks() {
+  // Dev and local release builds are for testing the current checkout. Do not
+  // replace them with the published auto-update channel.
+  return !import.meta.env.DEV && !__CLIPS_DESKTOP_LOCAL_BUILD__;
+}
 
 function setStatus(next: UpdateStatus) {
   cachedStatus = next;
@@ -33,55 +40,60 @@ function setStatus(next: UpdateStatus) {
 }
 
 async function runCheck() {
-  try {
-    setStatus({ state: "checking" });
-    const update = await check();
-    if (!update) {
-      setStatus({ state: "not-available" });
-      return;
-    }
-    pendingUpdate = update;
-    const version = update.version;
-    const notes = update.body ?? undefined;
-    setStatus({ state: "available", version, notes });
-
-    // Download ONLY — do not install here. On macOS `install` swaps the .app
-    // bundle on disk while this process keeps running, which invalidates the
-    // running process's Screen Recording (TCC) grant and breaks capture until
-    // relaunch. We defer the swap to `installAndRestart()` so a downloaded-but-
-    // not-yet-installed update leaves the running app fully functional; the
-    // user records normally until they choose to restart.
-    let total = 0;
-    let downloaded = 0;
-    await update.download((event) => {
-      if (event.event === "Started") {
-        total = event.data.contentLength ?? 0;
-        downloaded = 0;
-        setStatus({ state: "downloading", version, notes, percent: 0 });
-      } else if (event.event === "Progress") {
-        downloaded += event.data.chunkLength;
-        const percent =
-          total > 0 ? Math.min(100, Math.round((downloaded / total) * 100)) : 0;
-        setStatus({ state: "downloading", version, notes, percent });
-      } else if (event.event === "Finished") {
-        setStatus({ state: "downloaded", version, notes });
+  if (checkInFlight) return checkInFlight;
+
+  checkInFlight = (async () => {
+    try {
+      setStatus({ state: "checking" });
+      const update = await check();
+      if (!update) {
+        setStatus({ state: "not-available" });
+        return;
       }
-    });
-  } catch (err) {
-    const message = err instanceof Error ? err.message : String(err);
-    setStatus({ state: "error", message });
-  }
+      pendingUpdate = update;
+      const version = update.version;
+      const notes = update.body ?? undefined;
+      setStatus({ state: "available", version, notes });
+
+      // Download ONLY — do not install here. On macOS `install` swaps the .app
+      // bundle on disk while this process keeps running, which invalidates the
+      // running process's Screen Recording (TCC) grant and breaks capture until
+      // relaunch. We defer the swap to `installAndRestart()` so a downloaded-but-
+      // not-yet-installed update leaves the running app fully functional; the
+      // user records normally until they choose to restart.
+      let total = 0;
+      let downloaded = 0;
+      await update.download((event) => {
+        if (event.event === "Started") {
+          total = event.data.contentLength ?? 0;
+          downloaded = 0;
+          setStatus({ state: "downloading", version, notes, percent: 0 });
+        } else if (event.event === "Progress") {
+          downloaded += event.data.chunkLength;
+          const percent =
+            total > 0
+              ? Math.min(100, Math.round((downloaded / total) * 100))
+              : 0;
+          setStatus({ state: "downloading", version, notes, percent });
+        } else if (event.event === "Finished") {
+          setStatus({ state: "downloaded", version, notes });
+        }
+      });
+    } catch (err) {
+      const message = err instanceof Error ? err.message : String(err);
+      setStatus({ state: "error", message });
+    } finally {
+      checkInFlight = null;
+    }
+  })();
+
+  return checkInFlight;
 }
 
 function startUpdateLoop() {
   if (started) return;
   started = true;
-  // Skip update checks in dev — there's no release endpoint to check.
-  if (import.meta.env.DEV) return;
-  // Local release builds are for testing the current checkout. Do not replace
-  // them with the published auto-update channel just because package.json has
-  // a lower development version.
-  if (__CLIPS_DESKTOP_LOCAL_BUILD__) return;
+  if (!canRunUpdateChecks()) return;
   // Check 3s after launch (let the popover finish first paint), then every
   // 4 hours. Matches the cadence used by the Electron app.
   setTimeout(runCheck, 3000);
@@ -125,11 +137,16 @@ export function isUpdatePendingRestart(): boolean {
   return cachedStatus.state === "downloaded";
 }
 
+export function canCheckForUpdates(): boolean {
+  return canRunUpdateChecks();
+}
+
 /**
  * Manual retry entry point. Used by the UpdateBanner's error state to let
  * users re-attempt after a signature-verification / download / network
  * failure. Runs a full check + download pass, same as the periodic loop.
  */
 export function retryUpdateCheck(): Promise<void> {
+  if (!canRunUpdateChecks()) return Promise.resolve();
   return runCheck();
 }

package/corpus/templates/clips/desktop/src/styles.css

@@ -835,6 +835,11 @@ body[data-clips-route="recording-pill"] #root {
   cursor: not-allowed;
 }
 
+.setup-connect-button {
+  height: 38px;
+  margin-top: 2px;
+}
+
 .primary.start {
   margin-top: 2px;
 }

package/corpus/templates/clips/desktop/src-tauri/src/shortcuts.rs

@@ -624,6 +624,32 @@ fn ensure_fn_event_tap(app: tauri::AppHandle) {
     install_fn_event_tap(app);
 }
 
+#[cfg(target_os = "macos")]
+fn fn_event_tap_is_enabled(tap: &core_graphics::event::CGEventTap<'static>) -> bool {
+    use core_foundation::base::TCFType;
+
+    extern "C" {
+        fn CGEventTapIsEnabled(tap: core_foundation::mach_port::CFMachPortRef) -> bool;
+    }
+
+    unsafe { CGEventTapIsEnabled(tap.mach_port().as_concrete_TypeRef()) }
+}
+
+#[cfg(target_os = "macos")]
+fn schedule_fn_event_tap_restart(app: tauri::AppHandle, reason: &'static str, delay: Duration) {
+    eprintln!("[clips-tray][fn-tap] restarting Fn event tap: {reason}");
+    FN_TAP_INSTALL_STARTED.store(false, Ordering::SeqCst);
+    if !FN_TAP_ENABLED.load(Ordering::SeqCst) {
+        return;
+    }
+    thread::spawn(move || {
+        thread::sleep(delay);
+        if FN_TAP_ENABLED.load(Ordering::SeqCst) {
+            ensure_fn_event_tap(app);
+        }
+    });
+}
+
 #[cfg(target_os = "macos")]
 fn install_fn_event_tap(app: tauri::AppHandle) {
     use std::sync::atomic::{AtomicBool, AtomicU64, Ordering};
@@ -631,7 +657,9 @@ fn install_fn_event_tap(app: tauri::AppHandle) {
     use std::thread;
     use std::time::Duration;
 
-    use core_foundation::runloop::{kCFRunLoopCommonModes, CFRunLoop};
+    use core_foundation::runloop::{
+        kCFRunLoopCommonModes, kCFRunLoopDefaultMode, CFRunLoop, CFRunLoopRunResult,
+    };
     use core_graphics::event::{
         CGEventFlags, CGEventTap, CGEventTapLocation, CGEventTapOptions, CGEventTapPlacement,
         CGEventType, CallbackResult,
@@ -836,7 +864,6 @@ fn install_fn_event_tap(app: tauri::AppHandle) {
                     t
                 }
                 Err(()) => {
-                    FN_TAP_INSTALL_STARTED.store(false, Ordering::SeqCst);
                     eprintln!(
                         "[clips-tray][fn-tap] CGEventTapCreate returned NULL. Most likely cause: \
                          Input Monitoring is not granted to Clips. Open System Settings → \
@@ -844,6 +871,11 @@ fn install_fn_event_tap(app: tauri::AppHandle) {
                          terminal running `tauri dev`). Note: Accessibility is a separate \
                          permission and is not sufficient for ListenOnly taps."
                     );
+                    schedule_fn_event_tap_restart(
+                        app,
+                        "CGEventTapCreate returned NULL",
+                        Duration::from_secs(5),
+                    );
                     return;
                 }
             };
@@ -853,8 +885,12 @@ fn install_fn_event_tap(app: tauri::AppHandle) {
                     s
                 }
                 Err(()) => {
-                    FN_TAP_INSTALL_STARTED.store(false, Ordering::SeqCst);
                     eprintln!("[clips-tray][fn-tap] CFMachPortCreateRunLoopSource failed");
+                    schedule_fn_event_tap_restart(
+                        app,
+                        "CFMachPortCreateRunLoopSource failed",
+                        Duration::from_secs(2),
+                    );
                     return;
                 }
             };
@@ -865,29 +901,63 @@ fn install_fn_event_tap(app: tauri::AppHandle) {
                 "[clips-tray][fn-tap] tap enabled; entering runloop — press Fn now to test"
             );
 
-            // Run the runloop in repeated short bursts so we can re-enable
-            // the tap if the OS disables it. We use run_current (blocks
-            // until something stops the loop) and re-enter on exit. The
-            // disable callbacks above call CFRunLoop::stop, which makes
-            // run_current return; we then call tap.enable() and re-enter.
-            // This is the handy-keys / linespeed pattern.
+            // Run the runloop in short slices instead of `run_current()`.
+            // macOS can leave a tap created but disabled/inert after TCC or
+            // user-input churn; periodic health checks let us re-enable or
+            // rebuild it even when no further callback arrives.
+            let mut consecutive_reenable_failures = 0_u8;
             loop {
-                if needs_reenable.swap(false, Ordering::SeqCst) {
-                    dlog!("[clips-tray] re-enabling Fn event tap");
+                if !FN_TAP_ENABLED.load(Ordering::SeqCst) {
+                    FN_TAP_INSTALL_STARTED.store(false, Ordering::SeqCst);
+                    return;
+                }
+
+                let reenable_reason = if needs_reenable.swap(false, Ordering::SeqCst) {
+                    Some("disabled callback")
+                } else if !fn_event_tap_is_enabled(&tap) {
+                    Some("health check")
+                } else {
+                    None
+                };
+
+                if let Some(reason) = reenable_reason {
+                    eprintln!("[clips-tray][fn-tap] re-enabling Fn event tap ({reason})");
                     tap.enable();
+                    thread::sleep(Duration::from_millis(20));
+                    if fn_event_tap_is_enabled(&tap) {
+                        consecutive_reenable_failures = 0;
+                    } else {
+                        consecutive_reenable_failures =
+                            consecutive_reenable_failures.saturating_add(1);
+                        if consecutive_reenable_failures >= 2 {
+                            schedule_fn_event_tap_restart(
+                                app.clone(),
+                                "tapEnable did not stick",
+                                Duration::from_millis(750),
+                            );
+                            return;
+                        }
+                    }
                 }
-                CFRunLoop::run_current();
-                // run_current returned — either we asked it to (a disable
-                // event flagged needs_reenable above), or something else
-                // removed our source. In the latter case avoid a tight
-                // spin, then re-call enable() defensively (it's idempotent
-                // — calling on an already-enabled tap is a no-op).
-                if !needs_reenable.load(Ordering::SeqCst) {
-                    thread::sleep(Duration::from_millis(50));
-                    dlog!(
-                        "[clips-tray] Fn runloop exited unexpectedly — re-enabling tap"
-                    );
-                    needs_reenable.store(true, Ordering::SeqCst);
+
+                match unsafe {
+                    CFRunLoop::run_in_mode(
+                        kCFRunLoopDefaultMode,
+                        Duration::from_millis(500),
+                        true,
+                    )
+                } {
+                    CFRunLoopRunResult::Finished => {
+                        schedule_fn_event_tap_restart(
+                            app.clone(),
+                            "runloop finished",
+                            Duration::from_millis(750),
+                        );
+                        return;
+                    }
+                    CFRunLoopRunResult::Stopped
+                    | CFRunLoopRunResult::TimedOut
+                    | CFRunLoopRunResult::HandledSource => {}
                 }
             }
         })

package/corpus/templates/dispatch/changelog/2026-07-07-overview-is-now-just-ask-dispatch-and-a-list-of-apps.md

@@ -0,0 +1,6 @@
+---
+type: improved
+date: 2026-07-07
+---
+
+Overview is now just Ask Dispatch and a list of apps you can open.

package/dist/agent/durable-background.d.ts

@@ -103,7 +103,7 @@ export declare function isHostedRuntimeForDurableBackground(): boolean;
  */
 export declare function isInBackgroundFunctionRuntime(): boolean;
 export declare function backgroundRunMarkerExpectsBackgroundRuntime(marker: unknown): boolean;
-export declare function shouldUseBackgroundFunctionTimeoutForWorker(marker: unknown): boolean;
+export declare function shouldUseBackgroundFunctionTimeoutForWorker(_marker: unknown): boolean;
 export declare function backgroundRuntimeDiagnosticDetail(marker: unknown): string;
 /**
  * The single gate. True when the env flag is explicitly enabled, or a workspace

package/dist/agent/durable-background.d.ts.map

@@ -1 +1 @@
-{"version":3,"file":"durable-background.d.ts","sourceRoot":"","sources":["../../src/agent/durable-background.ts"],"names":[],"mappings":"AAgDA;;;;GAIG;AACH,eAAO,MAAM,2BAA2B,2CACE,CAAC;AAE3C;;;;;;;;GAQG;AACH,eAAO,MAAM,8BAA8B,4BAA4B,CAAC;AAExE;;;;;;;;;GASG;AACH,eAAO,MAAM,kCAAkC,gDAA0D,CAAC;AAiC1G;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;GA8BG;AACH,wBAAgB,sCAAsC,IAAI,MAAM,CAQ/D;AAED,wBAAgB,4CAA4C,CAC1D,YAAY,EAAE,MAAM,GACnB,OAAO,CAET;AAED;;;GAGG;AACH,eAAO,MAAM,iCAAiC,kCACb,CAAC;AAElC;;;;;;GAMG;AACH,eAAO,MAAM,+BAA+B,oBAAoB,CAAC;AAEjE;;;;GAIG;AACH,wBAAgB,mCAAmC,IAAI,OAAO,CAsB7D;AAED;;;;;;;;;;;;;;;;;;;;;;;GAuBG;AACH,wBAAgB,6BAA6B,IAAI,OAAO,CAsBvD;AAED,wBAAgB,2CAA2C,CACzD,MAAM,EAAE,OAAO,GACd,OAAO,CAOT;AAED,wBAAgB,2CAA2C,CACzD,MAAM,EAAE,OAAO,GACd,OAAO,CAKT;AAED,wBAAgB,iCAAiC,CAAC,MAAM,EAAE,OAAO,GAAG,MAAM,CAQzE;AAwCD;;;;;;;GAOG;AACH,wBAAgB,mCAAmC,CAAC,OAAO,CAAC,EAAE;IAC5D,QAAQ,CAAC,EAAE,OAAO,CAAC;CACpB,GAAG,OAAO,CAWV;AAED;;;;;;;GAOG;AACH,eAAO,MAAM,oCAAoC,qCACb,CAAC;AAiBrC;;;;;;;;;;;;;;;;;;GAkBG;AACH,wBAAgB,qCAAqC,IAAI,OAAO,CAM/D;AAED,uDAAuD;AACvD,MAAM,MAAM,qBAAqB,GAC7B;IACE,EAAE,EAAE,IAAI,CAAC;IACT,+DAA+D;IAC/D,KAAK,EAAE,MAAM,CAAC;IACd,4EAA4E;IAC5E,IAAI,EAAE,MAAM,CAAC,MAAM,EAAE,OAAO,CAAC,CAAC;CAC/B,GACD;IACE,EAAE,EAAE,KAAK,CAAC;IACV,2CAA2C;IAC3C,MAAM,EAAE,MAAM,CAAC;IACf,qBAAqB;IACrB,KAAK,EAAE,MAAM,CAAC;IACd;;;;;;OAMG;IACH,KAAK,EAAE,MAAM,GAAG,IAAI,CAAC;CACtB,CAAC;AAEN;;;;;GAKG;AACH,wBAAgB,mBAAmB,CAAC,IAAI,EAAE,OAAO,GAAG,MAAM,GAAG,IAAI,CAahE;AAED;;;;;;;;;;;;;;;GAeG;AACH,wBAAgB,wBAAwB,CACtC,IAAI,EAAE,OAAO,EACb,UAAU,EAAE,MAAM,GAAG,SAAS,GAC7B,qBAAqB,CAiDvB"}
+{"version":3,"file":"durable-background.d.ts","sourceRoot":"","sources":["../../src/agent/durable-background.ts"],"names":[],"mappings":"AAgDA;;;;GAIG;AACH,eAAO,MAAM,2BAA2B,2CACE,CAAC;AAE3C;;;;;;;;GAQG;AACH,eAAO,MAAM,8BAA8B,4BAA4B,CAAC;AAExE;;;;;;;;;GASG;AACH,eAAO,MAAM,kCAAkC,gDAA0D,CAAC;AAiC1G;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;GA8BG;AACH,wBAAgB,sCAAsC,IAAI,MAAM,CAQ/D;AAED,wBAAgB,4CAA4C,CAC1D,YAAY,EAAE,MAAM,GACnB,OAAO,CAET;AAED;;;GAGG;AACH,eAAO,MAAM,iCAAiC,kCACb,CAAC;AAElC;;;;;;GAMG;AACH,eAAO,MAAM,+BAA+B,oBAAoB,CAAC;AAEjE;;;;GAIG;AACH,wBAAgB,mCAAmC,IAAI,OAAO,CAsB7D;AAED;;;;;;;;;;;;;;;;;;;;;;;GAuBG;AACH,wBAAgB,6BAA6B,IAAI,OAAO,CAsBvD;AAED,wBAAgB,2CAA2C,CACzD,MAAM,EAAE,OAAO,GACd,OAAO,CAOT;AAED,wBAAgB,2CAA2C,CACzD,OAAO,EAAE,OAAO,GACf,OAAO,CAKT;AAED,wBAAgB,iCAAiC,CAAC,MAAM,EAAE,OAAO,GAAG,MAAM,CAQzE;AAwCD;;;;;;;GAOG;AACH,wBAAgB,mCAAmC,CAAC,OAAO,CAAC,EAAE;IAC5D,QAAQ,CAAC,EAAE,OAAO,CAAC;CACpB,GAAG,OAAO,CAWV;AAED;;;;;;;GAOG;AACH,eAAO,MAAM,oCAAoC,qCACb,CAAC;AAiBrC;;;;;;;;;;;;;;;;;;GAkBG;AACH,wBAAgB,qCAAqC,IAAI,OAAO,CAM/D;AAED,uDAAuD;AACvD,MAAM,MAAM,qBAAqB,GAC7B;IACE,EAAE,EAAE,IAAI,CAAC;IACT,+DAA+D;IAC/D,KAAK,EAAE,MAAM,CAAC;IACd,4EAA4E;IAC5E,IAAI,EAAE,MAAM,CAAC,MAAM,EAAE,OAAO,CAAC,CAAC;CAC/B,GACD;IACE,EAAE,EAAE,KAAK,CAAC;IACV,2CAA2C;IAC3C,MAAM,EAAE,MAAM,CAAC;IACf,qBAAqB;IACrB,KAAK,EAAE,MAAM,CAAC;IACd;;;;;;OAMG;IACH,KAAK,EAAE,MAAM,GAAG,IAAI,CAAC;CACtB,CAAC;AAEN;;;;;GAKG;AACH,wBAAgB,mBAAmB,CAAC,IAAI,EAAE,OAAO,GAAG,MAAM,GAAG,IAAI,CAahE;AAED;;;;;;;;;;;;;;;GAeG;AACH,wBAAgB,wBAAwB,CACtC,IAAI,EAAE,OAAO,EACb,UAAU,EAAE,MAAM,GAAG,SAAS,GAC7B,qBAAqB,CAiDvB"}

package/dist/agent/durable-background.js

@@ -225,9 +225,11 @@ export function backgroundRunMarkerExpectsBackgroundRuntime(marker) {
         marker
             .backgroundFunctionRuntimeExpected === true);
 }
-export function shouldUseBackgroundFunctionTimeoutForWorker(marker) {
-    return (isInBackgroundFunctionRuntime() ||
-        backgroundRunMarkerExpectsBackgroundRuntime(marker));
+export function shouldUseBackgroundFunctionTimeoutForWorker(_marker) {
+    // The dispatch marker says which URL the foreground targeted, not where the
+    // request actually landed. Only the worker runtime proof can safely lift the
+    // hosted 40s clamp to the 15-minute background-function budget.
+    return isInBackgroundFunctionRuntime();
 }
 export function backgroundRuntimeDiagnosticDetail(marker) {
     return [