The open-source app everyone uses to manage agents at work
TypeScript acpxagent-orchestrationagent-skillsagentic-aiai-agentsai-engineeringai-governanceai-toolsautonomous-agentsclaudeclaude-codeclaude-skillscodexhermesllmmcpmulti-agentopenclawproject-managementworkflow-automation
perf(ui): cut live-updates churn that inflates tab memory (#9624)
Dotta3e348b96b99e
diff --git a/ui/src/components/IssueChatThread.tsx b/ui/src/components/IssueChatThread.tsxindex aed1de750d..a23f16d90d 100644--- a/ui/src/components/IssueChatThread.tsx+++ b/ui/src/components/IssueChatThread.tsx@@ -45,6 +45,7 @@ import type {} from "@paperclipai/shared";import type { ActiveRunForIssue, LiveRunForIssue } from "../api/heartbeats";import { useLiveRunTranscripts } from "./transcript/useLiveRunTranscripts";+import { useSecondTick } from "../hooks/useSecondTick";import { usePaperclipIssueRuntime, type PaperclipIssueRuntimeReassignment } from "../hooks/usePaperclipIssueRuntime";import { useOptionalToastActions } from "../context/ToastContext";import { copyTextToClipboard } from "../lib/clipboard";@@ -305,12 +306,10 @@ function findCoTSegmentIndex(}function useLiveElapsed(startMs: number | null | undefined, active: boolean): string | null {- const [, rerender] = useState(0);- useEffect(() => {- if (!active || !startMs) return;- const interval = setInterval(() => rerender((n) => n + 1), 1000);- return () => clearInterval(interval);- }, [active, startMs]);+ // Drive the 1s refresh from the shared page-wide ticker instead of a+ // per-instance setInterval, so a thread with many live elements uses one+ // timer rather than one per element.+ useSecondTick(Boolean(active && startMs));if (!active || !startMs) return null;return formatDurationWords(Date.now() - startMs);}diff --git a/ui/src/components/transcript/useLiveRunTranscripts.ts b/ui/src/components/transcript/useLiveRunTranscripts.tsindex 5b8e4edb9e..1d272954ee 100644--- a/ui/src/components/transcript/useLiveRunTranscripts.ts+++ b/ui/src/components/transcript/useLiveRunTranscripts.ts@@ -8,8 +8,16 @@ import { buildTranscript, getUIAdapter, onAdapterChange, type RunLogChunk, typeimport { queryKeys } from "../../lib/queryKeys";import { buildSameOriginWebSocketUrl } from "../../lib/websocket-url";+// TODO(perf): this whole hook polls the log/runs endpoints on an interval. The+// durable fix is server push (SSE/websocket) for transcript deltas so idle tabs+// do no periodic work at all; the constants below only reduce the churn of the+// current polling approach.const LOG_POLL_INTERVAL_MS = 2000;const LOG_READ_LIMIT_BYTES = 256_000;+// When realtime websocket updates are enabled, the frequent log poll is+// redundant with the live stream; keep only a slow safety-net poll to cover+// gaps and reconnects instead of polling every couple of seconds.+const REALTIME_FALLBACK_POLL_INTERVAL_MS = 30_000;const EMPTY_RUN_LOG_CHUNKS: RunLogChunk[] = [];export interface RunTranscriptSource {@@ -315,17 +323,23 @@ export function useLiveRunTranscripts({void readAll();const activeRuns = normalizedRuns.filter((run) => !isTerminalStatus(run.status));- const interval = activeRuns.length > 0 && logPollIntervalMs > 0+ // The realtime websocket is the primary live source when enabled, so the+ // recurring poll only needs to run as a slow fallback rather than doubling+ // the live update work every couple of seconds.+ const effectivePollMs = enableRealtimeUpdates+ ? Math.max(logPollIntervalMs, REALTIME_FALLBACK_POLL_INTERVAL_MS)+ : logPollIntervalMs;+ const interval = activeRuns.length > 0 && effectivePollMs > 0? window.setInterval(() => {void Promise.all(activeRuns.map((run) => readRunLog(run)));- }, logPollIntervalMs)+ }, effectivePollMs): null;return () => {cancelled = true;if (interval !== null) window.clearInterval(interval);};- }, [logPollIntervalMs, logReadLimitBytes, normalizedRuns, runIdsKey]);+ }, [enableRealtimeUpdates, logPollIntervalMs, logReadLimitBytes, normalizedRuns, runIdsKey]);useEffect(() => {if (!enableRealtimeUpdates) return;diff --git a/ui/src/context/LiveUpdatesProvider.tsx b/ui/src/context/LiveUpdatesProvider.tsxindex 19eb9ce7f7..f864e45a6c 100644--- a/ui/src/context/LiveUpdatesProvider.tsx+++ b/ui/src/context/LiveUpdatesProvider.tsx@@ -1,5 +1,6 @@-import { useEffect, useRef, type ReactNode } from "react";+import { useEffect, useMemo, useRef, type ReactNode } from "react";import { useQuery, useQueryClient, type InfiniteData, type QueryClient } from "@tanstack/react-query";+import { createCoalescingQueryClient, createInvalidationBatcher } from "../lib/query-invalidation-batcher";import type { Agent, Issue, IssueComment, LiveEvent } from "@paperclipai/shared";import type { RunForIssue } from "../api/activity";import type { ActiveRunForIssue, LiveRunForIssue } from "../api/heartbeats";@@ -1197,6 +1198,16 @@ export function LiveUpdatesProvider({ children }: { children: ReactNode }) {agentId: null,});+ // Coalesce the per-event invalidation storm. Optimistic setQueryData writes+ // still pass straight through (immediate); only invalidateQueries is batched+ // and flushed at most a few times per second.+ const invalidationBatcher = useMemo(() => createInvalidationBatcher(queryClient), [queryClient]);+ const coalescingClient = useMemo(+ () => createCoalescingQueryClient(queryClient, invalidationBatcher),+ [queryClient, invalidationBatcher],+ );+ useEffect(() => () => invalidationBatcher.dispose(), [invalidationBatcher]);+useEffect(() => {pathnameRef.current = location.pathname;}, [location.pathname]);@@ -1258,7 +1269,7 @@ export function LiveUpdatesProvider({ children }: { children: ReactNode }) {try {const parsed = JSON.parse(raw) as LiveEvent;- handleLiveEvent(queryClient, liveCompanyId, pathnameRef.current, parsed, pushToast, gateRef.current, {+ handleLiveEvent(coalescingClient, liveCompanyId, pathnameRef.current, parsed, pushToast, gateRef.current, {userId: currentActorRef.current.userId,agentId: currentActorRef.current.agentId,});@@ -1293,7 +1304,7 @@ export function LiveUpdatesProvider({ children }: { children: ReactNode }) {socket = null;closeSocketQuietly(activeSocket, "provider_unmount");};- }, [queryClient, liveCompanyId, pushToast, canConnectSocket, socketAuthKey]);+ }, [coalescingClient, liveCompanyId, pushToast, canConnectSocket, socketAuthKey]);return <>{children}</>;}diff --git a/ui/src/hooks/useSecondTick.test.tsx b/ui/src/hooks/useSecondTick.test.tsxnew file mode 100644index 0000000000..e9daa23ead--- /dev/null+++ b/ui/src/hooks/useSecondTick.test.tsx@@ -0,0 +1,45 @@+// @vitest-environment jsdom++import { flushSync } from "react-dom";+import { createRoot } from "react-dom/client";+import { afterEach, beforeEach, describe, expect, it, vi } from "vitest";+import { __secondTickInternals, useSecondTick } from "./useSecondTick";++function mount(active: boolean) {+ const container = document.createElement("div");+ const root = createRoot(container);+ function Probe() {+ useSecondTick(active);+ return null;+ }+ flushSync(() => root.render(<Probe />));+ return { unmount: () => flushSync(() => root.unmount()) };+}++describe("useSecondTick", () => {+ beforeEach(() => vi.useFakeTimers());+ afterEach(() => vi.useRealTimers());++ it("shares a single timer across multiple active subscribers and stops when idle", () => {+ const a = mount(true);+ const b = mount(true);++ expect(__secondTickInternals.subscriberCount()).toBe(2);+ expect(__secondTickInternals.isRunning()).toBe(true);++ a.unmount();+ expect(__secondTickInternals.subscriberCount()).toBe(1);+ expect(__secondTickInternals.isRunning()).toBe(true); // still one subscriber++ b.unmount();+ expect(__secondTickInternals.subscriberCount()).toBe(0);+ expect(__secondTickInternals.isRunning()).toBe(false); // timer stopped when idle+ });++ it("does not subscribe or start a timer when inactive", () => {+ const c = mount(false);+ expect(__secondTickInternals.subscriberCount()).toBe(0);+ expect(__secondTickInternals.isRunning()).toBe(false);+ c.unmount();+ });+});diff --git a/ui/src/hooks/useSecondTick.ts b/ui/src/hooks/useSecondTick.tsnew file mode 100644index 0000000000..8065b6bf9a--- /dev/null+++ b/ui/src/hooks/useSecondTick.ts@@ -0,0 +1,54 @@+import { useEffect, useState } from "react";++/**+ * A single, process-wide 1-second ticker shared by every subscriber.+ *+ * Live "elapsed time" displays (e.g. "2m ago", running-agent timers) used to+ * each create their own `setInterval(..., 1000)`. On a busy issue thread that+ * meant dozens of independent 1s timers, each forcing a component re-render+ * every second — a major driver of steady-state CPU churn (and, compounded+ * across a long-lived tab, off-heap allocation growth). This collapses all of+ * them onto one interval that only runs while at least one subscriber is active.+ */+const subscribers = new Set<() => void>();+let intervalId: ReturnType<typeof setInterval> | null = null;++function ensureRunning(): void {+ if (intervalId !== null) return;+ intervalId = setInterval(() => {+ for (const notify of subscribers) notify();+ }, 1000);+}++function stopIfIdle(): void {+ if (intervalId !== null && subscribers.size === 0) {+ clearInterval(intervalId);+ intervalId = null;+ }+}++/**+ * Re-render the calling component once per second while `active` is true, driven+ * by the shared ticker. Returns a monotonically increasing tick count in case a+ * caller wants it as a dependency.+ */+export function useSecondTick(active: boolean): number {+ const [tick, setTick] = useState(0);+ useEffect(() => {+ if (!active) return;+ const notify = () => setTick((n) => n + 1);+ subscribers.add(notify);+ ensureRunning();+ return () => {+ subscribers.delete(notify);+ stopIfIdle();+ };+ }, [active]);+ return tick;+}++/** Test-only hook to observe the shared ticker's internal state. */+export const __secondTickInternals = {+ subscriberCount: () => subscribers.size,+ isRunning: () => intervalId !== null,+};diff --git a/ui/src/lib/issueChatTranscriptRuns.test.ts b/ui/src/lib/issueChatTranscriptRuns.test.tsindex 3f45465923..cc4216cef8 100644--- a/ui/src/lib/issueChatTranscriptRuns.test.ts+++ b/ui/src/lib/issueChatTranscriptRuns.test.ts@@ -1,5 +1,20 @@import { describe, expect, it } from "vitest";-import { resolveIssueChatTranscriptRuns } from "./issueChatTranscriptRuns";+import type { LiveRunForIssue } from "../api/heartbeats";+import type { IssueChatLinkedRun } from "./issue-chat-messages";+import { MAX_ISSUE_CHAT_TRANSCRIPT_RUNS, resolveIssueChatTranscriptRuns } from "./issueChatTranscriptRuns";++function linkedRun(n: number, isoDate: string): IssueChatLinkedRun {+ return {+ runId: `run-${n}`,+ status: "succeeded",+ agentId: "agent-1",+ adapterType: "codex_local",+ createdAt: isoDate,+ startedAt: isoDate,+ finishedAt: isoDate,+ hasStoredOutput: true,+ } as IssueChatLinkedRun;+}describe("resolveIssueChatTranscriptRuns", () => {it("uses adapterType from linked runs without requiring agent metadata", () => {@@ -27,4 +42,46 @@ describe("resolveIssueChatTranscriptRuns", () => {},]);});++ it("caps linked runs to the limit, keeping the most recent by createdAt", () => {+ // 30 runs, run-0 oldest … run-29 newest.+ const linkedRuns = Array.from({ length: 30 }, (_, i) =>+ linkedRun(i, new Date(Date.UTC(2026, 0, 1, 0, i)).toISOString()),+ );++ const runs = resolveIssueChatTranscriptRuns({ linkedRuns });++ expect(runs.length).toBe(MAX_ISSUE_CHAT_TRANSCRIPT_RUNS);+ // Newest run retained, oldest dropped.+ const ids = runs.map((r) => r.id);+ expect(ids).toContain("run-29");+ expect(ids).not.toContain("run-0");+ });++ it("respects a custom limit", () => {+ const linkedRuns = Array.from({ length: 10 }, (_, i) =>+ linkedRun(i, new Date(Date.UTC(2026, 0, 1, 0, i)).toISOString()),+ );++ const runs = resolveIssueChatTranscriptRuns({ linkedRuns, limit: 3 });++ expect(runs.length).toBe(3);+ expect(runs.map((r) => r.id)).toEqual(["run-9", "run-8", "run-7"]);+ });++ it("always retains live/active runs even beyond the limit", () => {+ const linkedRuns = Array.from({ length: 25 }, (_, i) =>+ linkedRun(i, new Date(Date.UTC(2026, 0, 1, 0, i)).toISOString()),+ );+ const liveRuns = [+ { id: "live-1", status: "running", adapterType: "claude_local", logBytes: null, lastOutputBytes: 10 },+ ] as unknown as LiveRunForIssue[];++ const runs = resolveIssueChatTranscriptRuns({ linkedRuns, liveRuns, limit: 5 });++ const ids = runs.map((r) => r.id);+ // The live run is always present; linked runs fill the remaining slots.+ expect(ids).toContain("live-1");+ expect(runs.length).toBe(5);+ });});diff --git a/ui/src/lib/issueChatTranscriptRuns.ts b/ui/src/lib/issueChatTranscriptRuns.tsindex a2b5c1e754..3b67fc286a 100644--- a/ui/src/lib/issueChatTranscriptRuns.ts+++ b/ui/src/lib/issueChatTranscriptRuns.ts@@ -2,12 +2,31 @@ import type { ActiveRunForIssue, LiveRunForIssue } from "../api/heartbeats";import type { RunTranscriptSource } from "../components/transcript/useLiveRunTranscripts";import type { IssueChatLinkedRun } from "./issue-chat-messages";+/**+ * Upper bound on how many runs an issue thread streams live transcripts for.+ *+ * Live/active runs are always included (they are the ones actually streaming);+ * older linked runs are historical and only fill the remaining slots, most+ * recent first. Without this cap a long-lived issue with a large run history+ * would open a live-transcript poll/subscription for every run it ever had —+ * multiplying the steady-state polling and re-render churn (and off-heap+ * growth) that this change set is fixing.+ */+export const MAX_ISSUE_CHAT_TRANSCRIPT_RUNS = 20;++function toTimestamp(value: Date | string | null | undefined): number {+ if (!value) return 0;+ const ms = value instanceof Date ? value.getTime() : new Date(value).getTime();+ return Number.isFinite(ms) ? ms : 0;+}+export function resolveIssueChatTranscriptRuns(args: {linkedRuns?: readonly IssueChatLinkedRun[];liveRuns?: readonly LiveRunForIssue[];activeRun?: ActiveRunForIssue | null;+ limit?: number;}): RunTranscriptSource[] {- const { linkedRuns = [], liveRuns = [], activeRun = null } = args;+ const { linkedRuns = [], liveRuns = [], activeRun = null, limit = MAX_ISSUE_CHAT_TRANSCRIPT_RUNS } = args;const combined = new Map<string, RunTranscriptSource>();for (const run of liveRuns) {@@ -30,8 +49,14 @@ export function resolveIssueChatTranscriptRuns(args: {});}- for (const run of linkedRuns) {- if (combined.has(run.runId)) continue;+ // Live/active runs above are always retained; fill the remaining slots with+ // the most recently created linked runs so the retained set is bounded.+ const remainingLinked = [...linkedRuns]+ .filter((run) => !combined.has(run.runId) && run.adapterType)+ .sort((a, b) => toTimestamp(b.createdAt) - toTimestamp(a.createdAt));++ for (const run of remainingLinked) {+ if (combined.size >= limit) break;const adapterType = run.adapterType;if (!adapterType) continue;combined.set(run.runId, {diff --git a/ui/src/lib/query-invalidation-batcher.test.ts b/ui/src/lib/query-invalidation-batcher.test.tsnew file mode 100644index 0000000000..12ce094ac7--- /dev/null+++ b/ui/src/lib/query-invalidation-batcher.test.ts@@ -0,0 +1,141 @@+import { afterEach, beforeEach, describe, expect, it, vi } from "vitest";+import type { QueryClient } from "@tanstack/react-query";+import {+ createCoalescingQueryClient,+ createInvalidationBatcher,+} from "./query-invalidation-batcher";++function fakeClient() {+ const calls: unknown[] = [];+ const client = {+ invalidateQueries: vi.fn((filters?: unknown) => {+ calls.push(filters);+ return Promise.resolve();+ }),+ };+ return { client, calls };+}++describe("createInvalidationBatcher", () => {+ beforeEach(() => vi.useFakeTimers());+ afterEach(() => vi.useRealTimers());++ it("coalesces repeated invalidations of the same key into one call per window", () => {+ const { client } = fakeClient();+ const batcher = createInvalidationBatcher(client, 300);++ for (let i = 0; i < 20; i++) batcher.schedule({ queryKey: ["dashboard", "c1"] });+ expect(client.invalidateQueries).not.toHaveBeenCalled(); // nothing until flush++ vi.advanceTimersByTime(300);+ expect(client.invalidateQueries).toHaveBeenCalledTimes(1);+ expect(client.invalidateQueries).toHaveBeenCalledWith({ queryKey: ["dashboard", "c1"] });+ });++ it("keeps distinct keys and distinct refetchType variants separate", () => {+ const { client } = fakeClient();+ const batcher = createInvalidationBatcher(client, 300);++ batcher.schedule({ queryKey: ["a"] });+ batcher.schedule({ queryKey: ["b"] });+ batcher.schedule({ queryKey: ["a"] }); // dup of first+ batcher.schedule({ queryKey: ["a"], refetchType: "inactive" }); // distinct variant++ vi.advanceTimersByTime(300);+ expect(client.invalidateQueries).toHaveBeenCalledTimes(3);+ });++ it("never coalesces predicate-based invalidations", () => {+ const { client } = fakeClient();+ const batcher = createInvalidationBatcher(client, 300);++ // Two distinct predicate filters must both run — they can't be proven equal.+ batcher.schedule({ predicate: () => true });+ batcher.schedule({ predicate: () => false });++ vi.advanceTimersByTime(300);+ expect(client.invalidateQueries).toHaveBeenCalledTimes(2);+ });++ it("schedule() resolves only after the flush has invalidated", async () => {+ const { client } = fakeClient();+ const batcher = createInvalidationBatcher(client, 300);++ let resolved = false;+ const p = batcher.schedule({ queryKey: ["a"] }).then(() => {+ resolved = true;+ });++ await Promise.resolve();+ expect(resolved).toBe(false); // not yet — window still open+ expect(client.invalidateQueries).not.toHaveBeenCalled();++ vi.advanceTimersByTime(300);+ await p;+ expect(resolved).toBe(true);+ expect(client.invalidateQueries).toHaveBeenCalledTimes(1);+ });++ it("starts a fresh window after flushing", () => {+ const { client } = fakeClient();+ const batcher = createInvalidationBatcher(client, 300);++ batcher.schedule({ queryKey: ["a"] });+ vi.advanceTimersByTime(300);+ expect(client.invalidateQueries).toHaveBeenCalledTimes(1);++ batcher.schedule({ queryKey: ["a"] });+ vi.advanceTimersByTime(300);+ expect(client.invalidateQueries).toHaveBeenCalledTimes(2);+ });++ it("dispose cancels a pending flush", () => {+ const { client } = fakeClient();+ const batcher = createInvalidationBatcher(client, 300);++ batcher.schedule({ queryKey: ["a"] });+ batcher.dispose();+ vi.advanceTimersByTime(1000);+ expect(client.invalidateQueries).not.toHaveBeenCalled();+ });++ it("flush() invalidates immediately", () => {+ const { client } = fakeClient();+ const batcher = createInvalidationBatcher(client, 300);++ batcher.schedule({ queryKey: ["a"] });+ batcher.flush();+ expect(client.invalidateQueries).toHaveBeenCalledTimes(1);+ });+});++describe("createCoalescingQueryClient", () => {+ beforeEach(() => vi.useFakeTimers());+ afterEach(() => vi.useRealTimers());++ it("batches invalidateQueries but passes other methods straight through", () => {+ const setQueryData = vi.fn();+ const getQueryData = vi.fn(() => ({ some: "data" }));+ const realInvalidate = vi.fn(() => Promise.resolve());+ const real = { invalidateQueries: realInvalidate, setQueryData, getQueryData } as unknown as QueryClient;++ const batcher = createInvalidationBatcher(+ { invalidateQueries: realInvalidate } as unknown as QueryClient,+ 300,+ );+ const proxied = createCoalescingQueryClient(real, batcher);++ // setQueryData / getQueryData pass through immediately.+ proxied.setQueryData(["k"], 1);+ expect(setQueryData).toHaveBeenCalledWith(["k"], 1);+ expect(proxied.getQueryData(["k"])).toEqual({ some: "data" });++ // invalidateQueries is deferred through the batcher.+ void proxied.invalidateQueries({ queryKey: ["k"] });+ void proxied.invalidateQueries({ queryKey: ["k"] });+ expect(realInvalidate).not.toHaveBeenCalled();++ vi.advanceTimersByTime(300);+ expect(realInvalidate).toHaveBeenCalledTimes(1);+ });+});diff --git a/ui/src/lib/query-invalidation-batcher.ts b/ui/src/lib/query-invalidation-batcher.tsnew file mode 100644index 0000000000..d5967aff5c--- /dev/null+++ b/ui/src/lib/query-invalidation-batcher.ts@@ -0,0 +1,144 @@+import type { InvalidateQueryFilters, QueryClient } from "@tanstack/react-query";++/**+ * Coalesces React Query invalidations triggered by the live-events stream.+ *+ * `LiveUpdatesProvider` used to call `queryClient.invalidateQueries(...)`+ * synchronously for every websocket event. During an active agent run these+ * fire many times per second, and each invalidation cascades into refetches+ * and re-renders — the dominant source of steady-state CPU churn (and, over a+ * long-lived tab, off-heap allocation growth).+ *+ * The batcher collects invalidation filters over a short window, de-duplicates+ * identical ones, and flushes them in a single pass at most once per interval.+ * A trailing-throttle (not a pure debounce) is used deliberately: during a+ * continuous event stream a pure debounce would never flush, so UI updates+ * would stall; throttling guarantees the buffered invalidations flush every+ * `intervalMs`.+ */+export interface InvalidationBatcher {+ /** Schedule an invalidation; resolves once the batched flush has run. */+ schedule: (filters: InvalidateQueryFilters) => Promise<void>;+ /** Flush any buffered invalidations immediately (e.g. before teardown). */+ flush: () => Promise<void>;+ dispose: () => void;+}++export const DEFAULT_INVALIDATION_INTERVAL_MS = 300;++type Deferred = { promise: Promise<void>; resolve: () => void };++function createDeferred(): Deferred {+ let resolve!: () => void;+ const promise = new Promise<void>((r) => {+ resolve = r;+ });+ return { promise, resolve };+}++export function createInvalidationBatcher(+ queryClient: Pick<QueryClient, "invalidateQueries">,+ intervalMs: number = DEFAULT_INVALIDATION_INTERVAL_MS,+): InvalidationBatcher {+ // Keyed by a stable serialization of the filters so repeated invalidations of+ // the same key (the common case) collapse to one entry.+ const pending = new Map<string, InvalidateQueryFilters>();+ let timer: ReturnType<typeof setTimeout> | null = null;+ // Resolves when the currently-buffered window has been flushed. `schedule`+ // hands this back so callers that await it observe the real invalidation.+ let windowDeferred: Deferred | null = null;++ const flush = async (): Promise<void> => {+ if (timer !== null) {+ clearTimeout(timer);+ timer = null;+ }+ const deferred = windowDeferred;+ windowDeferred = null;+ if (pending.size === 0) {+ deferred?.resolve();+ return;+ }+ const filtersList = [...pending.values()];+ pending.clear();+ try {+ await Promise.all(filtersList.map((filters) => queryClient.invalidateQueries(filters)));+ } finally {+ deferred?.resolve();+ }+ };++ const schedule = (filters: InvalidateQueryFilters): Promise<void> => {+ pending.set(serializeFilters(filters), filters);+ if (windowDeferred === null) {+ windowDeferred = createDeferred();+ }+ if (timer === null) {+ timer = setTimeout(() => void flush(), intervalMs);+ }+ return windowDeferred.promise;+ };++ const dispose = () => {+ if (timer !== null) {+ clearTimeout(timer);+ timer = null;+ }+ pending.clear();+ // Release any awaiters so they don't hang forever after teardown.+ windowDeferred?.resolve();+ windowDeferred = null;+ };++ return { schedule, flush, dispose };+}++let uniqueFilterCounter = 0;++function serializeFilters(filters: InvalidateQueryFilters): string {+ // A predicate is an opaque function — two predicate-based filters can never be+ // proven equal, so never coalesce them (that would silently drop one). Give+ // each its own key.+ if (typeof filters.predicate === "function") {+ return `__predicate__:${(uniqueFilterCounter += 1)}`;+ }+ // queryKey drives the identity; refetchType/exact/type change the behavior, so+ // keep them distinct while still collapsing exact repeats.+ try {+ return JSON.stringify([+ filters.queryKey ?? null,+ filters.refetchType ?? null,+ filters.exact ?? null,+ filters.type ?? null,+ ]);+ } catch {+ // Non-serializable filter (shouldn't happen for our query keys) — fall back+ // to a unique key so it is never dropped.+ return `__nonserializable__:${(uniqueFilterCounter += 1)}`;+ }+}++/**+ * Wrap a QueryClient so `invalidateQueries` is routed through `batcher` while+ * every other method (reads, `setQueryData`, …) passes straight through to the+ * real client. Returned value is a `QueryClient` and can be used anywhere one+ * is expected. Private class fields keep working because methods are bound to+ * the real client via `Reflect.get(target, prop, target)`.+ *+ * The batched `invalidateQueries` returns a promise that resolves only after the+ * flush actually runs, so callers that await it still observe completion.+ */+export function createCoalescingQueryClient(+ queryClient: QueryClient,+ batcher: InvalidationBatcher,+): QueryClient {+ return new Proxy(queryClient, {+ get(target, prop) {+ if (prop === "invalidateQueries") {+ return (filters?: InvalidateQueryFilters) => batcher.schedule(filters ?? {});+ }+ const value = Reflect.get(target, prop, target);+ return typeof value === "function" ? value.bind(target) : value;+ },+ });+}diff --git a/ui/src/main.tsx b/ui/src/main.tsxindex b37c5a0824..39a37bd5c5 100644--- a/ui/src/main.tsx+++ b/ui/src/main.tsx@@ -32,6 +32,10 @@ const queryClient = new QueryClient({defaultOptions: {queries: {staleTime: 30_000,+ // Explicit so cross-tab-published cache entries for resources this tab+ // isn't observing get collected promptly rather than lingering. Single+ // tuning point if we need to trim the cache footprint further.+ gcTime: 5 * 60_000,refetchOnWindowFocus: true,},},