@cortexkit/opencode-magic-context 0.21.8 → 0.22.1

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

@@ -10,7 +10,8 @@ import type { RpcNotificationMessage, SidebarSnapshot, StatusDetail } from "../.
 export type { SidebarSnapshot, StatusDetail };
 
 let rpcClient: MagicContextRpcClient | null = null;
-let lastReceivedNotificationId = 0;
+let rpcGeneration = 0;
+const lastReceivedNotificationIdBySession = new Map<string, number>();
 
 function getStorageDir(): string {
     // Plugin v0.16+ uses the shared cortexkit/magic-context path so OpenCode
@@ -24,14 +25,25 @@ function getStorageDir(): string {
 /** Initialize the RPC client. Call once on TUI startup. */
 export function initRpcClient(directory: string): void {
     const storageDir = getStorageDir();
+    // Bump the generation before replacing the client so late notification
+    // responses from a disposed client cannot repopulate cleared cursors.
+    rpcGeneration += 1;
+    lastReceivedNotificationIdBySession.clear();
     rpcClient = new MagicContextRpcClient(storageDir, directory);
 }
 
+export function getRpcGeneration(): number {
+    return rpcGeneration;
+}
+
 /** Clean up the RPC client. */
 export function closeRpc(): void {
+    // Closing invalidates any already-issued RPC calls; their callbacks must
+    // observe the new generation and avoid advancing stale notification cursors.
+    rpcGeneration += 1;
     rpcClient?.reset();
     rpcClient = null;
-    lastReceivedNotificationId = 0;
+    lastReceivedNotificationIdBySession.clear();
 }
 
 const EMPTY_SNAPSHOT: SidebarSnapshot = {
@@ -55,6 +67,8 @@ const EMPTY_SNAPSHOT: SidebarSnapshot = {
     compartmentTokens: 0,
     factTokens: 0,
     memoryTokens: 0,
+    docsTokens: 0,
+    profileTokens: 0,
     conversationTokens: 0,
     toolCallTokens: 0,
     toolDefinitionTokens: 0,
@@ -229,7 +243,35 @@ export async function requestRecomp(sessionId: string): Promise<boolean> {
     }
 }
 
+/** Run `/ctx-session-upgrade` for the session (full recomp + once-per-project
+ *  memory migration). Fired from the upgrade dialog's "Run upgrade now" action. */
+export async function requestUpgrade(sessionId: string): Promise<boolean> {
+    if (!rpcClient) return false;
+    try {
+        const result = await rpcClient.call<{ ok: boolean }>("upgrade", { sessionId });
+        return result.ok ?? false;
+    } catch {
+        return false;
+    }
+}
+
+/** Mark the upgrade reminder dismissed (the user made an explicit Confirm/Cancel
+ *  choice), setting the durable stamp so the FRESH dialog won't re-show. Resume
+ *  prompts are staging-driven and unaffected. */
+export async function dismissUpgradeReminder(sessionId: string): Promise<boolean> {
+    if (!rpcClient) return false;
+    try {
+        const result = await rpcClient.call<{ ok: boolean }>("dismiss-upgrade-reminder", {
+            sessionId,
+        });
+        return result.ok ?? false;
+    } catch {
+        return false;
+    }
+}
+
 export interface TuiMessage {
+    id: number;
     type: string;
     payload: Record<string, unknown>;
     sessionId?: string;
@@ -279,20 +321,24 @@ export async function markAnnounced(): Promise<boolean> {
 }
 
 /** Poll for pending server→TUI notifications via RPC. */
-export async function consumeTuiMessages(): Promise<TuiMessage[]> {
+export async function consumeTuiMessages(sessionId: string): Promise<TuiMessage[]> {
     if (!rpcClient) return [];
     try {
         const result = await rpcClient.call<{ messages: RpcNotificationMessage[] }>(
             "pending-notifications",
-            { lastReceivedId: lastReceivedNotificationId },
+            // Pass the TUI's active session so the server only drains
+            // notifications scoped to it (or global ones). Without this, a
+            // notification for another session served by the same process (e.g.
+            // OpenCode Desktop on the same project) could surface here. The
+            // cursor is per-session and is advanced by the poller only after it
+            // has delivered the returned batch.
+            {
+                lastReceivedId: lastReceivedNotificationIdBySession.get(sessionId) ?? 0,
+                sessionId,
+            },
         );
-        const messages = result.messages ?? [];
-        for (const message of messages) {
-            if (message.id > lastReceivedNotificationId) {
-                lastReceivedNotificationId = message.id;
-            }
-        }
-        return messages.map((m) => ({
+        return (result.messages ?? []).map((m) => ({
+            id: m.id,
             type: m.type,
             payload: m.payload,
             sessionId: m.sessionId,
@@ -301,3 +347,21 @@ export async function consumeTuiMessages(): Promise<TuiMessage[]> {
         return [];
     }
 }
+
+/**
+ * Advance the delivered-message cursor for one active TUI session.
+ * Callers must pass only the contiguous handled prefix of the drained batch;
+ * this helper remains empty-safe and monotonic for that prefix.
+ */
+export function markTuiMessagesHandled(sessionId: string, messages: TuiMessage[]): void {
+    const previous = lastReceivedNotificationIdBySession.get(sessionId) ?? 0;
+    let next = previous;
+    for (const message of messages) {
+        if (message.id > next) {
+            next = message.id;
+        }
+    }
+    if (next > previous) {
+        lastReceivedNotificationIdBySession.set(sessionId, next);
+    }
+}

package/src/tui/index.tsx

@@ -4,9 +4,9 @@ import { existsSync, mkdirSync, writeFileSync } from "node:fs"
 import { dirname, join } from "node:path"
 import { createMemo } from "solid-js"
 import type { TuiPlugin, TuiPluginApi, TuiThemeCurrent } from "@opencode-ai/plugin/tui"
-import { createSidebarContentSlot } from "./slots/sidebar-content"
+import { createSidebarContentSlot, kickRecompProgressRefresh } from "./slots/sidebar-content"
 import packageJson from "../../package.json"
-import { closeRpc, consumeTuiMessages, getAnnouncement, getCompartmentCount, initRpcClient, loadStatusDetail, markAnnounced, requestRecomp, type StatusDetail } from "./data/context-db"
+import { closeRpc, consumeTuiMessages, dismissUpgradeReminder, getAnnouncement, getCompartmentCount, getRpcGeneration, initRpcClient, loadStatusDetail, markAnnounced, markTuiMessagesHandled, requestRecomp, requestUpgrade, type TuiMessage, type StatusDetail } from "./data/context-db"
 import { formatThresholdPercent } from "../shared/format-threshold"
 import { detectConflicts } from "../shared/conflict-detector"
 import { fixConflicts } from "../shared/conflict-fixer"
@@ -213,9 +213,11 @@ const StatusDialog = (props: { api: TuiPluginApi; s: StatusDetail }) => {
     const COLORS = {
         // Cool / structured — injected by the plugin into message[0]
         system: "#c084fc",
+        docs: "#22d3ee",
         compartments: "#60a5fa",
         facts: "#fbbf24",
         memories: "#34d399",
+        profile: "#a3e635",
         // Warm / user-facing — chat and tool traffic
         conversation: "#f87171",
         toolCalls: "#fb923c",
@@ -229,6 +231,8 @@ const StatusDialog = (props: { api: TuiPluginApi; s: StatusDetail }) => {
 
         if (d.systemPromptTokens > 0)
             segs.push({ label: "System", tokens: d.systemPromptTokens, color: COLORS.system })
+        if (d.docsTokens > 0)
+            segs.push({ label: "Docs", tokens: d.docsTokens, color: COLORS.docs })
         if (d.compartmentTokens > 0)
             segs.push({
                 label: "Compartments",
@@ -250,6 +254,8 @@ const StatusDialog = (props: { api: TuiPluginApi; s: StatusDetail }) => {
                 color: COLORS.memories,
                 detail: `(${d.memoryBlockCount})`,
             })
+        if (d.profileTokens > 0)
+            segs.push({ label: "User Profile", tokens: d.profileTokens, color: COLORS.profile })
 
         if (d.conversationTokens > 0)
             segs.push({ label: "Conversation", tokens: d.conversationTokens, color: COLORS.conversation })
@@ -316,6 +322,35 @@ const StatusDialog = (props: { api: TuiPluginApi; s: StatusDetail }) => {
                 })}
             </box>
 
+            {/* Recomp / session-upgrade live progress (full width, only while
+                running or just finished — dogfood 2026-05-30). */}
+            {s().recompProgress && (
+                <box marginTop={1} width="100%" flexDirection="column">
+                    <text fg={t().text}><b>Recomp / Upgrade</b></text>
+                    {(() => {
+                        const p = s().recompProgress!
+                        if (p.phase === "recomp") {
+                            const frac = p.totalMessages > 0 ? p.processedMessages / p.totalMessages : 0
+                            const width = 24
+                            const filled = Math.round(Math.max(0, Math.min(1, frac)) * width)
+                            const bar = p.totalMessages > 0
+                                ? `[${"█".repeat(filled)}${"░".repeat(width - filled)}]`
+                                : "(starting…)"
+                            return (
+                                <>
+                                    <R t={t()} l="upgrading" v={p.totalMessages > 0 ? `${bar} ${Math.round(frac * 100)}%` : bar} fg={t().warning} />
+                                    {p.note ? <R t={t()} l="Status" v={p.note} fg={t().textMuted} /> : null}
+                                    <R t={t()} l="Compartments" v={`${p.compartmentsCreated} (${p.passCount} pass${p.passCount === 1 ? "" : "es"})`} fg={t().textMuted} />
+                                </>
+                            )
+                        }
+                        if (p.phase === "migration") return <R t={t()} l="Status" v={p.note ?? "Migrating memories ⟳"} fg={t().warning} />
+                        if (p.phase === "done") return <R t={t()} l="Status" v="✓ Upgrade complete" fg={t().accent} />
+                        return <R t={t()} l="Status" v={`✗ Failed${p.message ? `: ${p.message}` : ""}`} fg={t().error} />
+                    })()}
+                </box>
+            )}
+
             {/* 2-column layout */}
             <box flexDirection="row" width="100%" marginTop={1} gap={4}>
                 {/* Left column */}
@@ -406,49 +441,139 @@ function getModelKeyFromMessages(api: TuiPluginApi, sessionId: string): string |
     return undefined
 }
 
-function showRecompDialog(api: TuiPluginApi) {
-    const sessionId = getSessionId(api)
+async function showRecompDialog(api: TuiPluginApi, targetSessionId = getSessionId(api)): Promise<boolean> {
+    const sessionId = targetSessionId
     if (!sessionId) {
         api.ui.toast({ message: "No active session", variant: "warning" })
-        return
+        return false
     }
 
-    void getCompartmentCount(sessionId).then((count) => {
-        api.ui.dialog.replace(() => (
+    const count = 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
+
+    api.ui.dialog.replace(() => (
+        <api.ui.DialogConfirm
+            title="⚠️ Recomp Confirmation"
+            message={[
+                `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)
+                kickRecompProgressRefresh()
+                api.ui.toast({ message: "Recomp requested — historian will start shortly", variant: "info", duration: 5000 })
+            }}
+            onCancel={() => {
+                api.ui.toast({ message: "Recomp cancelled", variant: "info", duration: 3000 })
+            }}
+        />
+    ))
+    return true
+}
+
+function showUpgradeDialog(
+    api: TuiPluginApi,
+    resume?: { stagedCount: number; stagedThrough: number },
+    targetSessionId = getSessionId(api),
+): boolean {
+    const sessionId = targetSessionId
+    if (!sessionId) {
+        // No active session — nothing to upgrade. Silently skip (the server only
+        // enqueues this for sessions with legacy compartments, but the TUI may
+        // have switched sessions before the poller fired).
+        return false
+    }
+
+    if (getSessionId(api) !== sessionId) return false
+
+    const title = resume ? "🎆 Resume the interrupted upgrade?" : "🎆 Historian V2 is released!"
+    const message = resume
+        ? [
+              `An earlier upgrade to the new historian format was interrupted. ${resume.stagedCount} compartment${resume.stagedCount === 1 ? " was" : "s were"} already rebuilt (through message ${resume.stagedThrough}). Resuming continues from where it left off — nothing already rebuilt is reprocessed.`,
+              "",
+              "Resuming will:",
+              "• Rebuild the remaining compartments into the new layered format",
+              "• Re-organize this project's memories into the new taxonomy (once per project)",
+              "",
+              "The historian runs in the background and you can keep working. You can also resume via /ctx-session-upgrade later.",
+              "",
+              "Resume the upgrade now?",
+          ].join("\n")
+        : [
+              "This session's compartments are written by the old historian. The session is still usable with its old compartments, however it's strongly advised to upgrade them to the new format. This means every compartment needs to be reprocessed by the new historian, which might take a while depending on how big your session is.",
+              "",
+              "Running the upgrade will:",
+              "• Rebuild this session's compartments into the new layered format",
+              "• Re-organize this project's memories into the new taxonomy (once per project)",
+              "",
+              "The historian runs in the background and you can keep working while older compartments are reprocessed. You can also upgrade via /ctx-session-upgrade later.",
+              "",
+              "Run the upgrade now?",
+          ].join("\n")
+
+    api.ui.dialog.replace(
+        () => (
             <api.ui.DialogConfirm
-                title="⚠️ Recomp Confirmation"
-                message={[
-                    `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")}
+                title={title}
+                message={message}
                 onConfirm={() => {
-                    void requestRecomp(sessionId)
-                    api.ui.toast({ message: "Recomp requested — historian will start shortly", variant: "info", duration: 5000 })
+                    // Explicit choice → dismiss the fresh reminder durably so it
+                    // won't re-show. (Resume prompts are staging-driven and still
+                    // fire if this run is later interrupted.)
+                    void dismissUpgradeReminder(sessionId)
+                    void requestUpgrade(sessionId)
+                    // 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.
+                    kickRecompProgressRefresh()
+                    api.ui.toast({
+                        message: resume
+                            ? "Resuming session upgrade — running in the background"
+                            : "Session upgrade started — running in the background",
+                        variant: "info",
+                        duration: 5000,
+                    })
                 }}
                 onCancel={() => {
-                    api.ui.toast({ message: "Recomp cancelled", variant: "info", duration: 3000 })
+                    // Explicit decline → set the durable stamp so we don't re-prompt
+                    // on every restart. The fix for stamp-on-display trapping a
+                    // never-upgraded session (dogfood 2026-05-30) relies on THIS
+                    // being the only place the TUI path stamps.
+                    void dismissUpgradeReminder(sessionId)
+                    api.ui.toast({
+                        message: "Upgrade skipped — run /ctx-session-upgrade anytime",
+                        variant: "info",
+                        duration: 4000,
+                    })
                 }}
             />
-        ))
-    })
+        ),
+    )
+    return true
 }
 
-function showStatusDialog(api: TuiPluginApi) {
-    const sessionId = getSessionId(api)
+async function showStatusDialog(api: TuiPluginApi, targetSessionId = getSessionId(api)): Promise<boolean> {
+    const sessionId = targetSessionId
     if (!sessionId) {
         api.ui.toast({ message: "No active session", variant: "warning" })
-        return
+        return false
     }
 
     const directory = api.state.path.directory ?? ""
     const modelKey = getModelKeyFromMessages(api, sessionId)
-    void loadStatusDetail(sessionId, directory, modelKey).then((detail) => {
-        api.ui.dialog.replace(() => <StatusDialog api={api} s={detail} />)
-    })
+    const detail = await loadStatusDetail(sessionId, directory, modelKey)
+    // 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
+
+    api.ui.dialog.replace(() => <StatusDialog api={api} s={detail} />)
+    return true
 }
 
 /**
@@ -636,10 +761,46 @@ const tui: TuiPlugin = async (api, _options, meta) => {
     registerCommandPaletteEntries(api)
 
     // Poll for server→TUI messages: toasts and dialog requests.
-    // Single poller because consumeTuiMessages() is destructive (deletes consumed rows).
+    // The poller owns cursor advancement so notifications are acked only after
+    // they are accepted for the still-active session and delivered to the UI.
+    let pollInFlight = false
     const messagePoller = setInterval(() => {
-        void consumeTuiMessages().then((messages) => {
-            for (const msg of messages) {
+        // Scope the drain to the TUI's active session so notifications tagged for
+        // a different session (served by the same RPC process) are not consumed
+        // here. Do not poll on non-session routes: a session-scoped action fetched
+        // while sessionless could otherwise be acked without being shown.
+        // Avoid overlapping read-only drains: the server re-delivers until acked,
+        // so a second in-flight poll can fetch and dispatch the same batch twice.
+        if (pollInFlight) return
+
+        const requestedSessionId = getSessionId(api)
+        if (!requestedSessionId) return
+
+        pollInFlight = true
+        const pollGeneration = getRpcGeneration()
+        void consumeTuiMessages(requestedSessionId).then(async (messages) => {
+            // The dialog handlers read the current session when they run. If the
+            // user switched routes while the RPC was in flight, drop this whole
+            // batch without advancing the cursor; the next poll for the new
+            // session will fetch the right notifications.
+            // Ignore late responses from an older RPC client generation; close/init
+            // clears cursors and stale callbacks must not recreate them.
+            if (getRpcGeneration() !== pollGeneration) return
+
+            if (getSessionId(api) !== requestedSessionId) return
+
+            const orderedMessages = [...messages].sort((a, b) => a.id - b.id)
+            const handledMessageIds = new Set<number>()
+            for (const msg of orderedMessages) {
+                // Drop any action/dialog whose sessionId doesn't match this TUI's
+                // active session (session-less/global notifications still apply).
+                if (
+                    msg.type === "action" &&
+                    msg.sessionId &&
+                    msg.sessionId !== requestedSessionId
+                ) {
+                    continue
+                }
                 if (msg.type === "toast") {
                     const p = msg.payload
                     api.ui.toast({
@@ -647,17 +808,47 @@ const tui: TuiPlugin = async (api, _options, meta) => {
                         variant: (p.variant as "info" | "warning" | "error" | "success") ?? "info",
                         duration: typeof p.duration === "number" ? p.duration : 5000,
                     })
+                    handledMessageIds.add(msg.id)
                 } else if (msg.type === "action") {
                     const action = msg.payload?.action
                     if (action === "show-status-dialog") {
-                        showStatusDialog(api)
+                        if (await showStatusDialog(api, requestedSessionId)) {
+                            handledMessageIds.add(msg.id)
+                        }
                     } else if (action === "show-recomp-dialog") {
-                        showRecompDialog(api)
+                        if (await showRecompDialog(api, requestedSessionId)) {
+                            handledMessageIds.add(msg.id)
+                        }
+                    } else if (action === "show-upgrade-dialog") {
+                        const resume =
+                            msg.payload?.resume === true
+                                ? {
+                                      stagedCount: Number(msg.payload?.stagedCount ?? 0),
+                                      stagedThrough: Number(msg.payload?.stagedThrough ?? 0),
+                                  }
+                                : undefined
+                        if (showUpgradeDialog(api, resume, requestedSessionId)) {
+                            handledMessageIds.add(msg.id)
+                        }
                     }
                 }
             }
+            const handledPrefixMessages: TuiMessage[] = []
+            for (const msg of orderedMessages) {
+                if (!handledMessageIds.has(msg.id)) break
+                handledPrefixMessages.push(msg)
+            }
+            // A dialog helper may have awaited more RPC work; re-check before
+            // acking so a dispose/reinit or route switch during that await cannot
+            // advance a stale cursor.
+            if (getRpcGeneration() !== pollGeneration) return
+            if (getSessionId(api) !== requestedSessionId) return
+
+            markTuiMessagesHandled(requestedSessionId, handledPrefixMessages)
         }).catch(() => {
             // Intentional: message polling should never crash the TUI
+        }).finally(() => {
+            pollInFlight = false
         })
     }, 500)