@cortexkit/opencode-magic-context 0.31.5 → 0.32.1

package/src/tui-compiled/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-compiled/index.tsx

@@ -807,17 +807,32 @@ async function showRecompDialog(api, targetSessionId = getSessionId(api)) {
     });
     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(() => _$createComponent(api.ui.DialogConfirm, {
     title: "\u26A0\uFE0F Recomp Confirmation",
     get message() {
       return [count === 0 ? "This session has no compartments yet — recomp will build them from raw history." : `You have ${count} compartments.`, "", "Recomp will regenerate all compartments and facts from raw history.", "This may take a long time and consume significant tokens.", "", "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",
@@ -848,24 +863,23 @@ function showUpgradeDialog(api, resume, targetSessionId = getSessionId(api)) {
   api.ui.dialog.replace(() => _$createComponent(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 ? "Resuming session upgrade — running in the background" : "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
@@ -1089,13 +1103,20 @@ async function showStartupAnnouncement(api) {
   }
 }
 const tui = 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).
@@ -1124,7 +1145,7 @@ const tui = 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") {
@@ -1182,14 +1203,10 @@ const tui = 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