@cortexkit/opencode-magic-context 0.31.5 → 0.32.1

package/src/shared/models-dev-cache.test.ts

@@ -6,6 +6,7 @@ import {
     clearModelsDevCache,
     getModelsDevCacheState,
     getSdkContextLimit,
+    getSdkInputLimit,
     refreshModelLimitsAfterAuthOnce,
     refreshModelLimitsFromApi,
     resetAuthRewarmLatchForTest,
@@ -62,7 +63,9 @@ describe("models-dev-cache (SDK-only)", () => {
         );
 
         expect(getSdkContextLimit("github-copilot", "gpt-5.3-codex")).toBe(272000);
+        expect(getSdkInputLimit("github-copilot", "gpt-5.3-codex")).toBe(272000);
         expect(getSdkContextLimit("github-copilot", "legacy-only-context")).toBe(100000);
+        expect(getSdkInputLimit("github-copilot", "legacy-only-context")).toBeUndefined();
         expect(getSdkContextLimit("unknown", "unknown")).toBeUndefined();
     });
 
@@ -78,6 +81,7 @@ describe("models-dev-cache (SDK-only)", () => {
             ]),
         );
         expect(getSdkContextLimit("openai", "gpt-5.5")).toBe(272000);
+        expect(getSdkInputLimit("openai", "gpt-5.5")).toBe(272000);
     });
 
     test("derived experimental.modes inherit the effective (input) limit", async () => {
@@ -172,6 +176,7 @@ describe("models-dev-cache (SDK-only)", () => {
                 makeClient([{ id: "openai", models: { "gpt-5.5": { limit: { input: 272000 } } } }]),
             );
             expect(getSdkContextLimit("openai", "gpt-5.5")).toBe(272000);
+            expect(getSdkInputLimit("openai", "gpt-5.5")).toBe(272000);
 
             // Simulate a restart: in-memory cache gone, but the persisted file
             // remains under XDG_DATA_HOME. The next lookup seeds from disk.

package/src/shared/models-dev-cache.ts

@@ -56,6 +56,8 @@ export function isSaneLimit(limit: number | undefined): limit is number {
 
 interface CachedModelMetadata {
     limit?: number;
+    /** Provider-enforced prompt cap. Undefined when only a combined context window is known. */
+    inputLimit?: number;
 }
 
 /**
@@ -90,10 +92,20 @@ function loadPersistedApiCacheOnce(): void {
     persistSeedLoaded = true;
     try {
         const raw = readFileSync(persistFilePath(), "utf-8");
-        const obj = JSON.parse(raw) as Record<string, number>;
+        const obj = JSON.parse(raw) as Record<
+            string,
+            number | { limit?: number; inputLimit?: number }
+        >;
         const map = new Map<string, CachedModelMetadata>();
-        for (const [key, limit] of Object.entries(obj)) {
-            if (isSaneLimit(limit)) map.set(key, { limit });
+        for (const [key, persisted] of Object.entries(obj)) {
+            const limit = typeof persisted === "number" ? persisted : persisted.limit;
+            const inputLimit = typeof persisted === "number" ? undefined : persisted.inputLimit;
+            if (isSaneLimit(limit)) {
+                map.set(key, {
+                    limit,
+                    inputLimit: isSaneLimit(inputLimit) ? inputLimit : undefined,
+                });
+            }
         }
         if (map.size > 0) {
             apiCache = map;
@@ -112,9 +124,14 @@ function loadPersistedApiCacheOnce(): void {
  *  never sees a torn file (the exact failure mode we're eliminating). */
 function persistApiCache(): void {
     if (!apiCache) return;
-    const obj: Record<string, number> = {};
+    const obj: Record<string, CachedModelMetadata> = {};
     for (const [key, value] of apiCache) {
-        if (isSaneLimit(value.limit)) obj[key] = value.limit;
+        if (isSaneLimit(value.limit)) {
+            obj[key] = {
+                limit: value.limit,
+                inputLimit: isSaneLimit(value.inputLimit) ? value.inputLimit : undefined,
+            };
+        }
     }
     try {
         const dir = getMagicContextStorageDir();
@@ -157,6 +174,7 @@ function setCachedModelMetadata(
         | undefined,
 ): void {
     const limit = resolveLimit(model?.limit);
+    const inputLimit = model?.limit?.input;
 
     // Only cache plausible limits. A value outside [20k, 3M] is garbage (torn
     // read / unconfigured default) and must never enter the cache or get
@@ -165,7 +183,10 @@ function setCachedModelMetadata(
         return;
     }
 
-    const value: CachedModelMetadata = { limit };
+    const value: CachedModelMetadata = {
+        limit,
+        inputLimit: isSaneLimit(inputLimit) ? inputLimit : undefined,
+    };
     cache.set(key, value);
 
     // OpenCode creates derived model IDs from experimental.modes
@@ -332,6 +353,23 @@ export function getSdkContextLimit(providerID: string, modelID: string): number
     return isSaneLimit(fromApi) ? fromApi : undefined;
 }
 
+/**
+ * Return only a provider-declared input cap. A combined context window is useful
+ * for scheduling but is not safe as a fail-closed prompt boundary.
+ */
+export function getSdkInputLimit(providerID: string, modelID: string): number | undefined {
+    loadPersistedApiCacheOnce();
+    if (!apiCache) return undefined;
+    const direct = apiCache.get(`${providerID}/${modelID}`)?.inputLimit;
+    if (isSaneLimit(direct)) return direct;
+    const colon = modelID.indexOf(":");
+    if (colon > 0) {
+        const tagless = apiCache.get(`${providerID}/${modelID.slice(0, colon)}`)?.inputLimit;
+        if (isSaneLimit(tagless)) return tagless;
+    }
+    return undefined;
+}
+
 /**
  * Look up a model's limit in the cache, with an ollama-style tag-suffix
  * fallback. ollama invokes cloud models with a tag at runtime

package/src/shared/opencode-compaction-detector.test.ts

@@ -6,24 +6,33 @@ import * as configDir from "./opencode-config-dir";
 
 describe("opencode-compaction-detector", () => {
     let tmpDir: string;
+    let previousDisableAutocompact: string | undefined;
+    let restoreConfigPaths: () => void;
 
     beforeEach(() => {
         tmpDir = join("/tmp", `compaction-detector-test-${Date.now()}`);
         mkdirSync(join(tmpDir, ".opencode"), { recursive: true });
+        previousDisableAutocompact = process.env.OPENCODE_DISABLE_AUTOCOMPACT;
         delete process.env.OPENCODE_DISABLE_AUTOCOMPACT;
-        spyOn(configDir, "getOpenCodeConfigPaths").mockReturnValue({
+        const configPathsSpy = spyOn(configDir, "getOpenCodeConfigPaths").mockReturnValue({
             configJson: join(tmpDir, "user-config", "opencode.json"),
             configJsonc: join(tmpDir, "user-config", "opencode.jsonc"),
         } as ReturnType<typeof configDir.getOpenCodeConfigPaths>);
+        restoreConfigPaths = () => configPathsSpy.mockRestore();
     });
 
     afterEach(() => {
+        restoreConfigPaths();
         try {
             rmSync(tmpDir, { recursive: true, force: true, maxRetries: 10, retryDelay: 100 });
         } catch {
             /* Ignore EBUSY on Windows */
         }
-        delete process.env.OPENCODE_DISABLE_AUTOCOMPACT;
+        if (previousDisableAutocompact === undefined) {
+            delete process.env.OPENCODE_DISABLE_AUTOCOMPACT;
+        } else {
+            process.env.OPENCODE_DISABLE_AUTOCOMPACT = previousDisableAutocompact;
+        }
     });
 
     describe("#given no config exists", () => {

package/src/shared/rpc-client.test.ts

@@ -4,7 +4,12 @@ import { createServer } from "node:http";
 import { tmpdir } from "node:os";
 import { dirname, join } from "node:path";
 import { MagicContextRpcClient } from "./rpc-client";
-import { drainNotifications, isTuiConnected, pushNotification } from "./rpc-notifications";
+import {
+    __resetNotificationStateForTests,
+    drainNotifications,
+    isTuiConnected,
+    pushNotification,
+} from "./rpc-notifications";
 import { MagicContextRpcServer } from "./rpc-server";
 import { parseRpcPortFile, type RpcPortFileRecord, rpcPortDir, rpcPortFilePath } from "./rpc-utils";
 
@@ -20,6 +25,7 @@ afterEach(async () => {
     for (const server of servers.splice(0)) {
         await server.close();
     }
+    __resetNotificationStateForTests();
     for (const dir of tempDirs.splice(0)) {
         try {
             rmSync(dir, { recursive: true, force: true, maxRetries: 10, retryDelay: 100 });
@@ -51,10 +57,23 @@ function writePortFileForPid(
     port: number,
     pid: number,
     startedAt: number,
-): void {
-    const portFile = rpcPortFilePath(storageDir, directory, pid);
+    instanceId?: string,
+    token?: string,
+): string {
+    const portFile = rpcPortFilePath(storageDir, directory, pid, instanceId);
     mkdirSync(dirname(portFile), { recursive: true });
-    writeFileSync(portFile, JSON.stringify({ port, pid, started_at: startedAt }), "utf-8");
+    writeFileSync(
+        portFile,
+        JSON.stringify({
+            port,
+            pid,
+            started_at: startedAt,
+            instance_id: instanceId,
+            token,
+        }),
+        "utf-8",
+    );
+    return portFile;
 }
 
 function readNewestPortRecord(storageDir: string, directory: string): RpcPortFileRecord | null {
@@ -79,8 +98,16 @@ async function waitFor(condition: () => boolean, label: string, timeoutMs = 2_00
     throw new Error(`Timed out waiting for ${label}`);
 }
 
-async function openSocket(port: number, token: string): Promise<WebSocket> {
-    const ws = new WebSocket(`ws://127.0.0.1:${port}/ws?token=${encodeURIComponent(token)}`);
+async function openSocket(
+    port: number,
+    token: string,
+    legacyQueryAuth = false,
+): Promise<WebSocket> {
+    const ws = legacyQueryAuth
+        ? new WebSocket(`ws://127.0.0.1:${port}/ws?token=${encodeURIComponent(token)}`)
+        : new WebSocket(`ws://127.0.0.1:${port}/ws`, {
+              headers: { Authorization: `Bearer ${token}` },
+          });
     await new Promise<void>((resolve, reject) => {
         const timeout = setTimeout(() => reject(new Error("socket open timed out")), 2_000);
         ws.addEventListener(
@@ -129,11 +156,14 @@ function waitForJsonMessage<T extends { type?: string }>(
     });
 }
 
-async function startRpcServer(handler: (method: string) => Response | object): Promise<TestServer> {
+async function startRpcServer(
+    handler: (method: string) => Response | object,
+    health: { pid: number; instanceId?: string } = { pid: process.pid },
+): Promise<TestServer> {
     const server = createServer(async (req, res) => {
         if (req.method === "GET" && req.url === "/health") {
             res.writeHead(200, { "Content-Type": "application/json" });
-            res.end(JSON.stringify({ ok: true }));
+            res.end(JSON.stringify({ ok: true, pid: health.pid, instance_id: health.instanceId }));
             return;
         }
 
@@ -238,6 +268,31 @@ describe("MagicContextRpcClient", () => {
         }
     });
 
+    test("accepts a frozen v0.32 websocket upgrade with query-token auth", async () => {
+        const storageDir = makeTempDir();
+        const directory = "/repo-ws-v032";
+        const server = new MagicContextRpcServer(storageDir, directory);
+        const port = await server.start();
+        const record = readNewestPortRecord(storageDir, directory);
+        expect(typeof record?.token).toBe("string");
+
+        const ws = await openSocket(port, record?.token ?? "", true);
+        try {
+            const helloAck = waitForJsonMessage(ws, (message) => message.type === "hello-ack");
+            ws.send(
+                JSON.stringify({
+                    type: "hello",
+                    token: record?.token,
+                    sessionId: "ses_v032",
+                }),
+            );
+            expect((await helloAck).type).toBe("hello-ack");
+        } finally {
+            ws.close();
+            server.stop();
+        }
+    });
+
     test("websocket upgrade rejects missing bearer token before a socket is created", async () => {
         const storageDir = makeTempDir();
         const directory = "/repo-ws-auth";
@@ -300,6 +355,52 @@ describe("MagicContextRpcClient", () => {
         }
     });
 
+    test("accepts legacy cursor acknowledgements during protocol skew", async () => {
+        __resetNotificationStateForTests();
+        const storageDir = makeTempDir();
+        const directory = "/repo-legacy-ack";
+        const server = new MagicContextRpcServer(storageDir, directory);
+        const port = await server.start();
+        const record = readNewestPortRecord(storageDir, directory);
+        expect(typeof record?.token).toBe("string");
+
+        pushNotification("legacy-one", { ok: true }, "ses_legacy");
+        pushNotification("legacy-two", { ok: true }, "ses_legacy");
+        const queued = drainNotifications(0, "ses_legacy", { sessionOnly: true });
+        expect(queued).toHaveLength(2);
+
+        const ws = await openSocket(port, record?.token ?? "");
+        try {
+            const helloAck = waitForJsonMessage<{
+                type?: string;
+                instanceId?: string;
+            }>(ws, (message) => message.type === "hello-ack");
+            ws.send(
+                JSON.stringify({
+                    type: "hello",
+                    token: record?.token,
+                    sessionId: "ses_legacy",
+                }),
+            );
+            expect((await helloAck).instanceId).toBe(record?.instance_id);
+
+            ws.send(
+                JSON.stringify({
+                    type: "ack",
+                    cursor: queued[0].id,
+                    sessionId: "ses_legacy",
+                }),
+            );
+            await waitFor(() => {
+                const pending = drainNotifications(0, "ses_legacy", { sessionOnly: true });
+                return pending.length === 1 && pending[0].id === queued[1].id;
+            }, "legacy cursor acknowledgement pruning");
+        } finally {
+            ws.close();
+            server.stop();
+        }
+    });
+
     test("same-process servers keep distinct port files during overlap", async () => {
         const storageDir = makeTempDir();
         const directory = "/repo-port-collision";
@@ -319,7 +420,9 @@ describe("MagicContextRpcClient", () => {
             expect(remaining?.port).toBe(secondPort);
 
             const client = new MagicContextRpcClient(storageDir, directory);
-            expect((await client.resolveEndpoint())?.port).toBe(secondPort);
+            const endpoint = await client.resolveEndpoint();
+            expect(endpoint?.port).toBe(secondPort);
+            expect(endpoint?.instanceId).toBe(remaining?.instance_id);
         } finally {
             first.stop();
             second.stop();
@@ -368,4 +471,105 @@ describe("MagicContextRpcClient", () => {
         const client = new MagicContextRpcClient(storageDir, directory);
         expect(await client.call<{ value: string }>("value")).toEqual({ value: "live" });
     });
+
+    test("discovers a frozen v0.32 health response without an instance id", async () => {
+        const storageDir = makeTempDir();
+        const directory = "/repo-v032-health";
+        const legacy = await startRpcServer(() => ({ value: "legacy" }), {
+            pid: process.pid,
+        });
+        writePortFileForPid(
+            storageDir,
+            directory,
+            legacy.port,
+            process.pid,
+            Date.now(),
+            "new-client-record",
+        );
+
+        const client = new MagicContextRpcClient(storageDir, directory);
+        expect(await client.call<{ value: string }>("value")).toEqual({ value: "legacy" });
+    });
+
+    test("prefers this process and validates every discovery candidate identity", async () => {
+        const storageDir = makeTempDir();
+        const directory = "/repo-affinity";
+        const foreign = await startRpcServer(() => ({ value: "foreign" }), {
+            pid: process.ppid,
+            instanceId: "foreign",
+        });
+        const unrelated = await startRpcServer(() => ({ value: "unrelated" }), {
+            pid: process.pid,
+            instanceId: "different-service",
+        });
+        const local = await startRpcServer(() => ({ value: "local" }), {
+            pid: process.pid,
+            instanceId: "local-healthy",
+        });
+
+        writePortFileForPid(
+            storageDir,
+            directory,
+            foreign.port,
+            process.ppid,
+            Date.now() + 20_000,
+            "foreign",
+        );
+        writePortFileForPid(
+            storageDir,
+            directory,
+            unrelated.port,
+            process.pid,
+            Date.now() + 10_000,
+            "local-stale",
+        );
+        writePortFileForPid(
+            storageDir,
+            directory,
+            local.port,
+            process.pid,
+            Date.now(),
+            "local-healthy",
+        );
+
+        const client = new MagicContextRpcClient(storageDir, directory);
+        expect(await client.call<{ value: string }>("value")).toEqual({ value: "local" });
+    });
+
+    test("resets discovery after a 401 response", async () => {
+        const storageDir = makeTempDir();
+        const directory = "/repo-reauth";
+        let unauthorizedRecord = "";
+        const unauthorized = await startRpcServer(
+            () => {
+                rmSync(unauthorizedRecord, { force: true });
+                return new Response("stale token", { status: 401 });
+            },
+            { pid: process.pid, instanceId: "unauthorized" },
+        );
+        const healthy = await startRpcServer(() => ({ value: "healthy" }), {
+            pid: process.pid,
+            instanceId: "healthy",
+        });
+        unauthorizedRecord = writePortFileForPid(
+            storageDir,
+            directory,
+            unauthorized.port,
+            process.pid,
+            Date.now() + 10_000,
+            "unauthorized",
+            "stale",
+        );
+        writePortFileForPid(
+            storageDir,
+            directory,
+            healthy.port,
+            process.pid,
+            Date.now(),
+            "healthy",
+        );
+
+        const client = new MagicContextRpcClient(storageDir, directory);
+        expect(await client.call<{ value: string }>("value")).toEqual({ value: "healthy" });
+    });
 });

package/src/shared/rpc-client.ts

@@ -18,6 +18,7 @@ type NonRetryableRpcError = Error & { [NON_RETRYABLE_RPC_ERROR]: true };
 export class MagicContextRpcClient {
     private port: number | null = null;
     private token: string | null = null;
+    private instanceId: string | null = null;
     private portDir: string;
     private legacyPortFilePath: string;
     private healthChecked = false;
@@ -62,7 +63,7 @@ export class MagicContextRpcClient {
                 if (!response.ok) {
                     const text = await response.text();
                     const error = new Error(`RPC ${method} failed (${response.status}): ${text}`);
-                    if (response.status >= 500) {
+                    if (response.status === 401 || response.status >= 500) {
                         lastError = error;
                         this.reset();
                         continue;
@@ -101,52 +102,47 @@ export class MagicContextRpcClient {
      *  channel). Reuses the same health-checked port-file discovery as `call`,
      *  so the WS client and the HTTP client always agree on which server instance
      *  (and token) to use. Returns null when no live server is found. */
-    async resolveEndpoint(): Promise<{ port: number; token: string | null } | null> {
+    async resolveEndpoint(): Promise<{
+        port: number;
+        token: string | null;
+        instanceId: string | null;
+    } | null> {
         try {
-            const port = await this.resolvePort();
+            // The socket owns reconnect backoff, so endpoint discovery performs one
+            // filesystem/health pass instead of nesting the HTTP client's retries.
+            const port = await this.resolvePort(1);
             if (port === null) return null;
-            return { port, token: this.token };
+            return { port, token: this.token, instanceId: this.instanceId };
         } catch {
             return null;
         }
     }
 
-    private async resolvePort(): Promise<number | null> {
+    private async resolvePort(maxAttempts = MAX_RETRIES): Promise<number | null> {
         if (this.port && this.healthChecked) {
             return this.port;
         }
 
-        if (this.port) {
-            const alive = await this.healthCheck(this.port);
-            if (alive) {
+        for (let attempt = 0; attempt < maxAttempts; attempt++) {
+            for (const record of this.readPortFiles()) {
+                if (!(await this.healthCheck(record))) continue;
+                this.port = record.port;
+                this.token = record.token ?? null;
+                this.instanceId = record.instance_id ?? null;
                 this.healthChecked = true;
-                return this.port;
-            }
-            this.port = null;
-            this.healthChecked = false;
-        }
-
-        for (let attempt = 0; attempt < MAX_RETRIES; attempt++) {
-            const record = this.readPortFile();
-            if (record) {
-                const alive = await this.healthCheck(record.port);
-                if (alive) {
-                    this.port = record.port;
-                    this.token = record.token ?? null;
-                    this.healthChecked = true;
-                    return record.port;
-                }
+                return record.port;
             }
 
-            if (attempt < MAX_RETRIES - 1) {
-                await new Promise((r) => setTimeout(r, RETRY_DELAY_MS));
+            this.reset();
+            if (attempt < maxAttempts - 1) {
+                await new Promise((resolve) => setTimeout(resolve, RETRY_DELAY_MS));
             }
         }
 
         return null;
     }
 
-    private readPortFile(): RpcPortFileRecord | null {
+    private readPortFiles(): RpcPortFileRecord[] {
         const records: RpcPortFileRecord[] = [];
 
         try {
@@ -160,26 +156,38 @@ export class MagicContextRpcClient {
             // Directory may not exist yet. Fall back to the legacy file below.
         }
 
-        if (records.length > 0) {
-            records.sort((a, b) => b.started_at - a.started_at);
-            return records[0];
-        }
-
         try {
-            const record = parseRpcPortFile(readFileSync(this.legacyPortFilePath, "utf-8"));
-            if (record?.pid && !isPidAlive(record.pid)) return null;
-            return record;
+            const legacy = parseRpcPortFile(readFileSync(this.legacyPortFilePath, "utf-8"));
+            if (legacy && (!legacy.pid || isPidAlive(legacy.pid))) records.push(legacy);
         } catch {
-            return null;
+            // Legacy discovery is optional.
         }
+
+        // A TUI and its server plugin normally share a process. Prefer that exact
+        // process before considering another live OpenCode instance for the project.
+        records.sort((a, b) => {
+            const aLocal = a.pid === process.pid ? 1 : 0;
+            const bLocal = b.pid === process.pid ? 1 : 0;
+            return bLocal - aLocal || b.started_at - a.started_at;
+        });
+        return records;
     }
 
-    private async healthCheck(port: number): Promise<boolean> {
+    private async healthCheck(record: RpcPortFileRecord): Promise<boolean> {
         try {
-            const response = await this.fetchWithTimeout(`http://127.0.0.1:${port}/health`, {
+            const response = await this.fetchWithTimeout(`http://127.0.0.1:${record.port}/health`, {
                 method: "GET",
             });
-            return response.ok;
+            if (!response.ok) return false;
+            const body = (await response.json()) as { pid?: unknown; instance_id?: unknown };
+            if (body.pid !== record.pid) return false;
+            // v0.32 health responses predate instance ids. A missing id is the
+            // one-release discovery bridge; an id that is present must still match.
+            return (
+                body.instance_id === undefined ||
+                record.instance_id === undefined ||
+                body.instance_id === record.instance_id
+            );
         } catch {
             return false;
         }
@@ -198,6 +206,7 @@ export class MagicContextRpcClient {
     reset(): void {
         this.port = null;
         this.token = null;
+        this.instanceId = null;
         this.healthChecked = false;
     }
 }

package/src/shared/rpc-notifications.test.ts

@@ -70,10 +70,25 @@ describe("rpc notifications", () => {
         expect(isTuiConnected()).toBe(false);
     });
 
-    test("a session-less sink counts as connected for any session query", () => {
+    test("a modern session-less sink is global-only", () => {
+        const received: string[] = [];
+        const unregister = registerNotificationSink({
+            sessionId: undefined,
+            protocol: 2,
+            send: (notification) => received.push(notification.type),
+        });
+        expect(isTuiConnected("ses_whatever")).toBe(false);
+        expect(isTuiConnected()).toBe(true);
+
+        pushNotification("scoped", { ok: true }, "ses_whatever");
+        pushNotification("global", { ok: true });
+        expect(received).toEqual(["global"]);
+        unregister();
+    });
+
+    test("a legacy session-less sink retains broad compatibility", () => {
         const unregister = registerNotificationSink({ sessionId: undefined, send: () => {} });
         expect(isTuiConnected("ses_whatever")).toBe(true);
-        expect(isTuiConnected()).toBe(true);
         unregister();
     });
 
@@ -117,14 +132,20 @@ describe("rpc notifications", () => {
 
     test("queue-cap eviction is session-fair: a noisy session cannot evict another session's newest unseen item", () => {
         drainNotifications(Number.MAX_SAFE_INTEGER);
-        // One quiet session with a single pending dialog.
         pushNotification("quiet-dialog", { action: "show-upgrade-dialog" }, "ses_quiet");
-        // A noisy session floods well past the 100 cap.
         for (let i = 0; i < 200; i += 1) {
             pushNotification("noise", { i }, "ses_noisy");
         }
-        // The quiet session's newest item must survive the eviction.
         const quietPoll = drainNotifications(0, "ses_quiet");
         expect(quietPoll.some((m) => m.type === "quiet-dialog")).toBe(true);
+        expect(drainNotifications(0)).toHaveLength(100);
+    });
+
+    test("queue cap remains global across more than one hundred sessions", () => {
+        drainNotifications(Number.MAX_SAFE_INTEGER);
+        for (let i = 0; i < 250; i += 1) {
+            pushNotification("one-per-session", { i }, `ses_${i}`);
+        }
+        expect(drainNotifications(0)).toHaveLength(100);
     });
 });