@cortexkit/opencode-magic-context 0.31.5 → 0.32.1

package/src/shared/tui-config.test.ts

@@ -4,11 +4,7 @@ import { tmpdir } from "node:os";
 import { join } from "node:path";
 
 const roots: string[] = [];
-const prevConfigDir = process.env.OPENCODE_CONFIG_DIR;
-
 afterEach(() => {
-    if (prevConfigDir === undefined) delete process.env.OPENCODE_CONFIG_DIR;
-    else process.env.OPENCODE_CONFIG_DIR = prevConfigDir;
     for (const root of roots.splice(0)) {
         rmSync(root, { recursive: true, force: true });
     }
@@ -18,7 +14,6 @@ describe("ensureTuiPluginEntry", () => {
     it("preserves tuple dev-path plugin entry and does not add @latest", async () => {
         const root = mkdtempSync(join(tmpdir(), "mc-tui-"));
         roots.push(root);
-        process.env.OPENCODE_CONFIG_DIR = root;
         const devPath = "/Work/magic-context/packages/plugin";
         const tuiPath = join(root, "tui.json");
         writeFileSync(
@@ -27,7 +22,7 @@ describe("ensureTuiPluginEntry", () => {
         );
 
         const { ensureTuiPluginEntry } = await import("./tui-config");
-        const changed = ensureTuiPluginEntry();
+        const changed = ensureTuiPluginEntry({ configDir: root });
         expect(changed).toBe(false);
         const parsed = JSON.parse(readFileSync(tuiPath, "utf-8")) as { plugin: unknown[] };
         expect(parsed.plugin).toHaveLength(2);
@@ -40,7 +35,6 @@ describe("ensureTuiPluginEntry", () => {
     it("upgrades bare npm name to @latest while preserving tuple options", async () => {
         const root = mkdtempSync(join(tmpdir(), "mc-tui-npm-"));
         roots.push(root);
-        process.env.OPENCODE_CONFIG_DIR = root;
         const tuiPath = join(root, "tui.json");
         writeFileSync(
             tuiPath,
@@ -54,7 +48,7 @@ describe("ensureTuiPluginEntry", () => {
         );
 
         const { ensureTuiPluginEntry } = await import("./tui-config");
-        expect(ensureTuiPluginEntry()).toBe(true);
+        expect(ensureTuiPluginEntry({ configDir: root })).toBe(true);
         const parsed = JSON.parse(readFileSync(tuiPath, "utf-8")) as { plugin: unknown[] };
         const entry = parsed.plugin[0] as unknown[];
         expect(entry[0]).toBe("@cortexkit/opencode-magic-context@latest");
@@ -64,10 +58,9 @@ describe("ensureTuiPluginEntry", () => {
     it("creates tui.jsonc (not tui.json) on a fresh install", async () => {
         const root = mkdtempSync(join(tmpdir(), "mc-tui-fresh-"));
         roots.push(root);
-        process.env.OPENCODE_CONFIG_DIR = root;
 
         const { ensureTuiPluginEntry } = await import("./tui-config");
-        expect(ensureTuiPluginEntry()).toBe(true);
+        expect(ensureTuiPluginEntry({ configDir: root })).toBe(true);
 
         // The new file must be tui.jsonc so a tui.json stub never ends up
         // sitting next to a tui.jsonc the user writes later (#176).
@@ -82,7 +75,6 @@ describe("ensureTuiPluginEntry", () => {
     it("writes into the existing tui.jsonc when both files exist", async () => {
         const root = mkdtempSync(join(tmpdir(), "mc-tui-both-"));
         roots.push(root);
-        process.env.OPENCODE_CONFIG_DIR = root;
         // A real user config in tui.jsonc plus a leftover empty tui.json.
         writeFileSync(
             join(root, "tui.jsonc"),
@@ -91,7 +83,7 @@ describe("ensureTuiPluginEntry", () => {
         writeFileSync(join(root, "tui.json"), "{}\n");
 
         const { ensureTuiPluginEntry } = await import("./tui-config");
-        expect(ensureTuiPluginEntry()).toBe(true);
+        expect(ensureTuiPluginEntry({ configDir: root })).toBe(true);
 
         // The plugin entry must land in tui.jsonc (higher precedence), and the
         // user's keybinds must survive; tui.json must be left untouched.

package/src/shared/tui-config.ts

@@ -62,8 +62,8 @@ function writeTuiConfigAtomic(configPath: string, config: Record<string, unknown
     renameSync(tmpPath, configPath);
 }
 
-function resolveTuiConfigPath(): string {
-    const configDir = getOpenCodeConfigPaths({ binary: "opencode" }).configDir;
+function resolveTuiConfigPath(configDirOverride?: string): string {
+    const configDir = configDirOverride ?? getOpenCodeConfigPaths({ binary: "opencode" }).configDir;
     const jsoncPath = join(configDir, "tui.jsonc");
     const jsonPath = join(configDir, "tui.json");
 
@@ -80,12 +80,12 @@ function resolveTuiConfigPath(): string {
 }
 
 /**
- * Ensure tui.json has the magic-context TUI plugin entry.
- * Creates tui.json if it doesn't exist. Silently skips if already present.
+ * Ensure the selected TUI config has the magic-context plugin entry.
+ * Creates tui.jsonc if neither TUI config exists. Silently skips if already present.
  */
-export function ensureTuiPluginEntry(): boolean {
+export function ensureTuiPluginEntry(options: { configDir?: string } = {}): boolean {
     try {
-        const configPath = resolveTuiConfigPath();
+        const configPath = resolveTuiConfigPath(options.configDir);
 
         let config: Record<string, unknown> = {};
         if (existsSync(configPath)) {

package/src/tui/data/context-db.test.ts

@@ -0,0 +1,113 @@
+import { afterEach, describe, expect, test } from "bun:test";
+import { mkdtempSync, rmSync } from "node:fs";
+import { tmpdir } from "node:os";
+import { join } from "node:path";
+import { MagicContextRpcServer } from "../../shared/rpc-server";
+import type { SidebarSnapshot } from "../../shared/rpc-types";
+import { closeRpc, getCompartmentCount, initRpcClient, loadSidebarSnapshot } from "./context-db";
+
+const originalXdgDataHome = process.env.XDG_DATA_HOME;
+const tempDirs: string[] = [];
+const servers: MagicContextRpcServer[] = [];
+
+afterEach(() => {
+    closeRpc();
+    for (const server of servers.splice(0)) server.stop();
+    for (const dir of tempDirs.splice(0)) {
+        rmSync(dir, { recursive: true, force: true, maxRetries: 10, retryDelay: 100 });
+    }
+    if (originalXdgDataHome === undefined) delete process.env.XDG_DATA_HOME;
+    else process.env.XDG_DATA_HOME = originalXdgDataHome;
+});
+
+function makeDataHome(): string {
+    const dir = mkdtempSync(join(tmpdir(), "mc-context-db-"));
+    tempDirs.push(dir);
+    process.env.XDG_DATA_HOME = dir;
+    return dir;
+}
+
+function snapshot(sessionId: string, inputTokens: number): SidebarSnapshot {
+    return {
+        sessionId,
+        usagePercentage: inputTokens > 0 ? 25 : 0,
+        inputTokens,
+        contextLimit: 1000,
+        systemPromptTokens: 0,
+        compartmentCount: inputTokens > 0 ? 2 : 0,
+        memoryCount: 0,
+        memoryBlockCount: 0,
+        pendingOpsCount: 0,
+        historianRunning: false,
+        compartmentInProgress: false,
+        sessionNoteCount: 0,
+        readySmartNoteCount: 0,
+        cacheTtl: "5m",
+        lastDreamerRunAt: null,
+        projectIdentity: null,
+        compartmentTokens: 0,
+        factTokens: 0,
+        memoryTokens: 0,
+        docsTokens: 0,
+        profileTokens: 0,
+        conversationTokens: inputTokens,
+        toolCallTokens: 0,
+        toolDefinitionTokens: 0,
+        executeThreshold: 65,
+        newWorkTokens: null,
+        totalInputTokens: inputTokens,
+    };
+}
+
+async function startServer(
+    dataHome: string,
+    directory: string,
+    sidebar: () => Record<string, unknown>,
+): Promise<MagicContextRpcServer> {
+    const server = new MagicContextRpcServer(
+        join(dataHome, "cortexkit", "magic-context"),
+        directory,
+    );
+    server.handle("sidebar-snapshot", async () => sidebar());
+    await server.start();
+    servers.push(server);
+    return server;
+}
+
+describe("TUI context RPC data", () => {
+    test("uses an unexpired sticky snapshot only for failed responses", async () => {
+        const dataHome = makeDataHome();
+        const directory = "/repo-sticky";
+        const sessionId = "ses_sticky";
+        let response: Record<string, unknown> = snapshot(sessionId, 250) as unknown as Record<
+            string,
+            unknown
+        >;
+        await startServer(dataHome, directory, () => response);
+        initRpcClient(directory);
+
+        expect((await loadSidebarSnapshot(sessionId, directory)).inputTokens).toBe(250);
+        response = { error: "database busy" };
+        expect((await loadSidebarSnapshot(sessionId, directory)).inputTokens).toBe(250);
+
+        response = snapshot(sessionId, 0) as unknown as Record<string, unknown>;
+        expect((await loadSidebarSnapshot(sessionId, directory)).inputTokens).toBe(0);
+        response = { error: "database busy again" };
+        expect((await loadSidebarSnapshot(sessionId, directory)).inputTokens).toBe(0);
+    });
+
+    test("distinguishes a real zero compartment count from an RPC failure", async () => {
+        const dataHome = makeDataHome();
+        const directory = "/repo-count";
+        const server = await startServer(dataHome, directory, () => ({}));
+        server.handle("compartment-count", async () => ({ count: 0 }));
+        initRpcClient(directory);
+
+        expect(await getCompartmentCount("ses_zero")).toEqual({ ok: true, count: 0 });
+        server.handle("compartment-count", async () => {
+            throw new Error("database unavailable");
+        });
+        const failed = await getCompartmentCount("ses_zero");
+        expect(failed.ok).toBe(false);
+    });
+});

package/src/tui/data/context-db.ts

@@ -102,7 +102,13 @@ const STICKY_MAX_ENTRIES = 100;
 const stickySidebarCache = new Map<string, CachedSnapshot>();
 
 function rememberSidebarSnapshot(snapshot: SidebarSnapshot): void {
-    if (!snapshot.sessionId || snapshot.inputTokens <= 0) return;
+    if (!snapshot.sessionId) return;
+    if (snapshot.inputTokens <= 0) {
+        // A successful zero is authoritative (new/deleted/reverted session) and
+        // must prevent a later transport failure from resurrecting old values.
+        stickySidebarCache.delete(snapshot.sessionId);
+        return;
+    }
     // LRU-style bound: drop the oldest entry once we hit the cap. With a
     // 5-min TTL most stale entries time out naturally; this just prevents
     // unbounded growth across many session switches in a long TUI session.
@@ -126,19 +132,9 @@ function recallSidebarSnapshot(sessionId: string, fallback: SidebarSnapshot): Si
         stickySidebarCache.delete(sessionId);
         return fallback;
     }
-    if (!hasInFlightEvidence(fallback)) {
-        stickySidebarCache.delete(sessionId);
-        return fallback;
-    }
     return cached.snapshot;
 }
 
-function hasInFlightEvidence(snapshot: SidebarSnapshot): boolean {
-    return (
-        snapshot.compartmentInProgress || snapshot.historianRunning || snapshot.pendingOpsCount > 0
-    );
-}
-
 /** Fetch sidebar snapshot from the server via RPC. */
 export async function loadSidebarSnapshot(
     sessionId: string,
@@ -152,9 +148,11 @@ export async function loadSidebarSnapshot(
             directory,
         });
         if ((result as unknown as Record<string, unknown>).error) {
+            // Snapshot-build errors are explicit failure envelopes, equivalent to
+            // a transport failure: retain the last known-good client snapshot.
             return recallSidebarSnapshot(sessionId, empty);
         }
-        // Trust successful server responses. The server has its own sticky
+        // Trust successful server responses, including authoritative zeroes. The server has its own sticky
         // sidebar cache (`sidebar-snapshot-cache.ts`) that handles transient
         // zero-token windows by hybriding cached breakdown values into a
         // fresh snapshot, AND clears that cache on `session.deleted`. If the
@@ -249,14 +247,23 @@ export async function loadEmbedDetail(sessionId: string, directory: string): Pro
     }
 }
 
-/** Get compartment count via RPC. */
-export async function getCompartmentCount(sessionId: string): Promise<number> {
-    if (!rpcClient) return 0;
+export type CompartmentCountResult = { ok: true; count: number } | { ok: false; error: string };
+
+/** Get compartment count without making transport failure look like a real zero. */
+export async function getCompartmentCount(sessionId: string): Promise<CompartmentCountResult> {
+    if (!rpcClient) return { ok: false, error: "RPC client is not initialized" };
     try {
-        const result = await rpcClient.call<{ count: number }>("compartment-count", { sessionId });
-        return result.count ?? 0;
-    } catch {
-        return 0;
+        const result = await rpcClient.call<{ count?: number; error?: string }>(
+            "compartment-count",
+            { sessionId },
+        );
+        if (typeof result.error === "string") return { ok: false, error: result.error };
+        if (typeof result.count !== "number" || !Number.isFinite(result.count)) {
+            return { ok: false, error: "Invalid compartment count response" };
+        }
+        return { ok: true, count: result.count };
+    } catch (error) {
+        return { ok: false, error: error instanceof Error ? error.message : String(error) };
     }
 }
 

package/src/tui/data/notification-socket.test.ts

@@ -1,13 +1,15 @@
 import { afterEach, describe, expect, test } from "bun:test";
-import { mkdtempSync, rmSync } from "node:fs";
+import { mkdirSync, mkdtempSync, rmSync, writeFileSync } from "node:fs";
 import { tmpdir } from "node:os";
-import { join } from "node:path";
+import { dirname, join } from "node:path";
 import {
+    __resetNotificationStateForTests,
     drainNotifications,
     isTuiConnected,
     pushNotification,
 } from "../../shared/rpc-notifications";
 import { MagicContextRpcServer } from "../../shared/rpc-server";
+import { rpcPortFilePath } from "../../shared/rpc-utils";
 import { closeRpc, initRpcClient } from "./context-db";
 import {
     _resetNotificationSocketStateForTesting,
@@ -18,6 +20,7 @@ import {
 const originalXdgDataHome = process.env.XDG_DATA_HOME;
 const tempDirs: string[] = [];
 const servers: MagicContextRpcServer[] = [];
+const legacyServers: Array<ReturnType<typeof Bun.serve>> = [];
 
 afterEach(() => {
     _resetNotificationSocketStateForTesting();
@@ -25,7 +28,8 @@ afterEach(() => {
     for (const server of servers.splice(0)) {
         server.stop();
     }
-    drainNotifications(Number.MAX_SAFE_INTEGER);
+    for (const server of legacyServers.splice(0)) server.stop(true);
+    __resetNotificationStateForTests();
     for (const dir of tempDirs.splice(0)) {
         rmSync(dir, { recursive: true, force: true, maxRetries: 10, retryDelay: 100 });
     }
@@ -54,6 +58,77 @@ async function startServer(dataHome: string, directory: string): Promise<MagicCo
     return server;
 }
 
+function startLegacyServer(
+    dataHome: string,
+    directory: string,
+    notifications: SocketNotification[],
+): {
+    sockets: Set<{ close(): void }>;
+    helloCursors: number[];
+    ackCursors: number[];
+} {
+    const token = "v032-query-token";
+    const sockets = new Set<{ close(): void }>();
+    const helloCursors: number[] = [];
+    const ackCursors: number[] = [];
+    const server = Bun.serve({
+        hostname: "127.0.0.1",
+        port: 0,
+        fetch(req, bunServer) {
+            const url = new URL(req.url);
+            if (url.pathname === "/health") {
+                // Frozen v0.32 response: pid only, with no instance_id.
+                return Response.json({ ok: true, pid: process.pid });
+            }
+            if (
+                url.pathname === "/ws" &&
+                req.headers.get("authorization") === `Bearer ${token}` &&
+                bunServer.upgrade(req, { data: {} })
+            ) {
+                return undefined;
+            }
+            return new Response("Not Found", { status: 404 });
+        },
+        websocket: {
+            open(ws) {
+                sockets.add(ws);
+            },
+            message(ws, raw) {
+                const msg = JSON.parse(String(raw)) as {
+                    type?: string;
+                    lastReceivedId?: number;
+                    cursor?: number;
+                };
+                if (msg.type === "hello") {
+                    const cursor = Number(msg.lastReceivedId ?? 0);
+                    helloCursors.push(cursor);
+                    for (const notification of notifications) {
+                        if (notification.id > cursor) {
+                            ws.send(JSON.stringify({ type: "notification", notification }));
+                        }
+                    }
+                    // Frozen v0.32 acknowledgement: protocol epoch fields did not exist.
+                    ws.send(JSON.stringify({ type: "hello-ack" }));
+                } else if (msg.type === "ack" && typeof msg.cursor === "number") {
+                    ackCursors.push(msg.cursor);
+                }
+            },
+            close(ws) {
+                sockets.delete(ws);
+            },
+        },
+    });
+    legacyServers.push(server);
+
+    const portFile = rpcPortFilePath(storageDir(dataHome), directory, process.pid);
+    mkdirSync(dirname(portFile), { recursive: true });
+    writeFileSync(
+        portFile,
+        JSON.stringify({ port: server.port, pid: process.pid, started_at: Date.now(), token }),
+    );
+    return { sockets, helloCursors, ackCursors };
+}
+
 async function waitFor(condition: () => boolean, label: string, timeoutMs = 4_000): Promise<void> {
     const start = Date.now();
     while (Date.now() - start < timeoutMs) {
@@ -64,6 +139,58 @@ async function waitFor(condition: () => boolean, label: string, timeoutMs = 4_00
 }
 
 describe("notification socket", () => {
+    test("a home-screen socket receives globals but leaves scoped notifications pending", async () => {
+        drainNotifications(Number.MAX_SAFE_INTEGER);
+        const dataHome = makeDataHome();
+        const directory = "/repo-home-screen";
+        await startServer(dataHome, directory);
+        initRpcClient(directory);
+
+        const received: SocketNotification[] = [];
+        startNotificationSocket({
+            getSessionId: () => null,
+            onNotification: (notification) => {
+                received.push(notification);
+                return true;
+            },
+        });
+        await waitFor(() => isTuiConnected(), "home-screen socket connection");
+        expect(isTuiConnected("ses_hidden")).toBe(false);
+
+        pushNotification("scoped", { action: "show-status-dialog" }, "ses_hidden");
+        pushNotification("global", { action: "show-status-dialog" });
+        await waitFor(
+            () => received.some((notification) => notification.type === "global"),
+            "global home-screen notification",
+        );
+        expect(received.some((notification) => notification.type === "scoped")).toBe(false);
+        expect(drainNotifications(0, "ses_hidden", { sessionOnly: true })).toHaveLength(1);
+    });
+
+    test("overlapping starts create one socket and one delivery", async () => {
+        drainNotifications(Number.MAX_SAFE_INTEGER);
+        const dataHome = makeDataHome();
+        const directory = "/repo-overlapping-start";
+        await startServer(dataHome, directory);
+        initRpcClient(directory);
+
+        let deliveries = 0;
+        const options = {
+            getSessionId: () => "ses_once",
+            onNotification: () => {
+                deliveries += 1;
+                return true;
+            },
+        };
+        startNotificationSocket(options);
+        startNotificationSocket(options);
+        await waitFor(() => isTuiConnected("ses_once"), "single overlapping connection");
+        pushNotification("once", { ok: true }, "ses_once");
+        await waitFor(() => deliveries === 1, "single notification delivery");
+        await new Promise((resolve) => setTimeout(resolve, 75));
+        expect(deliveries).toBe(1);
+    });
+
     test("uses the active session cursor when switching sessions", async () => {
         drainNotifications(Number.MAX_SAFE_INTEGER);
         const dataHome = makeDataHome();
@@ -99,8 +226,8 @@ describe("notification socket", () => {
         expect(received.map((notification) => notification.type)).toContain("for-b");
     });
 
-    test("resets the cached endpoint after websocket close so reconnect discovers a new server", async () => {
-        drainNotifications(Number.MAX_SAFE_INTEGER);
+    test("clears cursors and deduplication when a fresh server reuses notification ids", async () => {
+        __resetNotificationStateForTests();
         const dataHome = makeDataHome();
         const directory = "/repo-reconnect";
         const first = await startServer(dataHome, directory);
@@ -116,16 +243,155 @@ describe("notification socket", () => {
         });
         await waitFor(() => isTuiConnected("ses_R"), "initial websocket connection");
 
-        const second = await startServer(dataHome, directory);
-        expect(second).toBeDefined();
+        pushNotification("before-restart", { action: "show-status-dialog" }, "ses_R");
+        await waitFor(() => received.length === 1, "first notification acknowledgement");
+        await waitFor(
+            () => drainNotifications(0, "ses_R").length === 0,
+            "first server queue to empty",
+        );
+        expect(received[0].id).toBe(1);
+
         first.stop();
         await waitFor(() => !isTuiConnected("ses_R"), "old websocket sink removed");
-        await waitFor(() => isTuiConnected("ses_R"), "websocket reconnected to replacement server");
+        // A process restart recreates module state as well as the RPC server. The
+        // client state intentionally survives so reused ids exercise epoch reset.
+        __resetNotificationStateForTests();
+        pushNotification("queued-after-restart", { action: "show-status-dialog" }, "ses_R");
+        const second = await startServer(dataHome, directory);
+        expect(second).toBeDefined();
 
-        pushNotification("after-restart", { action: "show-status-dialog" }, "ses_R");
         await waitFor(
-            () => received.some((notification) => notification.type === "after-restart"),
-            "notification from replacement server",
+            () => received.some((notification) => notification.type === "queued-after-restart"),
+            "reused id from replacement server backlog",
         );
+        const restarted = received.find(
+            (notification) => notification.type === "queued-after-restart",
+        );
+        expect(restarted?.id).toBe(received[0].id);
+    });
+
+    test("acknowledges only consumed ids and redelivers a failed earlier notification", async () => {
+        __resetNotificationStateForTests();
+        const dataHome = makeDataHome();
+        const directory = "/repo-exact-ack";
+        await startServer(dataHome, directory);
+        initRpcClient(directory);
+
+        let releaseFirst: ((consumed: boolean) => void) | undefined;
+        const firstResult = new Promise<boolean>((resolve) => {
+            releaseFirst = resolve;
+        });
+        let slowCalls = 0;
+        let fastCalls = 0;
+        startNotificationSocket({
+            getSessionId: () => "ses_exact",
+            onNotification: (notification) => {
+                if (notification.type === "slow") {
+                    slowCalls += 1;
+                    return slowCalls === 1 ? firstResult : true;
+                }
+                fastCalls += 1;
+                return true;
+            },
+        });
+        await waitFor(() => isTuiConnected("ses_exact"), "exact ack socket connection");
+
+        pushNotification("slow", { action: "show-status-dialog" }, "ses_exact");
+        pushNotification("fast", { action: "show-toast" }, "ses_exact");
+        await waitFor(() => slowCalls === 1, "blocked first handler");
+        expect(fastCalls).toBe(0);
+        releaseFirst?.(false);
+        await waitFor(() => fastCalls === 1, "later handler completion");
+        await waitFor(() => {
+            const pending = drainNotifications(0, "ses_exact");
+            return pending.length === 1 && pending[0].type === "slow";
+        }, "only failed notification to remain queued");
+
+        _resetNotificationSocketStateForTesting();
+        await waitFor(() => !isTuiConnected("ses_exact"), "socket disconnect before redelivery");
+        startNotificationSocket({
+            getSessionId: () => "ses_exact",
+            onNotification: (notification) => {
+                if (notification.type === "slow") slowCalls += 1;
+                if (notification.type === "fast") fastCalls += 1;
+                return true;
+            },
+        });
+        await waitFor(() => slowCalls === 2, "failed notification redelivery");
+        expect(fastCalls).toBe(1);
+    });
+
+    test("legacy mode keeps its watermark behind a declined notification across reconnect", async () => {
+        const dataHome = makeDataHome();
+        const directory = "/repo-v032-notifications";
+        const sessionId = "ses_v032";
+        const legacy = startLegacyServer(dataHome, directory, [
+            { id: 1, type: "declined", payload: {}, sessionId },
+            { id: 2, type: "consumed", payload: {}, sessionId },
+        ]);
+        initRpcClient(directory);
+
+        let declinedCalls = 0;
+        let consumedCalls = 0;
+        startNotificationSocket({
+            getSessionId: () => sessionId,
+            onNotification: (notification) => {
+                if (notification.type === "declined") {
+                    declinedCalls += 1;
+                    return declinedCalls > 1;
+                }
+                consumedCalls += 1;
+                return true;
+            },
+        });
+
+        await waitFor(() => declinedCalls === 1 && consumedCalls === 1, "legacy backlog handling");
+        expect(Math.max(0, ...legacy.ackCursors)).toBe(0);
+        for (const ws of legacy.sockets) ws.close();
+
+        await waitFor(() => legacy.helloCursors.length >= 2, "legacy reconnect hello");
+        await waitFor(() => declinedCalls === 2, "declined notification redelivery");
+        expect(legacy.helloCursors[1]).toBe(0);
+        expect(consumedCalls).toBe(1);
+        await waitFor(() => legacy.ackCursors.includes(2), "gap-safe legacy watermark advance");
+    });
+
+    test("serializes back-to-back dialog notification handlers", async () => {
+        __resetNotificationStateForTests();
+        const dataHome = makeDataHome();
+        const directory = "/repo-serialized-dialogs";
+        await startServer(dataHome, directory);
+        initRpcClient(directory);
+
+        let releaseFirst: (() => void) | undefined;
+        const firstSettled = new Promise<void>((resolve) => {
+            releaseFirst = resolve;
+        });
+        const events: string[] = [];
+        startNotificationSocket({
+            getSessionId: () => "ses_dialogs",
+            onNotification: async (notification) => {
+                events.push(`start:${notification.type}`);
+                if (notification.type === "dialog-one") await firstSettled;
+                events.push(`finish:${notification.type}`);
+                return true;
+            },
+        });
+        await waitFor(() => isTuiConnected("ses_dialogs"), "dialog socket connection");
+
+        pushNotification("dialog-one", { action: "show-status-dialog" }, "ses_dialogs");
+        pushNotification("dialog-two", { action: "show-upgrade-dialog" }, "ses_dialogs");
+        await waitFor(() => events.includes("start:dialog-one"), "first dialog handler start");
+        await new Promise((resolve) => setTimeout(resolve, 75));
+        expect(events).toEqual(["start:dialog-one"]);
+
+        releaseFirst?.();
+        await waitFor(() => events.includes("finish:dialog-two"), "second dialog handler finish");
+        expect(events).toEqual([
+            "start:dialog-one",
+            "finish:dialog-one",
+            "start:dialog-two",
+            "finish:dialog-two",
+        ]);
     });
 });