@cortexkit/opencode-magic-context 0.21.7 → 0.22.0

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 })
@@ -261,27 +267,12 @@ const StatusDialog = (props: { api: TuiPluginApi; s: StatusDetail }) => {
         return { segs, total }
     }
 
-    const barWidth = 56
-    const barSegments = () => {
-        const { segs, total } = breakdownSegments()
-        if (segs.length === 0) return []
-
-        let widths = segs.map((seg) => Math.max(1, Math.round((seg.tokens / total) * barWidth)))
-        let sum = widths.reduce((a, b) => a + b, 0)
-        while (sum > barWidth) {
-            const maxIdx = widths.indexOf(Math.max(...widths))
-            if (widths[maxIdx] > 1) { widths[maxIdx]--; sum-- } else break
-        }
-        while (sum < barWidth) {
-            const maxIdx = widths.indexOf(Math.max(...widths))
-            widths[maxIdx]++; sum++
-        }
-
-        return segs.map((seg, i) => ({
-            chars: "█".repeat(widths[i] || 0),
-            color: seg.color,
-        }))
-    }
+    // The status-dialog breakdown bar uses flex layout (same approach as the
+    // sidebar breakdown). Each segment becomes a colored box with
+    // flexGrow=tokens and flexBasis=0, parent has width="100%", so opentui
+    // distributes the dialog's full width proportionally regardless of the
+    // dialog's actual rendered width.
+    const barSegments = () => breakdownSegments().segs.filter((seg) => seg.tokens > 0)
 
     return (
         <box flexDirection="column" width="100%" paddingLeft={2} paddingRight={2} paddingTop={1} paddingBottom={1}>
@@ -304,10 +295,17 @@ const StatusDialog = (props: { api: TuiPluginApi; s: StatusDetail }) => {
                 </text>
             </box>
 
-            {/* Segmented breakdown bar */}
-            <box flexDirection="row">
-                {barSegments().map((seg, i) => (
-                    <text key={i} fg={seg.color}>{seg.chars}</text>
+            {/* Segmented breakdown bar: flex row of colored boxes filling
+                the dialog width. See barSegments comment above. */}
+            <box width="100%" flexDirection="row" height={1}>
+                {barSegments().map((seg) => (
+                    <box
+                        key={seg.label}
+                        flexGrow={Math.max(1, seg.tokens)}
+                        flexBasis={0}
+                        height={1}
+                        backgroundColor={seg.color}
+                    />
                 ))}
             </box>
 
@@ -324,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 */}
@@ -414,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
+    }
+
+    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
     }
 
-    void getCompartmentCount(sessionId).then((count) => {
-        api.ui.dialog.replace(() => (
+    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
 }
 
 /**
@@ -644,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({
@@ -655,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)