@cortexkit/opencode-magic-context 0.40.0 → 0.41.0

package/src/tui/index.tsx

@@ -12,6 +12,7 @@ import { closeRpc, dismissUpgradeReminder, getAnnouncement, getCompartmentCount,
 import { startNotificationSocket, stopNotificationSocket, type SocketNotification } from "./data/notification-socket"
 import { formatThresholdPercent } from "../shared/format-threshold"
 import { formatTailHygiene } from "../shared/tail-hygiene-status"
+import { RUST_MODE_HOST_PATHS_LINE } from "../shared/rust-mode-status"
 import { formatWindowDerivationLine } from "../shared/window-geometry"
 import { compactionOffSidebarRows, nativeCompactionContextLabel } from "./compaction-off"
 import { isCompactionEnabled } from "../config/agent-disable"
@@ -321,6 +322,13 @@ const StatusDialog = (props: { api: TuiPluginApi; s: StatusDetail }) => {
                 )
             })()}
 
+            {s().hostBackendsModuleSide && (
+                <box marginTop={1} width="100%" flexDirection="column">
+                    <text fg={t().text}><b>Rust Mode</b></text>
+                    <text fg={t().textMuted}>{RUST_MODE_HOST_PATHS_LINE}</text>
+                </box>
+            )}
+
             <box flexDirection="row" width="100%" marginTop={1} gap={4}>
                 {compactionOff() ? (
                     <box flexDirection="column" flexGrow={1} flexBasis={0}>
@@ -344,8 +352,24 @@ const StatusDialog = (props: { api: TuiPluginApi; s: StatusDetail }) => {
                     <>
                         <box flexDirection="column" flexGrow={1} flexBasis={0}>
                             <text fg={t().text}><b>Tags</b></text>
-                            <R t={t()} l="Active" v={`${s().activeTags} (~${fmtBytes(s().activeBytes)})`} />
-                            <R t={t()} l="Dropped" v={String(s().droppedTags)} />
+                            <R
+                                t={t()}
+                                l="Active"
+                                v={
+                                    s().tagCountsAuthoritative === false
+                                        ? "n/a (module total only)"
+                                        : `${s().activeTags} (~${fmtBytes(s().activeBytes)})`
+                                }
+                            />
+                            <R
+                                t={t()}
+                                l="Dropped"
+                                v={
+                                    s().tagCountsAuthoritative === false
+                                        ? "n/a (module total only)"
+                                        : String(s().droppedTags)
+                                }
+                            />
                             <R t={t()} l="Total" v={String(s().totalTags)} fg={t().textMuted} />
                             <box marginTop={1}>
                                 <text fg={t().text}><b>Pending Queue</b></text>
@@ -459,7 +483,7 @@ async function showRecompDialog(api: TuiPluginApi, targetSessionId = getSessionI
         return false
     }
 
-    const countResult = await getCompartmentCount(sessionId)
+    const countResult = await getCompartmentCount(sessionId, api.state.path.directory ?? "")
     // 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
@@ -588,10 +612,17 @@ async function showStatusDialog(api: TuiPluginApi, targetSessionId = getSessionI
 
     const directory = api.state.path.directory ?? ""
     const modelKey = getModelKeyFromMessages(api, sessionId)
-    const detail = await loadStatusDetail(sessionId, directory, modelKey)
+    const result = await loadStatusDetail(sessionId, directory, modelKey)
     if (getSessionId(api) !== sessionId) return false
+    if (!result.ok) {
+        showToast(api, {
+            message: `Status unavailable: ${result.error}`,
+            variant: "warning",
+        })
+        return false
+    }
 
-    api.ui.dialog.replace(() => <StatusDialog api={api} s={detail} />)
+    api.ui.dialog.replace(() => <StatusDialog api={api} s={result.detail} />)
     return true
 }
 

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

@@ -2,8 +2,7 @@
  * TUI data layer — pure RPC client, no direct SQLite access.
  * All data is fetched from the server plugin via HTTP RPC.
  */
-import os from "node:os";
-import path from "node:path";
+import { getMagicContextStorageDir } from "../../shared/data-path";
 import { MagicContextRpcClient } from "../../shared/rpc-client";
 import type { EmbedDetail, SidebarSnapshot, StatusDetail } from "../../shared/rpc-types";
 
@@ -12,18 +11,9 @@ export type { EmbedDetail, SidebarSnapshot, StatusDetail };
 let rpcClient: MagicContextRpcClient | null = null;
 let rpcGeneration = 0;
 
-function getStorageDir(): string {
-    // Plugin v0.16+ uses the shared cortexkit/magic-context path so OpenCode
-    // and Pi can share state. The TUI just needs to point its RPC client at
-    // the same storage directory the server plugin uses for the lock-file
-    // discovery convention.
-    const dataDir = process.env.XDG_DATA_HOME ?? path.join(os.homedir(), ".local", "share");
-    return path.join(dataDir, "cortexkit", "magic-context");
-}
-
 /** Initialize the RPC client. Call once on TUI startup. */
 export function initRpcClient(directory: string): void {
-    const storageDir = getStorageDir();
+    const storageDir = getMagicContextStorageDir();
     // Bump the generation before replacing the client so late notification
     // responses from a disposed client are ignored (the WS socket observes the
     // new generation and abandons its in-flight connect).
@@ -172,63 +162,26 @@ export async function loadSidebarSnapshot(
     }
 }
 
-/** Fetch full status detail from the server via RPC. */
+export type StatusDetailResult = { ok: true; detail: StatusDetail } | { ok: false; error: string };
+
+/** Fetch full status detail without presenting transport failure as an empty session. */
 export async function loadStatusDetail(
     sessionId: string,
     directory: string,
     modelKey?: string,
-): Promise<StatusDetail> {
-    const emptyDetail: StatusDetail = {
-        ...EMPTY_SNAPSHOT,
-        sessionId,
-        activeProfile: null,
-        tagCounter: 0,
-        activeTags: 0,
-        droppedTags: 0,
-        totalTags: 0,
-        activeBytes: 0,
-        lastResponseTime: 0,
-        lastNudgeTokens: 0,
-        lastTransformError: null,
-        isSubagent: false,
-        pendingOps: [],
-        contextLimit: 0,
-        cacheTtlMs: 0,
-        cacheRemainingMs: 0,
-        cacheExpired: false,
-        cacheNeverExpires: false,
-        executeThreshold: 65,
-        executeThresholdMode: "percentage",
-        protectedTagCount: 20,
-        historyBudgetPercentage: 0.15,
-        historyBlockTokens: 0,
-        compressionBudget: null,
-        compressionUsage: null,
-        toastDurationMs: 5000,
-        loggerDiagnostics: {
-            swallowedWriteCount: 0,
-            lastErrorMessage: null,
-            lastErrorTime: null,
-        },
-        storage_versions: {
-            context_db_schema_version: null,
-            plugin_supported_version: 0,
-        },
-    };
-
-    if (!rpcClient) return emptyDetail;
+): Promise<StatusDetailResult> {
+    if (!rpcClient) return { ok: false, error: "RPC client is not initialized" };
     try {
         const result = await rpcClient.call<StatusDetail>("status-detail", {
             sessionId,
             directory,
             modelKey,
         });
-        if ((result as unknown as Record<string, unknown>).error) {
-            return emptyDetail;
-        }
-        return result;
-    } catch {
-        return emptyDetail;
+        const error = (result as unknown as Record<string, unknown>).error;
+        if (typeof error === "string") return { ok: false, error };
+        return { ok: true, detail: result };
+    } catch (error) {
+        return { ok: false, error: error instanceof Error ? error.message : String(error) };
     }
 }
 
@@ -262,12 +215,15 @@ export async function loadEmbedDetail(sessionId: string, directory: string): Pro
 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> {
+export async function getCompartmentCount(
+    sessionId: string,
+    directory?: string,
+): Promise<CompartmentCountResult> {
     if (!rpcClient) return { ok: false, error: "RPC client is not initialized" };
     try {
         const result = await rpcClient.call<{ count?: number; error?: string }>(
             "compartment-count",
-            { sessionId },
+            { sessionId, directory },
         );
         if (typeof result.error === "string") return { ok: false, error: result.error };
         if (typeof result.count !== "number" || !Number.isFinite(result.count)) {