@cortexkit/opencode-magic-context 0.32.0 → 0.32.2

package/src/tui/slots/sidebar-content.tsx

@@ -33,6 +33,7 @@ export interface SidebarController {
     prefs: () => MagicContextTuiPrefs
     collapsed: () => boolean
     toggleCollapsed: () => void
+    dispose: () => void
 }
 
 // The TUI may unmount and remount sidebar_content when the user switches views
@@ -52,11 +53,10 @@ function createSidebarController(initialPrefs: MagicContextTuiPrefs): SidebarCon
     let lastPersistedCollapsed: boolean | null = initialPrefs.collapsed
     let lastApplied = JSON.stringify(initialPrefs)
 
-    // Watcher lives for the process lifetime — intentionally never disposed.
     // Collapse echo guard: lastPersistedCollapsed advances only once our own
     // write lands, so a watcher echo of the value we just wrote is rejected by
     // the `!==` check and cannot revert a user click.
-    watchTuiPreferences(() => {
+    const stopWatchingPreferences = watchTuiPreferences(() => {
         void (async () => {
             const next = resolveMagicContextPrefs(await readTuiPreferencesFile())
             const serialized = JSON.stringify(next)
@@ -84,7 +84,12 @@ function createSidebarController(initialPrefs: MagicContextTuiPrefs): SidebarCon
         }
     }
 
-    return { prefs, collapsed, toggleCollapsed }
+    return {
+        prefs,
+        collapsed,
+        toggleCollapsed,
+        dispose: stopWatchingPreferences,
+    }
 }
 
 function compactTokens(value: number): string {
@@ -490,6 +495,8 @@ const SidebarContent = (props: {
     let recompSawPhase = false
     let recompPollCount = 0
     let recompConsecutiveAbsent = 0
+    let recompSessionId: string | null = null
+    let snapshotRequestSequence = 0
     const RECOMP_PROBE_MAX = 12 // ~15s for the server's "Starting…" to land
     // After we've SEEN an active phase, a momentarily absent snapshot is almost
     // always transient — the server's sticky cache serves a pre-recomp snapshot
@@ -505,13 +512,14 @@ const SidebarContent = (props: {
     const refresh = () => {
         const sid = props.sessionID()
         if (!sid) return
+        const sequence = ++snapshotRequestSequence
         const directory = props.api.state.path.directory ?? ""
         void loadSidebarSnapshot(sid, directory)
             .then((data) => {
                 // Guard against a session switch while this load was in flight:
                 // painting session A's snapshot into the now-active session B shows
                 // the wrong session's numbers until B's own refresh resolves.
-                if (props.sessionID() !== sid) return
+                if (props.sessionID() !== sid || sequence !== snapshotRequestSequence) return
                 setSnapshot(data)
                 try {
                     props.api.renderer.requestRender()
@@ -524,11 +532,16 @@ const SidebarContent = (props: {
                 const phase = data?.recompProgress?.phase
                 if ((phase === "recomp" || phase === "migration") && !recompActive) {
                     kickRecompPoll()
+                } else if (recompActive && recompSessionId === sid) {
+                    scheduleRecompTick()
                 }
             })
             .catch(() => {
-                // one-shot refresh failure is non-fatal; the recomp loop (if any)
-                // has its own resilient retry.
+                // A one-shot refresh failure is non-fatal. If it superseded a fast
+                // poll request, keep that poll moving for the captured session.
+                if (recompActive && recompSessionId === sid && props.sessionID() === sid) {
+                    scheduleRecompTick()
+                }
             })
     }
 
@@ -540,6 +553,14 @@ const SidebarContent = (props: {
         }, REFRESH_DEBOUNCE_MS)
     }
 
+    const stopRecompPoll = () => {
+        recompActive = false
+        recompSessionId = null
+        snapshotRequestSequence += 1
+        if (recompPollTimer) clearTimeout(recompPollTimer)
+        recompPollTimer = undefined
+    }
+
     const scheduleRecompTick = () => {
         if (!recompActive) return
         if (recompPollTimer) clearTimeout(recompPollTimer)
@@ -547,20 +568,26 @@ const SidebarContent = (props: {
     }
 
     function recompTick(): void {
-        if (!recompActive) return
-        recompPollCount += 1
-        if (recompPollCount > RECOMP_MAX_POLLS) {
-            recompActive = false
+        const sid = recompSessionId
+        if (!recompActive || !sid || props.sessionID() !== sid) {
+            stopRecompPoll()
             return
         }
-        const sid = props.sessionID()
-        if (!sid) {
-            recompActive = false
+        recompPollCount += 1
+        if (recompPollCount > RECOMP_MAX_POLLS) {
+            stopRecompPoll()
             return
         }
+        const sequence = ++snapshotRequestSequence
         const directory = props.api.state.path.directory ?? ""
         void loadSidebarSnapshot(sid, directory)
             .then((data) => {
+                if (
+                    !recompActive ||
+                    recompSessionId !== sid ||
+                    props.sessionID() !== sid ||
+                    sequence !== snapshotRequestSequence
+                ) return
                 const phase = data?.recompProgress?.phase
                 // While a recomp is known-active, a transient snapshot that lost
                 // recompProgress (sticky cache / busy-DB empty) must NOT wipe the
@@ -585,7 +612,7 @@ const SidebarContent = (props: {
                     // Terminal state rendered — stop. The server keeps "done"/
                     // "skipped" for a grace window and "failed" until the next run,
                     // so the outcome stays visible without further polling.
-                    recompActive = false
+                    stopRecompPoll()
                 } else {
                     // Phase absent this poll.
                     recompConsecutiveAbsent += 1
@@ -593,7 +620,7 @@ const SidebarContent = (props: {
                         // Still waiting for the server's first "Starting…".
                         if (recompPollCount < RECOMP_PROBE_MAX) scheduleRecompTick()
                         else {
-                            recompActive = false
+                            stopRecompPoll()
                         }
                     } else if (recompConsecutiveAbsent < RECOMP_ABSENT_GIVEUP) {
                         // Seen it active — absent is almost certainly the sticky
@@ -603,14 +630,19 @@ const SidebarContent = (props: {
                         scheduleRecompTick()
                     } else {
                         // Long continuous absence — the entry is genuinely gone.
-                        recompActive = false
+                        stopRecompPoll()
                     }
                 }
             })
-            .catch((err) => {
-                // CRITICAL: a failed/slow fetch must NOT kill the loop — keep
-                // polling while active so we still catch the terminal state.
-                scheduleRecompTick()
+            .catch(() => {
+                // A failed fetch must not kill the loop, but a response from a
+                // superseded session or sequence must not restart it either.
+                if (
+                    recompActive &&
+                    recompSessionId === sid &&
+                    props.sessionID() === sid &&
+                    sequence === snapshotRequestSequence
+                ) scheduleRecompTick()
             })
     }
 
@@ -618,8 +650,12 @@ const SidebarContent = (props: {
     // first detects an active recomp). The server emits an immediate "Starting…"
     // entry; the probe window covers the brief RPC race before it lands.
     function kickRecompPoll(): void {
-        if (recompActive) return // already running
+        const sid = props.sessionID()
+        if (!sid) return
+        if (recompActive && recompSessionId === sid) return
+        stopRecompPoll()
         recompActive = true
+        recompSessionId = sid
         recompSawPhase = false
         recompPollCount = 0
         recompConsecutiveAbsent = 0
@@ -630,14 +666,15 @@ const SidebarContent = (props: {
 
     onCleanup(() => {
         if (refreshTimer) clearTimeout(refreshTimer)
-        if (recompPollTimer) clearTimeout(recompPollTimer)
-        recompActive = false
+        stopRecompPoll()
         if (activeRecompPollKick === kickRecompPoll) activeRecompPollKick = null
     })
 
     // Refresh on session change
     createEffect(
         on(props.sessionID, () => {
+            stopRecompPoll()
+            setSnapshot(null)
             refresh()
         }),
     )
@@ -893,7 +930,7 @@ const SidebarContent = (props: {
     )
 }
 
-export function createSidebarContentSlot(api: TuiPluginApi): TuiSlotPlugin {
+export function createSidebarContentSlot(api: TuiPluginApi): TuiSlotPlugin & { dispose: () => void } {
     // Seed synchronously at slot construction so the sidebar renders at its
     // final collapse state + order on the first paint (no async flicker). The
     // controller lives here in the factory closure for the plugin lifetime, so
@@ -903,6 +940,7 @@ export function createSidebarContentSlot(api: TuiPluginApi): TuiSlotPlugin {
     const effectiveOrder = computeEffectiveOrder(seedRoot, PLUGIN_KEY, DEFAULT_SLOT_ORDER)
     return {
         order: effectiveOrder,
+        dispose: controller.dispose,
         slots: {
             sidebar_content: (ctx, value) => {
                 const theme = createMemo(() => ctx.theme.current)

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

@@ -102,7 +102,13 @@ const STICKY_MAX_ENTRIES = 100;
 const stickySidebarCache = new Map<string, CachedSnapshot>();
 
 function rememberSidebarSnapshot(snapshot: SidebarSnapshot): void {
-    if (!snapshot.sessionId || snapshot.inputTokens <= 0) return;
+    if (!snapshot.sessionId) return;
+    if (snapshot.inputTokens <= 0) {
+        // A successful zero is authoritative (new/deleted/reverted session) and
+        // must prevent a later transport failure from resurrecting old values.
+        stickySidebarCache.delete(snapshot.sessionId);
+        return;
+    }
     // LRU-style bound: drop the oldest entry once we hit the cap. With a
     // 5-min TTL most stale entries time out naturally; this just prevents
     // unbounded growth across many session switches in a long TUI session.
@@ -126,19 +132,9 @@ function recallSidebarSnapshot(sessionId: string, fallback: SidebarSnapshot): Si
         stickySidebarCache.delete(sessionId);
         return fallback;
     }
-    if (!hasInFlightEvidence(fallback)) {
-        stickySidebarCache.delete(sessionId);
-        return fallback;
-    }
     return cached.snapshot;
 }
 
-function hasInFlightEvidence(snapshot: SidebarSnapshot): boolean {
-    return (
-        snapshot.compartmentInProgress || snapshot.historianRunning || snapshot.pendingOpsCount > 0
-    );
-}
-
 /** Fetch sidebar snapshot from the server via RPC. */
 export async function loadSidebarSnapshot(
     sessionId: string,
@@ -152,9 +148,11 @@ export async function loadSidebarSnapshot(
             directory,
         });
         if ((result as unknown as Record<string, unknown>).error) {
+            // Snapshot-build errors are explicit failure envelopes, equivalent to
+            // a transport failure: retain the last known-good client snapshot.
             return recallSidebarSnapshot(sessionId, empty);
         }
-        // Trust successful server responses. The server has its own sticky
+        // Trust successful server responses, including authoritative zeroes. The server has its own sticky
         // sidebar cache (`sidebar-snapshot-cache.ts`) that handles transient
         // zero-token windows by hybriding cached breakdown values into a
         // fresh snapshot, AND clears that cache on `session.deleted`. If the
@@ -249,14 +247,23 @@ export async function loadEmbedDetail(sessionId: string, directory: string): Pro
     }
 }
 
-/** Get compartment count via RPC. */
-export async function getCompartmentCount(sessionId: string): Promise<number> {
-    if (!rpcClient) return 0;
+export type CompartmentCountResult = { ok: true; count: number } | { ok: false; error: string };
+
+/** Get compartment count without making transport failure look like a real zero. */
+export async function getCompartmentCount(sessionId: string): Promise<CompartmentCountResult> {
+    if (!rpcClient) return { ok: false, error: "RPC client is not initialized" };
     try {
-        const result = await rpcClient.call<{ count: number }>("compartment-count", { sessionId });
-        return result.count ?? 0;
-    } catch {
-        return 0;
+        const result = await rpcClient.call<{ count?: number; error?: string }>(
+            "compartment-count",
+            { sessionId },
+        );
+        if (typeof result.error === "string") return { ok: false, error: result.error };
+        if (typeof result.count !== "number" || !Number.isFinite(result.count)) {
+            return { ok: false, error: "Invalid compartment count response" };
+        }
+        return { ok: true, count: result.count };
+    } catch (error) {
+        return { ok: false, error: error instanceof Error ? error.message : String(error) };
     }
 }