@cortexkit/opencode-magic-context 0.21.8 → 0.22.1

package/src/shared/announcement.ts

@@ -23,19 +23,18 @@ import { getMagicContextStorageDir } from "./data-path";
  * Bump only when there are user-visible changes worth a startup dialog.
  * Does NOT need to match the published package version.
  */
-export const ANNOUNCEMENT_VERSION = "0.21.7";
+export const ANNOUNCEMENT_VERSION = "0.22.0";
 
 /**
  * Short, user-facing bullet strings. Keep each line ~80 chars or shorter so the
  * TUI dialog renders cleanly without horizontal scroll on a typical terminal.
  */
 export const ANNOUNCEMENT_FEATURES: ReadonlyArray<string> = [
-    "Pi parity sweep: 44 audit findings fixed, including a critical SHIP-BLOCKER where /ctx-flush did not drain the pending Pi compaction queue.",
-    "Pi historian recovery fix: empty/no-op historian returns now clear emergency recovery so sessions cannot loop forever at 95%.",
-    "trimPiMessagesToBoundary now sweeps non-contiguous tool-result orphans, fixing provider 400s after compaction in long Pi sessions.",
-    "Hidden subagent tool isolation: historian, dreamer, and sidekick can no longer spawn subagents or run unsafe tools.",
-    "TUI sidebar and /ctx-status header now show execute threshold inline: '47.5% / 65%' on the left, '475K / 1.0M' on the right.",
-    "doctor --issue now caps GitHub issue bodies at ~60KB with a dedicated 'Recent errors' section so reports stay submittable.",
+    "NOW ON BY DEFAULT — Temporal awareness: the agent sees elapsed-time markers (e.g. +2h 15m) between messages and dated compartments, so it knows how long ago things happened. Opt out with temporal_awareness: false.",
+    "NOW ON BY DEFAULT — Auto-search hints: each turn a background ctx_search whispers a compact 'vague recall' when something relevant exists in your memories, past conversation, or git history. No full content injected. Opt out with memory.auto_search.enabled: false.",
+    "Experimental features graduated to stable config: temporal_awareness and caveman_text_compression are now top-level keys; auto_search and git_commit_indexing moved under memory.* . Run `doctor` to migrate old experimental.* settings (your opt-ins/opt-outs are preserved).",
+    "git_commit_indexing (make project history semantically searchable) stays opt-in — enable with memory.git_commit_indexing.enabled: true.",
+    "Audit hardening across both harnesses: memory config-bypass fix, supersede-delta cache-stability fixes, and dashboard correctness fixes.",
 ];
 
 /**
@@ -90,8 +89,31 @@ export function markAnnouncementSeen(version: string): void {
  * True when the configured `ANNOUNCEMENT_VERSION` has not yet been dismissed
  * AND there is at least one feature to show. Used by both the TUI dialog path
  * and the Desktop ignored-message fallback.
+ *
+ * First-run / sandbox handling: when NO state file exists yet, we seed it to the
+ * current `ANNOUNCEMENT_VERSION` and return false instead of announcing. This
+ * covers two cases that previously spammed the dialog (issue #99):
+ *   - Fresh installs: a brand-new user shouldn't be shown a changelog of release
+ *     bullets they have no context for — they need onboarding, not patch notes.
+ *   - Ephemeral/sandbox environments (Docker, CI, disposable dev containers)
+ *     where the storage dir is wiped between launches: without the seed, the
+ *     missing file made the announcement re-show on every single startup.
+ * Real upgrades still announce exactly once: an existing user already has a
+ * state file at the prior version, so the version mismatch shows the dialog and
+ * dismissing it advances the file to the current version.
+ *
+ * The seed is a deliberate write side-effect on the "no file" branch — folding
+ * it here (rather than a separate startup call) makes every caller path (plugin
+ * startup, Pi startup, TUI rpc pull) consistent with no ordering dependency.
  */
 export function shouldShowAnnouncement(): boolean {
     if (!ANNOUNCEMENT_VERSION || ANNOUNCEMENT_FEATURES.length === 0) return false;
-    return readLastAnnouncedVersion() !== ANNOUNCEMENT_VERSION;
+    const lastVersion = readLastAnnouncedVersion();
+    if (!lastVersion) {
+        // No prior state: fresh install or wiped sandbox. Seed to current and
+        // skip the announcement so we never pester first-run / ephemeral envs.
+        markAnnouncementSeen(ANNOUNCEMENT_VERSION);
+        return false;
+    }
+    return lastVersion !== ANNOUNCEMENT_VERSION;
 }

package/src/shared/conflict-detector.test.ts

@@ -46,8 +46,21 @@ describe("detectConflicts", () => {
             else process.env[k] = v;
         }
         // Test directories live under tmpdir(); cleanup is best-effort.
-        rmSync(projectDir, { recursive: true, force: true });
-        rmSync(userConfigDir, { recursive: true, force: true });
+        try {
+            rmSync(projectDir, { recursive: true, force: true, maxRetries: 10, retryDelay: 100 });
+        } catch {
+            /* Ignore EBUSY on Windows */
+        }
+        try {
+            rmSync(userConfigDir, {
+                recursive: true,
+                force: true,
+                maxRetries: 10,
+                retryDelay: 100,
+            });
+        } catch {
+            /* Ignore EBUSY on Windows */
+        }
     });
 
     function writeProjectConfig(plugins: Array<string | [string, unknown]>): void {

package/src/shared/conflict-fixer.test.ts

@@ -38,7 +38,11 @@ describe("fixConflicts", () => {
             if (value === undefined) delete process.env[key];
             else process.env[key] = value;
         }
-        rmSync(root, { recursive: true, force: true });
+        try {
+            rmSync(root, { recursive: true, force: true, maxRetries: 10, retryDelay: 100 });
+        } catch {
+            /* Ignore EBUSY on Windows */
+        }
     });
 
     it("preserves JSONC comments and tuple plugin entries while removing canonical DCP", () => {

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

@@ -39,7 +39,11 @@ describe("models-dev-cache", () => {
             if (v === undefined) delete process.env[k];
             else process.env[k] = v;
         }
-        rmSync(tempDir, { recursive: true, force: true });
+        try {
+            rmSync(tempDir, { recursive: true, force: true, maxRetries: 10, retryDelay: 100 });
+        } catch {
+            /* Ignore EBUSY on Windows */
+        }
         clearModelsDevCache();
     });
 
@@ -234,7 +238,7 @@ describe("models-dev-cache", () => {
         expect(getModelsDevContextLimit("anthropic", "claude-4")).toBeUndefined();
     });
 
-    test("API cache takes priority over file cache", async () => {
+    test("takes the larger limit when both layers know the model (API larger)", async () => {
         // Seed file layer with one value.
         const opencodeDir = join(tempDir, "opencode");
         mkdirSync(opencodeDir, { recursive: true });
@@ -248,7 +252,7 @@ describe("models-dev-cache", () => {
         // Sanity: file layer returns 100000 before API refresh.
         expect(getModelsDevContextLimit("anthropic", "claude-4")).toBe(100000);
 
-        // Mock client providing DIFFERENT value via API.
+        // Mock client providing a LARGER value via API.
         const mockClient = {
             config: {
                 providers: async () => ({
@@ -267,7 +271,7 @@ describe("models-dev-cache", () => {
         };
         await refreshModelLimitsFromApi(mockClient);
 
-        // API value wins.
+        // Larger (API) value wins.
         expect(getModelsDevContextLimit("anthropic", "claude-4")).toBe(1000000);
 
         const state = getModelsDevCacheState();
@@ -275,6 +279,70 @@ describe("models-dev-cache", () => {
         expect(state.apiCount).toBe(1);
     });
 
+    test("file value wins when the live API reports a smaller (wrong) limit (issue #117)", async () => {
+        // The ollama-cloud scenario: models.dev has the correct large window, but
+        // ollama reports its tiny default num_ctx via the live /config/providers
+        // API. The larger, correct file value must win so pressure isn't bogus.
+        const opencodeDir = join(tempDir, "opencode");
+        mkdirSync(opencodeDir, { recursive: true });
+        writeFileSync(
+            join(opencodeDir, "models.json"),
+            JSON.stringify({
+                "ollama-cloud": {
+                    models: { "deepseek-v4-pro": { limit: { context: 1048576 } } },
+                },
+            }),
+        );
+
+        const mockClient = {
+            config: {
+                providers: async () => ({
+                    data: {
+                        providers: [
+                            {
+                                id: "ollama-cloud",
+                                models: {
+                                    // Bogus tiny default num_ctx from ollama.
+                                    "deepseek-v4-pro": { limit: { context: 8192 } },
+                                },
+                            },
+                        ],
+                    },
+                }),
+            },
+        };
+        await refreshModelLimitsFromApi(mockClient);
+
+        // Larger (file/models.dev) value wins, not the tiny live-API value.
+        expect(getModelsDevContextLimit("ollama-cloud", "deepseek-v4-pro")).toBe(1048576);
+    });
+
+    test("matches a tagged ollama model against its tag-less models.dev entry (issue #117)", () => {
+        // ollama invokes cloud models with a tag (deepseek-v4-pro:cloud) while
+        // models.dev stores them tag-less (deepseek-v4-pro).
+        const opencodeDir = join(tempDir, "opencode");
+        mkdirSync(opencodeDir, { recursive: true });
+        writeFileSync(
+            join(opencodeDir, "models.json"),
+            JSON.stringify({
+                "ollama-cloud": {
+                    models: {
+                        "deepseek-v4-pro": { limit: { context: 1048576 } },
+                        // A legitimately-tagged model must still match exactly.
+                        "gemma3:27b": { limit: { context: 131072 } },
+                    },
+                },
+            }),
+        );
+
+        // Tagged invocation falls back to the tag-less entry.
+        expect(getModelsDevContextLimit("ollama-cloud", "deepseek-v4-pro:cloud")).toBe(1048576);
+        // Exact tagged match still wins (no wrongful collapse).
+        expect(getModelsDevContextLimit("ollama-cloud", "gemma3:27b")).toBe(131072);
+        // Unknown tagged model with no tag-less base stays undefined.
+        expect(getModelsDevContextLimit("ollama-cloud", "nonexistent:cloud")).toBeUndefined();
+    });
+
     test("refreshModelLimitsFromApi tolerates empty/malformed responses", async () => {
         // Undefined data.
         await refreshModelLimitsFromApi({

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

@@ -298,19 +298,58 @@ export async function refreshModelLimitsFromApi(client: OpencodeClientLike): Pro
  * Returns `undefined` if neither layer knows the model.
  */
 export function getModelsDevContextLimit(providerID: string, modelID: string): number | undefined {
-    const key = `${providerID}/${modelID}`;
-
-    if (apiCache) {
-        const fromApi = apiCache.get(key)?.limit;
-        if (typeof fromApi === "number") return fromApi;
-    }
-
     const now = Date.now();
     if (!fileCache || now - fileLastAttempt > RELOAD_INTERVAL_MS) {
         fileLastAttempt = now;
         fileCache = loadModelsDevMetadataFromFile();
     }
-    return fileCache.get(key)?.limit;
+
+    const fromApi = lookupLimitWithTagFallback(apiCache, providerID, modelID);
+    const fromFile = lookupLimitWithTagFallback(fileCache, providerID, modelID);
+
+    // When BOTH layers know the model, take the LARGER limit. Providers never
+    // under-report their real window, so a suspiciously small value — e.g.
+    // ollama reporting its default `num_ctx` (4k/8k) for a cloud model via the
+    // live `/config/providers` API — must not override the correct, larger
+    // models.dev value. A genuinely smaller real limit (provider actually
+    // rejects at N) is captured separately via the overflow-detection path
+    // (detectedContextLimit), not here. (issue #117)
+    if (typeof fromApi === "number" && typeof fromFile === "number") {
+        return Math.max(fromApi, fromFile);
+    }
+    return fromApi ?? fromFile;
+}
+
+/**
+ * Look up a model's limit in one cache layer, with an ollama-style tag-suffix
+ * fallback.
+ *
+ * models.dev stores some models WITH a colon tag (e.g. `gemma3:27b`,
+ * `deepseek-v3.1:671b`) and ollama-cloud base models WITHOUT one
+ * (`deepseek-v4-pro`). But ollama invokes cloud models with a tag at runtime
+ * (`deepseek-v4-pro:cloud`), so OpenCode reports the tagged id. An exact-only
+ * match therefore misses → falls back to the 128k default → wrong pressure
+ * denominator (issue #117).
+ *
+ * Strategy: exact match first (never collapses a legitimately-tagged model),
+ * then retry once with the last `:tag` segment stripped.
+ */
+function lookupLimitWithTagFallback(
+    cache: Map<string, CachedModelMetadata> | null,
+    providerID: string,
+    modelID: string,
+): number | undefined {
+    if (!cache) return undefined;
+    const exact = cache.get(`${providerID}/${modelID}`)?.limit;
+    if (typeof exact === "number") return exact;
+
+    const colonIdx = modelID.lastIndexOf(":");
+    if (colonIdx > 0) {
+        const baseModel = modelID.slice(0, colonIdx);
+        const fallback = cache.get(`${providerID}/${baseModel}`)?.limit;
+        if (typeof fallback === "number") return fallback;
+    }
+    return undefined;
 }
 
 /** Clear in-memory caches (for testing). */

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

@@ -18,7 +18,11 @@ describe("opencode-compaction-detector", () => {
     });
 
     afterEach(() => {
-        rmSync(tmpDir, { recursive: true, force: true });
+        try {
+            rmSync(tmpDir, { recursive: true, force: true, maxRetries: 10, retryDelay: 100 });
+        } catch {
+            /* Ignore EBUSY on Windows */
+        }
         delete process.env.OPENCODE_DISABLE_AUTOCOMPACT;
     });
 
@@ -30,7 +34,11 @@ describe("opencode-compaction-detector", () => {
             const result = isOpenCodeAutoCompactionEnabled(emptyDir);
 
             expect(result).toBe(true);
-            rmSync(emptyDir, { recursive: true, force: true });
+            try {
+                rmSync(emptyDir, { recursive: true, force: true, maxRetries: 10, retryDelay: 100 });
+            } catch {
+                /* Ignore EBUSY on Windows */
+            }
         });
     });
 

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

@@ -1,10 +1,11 @@
 import { afterEach, describe, expect, test } from "bun:test";
-import { mkdirSync, mkdtempSync, rmSync, writeFileSync } from "node:fs";
+import { mkdirSync, mkdtempSync, readFileSync, 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";
+import { MagicContextRpcServer } from "./rpc-server";
+import { parseRpcPortFile, rpcPortFilePath } from "./rpc-utils";
 
 interface TestServer {
     port: number;
@@ -19,7 +20,11 @@ afterEach(async () => {
         await server.close();
     }
     for (const dir of tempDirs.splice(0)) {
-        rmSync(dir, { recursive: true, force: true });
+        try {
+            rmSync(dir, { recursive: true, force: true, maxRetries: 10, retryDelay: 100 });
+        } catch {
+            /* Ignore EBUSY on Windows */
+        }
     }
 });
 
@@ -116,6 +121,52 @@ describe("MagicContextRpcClient", () => {
         expect(await client.call<{ value: string }>("value")).toEqual({ value: "second" });
     });
 
+    test("authenticates against a real server with the published token", async () => {
+        const storageDir = makeTempDir();
+        const directory = "/repo-auth";
+        const server = new MagicContextRpcServer(storageDir, directory);
+        server.handle("ping", async () => ({ pong: true }));
+        await server.start();
+        try {
+            const client = new MagicContextRpcClient(storageDir, directory);
+            // Real round-trip: client must read the token from the port file and
+            // send it as Bearer auth, or the server returns 401.
+            expect(await client.call<{ pong: boolean }>("ping")).toEqual({ pong: true });
+        } finally {
+            server.stop();
+        }
+    });
+
+    test("a request without the token is rejected 401 by the server", async () => {
+        const storageDir = makeTempDir();
+        const directory = "/repo-noauth";
+        const server = new MagicContextRpcServer(storageDir, directory);
+        server.handle("ping", async () => ({ pong: true }));
+        const port = await server.start();
+        try {
+            // Sanity: the port file carries a non-empty token.
+            const record = parseRpcPortFile(
+                readFileSync(rpcPortFilePath(storageDir, directory), "utf-8"),
+            );
+            expect(typeof record?.token).toBe("string");
+            expect((record?.token ?? "").length).toBeGreaterThan(0);
+
+            // A raw fetch with no Authorization header must be rejected.
+            const res = await fetch(`http://127.0.0.1:${port}/rpc/ping`, {
+                method: "POST",
+                headers: { "Content-Type": "application/json" },
+                body: "{}",
+            });
+            expect(res.status).toBe(401);
+
+            // Health stays open (no token required) for discovery.
+            const health = await fetch(`http://127.0.0.1:${port}/health`);
+            expect(health.status).toBe(200);
+        } finally {
+            server.stop();
+        }
+    });
+
     test("gives up when the port file points at a dead server", async () => {
         const storageDir = makeTempDir();
         const directory = "/repo";

package/src/shared/rpc-client.ts

@@ -17,6 +17,7 @@ type NonRetryableRpcError = Error & { [NON_RETRYABLE_RPC_ERROR]: true };
 
 export class MagicContextRpcClient {
     private port: number | null = null;
+    private token: string | null = null;
     private portDir: string;
     private legacyPortFilePath: string;
     private healthChecked = false;
@@ -46,7 +47,14 @@ export class MagicContextRpcClient {
                     `http://127.0.0.1:${port}/rpc/${method}`,
                     {
                         method: "POST",
-                        headers: { "Content-Type": "application/json" },
+                        headers: {
+                            "Content-Type": "application/json",
+                            // The server requires this per-process token on all
+                            // non-health calls; read from the same port file used
+                            // for discovery. Older servers wrote no token — send
+                            // nothing then (they also require nothing).
+                            ...(this.token ? { Authorization: `Bearer ${this.token}` } : {}),
+                        },
                         body: JSON.stringify(params),
                     },
                 );
@@ -105,13 +113,14 @@ export class MagicContextRpcClient {
         }
 
         for (let attempt = 0; attempt < MAX_RETRIES; attempt++) {
-            const port = this.readPortFile();
-            if (port) {
-                const alive = await this.healthCheck(port);
+            const record = this.readPortFile();
+            if (record) {
+                const alive = await this.healthCheck(record.port);
                 if (alive) {
-                    this.port = port;
+                    this.port = record.port;
+                    this.token = record.token ?? null;
                     this.healthChecked = true;
-                    return port;
+                    return record.port;
                 }
             }
 
@@ -123,7 +132,7 @@ export class MagicContextRpcClient {
         return null;
     }
 
-    private readPortFile(): number | null {
+    private readPortFile(): RpcPortFileRecord | null {
         const records: RpcPortFileRecord[] = [];
 
         try {
@@ -139,13 +148,13 @@ export class MagicContextRpcClient {
 
         if (records.length > 0) {
             records.sort((a, b) => b.started_at - a.started_at);
-            return records[0].port;
+            return records[0];
         }
 
         try {
             const record = parseRpcPortFile(readFileSync(this.legacyPortFilePath, "utf-8"));
             if (record?.pid && !isPidAlive(record.pid)) return null;
-            return record?.port ?? null;
+            return record;
         } catch {
             return null;
         }
@@ -174,6 +183,7 @@ export class MagicContextRpcClient {
 
     reset(): void {
         this.port = null;
+        this.token = null;
         this.healthChecked = false;
     }
 }

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

@@ -1,5 +1,5 @@
 import { describe, expect, test } from "bun:test";
-import { drainNotifications, pushNotification } from "./rpc-notifications";
+import { drainNotifications, isTuiConnected, pushNotification } from "./rpc-notifications";
 
 describe("rpc notifications", () => {
     test("keeps messages queued until the client acks their id", () => {
@@ -17,4 +17,57 @@ describe("rpc notifications", () => {
         const lastReceivedId = Math.max(...firstPoll.map((m) => m.id));
         expect(drainNotifications(lastReceivedId)).toEqual([]);
     });
+
+    test("scopes drain to the requesting session; other sessions' items survive", () => {
+        // drain everything left from prior tests
+        drainNotifications(Number.MAX_SAFE_INTEGER);
+
+        pushNotification("for-a", { action: "show-upgrade-dialog" }, "ses_A");
+        pushNotification("for-b", { action: "show-upgrade-dialog" }, "ses_B");
+        pushNotification("global", { action: "show-status-dialog" });
+
+        // Session A sees only its own item + the global one, never ses_B's.
+        const aPoll = drainNotifications(0, "ses_A");
+        expect(aPoll.map((m) => m.type).sort()).toEqual(["for-a", "global"]);
+
+        // Acking session A must NOT prune session B's still-unseen notification.
+        const ackId = Math.max(...aPoll.map((m) => m.id));
+        drainNotifications(ackId, "ses_A");
+        const bPoll = drainNotifications(0, "ses_B");
+        expect(bPoll.map((m) => m.type)).toContain("for-b");
+    });
+
+    test("session-less drain (legacy client) still receives all items", () => {
+        drainNotifications(Number.MAX_SAFE_INTEGER);
+        pushNotification("x", { ok: true }, "ses_1");
+        pushNotification("y", { ok: true }, "ses_2");
+        const poll = drainNotifications(0);
+        expect(poll.map((m) => m.type).sort()).toEqual(["x", "y"]);
+    });
+
+    test("isTuiConnected is per-session: a TUI on session A does not mark session B connected", () => {
+        // A TUI draining for tuiA must not make tuiB's producers think a TUI is
+        // polling for tuiB (which would route tuiB's /ctx-status, upgrade
+        // reminder, etc. to the dialog path and lose them in the unrelated TUI).
+        // Use ids no other test drains so the per-session window is unambiguous.
+        drainNotifications(0, "ses_tuiA_only");
+        expect(isTuiConnected("ses_tuiA_only")).toBe(true);
+        expect(isTuiConnected("ses_tuiB_never_drained")).toBe(false);
+        // The session-less (global) query still reports recent activity for the
+        // legacy callers that have no session context.
+        expect(isTuiConnected()).toBe(true);
+    });
+
+    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);
+    });
 });

package/src/shared/rpc-notifications.ts

@@ -16,10 +16,22 @@ export interface RpcNotification {
 
 let queue: RpcNotification[] = [];
 let nextNotificationId = 1;
-// Timestamp of last drain — used to detect if TUI is actively polling.
+// Timestamp of last drain — used to detect if a TUI is actively polling.
 // The TUI polls every 500ms; we consider it connected if it polled within
 // the last 3 seconds (6× the poll interval, tolerates transient delays).
-let lastDrainAt = 0;
+//
+// PER-SESSION: a single server process can serve MANY sessions (e.g. a TUI on
+// session A plus an OpenCode Desktop opened on session B for the same project,
+// whose newer RPC server this TUI's port discovery then selects). The TUI
+// poller drains with ITS active session id, so a session is "TUI-connected"
+// only if a TUI recently drained FOR THAT session. A process-global timestamp
+// would make session B's producers (`/ctx-status`, upgrade reminder) take the
+// TUI-dialog path because session A's TUI is polling — queuing a B-scoped
+// dialog action that A's poller correctly refuses to show, so B's notice is
+// lost (it also suppressed B's non-TUI fallback). Tracking drains per session
+// routes each producer to the right delivery path.
+const lastDrainAtBySession = new Map<string, number>();
+let lastDrainAtAny = 0;
 const TUI_CONNECTED_WINDOW_MS = 3_000;
 
 /** Push a notification for TUI to pick up via polling. */
@@ -29,25 +41,82 @@ export function pushNotification(
     sessionId?: string,
 ): void {
     queue.push({ id: nextNotificationId++, type, payload, sessionId });
-    // Cap queue size to prevent unbounded growth if TUI is not polling
+    // Cap queue size to prevent unbounded growth if a TUI is not draining.
+    // Session-FAIR eviction: a naive `slice(-50)` drops the globally-oldest
+    // items, so a noisy session could evict ANOTHER session's single unseen
+    // notification. Instead, always retain each session's newest item, then
+    // fill the rest of the budget with the newest overall — no session can
+    // starve another's pending dialog out of the window.
     if (queue.length > 100) {
-        queue = queue.slice(-50);
+        const newestPerSession = new Map<string | undefined, number>();
+        for (const n of queue) {
+            const prev = newestPerSession.get(n.sessionId);
+            if (prev === undefined || n.id > prev) {
+                newestPerSession.set(n.sessionId, n.id);
+            }
+        }
+        const mustKeep = new Set(newestPerSession.values());
+        const byNewest = [...queue].sort((a, b) => b.id - a.id);
+        const kept: RpcNotification[] = [];
+        for (const n of byNewest) {
+            if (kept.length < 50 || mustKeep.has(n.id)) kept.push(n);
+        }
+        queue = kept.sort((a, b) => a.id - b.id);
     }
 }
 
 /** Return pending notifications after acking the client's last received id.
- *  Updates lastDrainAt so isTuiConnected() reflects recent activity. */
-export function drainNotifications(lastReceivedId = 0): RpcNotification[] {
-    lastDrainAt = Date.now();
+ *  Updates lastDrainAt so isTuiConnected() reflects recent activity.
+ *
+ *  Session scoping: when `sessionId` is provided, only notifications tagged for
+ *  that session (or session-less/global ones) are returned and pruned — a
+ *  notification tagged for a DIFFERENT session is never handed to this client
+ *  and is never pruned by this client's ack. This matters because the in-memory
+ *  queue is per-process but a TUI can end up draining a process that also serves
+ *  OTHER sessions: e.g. opening OpenCode Desktop on the same project starts a
+ *  newer RPC server that the TUI's port discovery (newest-pid-wins) then selects,
+ *  so a Desktop-session upgrade-dialog action would otherwise surface in an
+ *  unrelated TUI session. Each client also tracks its own `lastReceivedId`, so a
+ *  global watermark prune would let session A's ack drop session B's still-unseen
+ *  notification — scoping the prune to the acking session prevents that too.
+ *
+ *  Delivery is at-least-once (non-destructive return + prune-on-ack): a returned
+ *  notification stays queued until a later call acks it via a higher
+ *  `lastReceivedId`, so a lost poll response re-delivers on the next poll. */
+export function drainNotifications(lastReceivedId = 0, sessionId?: string): RpcNotification[] {
+    const now = Date.now();
+    lastDrainAtAny = now;
+    if (sessionId !== undefined) lastDrainAtBySession.set(sessionId, now);
+    const matchesClient = (notification: RpcNotification): boolean =>
+        sessionId === undefined ||
+        notification.sessionId === undefined ||
+        notification.sessionId === sessionId;
     if (lastReceivedId > 0) {
-        queue = queue.filter((notification) => notification.id > lastReceivedId);
+        // Prune only notifications THIS client both owns (session-matched) and has
+        // acked (id <= lastReceivedId). Other sessions' notifications survive.
+        queue = queue.filter(
+            (notification) => !(notification.id <= lastReceivedId && matchesClient(notification)),
+        );
     }
-    return [...queue];
+    return queue.filter(
+        (notification) => notification.id > lastReceivedId && matchesClient(notification),
+    );
 }
 
 /** Whether a TUI client is actively polling for notifications.
- *  Returns true only if the TUI has drained within the last 3 seconds.
- *  This prevents stale-connected state after TUI closes or disconnects. */
-export function isTuiConnected(): boolean {
-    return lastDrainAt > 0 && Date.now() - lastDrainAt < TUI_CONNECTED_WINDOW_MS;
+ *  Returns true only if a TUI has drained within the last 3 seconds.
+ *
+ *  Pass `sessionId` (preferred) to ask whether a TUI is polling FOR THAT
+ *  SESSION — this is what producers (`/ctx-status`, `/ctx-recomp`, the upgrade
+ *  reminder) must use to decide dialog-vs-message, so a TUI on a different
+ *  session in the same process does not misroute their delivery. Omit it only
+ *  for legacy/global callers that genuinely have no session context; they fall
+ *  back to "any session recently drained" (the pre-per-session behavior). */
+export function isTuiConnected(sessionId?: string): boolean {
+    const now = Date.now();
+    if (sessionId !== undefined) {
+        const at = lastDrainAtBySession.get(sessionId) ?? 0;
+        return at > 0 && now - at < TUI_CONNECTED_WINDOW_MS;
+    }
+    return lastDrainAtAny > 0 && now - lastDrainAtAny < TUI_CONNECTED_WINDOW_MS;
 }