@cortexkit/opencode-magic-context 0.32.0 → 0.32.2

package/dist/tui-compiled/data/context-db.d.ts

@@ -15,8 +15,15 @@ export declare function loadSidebarSnapshot(sessionId: string, directory: string
 export declare function loadStatusDetail(sessionId: string, directory: string, modelKey?: string): Promise<StatusDetail>;
 /** Fetch embedding coverage status for `/ctx-embed` via RPC. */
 export declare function loadEmbedDetail(sessionId: string, directory: string): Promise<EmbedDetail>;
-/** Get compartment count via RPC. */
-export declare function getCompartmentCount(sessionId: string): Promise<number>;
+export type CompartmentCountResult = {
+    ok: true;
+    count: number;
+} | {
+    ok: false;
+    error: string;
+};
+/** Get compartment count without making transport failure look like a real zero. */
+export declare function getCompartmentCount(sessionId: string): Promise<CompartmentCountResult>;
 /** Send recomp request to server via RPC. */
 export declare function requestRecomp(sessionId: string): Promise<boolean>;
 /** Run `/ctx-session-upgrade` for the session (full recomp + once-per-project

package/dist/tui-compiled/data/context-db.d.ts.map

@@ -1 +1 @@
-{"version":3,"file":"context-db.d.ts","sourceRoot":"","sources":["../../../src/tui-compiled/data/context-db.ts"],"names":[],"mappings":"AAMA,OAAO,EAAE,qBAAqB,EAAE,MAAM,yBAAyB,CAAC;AAChE,OAAO,KAAK,EAAE,WAAW,EAAE,eAAe,EAAE,YAAY,EAAE,MAAM,wBAAwB,CAAC;AAEzF,YAAY,EAAE,WAAW,EAAE,eAAe,EAAE,YAAY,EAAE,CAAC;AAc3D,2DAA2D;AAC3D,wBAAgB,aAAa,CAAC,SAAS,EAAE,MAAM,GAAG,IAAI,CAOrD;AAED,wBAAgB,gBAAgB,IAAI,MAAM,CAEzC;AAED;sCACsC;AACtC,wBAAgB,YAAY,IAAI,qBAAqB,GAAG,IAAI,CAE3D;AAED,+BAA+B;AAC/B,wBAAgB,QAAQ,IAAI,IAAI,CAM/B;AA2FD,sDAAsD;AACtD,wBAAsB,mBAAmB,CACrC,SAAS,EAAE,MAAM,EACjB,SAAS,EAAE,MAAM,GAClB,OAAO,CAAC,eAAe,CAAC,CA4B1B;AAED,wDAAwD;AACxD,wBAAsB,gBAAgB,CAClC,SAAS,EAAE,MAAM,EACjB,SAAS,EAAE,MAAM,EACjB,QAAQ,CAAC,EAAE,MAAM,GAClB,OAAO,CAAC,YAAY,CAAC,CA0CvB;AAYD,gEAAgE;AAChE,wBAAsB,eAAe,CAAC,SAAS,EAAE,MAAM,EAAE,SAAS,EAAE,MAAM,GAAG,OAAO,CAAC,WAAW,CAAC,CAchG;AAED,qCAAqC;AACrC,wBAAsB,mBAAmB,CAAC,SAAS,EAAE,MAAM,GAAG,OAAO,CAAC,MAAM,CAAC,CAQ5E;AAED,6CAA6C;AAC7C,wBAAsB,aAAa,CAAC,SAAS,EAAE,MAAM,GAAG,OAAO,CAAC,OAAO,CAAC,CAQvE;AAED;mFACmF;AACnF,wBAAsB,cAAc,CAAC,SAAS,EAAE,MAAM,GAAG,OAAO,CAAC,OAAO,CAAC,CAQxE;AAED;;iDAEiD;AACjD,wBAAsB,sBAAsB,CAAC,SAAS,EAAE,MAAM,GAAG,OAAO,CAAC,OAAO,CAAC,CAUhF;AAED,gEAAgE;AAChE,wBAAsB,mBAAmB,IAAI,OAAO,CAAC,MAAM,CAAC,CAQ3D;AAED;;;;GAIG;AACH,MAAM,WAAW,oBAAoB;IACjC,IAAI,EAAE,OAAO,CAAC;IACd,OAAO,CAAC,EAAE,MAAM,CAAC;IACjB,QAAQ,CAAC,EAAE,MAAM,EAAE,CAAC;IACpB,MAAM,CAAC,EAAE,MAAM,CAAC;CACnB;AAED,wBAAsB,eAAe,IAAI,OAAO,CAAC,oBAAoB,CAAC,CAkBrE;AAED,wEAAwE;AACxE,wBAAsB,aAAa,IAAI,OAAO,CAAC,OAAO,CAAC,CAQtD"}
+{"version":3,"file":"context-db.d.ts","sourceRoot":"","sources":["../../../src/tui-compiled/data/context-db.ts"],"names":[],"mappings":"AAMA,OAAO,EAAE,qBAAqB,EAAE,MAAM,yBAAyB,CAAC;AAChE,OAAO,KAAK,EAAE,WAAW,EAAE,eAAe,EAAE,YAAY,EAAE,MAAM,wBAAwB,CAAC;AAEzF,YAAY,EAAE,WAAW,EAAE,eAAe,EAAE,YAAY,EAAE,CAAC;AAc3D,2DAA2D;AAC3D,wBAAgB,aAAa,CAAC,SAAS,EAAE,MAAM,GAAG,IAAI,CAOrD;AAED,wBAAgB,gBAAgB,IAAI,MAAM,CAEzC;AAED;sCACsC;AACtC,wBAAgB,YAAY,IAAI,qBAAqB,GAAG,IAAI,CAE3D;AAED,+BAA+B;AAC/B,wBAAgB,QAAQ,IAAI,IAAI,CAM/B;AAuFD,sDAAsD;AACtD,wBAAsB,mBAAmB,CACrC,SAAS,EAAE,MAAM,EACjB,SAAS,EAAE,MAAM,GAClB,OAAO,CAAC,eAAe,CAAC,CA8B1B;AAED,wDAAwD;AACxD,wBAAsB,gBAAgB,CAClC,SAAS,EAAE,MAAM,EACjB,SAAS,EAAE,MAAM,EACjB,QAAQ,CAAC,EAAE,MAAM,GAClB,OAAO,CAAC,YAAY,CAAC,CA0CvB;AAYD,gEAAgE;AAChE,wBAAsB,eAAe,CAAC,SAAS,EAAE,MAAM,EAAE,SAAS,EAAE,MAAM,GAAG,OAAO,CAAC,WAAW,CAAC,CAchG;AAED,MAAM,MAAM,sBAAsB,GAAG;IAAE,EAAE,EAAE,IAAI,CAAC;IAAC,KAAK,EAAE,MAAM,CAAA;CAAE,GAAG;IAAE,EAAE,EAAE,KAAK,CAAC;IAAC,KAAK,EAAE,MAAM,CAAA;CAAE,CAAC;AAEhG,oFAAoF;AACpF,wBAAsB,mBAAmB,CAAC,SAAS,EAAE,MAAM,GAAG,OAAO,CAAC,sBAAsB,CAAC,CAe5F;AAED,6CAA6C;AAC7C,wBAAsB,aAAa,CAAC,SAAS,EAAE,MAAM,GAAG,OAAO,CAAC,OAAO,CAAC,CAQvE;AAED;mFACmF;AACnF,wBAAsB,cAAc,CAAC,SAAS,EAAE,MAAM,GAAG,OAAO,CAAC,OAAO,CAAC,CAQxE;AAED;;iDAEiD;AACjD,wBAAsB,sBAAsB,CAAC,SAAS,EAAE,MAAM,GAAG,OAAO,CAAC,OAAO,CAAC,CAUhF;AAED,gEAAgE;AAChE,wBAAsB,mBAAmB,IAAI,OAAO,CAAC,MAAM,CAAC,CAQ3D;AAED;;;;GAIG;AACH,MAAM,WAAW,oBAAoB;IACjC,IAAI,EAAE,OAAO,CAAC;IACd,OAAO,CAAC,EAAE,MAAM,CAAC;IACjB,QAAQ,CAAC,EAAE,MAAM,EAAE,CAAC;IACpB,MAAM,CAAC,EAAE,MAAM,CAAC;CACnB;AAED,wBAAsB,eAAe,IAAI,OAAO,CAAC,oBAAoB,CAAC,CAkBrE;AAED,wEAAwE;AACxE,wBAAsB,aAAa,IAAI,OAAO,CAAC,OAAO,CAAC,CAQtD"}

package/dist/tui-compiled/data/notification-socket.d.ts

@@ -26,14 +26,13 @@ export interface SocketNotification {
 interface NotificationSocketOptions {
     /** Current active session id (re-read cheaply to follow session switches). */
     getSessionId: () => string | null;
-    /** Handle one delivered notification. Returns true if it was consumed (so its
-     *  id can advance the ack cursor). Async because dialog handlers await. */
+    /** Handle one delivered notification. Returns true only after it is fully
+     *  consumed and can be acknowledged. Async because dialog handlers await. */
     onNotification: (notification: SocketNotification) => boolean | Promise<boolean>;
 }
-/** Open the persistent notification socket. Idempotent: a second call while open
- *  is a no-op. Reconnects on its own after any drop. */
+/** Open the persistent notification socket. Reconnects on its own after a drop. */
 export declare function startNotificationSocket(options: NotificationSocketOptions): void;
-/** Close the socket and stop reconnecting. Call on TUI dispose. */
+/** Close the socket and release all state owned by this TUI initialization. */
 export declare function stopNotificationSocket(): void;
 export declare function _resetNotificationSocketStateForTesting(): void;
 export {};

package/dist/tui-compiled/data/notification-socket.d.ts.map

@@ -1 +1 @@
-{"version":3,"file":"notification-socket.d.ts","sourceRoot":"","sources":["../../../src/tui-compiled/data/notification-socket.ts"],"names":[],"mappings":"AAAA;;;;;;;;;;;;;;;;;;GAkBG;AAIH,MAAM,WAAW,kBAAkB;IAC/B,EAAE,EAAE,MAAM,CAAC;IACX,IAAI,EAAE,MAAM,CAAC;IACb,OAAO,EAAE,MAAM,CAAC,MAAM,EAAE,OAAO,CAAC,CAAC;IACjC,SAAS,CAAC,EAAE,MAAM,CAAC;CACtB;AAED,UAAU,yBAAyB;IAC/B,8EAA8E;IAC9E,YAAY,EAAE,MAAM,MAAM,GAAG,IAAI,CAAC;IAClC;+EAC2E;IAC3E,cAAc,EAAE,CAAC,YAAY,EAAE,kBAAkB,KAAK,OAAO,GAAG,OAAO,CAAC,OAAO,CAAC,CAAC;CACpF;AAkCD;wDACwD;AACxD,wBAAgB,uBAAuB,CAAC,OAAO,EAAE,yBAAyB,GAAG,IAAI,CAQhF;AAED,mEAAmE;AACnE,wBAAgB,sBAAsB,IAAI,IAAI,CAkB7C;AA6KD,wBAAgB,uCAAuC,IAAI,IAAI,CAM9D"}
+{"version":3,"file":"notification-socket.d.ts","sourceRoot":"","sources":["../../../src/tui-compiled/data/notification-socket.ts"],"names":[],"mappings":"AAAA;;;;;;;;;;;;;;;;;;GAkBG;AAIH,MAAM,WAAW,kBAAkB;IAC/B,EAAE,EAAE,MAAM,CAAC;IACX,IAAI,EAAE,MAAM,CAAC;IACb,OAAO,EAAE,MAAM,CAAC,MAAM,EAAE,OAAO,CAAC,CAAC;IACjC,SAAS,CAAC,EAAE,MAAM,CAAC;CACtB;AAED,UAAU,yBAAyB;IAC/B,8EAA8E;IAC9E,YAAY,EAAE,MAAM,MAAM,GAAG,IAAI,CAAC;IAClC;iFAC6E;IAC7E,cAAc,EAAE,CAAC,YAAY,EAAE,kBAAkB,KAAK,OAAO,GAAG,OAAO,CAAC,OAAO,CAAC,CAAC;CACpF;AA6CD,mFAAmF;AACnF,wBAAgB,uBAAuB,CAAC,OAAO,EAAE,yBAAyB,GAAG,IAAI,CAOhF;AAED,+EAA+E;AAC/E,wBAAgB,sBAAsB,IAAI,IAAI,CA+B7C;AAyUD,wBAAgB,uCAAuC,IAAI,IAAI,CAE9D"}

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@cortexkit/opencode-magic-context",
-  "version": "0.32.0",
+  "version": "0.32.2",
   "type": "module",
   "description": "OpenCode plugin for Magic Context — cross-session memory and context management",
   "main": "dist/index.js",
@@ -43,6 +43,7 @@
     "prepublishOnly": "bun run build && bun run build:tui"
   },
   "dependencies": {
+    "@cortexkit/subc-client": "0.4.1",
     "@huggingface/transformers": "^4.1.0",
     "@jitl/quickjs-singlefile-cjs-release-asyncify": "0.32.0",
     "@opencode-ai/plugin": "^1.17.11",

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;
     }
 }