@cortexkit/opencode-magic-context 0.32.0 → 0.32.1

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

@@ -30,8 +30,8 @@ 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>;
 }
 
@@ -48,40 +48,51 @@ let reconnectAttempt = 0;
 let closed = false;
 let helloedSession: string | null = null;
 let opts: NotificationSocketOptions | null = null;
-/** Generation of the rpc client at connect time; a dispose/reinit bumps it and
- *  invalidates an in-flight socket so its late callbacks are ignored. */
+let activeToken: string | null = null;
+/** Generation of the rpc client used by the active socket. */
 let connectGeneration = 0;
+/** Exactly one endpoint lookup may be active. A monotonically increasing id lets
+ * stop/restart invalidate a late lookup before it can publish a socket. */
+let nextAttemptId = 0;
+let inFlightAttemptId: number | null = null;
 
 const GLOBAL_CURSOR_KEY = "global";
 const SESSION_CURSOR_PREFIX = "session:";
 const MAX_DEDUPED_NOTIFICATION_IDS = 500;
+const LEGACY_INSTANCE_ID = "legacy";
+type NotificationProtocolMode = "legacy" | "v2";
 
 /**
- * Notification ids are process-global, but acknowledgement cursors are scoped. A
- * high id consumed in session A must not become the prune watermark for session B;
- * global notifications also carry their own cursor so they cannot skip session
- * backlog. The id set de-dupes at-least-once re-delivery when a reconnect sends
- * a session cursor that is intentionally lower than the global cursor.
+ * Notification ids restart with every server instance. Epoch-prefixing cursor keys
+ * and deduplication ids prevents a surviving TUI from applying a replaced server's
+ * high watermark or remembered ids to the replacement's fresh queue.
  */
+let activeInstanceId: string | null = null;
+let notificationProtocolMode: NotificationProtocolMode | null = null;
+const bufferedNotifications: SocketNotification[] = [];
 const lastHandledIdByCursor = new Map<string, number>();
-const handledNotificationIds = new Set<number>();
-const handledNotificationIdOrder: number[] = [];
+const handledNotificationIds = new Set<string>();
+const handledNotificationIdOrder: string[] = [];
+const legacyUnconsumedIdsByCursor = new Map<string, Set<number>>();
+const legacyConsumedIdsByCursor = new Map<string, Set<number>>();
+/** Dialog actions share UI state, so notification handlers must never overlap. */
+let notificationHandlingChain: Promise<void> = Promise.resolve();
 
-/** 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 function startNotificationSocket(options: NotificationSocketOptions): void {
     opts = options;
     closed = false;
-    connectGeneration = getRpcGeneration();
-    connect();
+    if (!socket && inFlightAttemptId === null) void connect();
     if (!sessionWatchTimer) {
         sessionWatchTimer = setInterval(watchSession, SESSION_WATCH_MS);
     }
 }
 
-/** Close the socket and stop reconnecting. Call on TUI dispose. */
+/** Close the socket and release all state owned by this TUI initialization. */
 export function stopNotificationSocket(): void {
     closed = true;
+    nextAttemptId += 1;
+    inFlightAttemptId = null;
     if (reconnectTimer) {
         clearTimeout(reconnectTimer);
         reconnectTimer = undefined;
@@ -96,8 +107,19 @@ export function stopNotificationSocket(): void {
         // best-effort
     }
     socket = null;
+    opts = null;
+    activeToken = null;
     helloedSession = null;
     reconnectAttempt = 0;
+    activeInstanceId = null;
+    notificationProtocolMode = null;
+    bufferedNotifications.length = 0;
+    lastHandledIdByCursor.clear();
+    handledNotificationIds.clear();
+    handledNotificationIdOrder.length = 0;
+    legacyUnconsumedIdsByCursor.clear();
+    legacyConsumedIdsByCursor.clear();
+    notificationHandlingChain = Promise.resolve();
 }
 
 function scheduleReconnect(): void {
@@ -112,17 +134,22 @@ function scheduleReconnect(): void {
 }
 
 async function connect(): Promise<void> {
-    if (closed) return;
-    if (socket) return; // already connected/connecting
+    if (closed || socket || inFlightAttemptId !== null) return;
 
     const client = getRpcClient();
     if (!client) {
         scheduleReconnect();
         return;
     }
+
+    const attemptId = ++nextAttemptId;
+    const rpcGeneration = getRpcGeneration();
+    inFlightAttemptId = attemptId;
     const endpoint = await client.resolveEndpoint();
-    // The generation may have bumped (dispose/reinit) while resolving — abandon.
-    if (closed || getRpcGeneration() !== connectGeneration) return;
+    if (closed || inFlightAttemptId !== attemptId || getRpcGeneration() !== rpcGeneration) {
+        return;
+    }
+    inFlightAttemptId = null;
     if (!endpoint) {
         scheduleReconnect();
         return;
@@ -130,32 +157,48 @@ async function connect(): Promise<void> {
 
     let ws: WebSocket;
     try {
-        const tokenQuery = `?token=${encodeURIComponent(endpoint.token ?? "")}`;
-        ws = new WebSocket(`ws://127.0.0.1:${endpoint.port}/ws${tokenQuery}`);
+        ws = new WebSocket(`ws://127.0.0.1:${endpoint.port}/ws`, {
+            headers: endpoint.token ? { Authorization: `Bearer ${endpoint.token}` } : {},
+        });
     } catch {
         client.reset();
         scheduleReconnect();
         return;
     }
+
+    if (closed || getRpcGeneration() !== rpcGeneration || socket) {
+        ws.close();
+        return;
+    }
+    connectGeneration = rpcGeneration;
+    activeToken = endpoint.token;
+    notificationProtocolMode = null;
+    bufferedNotifications.length = 0;
+    switchNotificationEpoch(endpoint.instanceId ?? LEGACY_INSTANCE_ID);
     socket = ws;
 
     ws.addEventListener("open", () => {
-        if (socket !== ws) return;
+        if (socket !== ws || getRpcGeneration() !== connectGeneration) {
+            ws.close();
+            return;
+        }
         reconnectAttempt = 0;
         sendHello(ws, endpoint.token);
     });
 
     ws.addEventListener("message", (event) => {
         if (socket !== ws) return;
-        void handleSocketMessage(ws, String((event as MessageEvent).data));
+        handleSocketMessage(ws, String((event as MessageEvent).data), endpoint.token);
     });
 
     const onDown = () => {
+        if (socket !== ws) return;
         client.reset();
-        if (socket === ws) {
-            socket = null;
-            helloedSession = null;
-        }
+        socket = null;
+        activeToken = null;
+        helloedSession = null;
+        notificationProtocolMode = null;
+        bufferedNotifications.length = 0;
         scheduleReconnect();
     };
     ws.addEventListener("close", onDown);
@@ -168,54 +211,55 @@ function sendHello(ws: WebSocket, token: string | null): void {
     ws.send(
         JSON.stringify({
             type: "hello",
+            protocol: 2,
+            instanceId: activeInstanceId,
             token: token ?? "",
             sessionId,
+            // Older servers still read these scoped cursors. Protocol 2 servers
+            // rely only on exact acknowledgements and do not prune from them.
             lastReceivedId: cursorForKey(cursorKeyForSession(sessionId)),
-            globalLastReceivedId: cursorForKey(GLOBAL_CURSOR_KEY),
+            globalLastReceivedId: cursorForKey(cursorKeyForSession(undefined)),
         }),
     );
 }
 
-async function handleSocketMessage(ws: WebSocket, raw: string): Promise<void> {
-    let msg: { type?: string; notification?: SocketNotification; error?: string };
+function handleSocketMessage(ws: WebSocket, raw: string, token: string | null): void {
+    let msg: {
+        type?: string;
+        notification?: SocketNotification;
+        error?: string;
+        instanceId?: string;
+    };
     try {
         msg = JSON.parse(raw);
     } catch {
         return;
     }
 
-    if (msg.type === "notification" && msg.notification) {
-        const notification = msg.notification;
-        // Client-side session filter mirrors the old poller's per-message re-check:
-        // a session-scoped notification is only acted on while the TUI is actually
-        // viewing that session (the active session can change between queueing and
-        // delivery). Global (session-less) notifications always apply.
-        const active = opts?.getSessionId() ?? null;
-        if (notification.sessionId && active && notification.sessionId !== active) {
-            // Not for the session we're viewing — do NOT ack it (a TUI on the right
-            // session, or a later switch back, should still get it). Just skip.
-            return;
-        }
-        if (handledNotificationIds.has(notification.id)) {
-            sendAck(ws, notification);
-            return;
+    if (msg.type === "hello-ack") {
+        if (typeof msg.instanceId === "string") {
+            notificationProtocolMode = "v2";
+            if (msg.instanceId !== activeInstanceId) {
+                switchNotificationEpoch(msg.instanceId);
+                // The server does not prune protocol 2 backlog from hello cursors, so a
+                // corrected hello safely establishes fresh epoch-scoped state.
+                sendHello(ws, token);
+            }
+        } else {
+            // A hello-ack without an instance id is the frozen v0.32 shape. Its
+            // server ignores exact-id acks, so cursors must remain gap-safe.
+            notificationProtocolMode = "legacy";
+            switchNotificationEpoch(LEGACY_INSTANCE_ID);
         }
+        flushBufferedNotifications(ws);
+        return;
+    }
 
-        let consumed = false;
-        try {
-            consumed = await Promise.resolve(opts?.onNotification(notification) ?? false);
-        } catch {
-            consumed = false;
-        }
-        // A dispose/reinit during an awaited dialog handler invalidates this socket.
-        if (socket !== ws || getRpcGeneration() !== connectGeneration) return;
-        if (consumed) {
-            rememberHandledId(notification.id);
-            advanceCursor(notificationCursorKey(notification), notification.id);
-            // Ack only the notification's own cursor scope. A dropped ack is safe:
-            // the next hello sends the same per-scope cursors and duplicates are
-            // ignored locally.
-            sendAck(ws, notification);
+    if (msg.type === "notification" && msg.notification) {
+        if (notificationProtocolMode === null) {
+            bufferedNotifications.push(msg.notification);
+        } else {
+            queueNotification(ws, msg.notification);
         }
         return;
     }
@@ -231,14 +275,82 @@ async function handleSocketMessage(ws: WebSocket, raw: string): Promise<void> {
     }
 }
 
+function flushBufferedNotifications(ws: WebSocket): void {
+    const pending = bufferedNotifications.splice(0);
+    for (const notification of pending) queueNotification(ws, notification);
+}
+
+function queueNotification(ws: WebSocket, notification: SocketNotification): void {
+    const deliveryInstanceId = activeInstanceId ?? LEGACY_INSTANCE_ID;
+    const deliveryMode = notificationProtocolMode;
+    if (deliveryMode === null) return;
+    // A single promise chain prevents two dialog actions from replacing each
+    // other's UI while either handler is still awaiting user input.
+    notificationHandlingChain = notificationHandlingChain
+        .then(() => handleNotification(ws, notification, deliveryInstanceId, deliveryMode))
+        .catch(() => {});
+}
+
+async function handleNotification(
+    ws: WebSocket,
+    notification: SocketNotification,
+    deliveryInstanceId: string,
+    deliveryMode: NotificationProtocolMode,
+): Promise<void> {
+    if (
+        socket !== ws ||
+        getRpcGeneration() !== connectGeneration ||
+        activeInstanceId !== deliveryInstanceId ||
+        notificationProtocolMode !== deliveryMode
+    ) {
+        return;
+    }
+    // Client-side session filtering follows session switches that happen between
+    // queueing and delivery. Global notifications always apply.
+    const active = opts?.getSessionId() ?? null;
+    if (notification.sessionId !== undefined && notification.sessionId !== active) return;
+
+    if (deliveryMode === "legacy") markLegacyUnconsumed(notification);
+    if (handledNotificationIds.has(notificationDedupKey(notification.id, deliveryInstanceId))) {
+        if (deliveryMode === "legacy") markLegacyConsumed(notification);
+        sendAck(ws, notification, deliveryMode);
+        return;
+    }
+
+    let consumed = false;
+    try {
+        consumed = await Promise.resolve(opts?.onNotification(notification) ?? false);
+    } catch {
+        consumed = false;
+    }
+    // A dispose, reconnect, or epoch correction during an awaited dialog invalidates
+    // the delivery. The server retains it for the current socket to redeliver.
+    if (
+        socket !== ws ||
+        getRpcGeneration() !== connectGeneration ||
+        activeInstanceId !== deliveryInstanceId ||
+        notificationProtocolMode !== deliveryMode
+    ) {
+        return;
+    }
+    if (consumed) {
+        rememberHandledId(notification.id, deliveryInstanceId);
+        if (deliveryMode === "legacy") {
+            markLegacyConsumed(notification);
+        } else {
+            advanceCursor(notificationCursorKey(notification), notification.id);
+        }
+        sendAck(ws, notification, deliveryMode);
+    }
+}
+
 function cursorKeyForSession(sessionId: string | null | undefined): string {
-    return sessionId ? `${SESSION_CURSOR_PREFIX}${sessionId}` : GLOBAL_CURSOR_KEY;
+    const scope = sessionId ? `${SESSION_CURSOR_PREFIX}${sessionId}` : GLOBAL_CURSOR_KEY;
+    return `${activeInstanceId ?? LEGACY_INSTANCE_ID}:${scope}`;
 }
 
 function notificationCursorKey(notification: SocketNotification): string {
-    return notification.sessionId
-        ? `${SESSION_CURSOR_PREFIX}${notification.sessionId}`
-        : GLOBAL_CURSOR_KEY;
+    return cursorKeyForSession(notification.sessionId);
 }
 
 function cursorForKey(key: string): number {
@@ -249,34 +361,96 @@ function advanceCursor(key: string, id: number): void {
     if (id > cursorForKey(key)) lastHandledIdByCursor.set(key, id);
 }
 
-function rememberHandledId(id: number): void {
-    if (handledNotificationIds.has(id)) return;
-    handledNotificationIds.add(id);
-    handledNotificationIdOrder.push(id);
+function idsForCursor(map: Map<string, Set<number>>, key: string): Set<number> {
+    let ids = map.get(key);
+    if (!ids) {
+        ids = new Set<number>();
+        map.set(key, ids);
+    }
+    return ids;
+}
+
+function markLegacyUnconsumed(notification: SocketNotification): void {
+    const key = notificationCursorKey(notification);
+    if (idsForCursor(legacyConsumedIdsByCursor, key).has(notification.id)) return;
+    idsForCursor(legacyUnconsumedIdsByCursor, key).add(notification.id);
+}
+
+function markLegacyConsumed(notification: SocketNotification): void {
+    const key = notificationCursorKey(notification);
+    idsForCursor(legacyUnconsumedIdsByCursor, key).delete(notification.id);
+    const consumedIds = idsForCursor(legacyConsumedIdsByCursor, key);
+    consumedIds.add(notification.id);
+
+    let safeCursor = Math.max(cursorForKey(key), ...consumedIds);
+    const unconsumedIds = legacyUnconsumedIdsByCursor.get(key);
+    if (unconsumedIds && unconsumedIds.size > 0) {
+        safeCursor = Math.min(safeCursor, Math.min(...unconsumedIds) - 1);
+    }
+    advanceCursor(key, safeCursor);
+    for (const id of consumedIds) {
+        if (id <= cursorForKey(key)) consumedIds.delete(id);
+    }
+}
+
+function notificationDedupKey(
+    id: number,
+    instanceId = activeInstanceId ?? LEGACY_INSTANCE_ID,
+): string {
+    return `${instanceId}:${id}`;
+}
+
+function rememberHandledId(id: number, instanceId: string): void {
+    const key = notificationDedupKey(id, instanceId);
+    if (handledNotificationIds.has(key)) return;
+    handledNotificationIds.add(key);
+    handledNotificationIdOrder.push(key);
     while (handledNotificationIdOrder.length > MAX_DEDUPED_NOTIFICATION_IDS) {
         const evicted = handledNotificationIdOrder.shift();
         if (evicted !== undefined) handledNotificationIds.delete(evicted);
     }
 }
 
-function sendAck(ws: WebSocket, notification: SocketNotification): void {
-    const lastReceivedId = cursorForKey(notificationCursorKey(notification));
-    const ack = notification.sessionId
-        ? { type: "ack", sessionId: notification.sessionId, lastReceivedId }
-        : { type: "ack", ackScope: "global", lastReceivedId };
+function switchNotificationEpoch(instanceId: string): void {
+    if (activeInstanceId === instanceId) return;
+    activeInstanceId = instanceId;
+    lastHandledIdByCursor.clear();
+    handledNotificationIds.clear();
+    handledNotificationIdOrder.length = 0;
+    legacyUnconsumedIdsByCursor.clear();
+    legacyConsumedIdsByCursor.clear();
+}
+
+function sendAck(
+    ws: WebSocket,
+    notification: SocketNotification,
+    mode: NotificationProtocolMode,
+): void {
     try {
-        ws.send(JSON.stringify(ack));
+        if (mode === "legacy") {
+            const cursor = cursorForKey(notificationCursorKey(notification));
+            ws.send(
+                JSON.stringify({
+                    type: "ack",
+                    cursor,
+                    ...(notification.sessionId
+                        ? { sessionId: notification.sessionId }
+                        : { ackScope: "global" }),
+                }),
+            );
+            return;
+        }
+        // Exact ids avoid deleting an earlier notification whose handler failed
+        // while a later notification was consumed successfully.
+        ws.send(JSON.stringify({ type: "ack", ids: [notification.id] }));
     } catch {
-        // best-effort; reconnect hello re-syncs via per-scope cursors
+        // Best-effort: an unacknowledged row is safely deduplicated and re-acked
+        // when the server delivers it again after reconnecting.
     }
 }
 
 export function _resetNotificationSocketStateForTesting(): void {
     stopNotificationSocket();
-    opts = null;
-    lastHandledIdByCursor.clear();
-    handledNotificationIds.clear();
-    handledNotificationIdOrder.length = 0;
 }
 
 /** Cheap session-change watcher: re-scope the socket only when the active session
@@ -285,10 +459,7 @@ function watchSession(): void {
     if (closed || !socket || socket.readyState !== WebSocket.OPEN) return;
     const current = opts?.getSessionId() ?? null;
     if (current === helloedSession) return;
-    // Re-hello with the new session; the server replaces this socket's sink scope.
-    const client = getRpcClient();
-    void client?.resolveEndpoint().then((endpoint) => {
-        if (!socket || socket.readyState !== WebSocket.OPEN) return;
-        sendHello(socket, endpoint?.token ?? null);
-    });
+    // Re-hello with the token authenticated by this socket; no rediscovery or
+    // network request is needed for a local route change.
+    sendHello(socket, activeToken);
 }

package/src/tui/index.tsx

@@ -389,10 +389,15 @@ async function showRecompDialog(api: TuiPluginApi, targetSessionId = getSessionI
         return false
     }
 
-    const count = await getCompartmentCount(sessionId)
+    const countResult = await getCompartmentCount(sessionId)
     // Ack only after the dialog is actually shown for the same active session;
     // route switches while the RPC detail load is in flight must leave it pending.
     if (getSessionId(api) !== sessionId) return false
+    if (!countResult.ok) {
+        showToast(api, { message: "Unable to load recomp details", variant: "error" })
+        return false
+    }
+    const count = countResult.count
 
     api.ui.dialog.replace(() => (
         <api.ui.DialogConfirm
@@ -407,8 +412,12 @@ async function showRecompDialog(api: TuiPluginApi, targetSessionId = getSessionI
                 "",
                 "Proceed?",
             ].join("\n")}
-            onConfirm={() => {
-                void requestRecomp(sessionId)
+            onConfirm={async () => {
+                const requested = await requestRecomp(sessionId)
+                if (!requested) {
+                    showToast(api, { message: "Recomp request failed", variant: "error" })
+                    return
+                }
                 kickRecompProgressRefresh()
                 showToast(api, { message: "Recomp requested — historian will start shortly", variant: "info" })
             }}
@@ -465,10 +474,14 @@ function showUpgradeDialog(
             <api.ui.DialogConfirm
                 title={title}
                 message={message}
-                onConfirm={() => {
-                    // Start the sidebar's recomp self-poll immediately — the RPC
-                    // call fires no message event, so without this the progress
-                    // bar wouldn't appear until the upgrade finished.
+                onConfirm={async () => {
+                    const started = await requestUpgrade(sessionId)
+                    if (!started) {
+                        showToast(api, { message: "Session upgrade request failed", variant: "error" })
+                        return
+                    }
+                    // The RPC call fires no message event, so start the sidebar's
+                    // progress poll only after the server accepts the request.
                     kickRecompProgressRefresh()
                     showToast(api, {
                         message: resume
@@ -476,15 +489,7 @@ function showUpgradeDialog(
                             : "Session upgrade started — running in the background",
                         variant: "info",
                     })
-                    // Dismiss the durable reminder ONLY after the upgrade request
-                    // actually started. If requestUpgrade() returns false (RPC /
-                    // server / db / auth failure, restart race), the session stays
-                    // legacy — dismissing first would set upgradeRemindedAt and
-                    // suppress all future reminders for a session that never
-                    // upgraded. (Resume prompts are staging-driven and unaffected.)
-                    void requestUpgrade(sessionId).then((started) => {
-                        if (started) void dismissUpgradeReminder(sessionId)
-                    })
+                    void dismissUpgradeReminder(sessionId)
                 }}
                 onCancel={() => {
                     // Explicit decline → set the durable stamp so we don't re-prompt
@@ -724,13 +729,21 @@ async function showStartupAnnouncement(api: TuiPluginApi): Promise<void> {
 }
 
 const tui: TuiPlugin = async (api, _options, meta) => {
-    // Initialize RPC client for server communication
     const directory = api.state.path.directory ?? ""
+    // A conflicted installation intentionally has no server. Gate before RPC
+    // discovery or socket startup so disabled installs perform no idle work.
+    const conflictResult = detectConflicts(directory)
+    if (conflictResult.hasConflict) {
+        showConflictDialog(api, directory, conflictResult.reasons, conflictResult.conflicts)
+        return
+    }
+
     initRpcClient(directory)
     await refreshToastDurationMs()
 
     // Register sidebar slot
-    api.slots.register(createSidebarContentSlot(api))
+    const sidebarSlot = createSidebarContentSlot(api)
+    api.slots.register(sidebarSlot)
 
     // Register TUI command palette entries (no slash field — slash commands
     // are registered server-side so there's only one /ctx-* registration).
@@ -759,7 +772,7 @@ const tui: TuiPlugin = async (api, _options, meta) => {
         // session; global (session-less) ones always apply. Returning false leaves
         // it unacked so a TUI on the right session (or a later switch back) still
         // gets it.
-        if (n.sessionId && requestedSessionId && n.sessionId !== requestedSessionId) {
+        if (n.sessionId !== undefined && n.sessionId !== requestedSessionId) {
             return false
         }
         if (n.type === "toast") {
@@ -825,16 +838,11 @@ const tui: TuiPlugin = async (api, _options, meta) => {
 
     // Clean up on dispose
     api.lifecycle.onDispose(() => {
+        sidebarSlot.dispose()
         stopNotificationSocket()
         closeRpc()
     })
 
-    const conflictResult = detectConflicts(directory)
-    if (conflictResult.hasConflict) {
-        showConflictDialog(api, directory, conflictResult.reasons, conflictResult.conflicts)
-        return
-    }
-
     // Show one-shot release announcement after conflict gate.
     // Fire-and-forget: if the server isn't ready or RPC fails, the next TUI
     // launch will retry. Dialog only appears once per ANNOUNCEMENT_VERSION