@cortexkit/opencode-magic-context 0.18.0 → 0.19.0

package/src/shared/conflict-fixer.ts

@@ -1,8 +1,13 @@
-import { existsSync, mkdirSync, writeFileSync } from "node:fs";
-import { dirname, join } from "node:path";
-
-import type { ConflictResult } from "./conflict-detector";
-import { readJsoncFile } from "./jsonc-parser";
+import { existsSync, readFileSync, writeFileSync } from "node:fs";
+import { join } from "node:path";
+import { parse, stringify } from "comment-json";
+
+import {
+    type ConflictResult,
+    DCP_PACKAGE_NAMES,
+    extractPluginName,
+    matchesPackageName,
+} from "./conflict-detector";
 import { getOpenCodeConfigPaths } from "./opencode-config-dir";
 
 type JsonObject = Record<string, unknown>;
@@ -20,10 +25,6 @@ const OMO_CONFIG_NAMES = [
     "oh-my-opencode.json",
 ] as const;
 
-function ensureParentDir(filePath: string): void {
-    mkdirSync(dirname(filePath), { recursive: true });
-}
-
 function isRecord(value: unknown): value is JsonObject {
     return typeof value === "object" && value !== null && !Array.isArray(value);
 }
@@ -36,18 +37,19 @@ function asStringArray(value: unknown): string[] {
 
 function readConfig(filePath: string): JsonObject | null {
     if (!existsSync(filePath)) {
-        return {};
+        return null;
     }
 
-    return readJsoncFile<JsonObject>(filePath);
+    try {
+        const parsed = parse(readFileSync(filePath, "utf-8"));
+        return isRecord(parsed) ? parsed : null;
+    } catch {
+        return null;
+    }
 }
 
-// Intentional: conflict-fixer uses JSON.stringify (not comment-json) because this module
-// is imported by the TUI process which loads raw source and cannot resolve npm dependencies.
-// Comment preservation for config writes is handled by the CLI paths (doctor.ts, setup.ts).
 function writeConfig(filePath: string, config: JsonObject): void {
-    ensureParentDir(filePath);
-    writeFileSync(filePath, `${JSON.stringify(config, null, 2)}\n`);
+    writeFileSync(filePath, `${stringify(config, null, 2)}\n`);
 }
 
 function resolveUserOpenCodeConfigPath(): string {
@@ -60,7 +62,9 @@ function collectOpenCodeConfigPaths(directory: string): string[] {
     const paths = new Set<string>();
     const userConfig = resolveUserOpenCodeConfigPath();
 
-    paths.add(userConfig);
+    if (existsSync(userConfig)) {
+        paths.add(userConfig);
+    }
 
     for (const filePath of [
         join(directory, ".opencode", "opencode.jsonc"),
@@ -93,13 +97,17 @@ function collectOmoConfigPaths(directory: string): string[] {
         }
     }
 
-    if (paths.size === 0) {
-        paths.add(join(configDir, "oh-my-openagent.json"));
-    }
-
     return [...paths];
 }
 
+function filterDcpPluginEntries(entries: unknown[]): { plugins: unknown[]; removed: boolean } {
+    const plugins = entries.filter((entry) => {
+        const name = extractPluginName(entry);
+        return name ? !matchesPackageName(name, DCP_PACKAGE_NAMES) : true;
+    });
+    return { plugins, removed: plugins.length !== entries.length };
+}
+
 export function fixConflicts(directory: string, conflicts: ConflictResult["conflicts"]): string[] {
     const actions: string[] = [];
     let updatedCompaction = false;
@@ -116,7 +124,7 @@ export function fixConflicts(directory: string, conflicts: ConflictResult["confl
             let changed = false;
 
             if (conflicts.compactionAuto || conflicts.compactionPrune) {
-                const compaction = isRecord(config.compaction) ? { ...config.compaction } : {};
+                const compaction = isRecord(config.compaction) ? config.compaction : {};
 
                 if (compaction.auto !== false) {
                     compaction.auto = false;
@@ -134,13 +142,11 @@ export function fixConflicts(directory: string, conflicts: ConflictResult["confl
             }
 
             if (conflicts.dcpPlugin) {
-                const plugins = asStringArray(config.plugin);
-                const filteredPlugins = plugins.filter(
-                    (plugin) => !plugin.includes("opencode-dcp"),
-                );
+                const plugins = Array.isArray(config.plugin) ? config.plugin : [];
+                const filtered = filterDcpPluginEntries(plugins);
 
-                if (filteredPlugins.length !== plugins.length) {
-                    config.plugin = filteredPlugins;
+                if (filtered.removed) {
+                    config.plugin = filtered.plugins;
                     changed = true;
                     removedDcpPlugin = true;
                 }

package/src/shared/data-path.test.ts

@@ -8,6 +8,8 @@ import {
     getMagicContextStorageDir,
     getOpenCodeCacheDir,
     getOpenCodeStorageDir,
+    getProjectMagicContextDir,
+    getProjectMagicContextHistorianDir,
 } from "./data-path";
 
 const savedEnv = {
@@ -118,4 +120,40 @@ describe("data-path", () => {
         expect(legacy).toContain("opencode");
         expect(shared).toContain("cortexkit");
     });
+
+    test("getProjectMagicContextDir composes <project>/.opencode/magic-context", () => {
+        // Project-local artifacts (historian state file, failure dumps) live
+        // inside the project so OpenCode's external_directory permission system
+        // treats them as project-internal. Without this, historian's Read tool
+        // would trigger a permission prompt on every run when artifacts lived
+        // under os.tmpdir().
+        expect(getProjectMagicContextDir("/Users/me/Work/proj")).toBe(
+            path.join("/Users/me/Work/proj", ".opencode", "magic-context"),
+        );
+    });
+
+    test("getProjectMagicContextHistorianDir appends historian/", () => {
+        expect(getProjectMagicContextHistorianDir("/Users/me/Work/proj")).toBe(
+            path.join("/Users/me/Work/proj", ".opencode", "magic-context", "historian"),
+        );
+    });
+
+    test("getProjectMagicContextDir is unaffected by XDG_DATA_HOME", () => {
+        // Project-local paths anchor to the project directory the caller
+        // passes in, NOT to any user-config env var. Setting XDG_DATA_HOME
+        // (which changes the shared storage dir) must not change the
+        // project-local historian dir.
+        process.env.XDG_DATA_HOME = "/tmp/custom-data";
+        expect(getProjectMagicContextDir("/some/project")).toBe(
+            path.join("/some/project", ".opencode", "magic-context"),
+        );
+    });
+
+    test("getProjectMagicContextDir handles trailing slashes via path.join", () => {
+        // path.join normalizes redundant separators so callers don't need to
+        // worry about how the project directory was constructed.
+        expect(getProjectMagicContextDir("/some/project/")).toBe(
+            path.join("/some/project/", ".opencode", "magic-context"),
+        );
+    });
 });

package/src/shared/data-path.ts

@@ -1,10 +1,109 @@
 import * as os from "node:os";
 import * as path from "node:path";
+import { getHarness, type HarnessId } from "./harness";
 
 export function getDataDir(): string {
     return process.env.XDG_DATA_HOME ?? path.join(os.homedir(), ".local", "share");
 }
 
+/**
+ * Per-harness scratch directory under the OS temp dir.
+ *
+ * Layout:
+ *   - OpenCode: `${os.tmpdir()}/opencode/magic-context/`
+ *   - Pi:       `${os.tmpdir()}/pi/magic-context/`
+ *
+ * Why a per-harness subtree of `os.tmpdir()`:
+ *   1. OpenCode Desktop runs as an Electron app with a permission sandbox.
+ *      Writing to arbitrary tmp paths can trigger user-visible permission
+ *      prompts; the `${tmpdir}/opencode/` subtree is allow-listed by
+ *      OpenCode, so anything we put under it never asks for permission.
+ *   2. Splitting OpenCode from Pi keeps their logs and historian dump
+ *      directories cleanly separated. `doctor --issue` for each harness
+ *      reports diagnostics from the matching subtree, so an OpenCode
+ *      issue report never includes Pi log noise (and vice versa).
+ *   3. Pi has no permission sandbox, so the path choice is purely
+ *      cosmetic for Pi — it just keeps the layout symmetric.
+ *
+ * Pass an explicit `harness` only when the caller already knows the
+ * harness without relying on the global `setHarness()` state (e.g. the
+ * CLI's doctor commands, which target a specific harness regardless of
+ * which plugin is loaded). Production runtime callers should omit it so
+ * the helper picks up the boot-time harness automatically.
+ */
+export function getMagicContextTempDir(harness: HarnessId = getHarness()): string {
+    return path.join(os.tmpdir(), harness, "magic-context");
+}
+
+/**
+ * Standard log file path the plugin writes to. Pi and OpenCode write to
+ * SEPARATE logs under their respective harness subtrees so a single
+ * machine running both harnesses doesn't interleave session traces.
+ *
+ * The plugin's buffered logger calls this on every flush rather than
+ * caching, so `setHarness("pi")` taking effect after module load is
+ * reflected in the next flush.
+ */
+export function getMagicContextLogPath(harness: HarnessId = getHarness()): string {
+    return path.join(getMagicContextTempDir(harness), "magic-context.log");
+}
+
+/**
+ * Directory used for both historian validation-failure dumps and the
+ * existing-state offload XMLs that large historian/recomp passes write
+ * before invoking the model. Per-harness so dumps from different
+ * harnesses don't collide on filename and so `doctor --issue` for each
+ * harness reports only its own historian artifacts.
+ */
+export function getMagicContextHistorianDir(harness: HarnessId = getHarness()): string {
+    return path.join(getMagicContextTempDir(harness), "historian");
+}
+
+/**
+ * Project-local magic-context artifact directory.
+ *
+ * Layout: `<project-directory>/.opencode/magic-context/`
+ *
+ * Used for artifacts that the historian/recomp pipeline writes during a run
+ * and that the model is asked to read via its native Read tool. OpenCode's
+ * `external_directory` permission system asks the user before reading any
+ * file outside the project directory or its worktree, which interrupts every
+ * historian run when artifacts live under `os.tmpdir()`. Writing under the
+ * project's own `.opencode/` subtree falls inside the project boundary and
+ * never triggers a permission prompt.
+ *
+ * The `.opencode/` parent dir is OpenCode's own per-project convention (used
+ * for project-local config, plans, dumps, plugin installs). Anchoring
+ * magic-context artifacts under `.opencode/magic-context/` keeps them
+ * co-located with related OpenCode metadata and makes them easy for users to
+ * locate when debugging.
+ *
+ * Logger does NOT use this — log files stay in the per-harness tmp subtree
+ * because they are written by the plugin process itself (no model-side Read
+ * tool call, no permission prompt) and span sessions/projects.
+ */
+export function getProjectMagicContextDir(directory: string): string {
+    return path.join(directory, ".opencode", "magic-context");
+}
+
+/**
+ * Project-local historian artifact directory.
+ *
+ * Layout: `<project-directory>/.opencode/magic-context/historian/`
+ *
+ * Used for:
+ *   - existing-state offload XMLs that long historian/recomp passes write
+ *     before invoking the model (the model reads the file via Read tool)
+ *   - validation-failure dump XMLs preserved for debugging
+ *
+ * Callers must `mkdirSync(dir, { recursive: true })` before writing — the
+ * `.opencode/` parent may not exist on a fresh project, and write failures
+ * here must degrade gracefully (e.g. historian falls back to inline state).
+ */
+export function getProjectMagicContextHistorianDir(directory: string): string {
+    return path.join(getProjectMagicContextDir(directory), "historian");
+}
+
 export function getOpenCodeStorageDir(): string {
     return path.join(getDataDir(), "opencode", "storage");
 }

package/src/shared/logger.ts

@@ -1,8 +1,7 @@
 import * as fs from "node:fs";
-import * as os from "node:os";
 import * as path from "node:path";
+import { getMagicContextLogPath } from "./data-path";
 
-const logFile = path.join(os.tmpdir(), "magic-context.log");
 const isTestEnv = process.env.NODE_ENV === "test";
 
 let buffer: string[] = [];
@@ -10,6 +9,25 @@ let flushTimer: ReturnType<typeof setTimeout> | null = null;
 const FLUSH_INTERVAL_MS = 500;
 const BUFFER_SIZE_LIMIT = 50;
 
+// Cache the last log directory we mkdir'd successfully so we only retry the
+// filesystem call when the resolved path actually changes. The path is
+// re-evaluated on every flush because `setHarness("pi")` runs after module
+// load on Pi; we MUST NOT freeze it at import time, or Pi's first flush
+// could land in the OpenCode subtree.
+let lastEnsuredDir: string | null = null;
+
+function ensureDir(filePath: string): void {
+    const dir = path.dirname(filePath);
+    if (dir === lastEnsuredDir) return;
+    try {
+        fs.mkdirSync(dir, { recursive: true });
+        lastEnsuredDir = dir;
+    } catch {
+        // Intentional: logging must never throw. If mkdir fails we still
+        // try the append; failure there is also swallowed.
+    }
+}
+
 function flush(): void {
     if (flushTimer) {
         clearTimeout(flushTimer);
@@ -19,6 +37,8 @@ function flush(): void {
     const data = buffer.join("");
     buffer = [];
     try {
+        const logFile = getMagicContextLogPath();
+        ensureDir(logFile);
         fs.appendFileSync(logFile, data);
     } catch {
         // Intentional: logging must never throw
@@ -58,8 +78,14 @@ export function sessionLog(sessionId: string, message: string, data?: unknown):
     log(`[magic-context][${sessionId}] ${message}`, data);
 }
 
+/**
+ * Resolve the current log file path. The path is harness-aware (see
+ * {@link getMagicContextLogPath}) and re-evaluated on every call, so callers
+ * who format diagnostic output with this value always see the path the next
+ * flush will actually use.
+ */
 export function getLogFilePath(): string {
-    return logFile;
+    return getMagicContextLogPath();
 }
 
 // Flush remaining buffer on process exit

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

@@ -0,0 +1,161 @@
+import { afterEach, describe, expect, test } from "bun:test";
+import { mkdirSync, mkdtempSync, rmSync, writeFileSync } from "node:fs";
+import { createServer } from "node:http";
+import { tmpdir } from "node:os";
+import { dirname, join } from "node:path";
+import { MagicContextRpcClient } from "./rpc-client";
+import { rpcPortFilePath } from "./rpc-utils";
+
+interface TestServer {
+    port: number;
+    close: () => Promise<void>;
+}
+
+const tempDirs: string[] = [];
+let servers: TestServer[] = [];
+
+afterEach(async () => {
+    for (const server of servers.splice(0)) {
+        await server.close();
+    }
+    for (const dir of tempDirs.splice(0)) {
+        rmSync(dir, { recursive: true, force: true });
+    }
+});
+
+function makeTempDir(): string {
+    const dir = mkdtempSync(join(tmpdir(), "mc-rpc-client-"));
+    tempDirs.push(dir);
+    return dir;
+}
+
+function writePortFile(storageDir: string, directory: string, port: number): void {
+    const portFile = rpcPortFilePath(storageDir, directory);
+    mkdirSync(dirname(portFile), { recursive: true });
+    writeFileSync(
+        portFile,
+        JSON.stringify({ port, pid: process.pid, started_at: Date.now() }),
+        "utf-8",
+    );
+}
+
+function writePortFileForPid(
+    storageDir: string,
+    directory: string,
+    port: number,
+    pid: number,
+    startedAt: number,
+): void {
+    const portFile = rpcPortFilePath(storageDir, directory, pid);
+    mkdirSync(dirname(portFile), { recursive: true });
+    writeFileSync(portFile, JSON.stringify({ port, pid, started_at: startedAt }), "utf-8");
+}
+
+async function startRpcServer(handler: (method: string) => Response | object): 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 }));
+            return;
+        }
+
+        if (req.method === "POST" && req.url?.startsWith("/rpc/")) {
+            const method = req.url.slice("/rpc/".length);
+            const result = handler(method);
+            if (result instanceof Response) {
+                res.writeHead(result.status, { "Content-Type": "application/json" });
+                res.end(await result.text());
+                return;
+            }
+            res.writeHead(200, { "Content-Type": "application/json" });
+            res.end(JSON.stringify(result));
+            return;
+        }
+
+        res.writeHead(404);
+        res.end("Not Found");
+    });
+
+    await new Promise<void>((resolve, reject) => {
+        server.once("error", reject);
+        server.listen(0, "127.0.0.1", () => resolve());
+    });
+    const addr = server.address();
+    if (!addr || typeof addr === "string") throw new Error("failed to bind test server");
+
+    const testServer = {
+        port: addr.port,
+        close: () =>
+            new Promise<void>((resolve, reject) => {
+                server.close((err) => (err ? reject(err) : resolve()));
+            }),
+    };
+    servers.push(testServer);
+    return testServer;
+}
+
+async function closeServer(server: TestServer): Promise<void> {
+    servers = servers.filter((s) => s !== server);
+    await server.close();
+}
+
+describe("MagicContextRpcClient", () => {
+    test("re-reads the port file after the cached server restarts on a new port", async () => {
+        const storageDir = makeTempDir();
+        const directory = "/repo";
+        const client = new MagicContextRpcClient(storageDir, directory);
+
+        const first = await startRpcServer(() => ({ value: "first" }));
+        writePortFile(storageDir, directory, first.port);
+        expect(await client.call<{ value: string }>("value")).toEqual({ value: "first" });
+
+        await closeServer(first);
+        const second = await startRpcServer(() => ({ value: "second" }));
+        writePortFile(storageDir, directory, second.port);
+
+        expect(await client.call<{ value: string }>("value")).toEqual({ value: "second" });
+    });
+
+    test("gives up when the port file points at a dead server", async () => {
+        const storageDir = makeTempDir();
+        const directory = "/repo";
+        const dead = await startRpcServer(() => ({ ok: true }));
+        const port = dead.port;
+        await closeServer(dead);
+        writePortFile(storageDir, directory, port);
+
+        const client = new MagicContextRpcClient(storageDir, directory);
+        await expect(client.call("value")).rejects.toThrow(
+            "Magic Context RPC server not available",
+        );
+    }, 20_000);
+
+    test("re-resolves and retries transient 5xx responses", async () => {
+        const storageDir = makeTempDir();
+        const directory = "/repo";
+        let calls = 0;
+        const server = await startRpcServer(() => {
+            calls++;
+            if (calls === 1) {
+                return new Response(JSON.stringify({ error: "warming up" }), { status: 503 });
+            }
+            return { value: "ok" };
+        });
+        writePortFile(storageDir, directory, server.port);
+
+        const client = new MagicContextRpcClient(storageDir, directory);
+        expect(await client.call<{ value: string }>("value")).toEqual({ value: "ok" });
+        expect(calls).toBe(2);
+    });
+
+    test("ignores newer stale pid files and discovers the latest live instance", async () => {
+        const storageDir = makeTempDir();
+        const directory = "/repo";
+        const live = await startRpcServer(() => ({ value: "live" }));
+        writePortFileForPid(storageDir, directory, 65535, 999_999_999, Date.now() + 10_000);
+        writePortFileForPid(storageDir, directory, live.port, process.pid, Date.now());
+
+        const client = new MagicContextRpcClient(storageDir, directory);
+        expect(await client.call<{ value: string }>("value")).toEqual({ value: "live" });
+    });
+});

package/src/shared/rpc-client.ts

@@ -1,17 +1,29 @@
-import { readFileSync } from "node:fs";
-import { rpcPortFilePath } from "./rpc-utils";
+import { readdirSync, readFileSync } from "node:fs";
+import { join } from "node:path";
+import {
+    isPidAlive,
+    legacyRpcPortFilePath,
+    parseRpcPortFile,
+    type RpcPortFileRecord,
+    rpcPortDir,
+} from "./rpc-utils";
 
 const MAX_RETRIES = 10;
 const RETRY_DELAY_MS = 500;
 const REQUEST_TIMEOUT_MS = 5000;
+const MAX_RERESOLVE_ATTEMPTS = 3;
+const NON_RETRYABLE_RPC_ERROR = Symbol("nonRetryableRpcError");
+type NonRetryableRpcError = Error & { [NON_RETRYABLE_RPC_ERROR]: true };
 
 export class MagicContextRpcClient {
     private port: number | null = null;
-    private portFilePath: string;
+    private portDir: string;
+    private legacyPortFilePath: string;
     private healthChecked = false;
 
     constructor(storageDir: string, directory: string) {
-        this.portFilePath = rpcPortFilePath(storageDir, directory);
+        this.portDir = rpcPortDir(storageDir, directory);
+        this.legacyPortFilePath = legacyRpcPortFilePath(storageDir, directory);
     }
 
     /** Call an RPC method. Retries port resolution if the server isn't ready yet. */
@@ -19,23 +31,52 @@ export class MagicContextRpcClient {
         method: string,
         params: Record<string, unknown> = {},
     ): Promise<T> {
-        const port = await this.resolvePort();
-        if (!port) {
-            throw new Error("Magic Context RPC server not available");
-        }
+        let lastError: unknown = null;
 
-        const response = await this.fetchWithTimeout(`http://127.0.0.1:${port}/rpc/${method}`, {
-            method: "POST",
-            headers: { "Content-Type": "application/json" },
-            body: JSON.stringify(params),
-        });
+        for (let attempt = 0; attempt < MAX_RERESOLVE_ATTEMPTS; attempt++) {
+            const port = await this.resolvePort();
+            if (!port) {
+                lastError = new Error("Magic Context RPC server not available");
+                this.reset();
+                continue;
+            }
+
+            try {
+                const response = await this.fetchWithTimeout(
+                    `http://127.0.0.1:${port}/rpc/${method}`,
+                    {
+                        method: "POST",
+                        headers: { "Content-Type": "application/json" },
+                        body: JSON.stringify(params),
+                    },
+                );
+
+                if (!response.ok) {
+                    const text = await response.text();
+                    const error = new Error(`RPC ${method} failed (${response.status}): ${text}`);
+                    if (response.status >= 500) {
+                        lastError = error;
+                        this.reset();
+                        continue;
+                    }
+                    (error as NonRetryableRpcError)[NON_RETRYABLE_RPC_ERROR] = true;
+                    throw error;
+                }
 
-        if (!response.ok) {
-            const text = await response.text();
-            throw new Error(`RPC ${method} failed (${response.status}): ${text}`);
+                return (await response.json()) as T;
+            } catch (err) {
+                if (isNonRetryableRpcError(err)) {
+                    throw err;
+                }
+                lastError = err;
+                this.reset();
+            }
         }
 
-        return (await response.json()) as T;
+        if (lastError instanceof Error) {
+            throw lastError;
+        }
+        throw new Error("Magic Context RPC server not available");
     }
 
     /** Check if the RPC server is reachable. */
@@ -83,13 +124,28 @@ export class MagicContextRpcClient {
     }
 
     private readPortFile(): number | null {
+        const records: RpcPortFileRecord[] = [];
+
         try {
-            const content = readFileSync(this.portFilePath, "utf-8").trim();
-            const port = Number.parseInt(content, 10);
-            if (Number.isNaN(port) || port <= 0 || port > 65535) {
-                return null;
+            for (const entry of readdirSync(this.portDir)) {
+                if (!entry.startsWith("port-") || !entry.endsWith(".json")) continue;
+                const record = parseRpcPortFile(readFileSync(join(this.portDir, entry), "utf-8"));
+                if (!record || !isPidAlive(record.pid)) continue;
+                records.push(record);
             }
-            return port;
+        } catch {
+            // 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].port;
+        }
+
+        try {
+            const record = parseRpcPortFile(readFileSync(this.legacyPortFilePath, "utf-8"));
+            if (record?.pid && !isPidAlive(record.pid)) return null;
+            return record?.port ?? null;
         } catch {
             return null;
         }
@@ -121,3 +177,7 @@ export class MagicContextRpcClient {
         this.healthChecked = false;
     }
 }
+
+function isNonRetryableRpcError(err: unknown): err is NonRetryableRpcError {
+    return typeof err === "object" && err !== null && NON_RETRYABLE_RPC_ERROR in err;
+}

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

@@ -0,0 +1,20 @@
+import { describe, expect, test } from "bun:test";
+import { drainNotifications, pushNotification } from "./rpc-notifications";
+
+describe("rpc notifications", () => {
+    test("keeps messages queued until the client acks their id", () => {
+        const initial = drainNotifications(Number.MAX_SAFE_INTEGER);
+        expect(initial).toEqual([]);
+
+        pushNotification("one", { ok: true }, "ses_1");
+        const firstPoll = drainNotifications();
+        expect(firstPoll).toHaveLength(1);
+        expect(firstPoll[0].type).toBe("one");
+
+        const retryPoll = drainNotifications();
+        expect(retryPoll.map((m) => m.id)).toEqual(firstPoll.map((m) => m.id));
+
+        const lastReceivedId = Math.max(...firstPoll.map((m) => m.id));
+        expect(drainNotifications(lastReceivedId)).toEqual([]);
+    });
+});