@agent-native/core 0.161.23 → 0.163.0

package/corpus/templates/clips/app/components/recorder/recorder-engine.ts

@@ -505,6 +505,8 @@ export class RecorderEngine {
   private cameraComposite: CameraCompositeHandle | null = null;
   private audioMixCtx: AudioContext | null = null;
   private audioMixSources: MediaStreamAudioSourceNode[] = [];
+  private wakeLock: WakeLockSentinel | null = null;
+  private wakeLockGeneration = 0;
   private recorder: MediaRecorder | null = null;
   private mimeType: string = "video/webm";
 
@@ -890,7 +892,7 @@ export class RecorderEngine {
         this.opts.displaySurface ?? "window",
       );
       const displayOptions: ExtendedDisplayMediaOptions =
-        screenCaptureDisplayOptions(displaySurface);
+        screenCaptureDisplayOptions(displaySurface, wantsMic);
 
       if (wantsMic || wantsDisplay) {
         this.audioMixCtx?.close().catch(() => {});
@@ -904,6 +906,14 @@ export class RecorderEngine {
         } catch (err) {
           throw this.friendlyError(err, "screen");
         }
+        // The OS is as free to sleep/lock the display during a pause as
+        // during active recording, which ends getDisplayMedia's video track
+        // outright (unlike the mic/camera, display capture requires an
+        // active compositor). Without this, a paused recording left idle
+        // finalizes early with no warning — see onDisplayTrackEnded below.
+        // Best-effort: unsupported browsers or a denied request must never
+        // block capture.
+        void this.acquireWakeLock();
       }
 
       if (wantsCamera) {
@@ -2360,9 +2370,34 @@ export class RecorderEngine {
     );
   }
 
+  /** Best-effort — unsupported browsers or a denied request must never block capture. */
+  private async acquireWakeLock(): Promise<void> {
+    const generation = ++this.wakeLockGeneration;
+    try {
+      // coercion-ok: optional chaining yields undefined only when the Wake
+      // Lock API itself is absent (older/other browsers) — a real rejection
+      // (denied request) is caught below, not coerced here.
+      const wakeLock = (await navigator.wakeLock?.request?.("screen")) ?? null;
+      if (generation !== this.wakeLockGeneration || !this.displayStream) {
+        wakeLock?.release().catch(() => {});
+        return;
+      }
+      this.wakeLock = wakeLock;
+    } catch {
+      if (generation === this.wakeLockGeneration) this.wakeLock = null;
+    }
+  }
+
+  private releaseWakeLock(): void {
+    this.wakeLockGeneration += 1;
+    this.wakeLock?.release().catch(() => {});
+    this.wakeLock = null;
+  }
+
   private cleanupTracks(): void {
     // Clear before stopping tracks so the `ended` events our own stop() fires
     // aren't mistaken for a disconnect.
+    this.releaseWakeLock();
     this.cameraLive = false;
     this.audioMixSources = [];
     this.audioMixCtx?.close().catch(() => {});

package/corpus/templates/clips/app/i18n/en-US.ts

@@ -1335,10 +1335,11 @@ All notable user-facing changes to Clips are documented here. Open it any time f
     cameraOff: "Camera off",
     includeCameraAria: "Include camera in this recording",
     startRecording: "Start recording",
-    micOffConfirmTitle: "Record without a microphone?",
+    micOffConfirmTitle: "Your mic is muted",
     micOffConfirmDescription:
-      "Your mic is off, so this recording won't capture any audio. Turn it on before starting if you want narration.",
-    startWithoutMic: "Start anyway",
+      "To have sound in your video, you’ll need to unmute your microphone.",
+    startWithoutMic: "Continue",
+    unmuteMicrophone: "Unmute",
     uploadVideo: "Upload video",
     importLoom: "Import Loom",
     importing: "Importing...",

package/corpus/templates/clips/app/lib/camera-composite.ts

@@ -149,6 +149,13 @@ export function clampToMaxDimension(
   };
 }
 
+export function cameraBubbleStrokeRadius(
+  size: number,
+  lineWidth: number,
+): number {
+  return Math.max(0, size / 2 - lineWidth / 2);
+}
+
 function resizeCanvasToDisplay(
   canvas: HTMLCanvasElement,
   displayVideo: HTMLVideoElement,
@@ -225,6 +232,7 @@ function drawCameraBubble(
       maxSize,
     ),
   );
+  if (size <= 0) return;
   const margin = Math.round(
     clamp(minDimension * options.bubbleMarginRatio, 24, 80),
   );
@@ -255,7 +263,13 @@ function drawCameraBubble(
   ctx.strokeStyle = "rgba(255, 255, 255, 0.86)";
   ctx.lineWidth = Math.max(4, Math.round(size * 0.025));
   ctx.beginPath();
-  ctx.arc(centerX, centerY, radius - ctx.lineWidth / 2, 0, Math.PI * 2);
+  ctx.arc(
+    centerX,
+    centerY,
+    cameraBubbleStrokeRadius(size, ctx.lineWidth),
+    0,
+    Math.PI * 2,
+  );
   ctx.stroke();
   ctx.restore();
 }

package/corpus/templates/clips/changelog/2026-08-18-clips-no-longer-crashes-when-a-camera-bubble-starts-at-a-tin.md

@@ -0,0 +1,6 @@
+---
+type: fixed
+date: 2026-08-18
+---
+
+Clips no longer crashes when a camera bubble starts at a tiny size.

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

@@ -37,16 +37,6 @@ import {
   useState,
 } from "react";
 
-import {
-  AlertDialog,
-  AlertDialogAction,
-  AlertDialogCancel,
-  AlertDialogContent,
-  AlertDialogDescription,
-  AlertDialogFooter,
-  AlertDialogHeader,
-  AlertDialogTitle,
-} from "./components/AlertDialog";
 import { FeedbackButton } from "./components/FeedbackButton";
 import {
   CamIcon,
@@ -58,6 +48,7 @@ import {
   SettingsIcon,
 } from "./components/Icons";
 import { MediaDeviceRow } from "./components/MediaDeviceRow";
+import { MicOffConfirmation } from "./components/MicOffConfirmation";
 import { ReadinessPanel } from "./components/ReadinessPanel";
 import { SourceRow, type CaptureSource } from "./components/SourceRow";
 import { Switch } from "./components/Switch";
@@ -3333,6 +3324,22 @@ export function App() {
     void handleStartRecording(options);
   }
 
+  function closeMicOffConfirmation() {
+    pendingStartOptionsRef.current = undefined;
+    setMicOffConfirmOpen(false);
+  }
+
+  function unmuteFromConfirmation() {
+    setMicOn(true);
+    closeMicOffConfirmation();
+  }
+
+  function continueWithoutMic() {
+    const options = pendingStartOptionsRef.current;
+    closeMicOffConfirmation();
+    void handleStartRecording(options);
+  }
+
   recordShortcutHandlerRef.current = () => {
     if (recorder) {
       emit("clips:recorder-stop").catch(() => {});
@@ -3960,7 +3967,19 @@ export function App() {
 
   return (
     <div className="app app-recorder" ref={appRef}>
-      <div className="recorder-home-content">
+      {micOffConfirmOpen ? (
+        <MicOffConfirmation
+          onBack={closeMicOffConfirmation}
+          onUnmute={unmuteFromConfirmation}
+          onContinue={continueWithoutMic}
+        />
+      ) : null}
+
+      <div
+        className="recorder-home-content"
+        hidden={micOffConfirmOpen}
+        aria-hidden={micOffConfirmOpen}
+      >
         <Header
           mode={mode}
           onModeChange={setMode}
@@ -4077,35 +4096,6 @@ export function App() {
           </button>
         ) : null}
 
-        <AlertDialog
-          open={micOffConfirmOpen}
-          onOpenChange={(open) => {
-            setMicOffConfirmOpen(open);
-            if (!open) pendingStartOptionsRef.current = undefined;
-          }}
-        >
-          <AlertDialogContent>
-            <AlertDialogHeader>
-              <AlertDialogTitle>Record without a microphone?</AlertDialogTitle>
-              <AlertDialogDescription>
-                Your mic is off, so this recording won&apos;t capture any audio.
-                Turn it on before starting if you want narration.
-              </AlertDialogDescription>
-            </AlertDialogHeader>
-            <AlertDialogFooter>
-              <AlertDialogAction
-                onClick={() => {
-                  const options = pendingStartOptionsRef.current;
-                  pendingStartOptionsRef.current = undefined;
-                  void handleStartRecording(options);
-                }}
-              >
-                Start anyway
-              </AlertDialogAction>
-              <AlertDialogCancel>Cancel</AlertDialogCancel>
-            </AlertDialogFooter>
-          </AlertDialogContent>
-        </AlertDialog>
         {recError ? (
           recError === MACOS_UPDATE_RESTART_MESSAGE ? (
             <UpdateRestartBanner message={recError} />

package/corpus/templates/clips/desktop/src/components/MicOffConfirmation.tsx

@@ -0,0 +1,47 @@
+import { IconArrowLeft, IconMicrophone2 } from "@tabler/icons-react";
+
+export function MicOffConfirmation({
+  onBack,
+  onUnmute,
+  onContinue,
+}: {
+  onBack: () => void;
+  onUnmute: () => void;
+  onContinue: () => void;
+}) {
+  return (
+    <section className="mic-off-confirmation" aria-labelledby="mic-off-title">
+      <header className="mic-off-confirmation-header">
+        <button
+          type="button"
+          className="mic-off-confirmation-back"
+          onClick={onBack}
+        >
+          <IconArrowLeft size={18} aria-hidden="true" />
+          Back
+        </button>
+      </header>
+
+      <div className="mic-off-confirmation-body">
+        <div className="mic-off-confirmation-visual" aria-hidden="true">
+          <IconMicrophone2 size={42} strokeWidth={1.7} />
+          <span className="mic-off-confirmation-slash" />
+        </div>
+        <h2 id="mic-off-title">Your mic is muted</h2>
+        <p>
+          To have sound in your video, you&apos;ll need to unmute your
+          microphone.
+        </p>
+      </div>
+
+      <footer className="mic-off-confirmation-actions">
+        <button type="button" className="secondary" onClick={onUnmute}>
+          Unmute
+        </button>
+        <button type="button" className="primary" onClick={onContinue}>
+          Continue
+        </button>
+      </footer>
+    </section>
+  );
+}

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

@@ -3150,6 +3150,116 @@ body[data-clips-route="recording-pill"] #root {
   }
 }
 
+/* ------------------------------------------------------------------------- */
+/* Microphone-off confirmation                                                */
+/* ------------------------------------------------------------------------- */
+
+.mic-off-confirmation {
+  min-height: 430px;
+  display: flex;
+  flex-direction: column;
+  background: var(--bg);
+}
+
+.mic-off-confirmation-header {
+  display: flex;
+  align-items: center;
+  padding: 16px 18px 8px;
+}
+
+.mic-off-confirmation-back {
+  display: inline-flex;
+  align-items: center;
+  gap: 6px;
+  min-height: 30px;
+  padding: 4px 6px 4px 2px;
+  border: 0;
+  border-radius: var(--radius-sm);
+  background: transparent;
+  color: var(--fg);
+  cursor: pointer;
+  font-size: 15px;
+  font-weight: 650;
+  transition:
+    background 120ms,
+    color 120ms;
+}
+
+.mic-off-confirmation-back:hover {
+  background: var(--surface-hover);
+}
+
+.mic-off-confirmation-back:focus-visible {
+  outline: none;
+  box-shadow: 0 0 0 3px var(--brand-ring);
+}
+
+.mic-off-confirmation-body {
+  display: flex;
+  flex: 1 1 auto;
+  flex-direction: column;
+  align-items: center;
+  justify-content: center;
+  padding: 24px 28px 30px;
+  text-align: center;
+}
+
+.mic-off-confirmation-visual {
+  position: relative;
+  display: flex;
+  align-items: center;
+  justify-content: center;
+  width: 88px;
+  height: 88px;
+  border-radius: 50%;
+  background: var(--surface-strong);
+  color: var(--status-warn);
+}
+
+.mic-off-confirmation-slash {
+  position: absolute;
+  width: 58px;
+  height: 3px;
+  border-radius: var(--radius-pill);
+  background: var(--status-warn);
+  transform: rotate(45deg);
+}
+
+.mic-off-confirmation-body h2 {
+  margin: 24px 0 0;
+  font-size: 22px;
+  font-weight: 700;
+  letter-spacing: -0.02em;
+}
+
+.mic-off-confirmation-body p {
+  max-width: 300px;
+  margin: 8px 0 0;
+  color: var(--fg-muted);
+  font-size: 14px;
+  line-height: 1.55;
+}
+
+.mic-off-confirmation-actions {
+  display: grid;
+  grid-template-columns: repeat(2, minmax(0, 1fr));
+  gap: 10px;
+  padding: 16px 18px 18px;
+  border-top: 1px solid var(--border);
+  background: var(--surface);
+}
+
+.mic-off-confirmation-actions .primary,
+.mic-off-confirmation-actions .secondary {
+  width: auto;
+  min-width: 0;
+  height: 42px;
+  padding: 0 12px;
+  border-radius: var(--radius);
+  font-size: 13px;
+  white-space: nowrap;
+}
+
 /* ------------------------------------------------------------------------- */
 /* Alert dialog                                                              */
 /* ------------------------------------------------------------------------- */

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

@@ -630,6 +630,60 @@ mod macos {
         }
     }
 
+    /// RNNoise's voice-activity output is more useful than a fixed amplitude
+    /// threshold for the meeting microphone. A muted call still leaves Clips
+    /// with the local microphone, and fans, keyboard noise, or room noise can
+    /// be loud enough to cross the old RMS-only gate. Keep this state on the
+    /// worker thread so the realtime capture callback stays allocation-free.
+    struct MicVoiceActivity {
+        state: Box<nnnoiseless::DenoiseState<'static>>,
+        pending: Vec<f32>,
+    }
+
+    impl MicVoiceActivity {
+        const SAMPLE_RATE: f32 = 48_000.0;
+        const INPUT_SCALE: f32 = 32_768.0;
+
+        fn new() -> Self {
+            Self {
+                state: nnnoiseless::DenoiseState::new(),
+                pending: Vec::new(),
+            }
+        }
+
+        fn reset(&mut self) {
+            self.state = nnnoiseless::DenoiseState::new();
+            self.pending.clear();
+        }
+
+        /// Return the highest RNNoise speech probability in `samples`.
+        /// `None` means this capture format is not the 48 kHz PCM that
+        /// RNNoise expects; callers retain the existing RMS fallback for
+        /// those legacy devices.
+        fn observe(&mut self, samples: &[f32], sample_rate: f32) -> Option<f32> {
+            if (sample_rate - Self::SAMPLE_RATE).abs() > 1.0 {
+                self.reset();
+                return None;
+            }
+
+            self.pending.extend(samples.iter().map(|sample| {
+                (sample * Self::INPUT_SCALE).clamp(-Self::INPUT_SCALE, Self::INPUT_SCALE)
+            }));
+
+            let frame_size = nnnoiseless::DenoiseState::FRAME_SIZE;
+            let mut highest_probability: f32 = 0.0;
+            while self.pending.len() >= frame_size {
+                let mut denoised = [0.0_f32; nnnoiseless::DenoiseState::FRAME_SIZE];
+                let probability = self
+                    .state
+                    .process_frame(&mut denoised, &self.pending[..frame_size]);
+                highest_probability = highest_probability.max(probability);
+                self.pending.drain(..frame_size);
+            }
+            Some(highest_probability)
+        }
+    }
+
     /// Run whisper over `samples` (16 kHz mono f32), returning each speech
     /// segment as `(start_ms, end_ms, text)` with buffer-relative timestamps.
     /// `language` is the forced language code (e.g. "en"); `None` lets whisper
@@ -698,6 +752,10 @@ mod macos {
     const VOICE_RMS_THRESHOLD: f32 = 0.006;
     /// A second, model-level gate for ambient/no-speech Whisper segments.
     const MAX_NO_SPEECH_PROBABILITY: f32 = 0.72;
+    /// RNNoise speech probability required for a 48 kHz microphone frame to
+    /// count as voice. System audio and non-48 kHz legacy mic captures keep
+    /// the RMS path because this VAD is trained for 48 kHz microphone PCM.
+    const MIN_MIC_VAD_PROBABILITY: f32 = 0.6;
     /// Minimum average per-token probability for a segment to count as real
     /// speech. On noisy/near-silent audio whisper mis-detects the language and
     /// decodes fluent-looking gibberish in another language — but those tokens
@@ -733,6 +791,11 @@ mod macos {
         sum / count as f32
     }
 
+    fn mic_voice_detected(rms: f32, vad_probability: Option<f32>) -> bool {
+        rms > VOICE_RMS_THRESHOLD
+            && vad_probability.is_none_or(|probability| probability >= MIN_MIC_VAD_PROBABILITY)
+    }
+
     fn buffer_start_after_drain(now: Instant, pending: Duration) -> Instant {
         now.checked_sub(pending).unwrap_or(now)
     }
@@ -788,6 +851,10 @@ mod macos {
         let mut seen_reset_generation = stream.reset_generation.load(Ordering::SeqCst);
         // Growing-utterance resample cache — see `IncrementalResample`.
         let mut resample_state = IncrementalResample::new();
+        // Only the microphone stream needs a speech/noise classifier. The
+        // system stream must preserve remote speech even when it is mixed
+        // with music or other non-voice audio.
+        let mut mic_voice_activity = (stream.source == "mic").then(MicVoiceActivity::new);
 
         while stream.running.load(Ordering::SeqCst) {
             std::thread::sleep(Duration::from_millis(250));
@@ -800,6 +867,9 @@ mod macos {
                 last_infer = Instant::now() - Duration::from_secs(10);
                 had_voice = false;
                 resample_state.drop_all();
+                if let Some(vad) = mic_voice_activity.as_mut() {
+                    vad.reset();
+                }
                 continue;
             }
 
@@ -807,31 +877,40 @@ mod macos {
             // poll. Inspect that tail in place instead of cloning + resampling
             // the entire growing utterance four times per second. Full snapshots
             // are reserved for an inference that is actually due.
-            let (raw_len, new_rms) = match stream.buf.lock() {
+            let (raw_len, new_rms, new_mic_samples) = match stream.buf.lock() {
                 Ok(b) => {
                     let raw_len = b.len();
-                    let new_rms = if raw_len > last_raw_len {
+                    let (new_rms, new_mic_samples) = if raw_len > last_raw_len {
                         let new = &b[last_raw_len..];
-                        Some((new.iter().map(|x| x * x).sum::<f32>() / new.len() as f32).sqrt())
+                        (
+                            Some(
+                                (new.iter().map(|x| x * x).sum::<f32>() / new.len() as f32).sqrt(),
+                            ),
+                            (stream.source == "mic").then(|| new.to_vec()),
+                        )
                     } else {
-                        None
+                        (None, None)
                     };
-                    (raw_len, new_rms)
+                    (raw_len, new_rms, new_mic_samples)
                 }
                 Err(_) => continue,
             };
             if stream.reset_generation.load(Ordering::SeqCst) != seen_reset_generation {
                 continue;
             }
+            let src_rate = (stream.src_rate.load(Ordering::SeqCst) as f32).max(1.0);
             if let Some(rms) = new_rms {
-                if rms > VOICE_RMS_THRESHOLD {
+                let vad_probability = mic_voice_activity
+                    .as_mut()
+                    .zip(new_mic_samples.as_deref())
+                    .and_then(|(vad, samples)| vad.observe(samples, src_rate));
+                if mic_voice_detected(rms, vad_probability) {
                     last_voice = Instant::now();
                     had_voice = true;
                 }
             }
             last_raw_len = raw_len;
 
-            let src_rate = (stream.src_rate.load(Ordering::SeqCst) as f32).max(1.0);
             let have_secs = raw_len as f32 / src_rate;
             let silence = last_voice.elapsed();
 
@@ -878,6 +957,9 @@ mod macos {
                 // so the resample cache is invalid regardless of whether this
                 // utterance ran inference — rebuild fresh from whatever's left.
                 resample_state.drop_all();
+                if let Some(vad) = mic_voice_activity.as_mut() {
+                    vad.reset();
+                }
                 // Advance the timeline offset so the next utterance's whisper
                 // timestamps map correctly. Inference can take seconds, and
                 // audio kept arriving throughout it, so the new buffer starts
@@ -1568,6 +1650,31 @@ mod macos {
             );
         }
 
+        #[test]
+        fn mic_voice_gate_requires_speech_probability_on_supported_captures() {
+            assert!(!super::mic_voice_detected(0.02, Some(0.59)));
+            assert!(!super::mic_voice_detected(0.004, Some(0.99)));
+            assert!(super::mic_voice_detected(0.02, Some(0.6)));
+            assert!(super::mic_voice_detected(0.02, None));
+        }
+
+        #[test]
+        fn rnnoise_vad_rejects_steady_ambient_noise() {
+            let mut vad = super::MicVoiceActivity::new();
+            let samples: Vec<f32> = (0..(nnnoiseless::DenoiseState::FRAME_SIZE * 8))
+                .map(|index| {
+                    let value = index.wrapping_mul(1_103_515_245usize).wrapping_add(12_345);
+                    (((value >> 16) & 0x7fff) as f32 / 16_384.0 - 1.0) * 0.012
+                })
+                .collect();
+
+            let probability = vad.observe(&samples, 48_000.0).unwrap();
+            assert!(
+                probability < super::MIN_MIC_VAD_PROBABILITY,
+                "ambient noise was classified as speech: {probability:.3}"
+            );
+        }
+
         #[test]
         fn filters_multilingual_caption_hallucinations() {
             assert_eq!(clean_transcript("ご視聴ありがとうございました"), None);

package/corpus/templates/clips/shared/recording-capture.ts

@@ -47,29 +47,34 @@ export type ScreenCaptureDisplayOptions = {
 /**
  * The `getDisplayMedia` options for a screen recording.
  *
- * Screen/tab audio is requested ALWAYS, and deliberately does not depend on
- * whether the microphone is on. They are two different sources, and one toggle
- * used to govern both: with the mic off, Chrome was never even offered the
- * "share tab audio" checkbox, so a screen recording of a call or a demo
- * captured zero audio tracks. Measured in production, 345 recordings landed
- * with `has_audio = false` — 95 over a minute, 17 over five — and each was told
- * "No speech was detected because this recording was saved without audio",
- * blaming the recording for a capture setting. That was 64% of recent
- * transcript failures. The Chrome extension always requested display audio and
- * never had the problem.
+ * Screen/tab audio is requested whenever the microphone is enabled, and
+ * withheld when it's off. The mic toggle is the only audio control the
+ * recorder UI shows, so a user who turns it off reasonably expects the
+ * recording to capture no audio at all — not just their voice. Requesting
+ * system audio anyway relies on the user separately noticing and unchecking
+ * the browser's native "share tab audio" checkbox, which they may not even
+ * know exists. See Slack thread 1786086902028429: a user turned the mic off
+ * and still got system audio in the recording; the agreed fix is to gate
+ * system audio on the same toggle.
  *
- * Declining the checkbox is still respected; the user simply gets the choice.
+ * When the mic IS on, audio is still requested unconditionally (not made
+ * conditional on some separate "include system audio" flag) — that used to be
+ * one toggle governing both, and with the mic off Chrome never even offered
+ * the checkbox, so 345 production recordings landed with `has_audio = false`
+ * while recording a call/demo. Declining the checkbox is still respected; the
+ * user simply gets the choice whenever the mic is on.
  */
 export function screenCaptureDisplayOptions(
   displaySurface: ScreenCaptureSurface,
+  wantsMic: boolean,
 ): ScreenCaptureDisplayOptions {
   return {
     video: screenCaptureVideoConstraints(displaySurface),
-    audio: true,
+    audio: wantsMic,
     // Let "Browser tab" open the tab picker. preferCurrentTab turns it into a
     // current-tab shortcut, which makes choosing another tab harder.
     selfBrowserSurface: displaySurface === "browser" ? "include" : "exclude",
     surfaceSwitching: "include",
-    systemAudio: "include",
+    systemAudio: wantsMic ? "include" : "exclude",
   };
 }

package/corpus/templates/content/.agents/skills/real-time-sync/SKILL.md

@@ -50,7 +50,7 @@ The agent modifies data in SQL, but the UI runs in the browser. SSE bridges same
 
    For list/sidebar queries, use the same pattern — pass the counter into the queryKey of every list query you want to keep fresh.
 
-4. **Fallback** polling calls `/_agent-native/poll?since=N`. It runs every 2 seconds until SSE is connected, then relaxes to 15 seconds (`SSE_FALLBACK_INTERVAL_MS`). If SSE is disabled or unavailable (e.g., edge/serverless deployments), polling continues at the 2 s cadence. Polling is the universal serverless fallback: new framework writes are read from the durable `sync_events` log, while the older DB timestamp scan remains as a slower safety net for direct SQL writes and older processes.
+4. **Fallback** polling calls `/_agent-native/poll?since=N`. It polls every 2 seconds only while an agent run is in flight; otherwise it idles at 60 seconds whether or not SSE is connected (`SSE_FALLBACK_INTERVAL_MS` and `IDLE_POLL_INTERVAL_MS`, both 60 s). A hidden tab polls no faster than every 10 seconds (`HIDDEN_POLL_INTERVAL_MS`). Polling is the universal serverless fallback: new framework writes are read from the durable `sync_events` log, while the older DB timestamp scan remains as a slower safety net for direct SQL writes and older processes.
 
 5. When the agent writes to the database, the version increments, SSE/polling detects it, and React Query refetches the affected queries.