@hugpy/video-intelligence-ui 0.3.3 → 0.3.4

package/src/stations/studio/StudioPlane.tsx

@@ -61,9 +61,10 @@ export interface StudioPlaneProps {
    *  that sub-mode and hide its internal Clip|Cinema switcher. Omitted by the standalone
    *  /studio-clips station, which keeps the internal switcher. */
   lockedSurfaceMode?: "clip" | "movie";
+  onSelectSurfaceMode?: (mode: "clip" | "movie") => void;
 }
 
-export function StudioPlane({ registerBridge = false, lockedSurfaceMode }: StudioPlaneProps) {
+export function StudioPlane({ registerBridge = false, lockedSurfaceMode, onSelectSurfaceMode }: StudioPlaneProps) {
   const reg = useSidebarRegistry();
   const { presets, loading: presetsLoading } = useStudioPresets(true);
   const clipsState = useStudioClips();
@@ -341,6 +342,7 @@ export function StudioPlane({ registerBridge = false, lockedSurfaceMode }: Studi
         onEnqueued={clipsState.refresh}
         settingsHost={reg.settingsHost}
         lockedSurfaceMode={lockedSurfaceMode}
+        onSelectSurfaceMode={onSelectSurfaceMode}
       />
       </div>
       {/* STUDIO-ASSIST LIVE LOG → portaled into the sidebar's ACTIVE (Active

package/src/stations/studio/StudioViewer.tsx

@@ -109,18 +109,13 @@ export function StudioViewer({
   const [sentMsg, setSentMsg] = useState<string | null>(null);
   const [sendErr, setSendErr] = useState<string | null>(null);
 
+  // The operator probe (GET /keys/video-share) was dropped (2026-10-05): the
+  // route has no backend here, so it only 404'd — i.e. always resolved to
+  // "not operator". Set that outcome directly, with no dead request. (The
+  // Send-to-Editor target /video/studio/clip/<id>/to-editor is itself a 501 in
+  // this build, so the affordance has nothing to call anyway.)
   useEffect(() => {
-    let alive = true;
-    void (async () => {
-      const res = await request<unknown>(hugpyConfig.keysVideoShareUrl, {
-        method: "GET",
-        meta: { specKey: "studio", operation: "studio.operatorProbe" },
-      });
-      if (alive) setOperator(res.ok);
-    })();
-    return () => {
-      alive = false;
-    };
+    setOperator(false);
   }, []);
 
   // Clear any transient send message when the shown clip changes, so a "sent"

package/src/stations/studio/studioShared.tsx

@@ -24,6 +24,7 @@ import { z } from "zod";
 import { request, okValue, errorOf, describeAppError } from "../../transport/client";
 import { hugpyConfig, studioClipDetailUrl, mediaBytesUrl } from "../../config";
 import { addToLibrary, updateLibraryProvenance } from "../../video/mediaLibrary";
+import { subscribeJobStream } from "../../video/jobStream";
 import type { LibraryItem } from "../../video/mediaLibrary";
 import type { MediaRef } from "../../video/contract";
 import type { StudioPreset } from "../../video/useStudioPresets";
@@ -804,13 +805,24 @@ export function useStudioClips(): StudioClipsState {
     }
   }, [backfillProvenance]);
 
+  // Seed once, then refresh the clip catalog only when a worker reports a job
+  // transition (coalesced) — a produced clip appears on the DONE push, not on a
+  // 6s timer.
   useEffect(() => {
     mounted.current = true;
     void load(false);
-    const iv = window.setInterval(() => void load(true), 6000);
+    let coalesce: number | null = null;
+    const unsub = subscribeJobStream(() => {
+      if (coalesce != null) return;
+      coalesce = window.setTimeout(() => {
+        coalesce = null;
+        void load(true);
+      }, 400);
+    });
     return () => {
       mounted.current = false;
-      window.clearInterval(iv);
+      if (coalesce != null) window.clearTimeout(coalesce);
+      unsub();
     };
   }, [load]);
 

package/src/stations/studio/useIdentityCreateJob.ts

@@ -1,8 +1,8 @@
 // k94 — the ONE-PATH "Create identity" job watcher.
 //
 // Both create routes (from-video → identity_from_video, from-images →
-// identity_mesh_build) hand back a bus job_id; this hook polls the generic
-// GET /video/jobs/<id> (`videoJobUrl`) the way the other identity flows in this
+// identity_mesh_build) hand back a bus job_id; this hook seeds once from the generic
+// GET /video/jobs/<id> (`videoJobUrl`) and follows pushed job transitions.
 // station do, and reduces the reply to what the panel shows on ONE line:
 //   stage · % · log tail
 // `progress` is the relay's mirrored blob ({stage, progress 0..1, log_tail[]}
@@ -10,16 +10,17 @@
 // bus's numeric bar, `result` is the terminal JobResult ({ok, error?,
 // identities?}). Terminal = `result.ok` is a boolean. Bounded (90 min — char360
 // plus a textured Hunyuan3D mesh PER character runs minutes each; clownworld's
-// own ceiling) so a wedged remote never spins the panel forever.
+// own ceiling) so a wedged remote never holds the panel forever.
 //
 // Why not the session job tracker (video/jobTracker.ts)? Its JobKind/StationId
 // unions + per-kind terminal parse are closed over the crop/frames/generate
 // arms; widening them is a cross-station change outside this task's files. The
-// poll shape here is the same one ExtractFromVideoPanel / generateFullIdentity
+// job shape here is the same one ExtractFromVideoPanel / generateFullIdentity
 // already use in this station.
 import { useCallback, useEffect, useRef, useState } from "react";
 import { request, okValue } from "../../transport/client";
 import { videoJobUrl } from "../../config";
+import { subscribeJobStream } from "../../video/jobStream";
 
 export type CreateJobPhase = "idle" | "queued" | "running" | "done" | "error";
 
@@ -52,7 +53,6 @@ const IDLE: CreateJobView = {
   phase: "idle", jobId: null, stage: null, pct: null, logLine: null, error: null, identities: [],
 };
 
-const POLL_MS = 4000;
 const CAP_MS = 90 * 60 * 1000;
 
 type JobReply = {
@@ -79,6 +79,7 @@ export interface CreateJobApi {
 export function useIdentityCreateJob(): CreateJobApi {
   const [view, setView] = useState<CreateJobView>(IDLE);
   const timer = useRef<number | null>(null);
+  const unsubscribe = useRef<(() => void) | null>(null);
   const active = useRef(false);
 
   const stop = useCallback(() => {
@@ -87,6 +88,8 @@ export function useIdentityCreateJob(): CreateJobApi {
       window.clearTimeout(timer.current);
       timer.current = null;
     }
+    unsubscribe.current?.();
+    unsubscribe.current = null;
   }, []);
 
   useEffect(() => stop, [stop]);
@@ -98,19 +101,14 @@ export function useIdentityCreateJob(): CreateJobApi {
       setView({ ...IDLE, phase: "queued", jobId });
       const deadline = Date.now() + CAP_MS;
 
-      const pollOnce = async () => {
-        if (!active.current) return;
-        if (Date.now() > deadline) {
-          stop();
-          setView((v) => ({ ...v, phase: "error", error: "Timed out waiting for the identity build." }));
-          return;
-        }
-        const res = await request<unknown>(videoJobUrl(jobId), {
-          meta: { specKey: "studio", operation: "identity.create.status" },
-        });
+      timer.current = window.setTimeout(() => {
+        if (!active.current || Date.now() < deadline) return;
+        stop();
+        setView((v) => ({ ...v, phase: "error", error: "Timed out waiting for the identity build." }));
+      }, CAP_MS);
+
+      const accept = (job: JobReply) => {
         if (!active.current) return;
-        if (res.ok) {
-          const job = okValue(res) as JobReply;
           const result = job.result;
           if (result && typeof result.ok === "boolean") {
             stop();
@@ -150,11 +148,18 @@ export function useIdentityCreateJob(): CreateJobApi {
             pct: ratio == null ? null : Math.max(0, Math.min(100, Math.round(ratio * 100))),
             logLine: typeof last === "string" ? last : null,
           }));
-        }
-        // queued / running / transient poll failure → keep polling.
-        timer.current = window.setTimeout(() => void pollOnce(), POLL_MS);
       };
-      timer.current = window.setTimeout(() => void pollOnce(), POLL_MS);
+      let pushed = false;
+      unsubscribe.current = subscribeJobStream((ev) => {
+        if (ev.job_id !== jobId || !ev.job) return;
+        pushed = true;
+        accept(ev.job as JobReply);
+      });
+      void request<unknown>(videoJobUrl(jobId), {
+        meta: { specKey: "studio", operation: "identity.create.status" },
+      }).then((res) => {
+        if (res.ok && !pushed) accept(okValue(res) as JobReply);
+      });
     },
     [stop],
   );

package/src/stations/studio/useReconstruction.ts

@@ -9,6 +9,7 @@ import {
 } from "../../config";
 import { jobRecordSchema, isTerminal } from "../../video/contract";
 import type { JobStatus } from "../../video/contract";
+import { subscribeJobStream } from "../../video/jobStream";
 
 export const DEFAULT_VIEWS = ["front", "three_quarter", "profile", "back"] as const;
 export type ViewName = (typeof DEFAULT_VIEWS)[number];
@@ -69,16 +70,18 @@ export function useReconstruction(slug: string, onComplete: () => void): Reconst
   const [error, setError] = useState<string | null>(null);
 
   const mounted = useRef(true);
-  const timer = useRef<number | null>(null);
+  // Unsubscribe from the shared job stream while this run's jobs are in flight
+  // (replaces the retired 2s poll interval — a transition re-reads on push).
+  const unsub = useRef<null | (() => void)>(null);
   const idsRef = useRef<string[]>([]);
   const statusesRef = useRef<Record<string, JobStatus>>({});
   const onCompleteRef = useRef(onComplete);
   onCompleteRef.current = onComplete;
 
   const stopPoll = useCallback(() => {
-    if (timer.current != null) {
-      window.clearInterval(timer.current);
-      timer.current = null;
+    if (unsub.current != null) {
+      unsub.current();
+      unsub.current = null;
     }
   }, []);
 
@@ -156,7 +159,10 @@ export function useReconstruction(slug: string, onComplete: () => void): Reconst
     statusesRef.current = seeded;
     setStatuses(seeded);
     void poll();
-    timer.current = window.setInterval(() => void poll(), 2000);
+    // Re-read this run's job ids whenever a worker reports ANY transition. The
+    // set is tiny and poll() is idempotent, so no per-id event filtering is needed.
+    if (unsub.current != null) unsub.current();
+    unsub.current = subscribeJobStream(() => void poll());
   }, [poll]);
 
   const generate = useCallback(

package/src/video/PromptAssistButtons.tsx

@@ -71,14 +71,13 @@ export function PromptAssistButtons({
         >
           <option value="">fleet default</option>
           {models.map((m) => (
-            // Not decoration (canonical STATE-MODEL.md #4): a non-ready model pays a
-            // load on first use. `hot` = already on a worker drive (a t_load, seconds);
-            // `cold` = central only (a download THEN a load). "cold" is reserved for
-            // not-on-hot-drive, so it never mislabels a hot or loaded model.
+            // Only call a model "cold" when the server explicitly reports cold.
+            // Older responses lack state; use serving/held before saying unknown.
             <option key={m.model} value={m.model}>
               {m.model}
-              {m.state === "serving" || m.state === "loaded" ? ""
-                : m.state === "hot" ? " · hot (loads)" : " · cold (downloads)"}
+              {m.state === "serving" || m.state === "loaded" || m.serving ? " · ready"
+                : m.state === "hot" || m.held ? " · available (loads)"
+                : m.state === "cold" ? " · cold (downloads)" : " · availability unknown"}
             </option>
           ))}
         </select>

package/src/video/jobStream.ts

@@ -0,0 +1,119 @@
+// SHARED job-event stream — the client half of design 1 (2026-10-05). The /video
+// page no longer polls GET /video/jobs on a timer. Every list/tracker surface
+// SEEDS ONCE from its own GET, then subscribes here; this module holds ONE
+// EventSource on /api/video/jobs/stream for the whole page (ref-counted: opens on
+// the first subscriber, closes on the last) and hands each pushed row to every
+// subscriber. A row is pushed the moment a worker reports a transition — never on
+// a timer.
+//
+// Structural twin of video/useStudioAssistLog.ts (the same module-scope store +
+// reference-counted connection), with ONE deliberate difference: it is
+// 404-TOLERANT and NEVER polls. If the stream endpoint is absent (first connect
+// errors before it ever opened), we do NOT reconnect — each consumer already did
+// its one-time seed, so the page simply stays on that seed. We reconnect ONLY
+// after a stream that HAD opened drops (the server caps a stream at an hour and
+// expects a re-attach); that is at most ~1/hour, not a poll.
+import { hugpyConfig } from "../config";
+import { videoShareKey } from "../share";
+
+/** One pushed job row (jobstream.py). `job` is the GET /video/jobs/<id> view, or
+ *  null when the job is gone; `stage:"stream.ready"` marks the transport hello. */
+export interface JobEvent {
+  job_id?: string;
+  status?: string | null;
+  owner?: string | null;
+  private?: boolean;
+  job?: unknown;
+  ts?: number;
+  stage?: string;
+}
+
+type Listener = (ev: JobEvent) => void;
+
+const listeners = new Set<Listener>();
+let es: EventSource | null = null;
+let refs = 0;
+let everOpened = false;
+let retryTimer: ReturnType<typeof setTimeout> | null = null;
+const RETRY_MS = 5000;
+
+function streamUrl(): string {
+  const base = hugpyConfig.jobsStreamUrl;
+  const key = videoShareKey();
+  if (!key) return base;
+  const sep = base.includes("?") ? "&" : "?";
+  return `${base}${sep}share=${encodeURIComponent(key)}`;
+}
+
+function openStream(): void {
+  if (es || typeof window === "undefined" || typeof EventSource === "undefined") return;
+  let source: EventSource;
+  try {
+    source = new EventSource(streamUrl(), { withCredentials: true });
+  } catch {
+    return; // EventSource unavailable — consumers keep their one-time seed
+  }
+  es = source;
+  source.onopen = () => {
+    everOpened = true;
+  };
+  source.onmessage = (e: MessageEvent) => {
+    let ev: JobEvent;
+    try {
+      ev = JSON.parse(e.data);
+    } catch {
+      return;
+    }
+    // Let consumers re-read their current rows after every attach. A transition
+    // can happen between their initial GET and the stream becoming ready.
+    for (const fn of listeners) {
+      try {
+        fn(ev);
+      } catch {
+        /* one bad subscriber must not stall the rest */
+      }
+    }
+  };
+  source.onerror = () => {
+    source.close();
+    if (es === source) es = null;
+    // RECONNECT only if this stream had actually opened before dropping (the
+    // server's hourly re-attach). A first connect that errors before opening =
+    // the endpoint is absent/unsupported → do NOT retry, do NOT poll; the page
+    // stays on each consumer's one-time seed.
+    if (refs > 0 && everOpened) {
+      everOpened = false;
+      if (retryTimer) clearTimeout(retryTimer);
+      retryTimer = setTimeout(() => {
+        if (refs > 0) openStream();
+      }, RETRY_MS);
+    }
+  };
+}
+
+function closeStream(): void {
+  if (retryTimer) {
+    clearTimeout(retryTimer);
+    retryTimer = null;
+  }
+  if (es) {
+    es.close();
+    es = null;
+  }
+  everOpened = false;
+}
+
+/**
+ * Subscribe to pushed job rows. Returns an unsubscribe. The underlying
+ * EventSource is opened on the first subscriber and closed on the last.
+ */
+export function subscribeJobStream(fn: Listener): () => void {
+  listeners.add(fn);
+  refs += 1;
+  if (refs === 1) openStream();
+  return () => {
+    listeners.delete(fn);
+    refs = Math.max(0, refs - 1);
+    if (refs === 0) closeStream();
+  };
+}

package/src/video/jobTracker.ts

@@ -25,9 +25,10 @@ import { useSyncExternalStore } from "react";
 import { getSessionId } from "../session";
 import { isCanned } from "../demo/mode";
 import { installDemoTransport } from "../demo/demoFetch";
-import { jobStatusUrl, jobCancelUrl } from "../config";
+import { jobCancelUrl, videoJobUrl } from "../config";
 import { request, okValue } from "../transport/client";
 import { addToLibrary } from "./mediaLibrary";
+import { subscribeJobStream, type JobEvent } from "./jobStream";
 import {
   jobRecordSchema,
   isTerminal,
@@ -38,12 +39,6 @@ import {
   type AnyProgress,
 } from "./contract";
 import type { SpatialRegion, TemporalRegion } from "../regions/types";
-import {
-  GENERATE_POLL_CAP_MS,
-  JOB_POLL_CAP_MS,
-  generateScenePollCapMs,
-  generateMoviePollCapMs,
-} from "../stations/pollCaps";
 
 /** The job kinds this arm enqueues, one poll-parse branch per kind. */
 export type JobKind =
@@ -52,7 +47,8 @@ export type JobKind =
   | "audio_extract"
   | "generate_image"
   | "generate_scene"
-  | "generate_movie";
+  | "generate_movie"
+  | "studio_i2v";
 
 /** The station a job belongs to — also the library origin for crop pushes.
  *  "video-crop" (Studio slice 2b) is the dedicated id for the one-pass spatial+
@@ -69,7 +65,8 @@ export type StationId =
   | "frames"
   | "generate"
   | "generate-tester"
-  | "generate-scene-parts";
+  | "generate-scene-parts"
+  | "studio";
 
 /**
  * One tracked job. Persisted to sessionStorage, so — because a record may be
@@ -172,9 +169,6 @@ export interface TrackedJob {
 /** The single sessionStorage key prefix (build marker — must reach the bundle). */
 const KEY_PREFIX = "vi.jobTracker.v1";
 
-/** Module poll cadence — matches the retired per-hook POLL_MS exactly. */
-const POLL_MS = 800;
-
 // Session-scoped key so two tabs keep independent trackers, and the persisted
 // list travels with the same session id the uploads/jobs are tagged by.
 //
@@ -199,7 +193,9 @@ function storageKey(): string {
 let cache: TrackedJob[] | null = null;
 const listeners = new Set<() => void>();
 let storageBound = false;
-let pollTimer: number | null = null;
+// The shared job-stream unsubscribe while ≥1 tracked job is active (null = not
+// subscribed). The tracker no longer polls; it applies pushed rows by job_id.
+let streamUnsub: (() => void) | null = null;
 
 function readStorage(): TrackedJob[] {
   try {
@@ -253,36 +249,6 @@ function anyActive(): boolean {
   return ensureLoaded().some(isJobActive);
 }
 
-function capFor(
-  kind: JobKind,
-  nFrames?: number | null,
-  chain?: boolean | null,
-  segments?: number | null,
-): number {
-  if (kind === "generate_movie")
-    return generateMoviePollCapMs(segments ?? 1, nFrames ?? undefined, chain ?? false);
-  if (kind === "generate_scene")
-    return generateScenePollCapMs(nFrames ?? 1, chain ?? false);
-  return kind === "generate_image" ? GENERATE_POLL_CAP_MS : JOB_POLL_CAP_MS;
-}
-
-function opFor(kind: JobKind): string {
-  switch (kind) {
-    case "crop":
-      return "crop.poll";
-    case "frame_extract":
-      return "frame_extract.poll";
-    case "audio_extract":
-      return "audio_extract.poll";
-    case "generate_image":
-      return "generate_image.poll";
-    case "generate_scene":
-      return "generate_scene.poll";
-    case "generate_movie":
-      return "generate_movie.poll";
-  }
-}
-
 function failMsgFor(kind: JobKind): string {
   switch (kind) {
     case "crop":
@@ -297,6 +263,8 @@ function failMsgFor(kind: JobKind): string {
       return "Scene generation failed.";
     case "generate_movie":
       return "Movie generation failed.";
+    case "studio_i2v":
+      return "Clip generation failed.";
   }
 }
 
@@ -383,6 +351,11 @@ function pushOutputs(rec: TrackedJob, outputs: MediaRef[]): void {
     });
     return;
   }
+  if (rec.kind === "studio_i2v") {
+    const out = outputs.find((m) => m.kind === "video");
+    if (out) addToLibrary(out, "studio", rec.libLabel ?? "studio clip");
+    return;
+  }
   // audio_extract: intermediate (feeds the temporal editor) — never pushed.
 }
 
@@ -432,51 +405,57 @@ function applyPoll(rec: TrackedJob, raw: unknown): void {
   }
 }
 
-// One module-level tick: poll every active record, cap the overrun ones. A
-// transport error is transient (matches the hooks) — skip and retry next tick.
-async function pollTick(): Promise<void> {
-  for (const rec of ensureLoaded()) {
-    if (!isJobActive(rec)) continue;
-    if (
-      Date.now() - rec.startedAt >
-      capFor(rec.kind, rec.nFrames, rec.chain, rec.segments)
-    ) {
-      // Cap reached — pause polling THIS record, but DON'T fail it.
-      mutate(rec.jobId, { capped: true });
-      continue;
+// Apply one pushed row to its tracked record. The stream event carries `job` —
+// the GET /video/jobs/<id> view applyPoll already parses — so a transition is
+// applied the moment a worker reports it, with no poll. Events for untracked or
+// already-terminal ids are ignored; a burst self-coalesces (each is cheap).
+function onStreamEvent(ev: JobEvent): void {
+  if (ev.stage === "stream.ready") {
+    for (const rec of ensureLoaded().filter((row) => !isJobTerminal(row))) {
+      void request<unknown>(videoJobUrl(rec.jobId), {
+        meta: { specKey: rec.station, operation: "video.job.reconcile" },
+      }).then((res) => {
+        const current = ensureLoaded().find((row) => row.jobId === rec.jobId);
+        if (res.ok && current && !isJobTerminal(current))
+          applyPoll(current, okValue(res));
+        disarmIfIdle();
+      });
     }
-    const r = await request<unknown>(jobStatusUrl(rec.jobId), {
-      meta: { specKey: rec.station, operation: opFor(rec.kind) },
-    });
-    if (!r.ok) continue; // transient — retry on the next tick
-    applyPoll(rec, okValue(r));
+    return;
+  }
+  const jobId = ev.job_id;
+  if (!jobId) return;
+  const rec = ensureLoaded().find((r) => r.jobId === jobId);
+  if (!rec || !isJobActive(rec)) return;
+  if (ev.job == null) {
+    // The server no longer holds this job (gone) — mark expired, stop watching it.
+    mutate(rec.jobId, { expired: true });
+  } else {
+    applyPoll(rec, ev.job);
   }
   disarmIfIdle();
 }
 
-// Arm the single interval while ≥1 record is active; a no-op if already armed or
-// nothing is active. Fires an immediate tick (matches the retired hooks).
+// Subscribe to the shared job stream while ≥1 record is active; a no-op if
+// already subscribed or nothing is active. Replaces the retired poll interval —
+// there is no timer anywhere now; rows arrive on push.
 function armPolling(): void {
   if (typeof window === "undefined") return;
-  if (pollTimer != null) return;
+  if (streamUnsub != null) return;
   if (!anyActive()) return;
-  // Ordering guard for the canned demo: this module's initTracker() runs at IMPORT
-  // time (before entry.tsx's installVideoDemo()), and on a reload it rehydrates any
-  // persisted in-flight record and immediately polls it. If the fetch shim isn't up
-  // yet, that first poll would hit the REAL backend (a 401 + a live wire hit — the
-  // brochure must never do that). installDemoTransport is idempotent, so calling it
-  // here guarantees the shim is installed before ANY canned poll fires, whatever the
-  // module import order. No-op outside canned mode.
+  // Ordering guard for the canned demo: initTracker() runs at IMPORT time (before
+  // entry.tsx's installVideoDemo()); installDemoTransport is idempotent and also
+  // shims EventSource, so calling it here guarantees the canned stream shim is up
+  // before we subscribe, whatever the module import order. No-op outside canned mode.
   if (isCanned()) installDemoTransport();
-  pollTimer = window.setInterval(() => void pollTick(), POLL_MS);
-  void pollTick();
+  streamUnsub = subscribeJobStream(onStreamEvent);
 }
 
-// Clear the interval once no record is active (keeps it alive for others).
+// Drop the subscription once no record is active (reopened by armPolling later).
 function disarmIfIdle(): void {
-  if (pollTimer != null && !anyActive()) {
-    window.clearInterval(pollTimer);
-    pollTimer = null;
+  if (streamUnsub != null && !anyActive()) {
+    streamUnsub();
+    streamUnsub = null;
   }
 }
 
@@ -547,6 +526,13 @@ export function trackJob(input: TrackJobInput): void {
   writeStorage(cache);
   emit();
   armPolling();
+  void request<unknown>(videoJobUrl(input.jobId), {
+    meta: { specKey: "studio", operation: "video.job.seed" },
+  }).then((res) => {
+    const active = ensureLoaded().find((row) => row.jobId === input.jobId);
+    if (res.ok && active && isJobActive(active)) applyPoll(active, okValue(res));
+    disarmIfIdle();
+  });
 }
 
 /**
@@ -645,6 +631,10 @@ function bindStorageOnce(): void {
     cache = readStorage();
     emit();
     armPolling();
+    onStreamEvent({ stage: "stream.ready" });
+  });
+  window.addEventListener("focus", () => {
+    onStreamEvent({ stage: "stream.ready" });
   });
 }
 
@@ -697,6 +687,7 @@ function initTracker(): void {
     writeStorage(cache);
   }
   armPolling();
+  onStreamEvent({ stage: "stream.ready" });
 }
 
 initTracker();