@cortexkit/opencode-magic-context 0.40.0 → 0.41.0

package/src/shared/data-path.test.ts

@@ -9,6 +9,7 @@ import {
     getLegacyOpenCodeMagicContextStorageDir,
     getMagicContextLogPath,
     getMagicContextStorageDir,
+    getMagicContextStorageResolution,
     getOpenCodeCacheDir,
     getOpenCodeStorageDir,
     getProjectMagicContextDir,
@@ -18,6 +19,7 @@ import {
 const savedEnv = {
     XDG_CACHE_HOME: process.env.XDG_CACHE_HOME,
     XDG_DATA_HOME: process.env.XDG_DATA_HOME,
+    MAGIC_CONTEXT_STORAGE_DIR: process.env.MAGIC_CONTEXT_STORAGE_DIR,
     LOCALAPPDATA: process.env.LOCALAPPDATA,
     MAGIC_CONTEXT_LOG_PATH: process.env.MAGIC_CONTEXT_LOG_PATH,
     MAGIC_CONTEXT_TEST_DATA_DIR: process.env.MAGIC_CONTEXT_TEST_DATA_DIR,
@@ -28,11 +30,14 @@ describe("data-path", () => {
     beforeEach(() => {
         process.env.XDG_CACHE_HOME = undefined;
         process.env.XDG_DATA_HOME = undefined;
+        delete process.env.MAGIC_CONTEXT_TEST_DATA_DIR;
+        delete process.env.NODE_ENV;
         process.env.LOCALAPPDATA = undefined;
         process.env.MAGIC_CONTEXT_LOG_PATH = undefined;
         // Bun's env handling: explicit delete for unset
         delete process.env.XDG_CACHE_HOME;
         delete process.env.XDG_DATA_HOME;
+        delete process.env.MAGIC_CONTEXT_STORAGE_DIR;
         delete process.env.LOCALAPPDATA;
         delete process.env.MAGIC_CONTEXT_LOG_PATH;
     });
@@ -140,17 +145,52 @@ describe("data-path", () => {
         );
     });
 
-    test("getMagicContextStorageDir prefers XDG_DATA_HOME over MAGIC_CONTEXT_TEST_DATA_DIR", () => {
-        // A test managing its own per-test data home is already controlled, and
-        // several suites depend on that dir being honored.
+    test("test storage isolation takes precedence over MAGIC_CONTEXT_STORAGE_DIR", () => {
+        process.env.MAGIC_CONTEXT_TEST_DATA_DIR = "/tmp/mc-test-isolation";
+        process.env.MAGIC_CONTEXT_STORAGE_DIR = "/tmp/production-shared-data";
+        expect(getMagicContextStorageDir()).toBe(
+            path.join("/tmp/mc-test-isolation", "cortexkit", "magic-context"),
+        );
+    });
+
+    test("a per-test XDG_DATA_HOME overrides the preload root without escaping test isolation", () => {
         process.env.MAGIC_CONTEXT_TEST_DATA_DIR = "/tmp/mc-test-isolation";
+        process.env.XDG_DATA_HOME = "/tmp/custom-test-data";
+        process.env.MAGIC_CONTEXT_STORAGE_DIR = "/tmp/production-shared-data";
+        expect(getMagicContextStorageResolution()).toEqual({
+            path: path.join("/tmp/custom-test-data", "cortexkit", "magic-context"),
+            source: "test isolation",
+        });
+    });
+
+    test("getMagicContextStorageDir honors XDG_DATA_HOME", () => {
         process.env.XDG_DATA_HOME = "/tmp/custom-data";
         expect(getMagicContextStorageDir()).toBe(
             path.join("/tmp/custom-data", "cortexkit", "magic-context"),
         );
     });
 
-    test("getMagicContextStorageDir honors XDG_DATA_HOME", () => {
+    test("getMagicContextStorageDir honors MAGIC_CONTEXT_STORAGE_DIR", () => {
+        process.env.XDG_DATA_HOME = "/tmp/private-agent-data";
+        process.env.MAGIC_CONTEXT_STORAGE_DIR = "/tmp/shared-magic-context";
+        expect(getMagicContextStorageDir()).toBe("/tmp/shared-magic-context");
+    });
+
+    test("MAGIC_CONTEXT_STORAGE_DIR takes precedence over XDG_DATA_HOME", () => {
+        process.env.XDG_DATA_HOME = "/tmp/private-agent-data";
+        process.env.MAGIC_CONTEXT_STORAGE_DIR = "/tmp/shared-magic-context";
+        expect(getMagicContextStorageDir()).toBe("/tmp/shared-magic-context");
+    });
+
+    test("relative MAGIC_CONTEXT_STORAGE_DIR is rejected", () => {
+        process.env.MAGIC_CONTEXT_STORAGE_DIR = "./shared-magic-context";
+        expect(() => getMagicContextStorageDir()).toThrow(
+            "MAGIC_CONTEXT_STORAGE_DIR must be an absolute path",
+        );
+    });
+
+    test("blank MAGIC_CONTEXT_STORAGE_DIR falls back to XDG_DATA_HOME", () => {
+        process.env.MAGIC_CONTEXT_STORAGE_DIR = "   ";
         process.env.XDG_DATA_HOME = "/tmp/custom-data";
         expect(getMagicContextStorageDir()).toBe(
             path.join("/tmp/custom-data", "cortexkit", "magic-context"),

package/src/shared/data-path.ts

@@ -166,7 +166,9 @@ export function getOpenCodeStorageDir(): string {
  *   - Shared Dreamer runs (one per project per machine)
  *   - Future cross-harness session migration
  *
- * Layout: <XDG_DATA_HOME>/cortexkit/magic-context/
+ * Resolution precedence: test isolation, MAGIC_CONTEXT_STORAGE_DIR, XDG data
+ * home, then the platform default. The explicit override is a complete storage
+ * directory and must be absolute so every process on a host selects one store.
  *
  * TEST-ISOLATION GUARD. `openDatabase()` has been guarded in
  * `resolveDatabasePath()` since the 2026-06-01 (v26) and 2026-06-19 (v41)
@@ -192,20 +194,61 @@ export function getOpenCodeStorageDir(): string {
  * `PRAGMA integrity_check`, announcements, the models.dev cache) are covered
  * too — they never go through the DB resolver.
  *
- * XDG_DATA_HOME still wins over both: a test that manages its own data home is
- * already controlled, and production has no test dir set at all.
+ * In production, MAGIC_CONTEXT_STORAGE_DIR takes precedence over XDG_DATA_HOME.
+ * Test isolation remains authoritative so an ambient override cannot redirect
+ * a test into a user's real shared database.
  */
-export function getMagicContextStorageDir(): string {
-    if (!process.env.XDG_DATA_HOME) {
-        const testDataDir = process.env.MAGIC_CONTEXT_TEST_DATA_DIR;
-        if (testDataDir) {
-            return path.join(testDataDir, "cortexkit", "magic-context");
+export type MagicContextStorageSource =
+    | "test isolation"
+    | "environment override"
+    | "XDG_DATA_HOME"
+    | "platform default";
+
+export interface MagicContextStorageResolution {
+    path: string;
+    source: MagicContextStorageSource;
+}
+
+export function getMagicContextStorageResolution(): MagicContextStorageResolution {
+    const testDataDir = process.env.MAGIC_CONTEXT_TEST_DATA_DIR?.trim();
+    if (testDataDir) {
+        const perTestDataHome = process.env.XDG_DATA_HOME?.trim();
+        if (perTestDataHome && path.resolve(perTestDataHome) !== path.resolve(testDataDir)) {
+            return {
+                path: path.join(perTestDataHome, "cortexkit", "magic-context"),
+                source: "test isolation",
+            };
         }
-        if (process.env.NODE_ENV === "test") {
-            return getTestBackstopStorageDir();
+        return {
+            path: path.join(testDataDir, "cortexkit", "magic-context"),
+            source: "test isolation",
+        };
+    }
+    if (process.env.NODE_ENV === "test") {
+        return { path: getTestBackstopStorageDir(), source: "test isolation" };
+    }
+    const explicitStorageDir = process.env.MAGIC_CONTEXT_STORAGE_DIR?.trim();
+    if (explicitStorageDir) {
+        if (!path.isAbsolute(explicitStorageDir)) {
+            throw new Error("MAGIC_CONTEXT_STORAGE_DIR must be an absolute path");
         }
+        return { path: explicitStorageDir, source: "environment override" };
+    }
+    const xdgDataHome = process.env.XDG_DATA_HOME?.trim();
+    if (xdgDataHome) {
+        return {
+            path: path.join(xdgDataHome, "cortexkit", "magic-context"),
+            source: "XDG_DATA_HOME",
+        };
     }
-    return path.join(getDataDir(), "cortexkit", "magic-context");
+    return {
+        path: path.join(os.homedir(), ".local", "share", "cortexkit", "magic-context"),
+        source: "platform default",
+    };
+}
+
+export function getMagicContextStorageDir(): string {
+    return getMagicContextStorageResolution().path;
 }
 
 let testBackstopStorageDir: string | null = null;

package/src/shared/logger.test.ts

@@ -30,6 +30,10 @@ const logger = await import(loggerModuleUrl);
 const logPath = path.join(root, "nested", "magic-context.log");
 process.env.MAGIC_CONTEXT_LOG_PATH = logPath;
 logger.log("first");
+logger.log(
+    "tokens.input=45000 api_key=sk-proj-abcdefghijklmnopqrstuvwxyzABCDEFGH",
+    { authorization: "Bearer abcdefghijklmnop", totalInputTokens: 132000 },
+);
 logger.flushLogger();
 const healthyDiagnostics = logger.getLoggerDiagnostics();
 
@@ -102,6 +106,17 @@ describe("logger", () => {
         expect(result.content).toContain("second");
     });
 
+    test("redacts secrets while preserving numeric diagnostics", async () => {
+        const result = await runLoggerScenario("diagnostics");
+
+        expect(result.content).toContain("tokens.input=45000");
+        expect(result.content).toContain('"totalInputTokens":132000');
+        expect(result.content).toContain("<REDACTED:api_key>");
+        expect(result.content).toContain("<REDACTED:authorization>");
+        expect(result.content).not.toContain("abcdefghijklmnopqrstuvwxyzABCDEFGH");
+        expect(result.content).not.toContain("abcdefghijklmnop");
+    });
+
     test("reports swallowed writes while healthy writes leave the counter at zero", async () => {
         const result = await runLoggerScenario("diagnostics");
 

package/src/shared/logger.ts

@@ -1,6 +1,7 @@
 import * as fs from "node:fs";
 import * as path from "node:path";
 import { getMagicContextLogPath } from "./data-path";
+import { sanitizeConfigValue, sanitizeDiagnosticText } from "./redaction";
 
 const isTestEnv = process.env.NODE_ENV === "test";
 
@@ -22,7 +23,9 @@ let lastErrorTime: string | null = null;
 function recordSwallowedWrite(error: unknown): void {
     try {
         swallowedWriteCount++;
-        lastErrorMessage = error instanceof Error ? error.message : String(error);
+        lastErrorMessage = sanitizeDiagnosticText(
+            error instanceof Error ? error.message : String(error),
+        );
         lastErrorTime = new Date().toISOString();
     } catch {
         // Diagnostics must not make the logger throw either.
@@ -66,9 +69,11 @@ export function log(message: string, data?: unknown): void {
             data === undefined
                 ? ""
                 : data instanceof Error
-                  ? ` ${data.message}${data.stack ? `\n${data.stack}` : ""}`
-                  : ` ${JSON.stringify(data)}`;
-        buffer.push(`[${timestamp}] ${message}${serialized}\n`);
+                  ? ` ${sanitizeDiagnosticText(
+                        `${data.message}${data.stack ? `\n${data.stack}` : ""}`,
+                    )}`
+                  : ` ${JSON.stringify(sanitizeConfigValue(data))}`;
+        buffer.push(`[${timestamp}] ${sanitizeDiagnosticText(message)}${serialized}\n`);
         if (buffer.length >= BUFFER_SIZE_LIMIT) {
             flush();
         } else {

package/src/shared/model-resolution.test.ts

@@ -4,10 +4,30 @@ import {
     normalizeModelEntry,
     resolveDreamerTaskModel,
     resolveFallbackEntries,
+    resolveHistorianAgentOverrides,
     resolveHistorianModel,
 } from "./model-resolution";
 
 describe("model-resolution", () => {
+    test("pins the historian calibration defaults while preserving explicit overrides", () => {
+        expect(resolveHistorianAgentOverrides(undefined)).toEqual({
+            temperature: 0.1,
+            maxTokens: 32_000,
+        });
+        expect(
+            resolveHistorianAgentOverrides({
+                temperature: 0.2,
+                maxTokens: 16_000,
+                opencode: { model: "google/flash", variant: "low" },
+            }),
+        ).toEqual({
+            temperature: 0.2,
+            maxTokens: 16_000,
+            model: "google/flash",
+            variant: "low",
+        });
+    });
+
     test("normalizes string and object entries to the same model identity", () => {
         expect(normalizeModelEntry("anthropic/sonnet", "opencode")).toEqual({
             model: "anthropic/sonnet",
@@ -36,6 +56,25 @@ describe("model-resolution", () => {
         ]);
     });
 
+    test("applies the flash-calibrated historian generation triple while preserving overrides", () => {
+        expect(
+            resolveHistorianAgentOverrides({
+                opencode: { model: { model: "google/flash", variant: "fast" } },
+                pi: { model: "pi/ignored" },
+                two_pass: true,
+            }),
+        ).toEqual({
+            temperature: 0.1,
+            maxTokens: 32_000,
+            two_pass: true,
+            model: "google/flash",
+            variant: "fast",
+        });
+        expect(
+            resolveHistorianAgentOverrides({ temperature: 0.2, maxTokens: 12_000 }),
+        ).toMatchObject({ temperature: 0.2, maxTokens: 12_000 });
+    });
+
     test("does not inherit a block qualifier into unqualified fallbacks", () => {
         const config = {
             historian: {

package/src/shared/model-resolution.ts

@@ -225,3 +225,11 @@ export function resolveOpenCodeAgentOverrides(agent: unknown): Record<string, un
         ...(primary?.qualifier ? { variant: primary.qualifier } : {}),
     };
 }
+
+export function resolveHistorianAgentOverrides(agent: unknown): Record<string, unknown> {
+    return {
+        temperature: 0.1,
+        maxTokens: 32_000,
+        ...resolveOpenCodeAgentOverrides(agent),
+    };
+}

package/src/shared/redaction.ts

@@ -108,7 +108,7 @@ export function isSecretKey(key: string): boolean {
 }
 
 export function sanitizePathString(value: string): string {
-    const home = homedir();
+    const home = process.env.HOME || process.env.USERPROFILE || homedir();
     const username = userInfo().username;
     let sanitized = value;
     if (home) {
@@ -132,7 +132,7 @@ const SECRET_TEXT_PATTERNS: Array<{
         replacement: "<ANTHROPIC_API_KEY_REDACTED>",
     },
     {
-        pattern: /\bsk-(?:proj-)?[A-Za-z0-9_-]{32,}/g,
+        pattern: /\bsk-(?:proj-)?[A-Za-z0-9_-]{12,}/g,
         replacement: "<OPENAI_API_KEY_REDACTED>",
     },
     {

package/src/shared/rpc-types.ts

@@ -141,12 +141,17 @@ export interface SidebarSnapshot {
 }
 
 export interface StatusDetail extends SidebarSnapshot {
+    /** True when Rust authority has rerouted host tool and historian paths to the module. */
+    hostBackendsModuleSide?: boolean;
     /** User-owned model profile selected for this project, or null for the base config. */
     activeProfile: string | null;
     tagCounter: number;
     activeTags: number;
     droppedTags: number;
     totalTags: number;
+    /** False when Rust authority supplies only the exact total; active/dropped host-mirror
+     *  counts are not presented as module truth. Omitted by older RPC servers means true. */
+    tagCountsAuthoritative?: boolean;
     activeBytes: number;
     lastResponseTime: number;
     lastNudgeTokens: number;

package/src/shared/rust-mode-status.ts

@@ -0,0 +1,3 @@
+/** User-visible paths that move out of the host when Rust authority is active. */
+export const RUST_MODE_HOST_PATHS_LINE =
+    "Host backends → MODULE: ctx_memory, ctx_note; historian: module-side";

package/src/shared/status-detail-text.test.ts

@@ -79,4 +79,17 @@ describe("formatStatusDetailMarkdown", () => {
 - **Tags:** 4 active, 1 dropped; 2 pending drops
 - **Execute threshold:** 65.0%`);
     });
+
+    test("shows module-routed host paths only in Rust-mode chat fallback", () => {
+        const rustStatus = formatStatusDetailMarkdown({
+            ...STATUS_FIXTURE,
+            hostBackendsModuleSide: true,
+        });
+        const tsStatus = formatStatusDetailMarkdown(STATUS_FIXTURE);
+
+        expect(rustStatus).toContain(
+            "Host backends → MODULE: ctx_memory, ctx_note; historian: module-side",
+        );
+        expect(tsStatus).not.toContain("Host backends → MODULE");
+    });
 });

package/src/shared/status-detail-text.ts

@@ -1,4 +1,5 @@
 import type { StatusDetail } from "./rpc-types";
+import { RUST_MODE_HOST_PATHS_LINE } from "./rust-mode-status";
 
 function formatCount(value: number): string {
     return Math.round(value).toLocaleString();
@@ -39,6 +40,7 @@ export function formatStatusDetailMarkdown(detail: StatusDetail): string {
         `- **Usage:** ${detail.usagePercentage.toFixed(1)}% (${formatCount(detail.inputTokens)} / ${usableLimit})`,
         `- **Cache lane:** ${formatCacheLane(detail)}`,
         `- **Historian:** ${[historianState, ...historianDetails].join("; ")}`,
+        ...(detail.hostBackendsModuleSide ? [`- ${RUST_MODE_HOST_PATHS_LINE}`] : []),
         `- **Memory:** ${formatCount(detail.memoryCount)} active; ${formatCount(detail.memoryBlockCount)} injected`,
         `- **Tags:** ${formatCount(detail.activeTags)} active, ${formatCount(detail.droppedTags)} dropped; ${formatCount(detail.pendingOpsCount)} pending drops`,
         `- **Execute threshold:** ${detail.executeThreshold.toFixed(1)}%${detail.executeThresholdClamped ? " (clamped)" : ""}`,

package/src/shared/subagent-runner.ts

@@ -67,6 +67,10 @@ export interface SubagentRunOptions {
     model?: string | undefined;
     fallbackModels?: readonly ModelInput[];
     timeoutMs?: number | undefined;
+    /** Sampling temperature for the provider request when the harness can enforce it. */
+    temperature?: number | undefined;
+    /** Requested output-token budget for the provider request. */
+    maxOutputTokens?: number | undefined;
     cwd?: string | undefined;
     signal?: AbortSignal | undefined;
     /**

package/src/shared/write-transaction-timing.ts

@@ -0,0 +1,25 @@
+import { log } from "./logger";
+
+/**
+ * A one-second threshold catches transactions that can noticeably hold back
+ * sibling writers without turning normal SQLite work into log noise.
+ */
+export const SLOW_WRITE_TRANSACTION_THRESHOLD_MS = 1_000;
+
+/**
+ * Log a slow write only after its COMMIT has completed. The timing diagnostic is
+ * deliberately best-effort so it can never change the transaction's behavior.
+ */
+export function logSlowWriteTransaction(
+    site: string,
+    startedAt: number,
+    thresholdMs = SLOW_WRITE_TRANSACTION_THRESHOLD_MS,
+): void {
+    try {
+        const durationMs = performance.now() - startedAt;
+        if (durationMs < thresholdMs) return;
+        log(`[magic-context] slow write transaction: site=${site} held=${durationMs.toFixed(1)}ms`);
+    } catch {
+        // Timing diagnostics must never make a committed write appear to fail.
+    }
+}

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

@@ -4,9 +4,17 @@ import { tmpdir } from "node:os";
 import { join } from "node:path";
 import { MagicContextRpcServer } from "../../shared/rpc-server";
 import type { SidebarSnapshot } from "../../shared/rpc-types";
-import { closeRpc, getCompartmentCount, initRpcClient, loadSidebarSnapshot } from "./context-db";
+import {
+    closeRpc,
+    getCompartmentCount,
+    initRpcClient,
+    loadSidebarSnapshot,
+    loadStatusDetail,
+} from "./context-db";
 
 const originalXdgDataHome = process.env.XDG_DATA_HOME;
+const originalTestDataDir = process.env.MAGIC_CONTEXT_TEST_DATA_DIR;
+const originalStorageDir = process.env.MAGIC_CONTEXT_STORAGE_DIR;
 const tempDirs: string[] = [];
 const servers: MagicContextRpcServer[] = [];
 
@@ -18,12 +26,19 @@ afterEach(() => {
     }
     if (originalXdgDataHome === undefined) delete process.env.XDG_DATA_HOME;
     else process.env.XDG_DATA_HOME = originalXdgDataHome;
+    if (originalTestDataDir === undefined) delete process.env.MAGIC_CONTEXT_TEST_DATA_DIR;
+    else process.env.MAGIC_CONTEXT_TEST_DATA_DIR = originalTestDataDir;
+    if (originalStorageDir === undefined) delete process.env.MAGIC_CONTEXT_STORAGE_DIR;
+    else process.env.MAGIC_CONTEXT_STORAGE_DIR = originalStorageDir;
 });
 
 function makeDataHome(): string {
     const dir = mkdtempSync(join(tmpdir(), "mc-context-db-"));
     tempDirs.push(dir);
     process.env.XDG_DATA_HOME = dir;
+    // The shared resolver gives test isolation priority. Keep both values
+    // aligned so the RPC client and fixture server exercise one directory.
+    process.env.MAGIC_CONTEXT_TEST_DATA_DIR = dir;
     return dir;
 }
 
@@ -96,6 +111,21 @@ describe("TUI context RPC data", () => {
         expect((await loadSidebarSnapshot(sessionId, directory)).inputTokens).toBe(0);
     });
 
+    test("does not turn a status authority failure into an empty session", async () => {
+        const dataHome = makeDataHome();
+        const directory = "/repo-status-error";
+        const server = await startServer(dataHome, directory, () => ({}));
+        server.handle("status-detail", async () => ({
+            error: "Rust module status unavailable; canonical session state was not read",
+        }));
+        initRpcClient(directory);
+
+        expect(await loadStatusDetail("ses_rust", directory)).toEqual({
+            ok: false,
+            error: "Rust module status unavailable; canonical session state was not read",
+        });
+    });
+
     test("distinguishes a real zero compartment count from an RPC failure", async () => {
         const dataHome = makeDataHome();
         const directory = "/repo-count";

package/src/tui/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)) {