@cortexkit/opencode-magic-context 0.33.0 → 0.34.0

package/src/shared/rpc-types.ts

@@ -8,8 +8,21 @@ export interface SidebarSnapshot {
     usagePercentage: number;
     inputTokens: number;
     contextLimit: number;
+    /**
+     * Raw wire-input pressure against the resolved model window. This is separate
+     * from Magic Context's execute threshold so native-compaction UI never shows
+     * a threshold-relative fill percentage.
+     */
+    native_context_usage_percentage?: number;
+    /**
+     * Magic Context compaction mode is resolved at startup and sent in the
+     * status-detail wire payload; snake_case matches that payload's field naming.
+     */
+    compaction_enabled?: boolean;
     systemPromptTokens: number;
     compartmentCount: number;
+    /** Historical compartment rows retained while native compaction owns the window. */
+    archivedCompartmentCount?: number;
     memoryCount: number;
     memoryBlockCount: number;
     pendingOpsCount: number;
@@ -18,6 +31,8 @@ export interface SidebarSnapshot {
     sessionNoteCount: number;
     readySmartNoteCount: number;
     cacheTtl: string;
+    /** Persistent runtime failure shown directly in the sidebar when non-null. */
+    lastTransformError: string | null;
     lastDreamerRunAt: number | null;
     projectIdentity: string | null;
     compartmentTokens: number;
@@ -69,7 +84,7 @@ export interface SidebarSnapshot {
     executeThreshold: number;
     /**
      * True when `executeThreshold` was clamped down from a higher configured value
-     * (tokens config above 80% × contextLimit, or a percentage above the 80% cap).
+     * (tokens config above 90% × contextLimit, or a percentage above the 90% cap).
      * The sidebar/status dialog append a small marker so the user knows their
      * configured value was reduced rather than applied verbatim (issue #241).
      * Absent when no clamp occurred.
@@ -111,9 +126,20 @@ export interface StatusDetail extends SidebarSnapshot {
     isSubagent: boolean;
     pendingOps: Array<{ tagId: number; operation: string }>;
     contextLimit: number;
+    /**
+     * Parsed cache TTL in ms. -1 = never expires (cacheTtl "never"; Infinity
+     * cannot ride JSON-RPC and 0 would be indistinguishable from unset). The
+     * values discriminate without the cacheNeverExpires flag: -1 never /
+     * N live. Falsy-value contract: see storage_versions for the precedent.
+     */
     cacheTtlMs: number;
+    /** Remaining ms in the idle-TTL window. -1 = never expires; 0 = expired
+     *  (only meaningful when lastResponseTime > 0); N = live countdown. */
     cacheRemainingMs: number;
     cacheExpired: boolean;
+    /** True when cacheTtl is "never" — the idle-TTL heuristic is disabled on
+     *  this lane. Redundant with cacheTtlMs === -1; kept as the readable form. */
+    cacheNeverExpires?: boolean;
     executeThreshold: number;
     /**
      * Which config source produced `executeThreshold`. "tokens" means
@@ -135,6 +161,25 @@ export interface StatusDetail extends SidebarSnapshot {
     toastDurationMs: number;
     /** One-line status data for the experimental memory mural. */
     mural?: { present: boolean; ageMs: number | null };
+    /**
+     * Stable storage-version probe: "which schema is the DB at, which fence does
+     * this binary carry". Field names are deliberately snake_case, mirroring the
+     * `storage_versions` block of the mc-module status envelope, so fleet probes
+     * parse one shape across both surfaces. The module cannot read context.db
+     * (the plugin owns it), so this surface supplies the live DB value; the module
+     * surface supplies the module-store value instead.
+     */
+    storage_versions: {
+        /**
+         * Persisted schema version of context.db (MAX of schema_migrations).
+         * null = the version probe FAILED (read threw — broken/unreachable store);
+         * 0 = probe succeeded on a fresh DB without a migrations table. Distinct so
+         * readers never conflate broken-with-empty (fleet status-surface contract).
+         */
+        context_db_schema_version: number | null;
+        /** Highest context.db schema version this plugin build supports. */
+        plugin_supported_version: number;
+    };
 }
 
 /** Embedding coverage for `/ctx-embed` status (mirrors getEmbeddingCoverageStatus). */

package/src/shared/sqlite.ts

@@ -201,30 +201,6 @@ export type Database = BetterSqlite3.Database;
 export type Statement = BetterSqlite3.Statement<unknown[], unknown>;
 
 const privilegeDepth = new WeakMap<Database, number>();
-const registeredPrivilegeFunctions = new WeakSet<Database>();
-const privilegeUdfAvailable = new WeakSet<Database>();
-
-/** Register the connection-local privilege predicate used by managed-write guards. */
-export function registerPrivilegedWriter(db: Database): void {
-    if (registeredPrivilegeFunctions.has(db)) return;
-    const native = db as unknown as {
-        function?: (name: string, implementation: () => number) => void;
-        createFunction?: (name: string, implementation: () => number) => void;
-    };
-    const implementation = (): number => ((privilegeDepth.get(db) ?? 0) > 0 ? 1 : 0);
-    if (typeof native.function === "function") {
-        native.function("mc_privileged_writer", implementation);
-    } else if (typeof native.createFunction === "function") {
-        native.createFunction("mc_privileged_writer", implementation);
-    } else {
-        // Older Bun releases do not expose scalar UDF registration. Migration 55
-        // retains the pre-UDF state-table trigger on those runtimes.
-        registeredPrivilegeFunctions.add(db);
-        return;
-    }
-    privilegeUdfAvailable.add(db);
-    registeredPrivilegeFunctions.add(db);
-}
 
 function isInTransaction(db: Database): boolean {
     const candidate = db as unknown as { inTransaction?: unknown; isTransaction?: unknown };
@@ -232,11 +208,17 @@ function isInTransaction(db: Database): boolean {
 }
 
 /**
- * Run a storage operation while the connection-local privilege predicate is enabled.
- * The depth lives outside SQLite, so a second connection can never observe or inherit it.
+ * Run a storage operation with the managed-write privilege enabled.
+ *
+ * The privilege is recorded in the durable `context_privilege_state` table (row
+ * id=1, enabled=1) so the guard triggers — which reference that table, never a
+ * connection-local UDF — stand down for this connection's writes. The write happens
+ * inside a BEGIN IMMEDIATE transaction (single writer), and enabled is cleared back
+ * to 0 before commit, so no second connection can ever observe enabled=1. Nesting is
+ * tracked by privilegeDepth (outside SQLite): only the outermost scope clears the
+ * flag, so an inner scope releasing does not drop permission out from under its caller.
  */
 export function withPrivilegedWriter<T>(db: Database, operation: () => T): T {
-    registerPrivilegedWriter(db);
     const previousDepth = privilegeDepth.get(db) ?? 0;
     const nested = isInTransaction(db);
     const savepoint = "mc_privilege_scope";
@@ -247,13 +229,11 @@ export function withPrivilegedWriter<T>(db: Database, operation: () => T): T {
     }
     privilegeDepth.set(db, previousDepth + 1);
     try {
-        if (!privilegeUdfAvailable.has(db)) {
-            db.prepare(
-                "INSERT INTO context_privilege_state(id, enabled) VALUES (1, 1) ON CONFLICT(id) DO UPDATE SET enabled = 1",
-            ).run();
-        }
+        db.prepare(
+            "INSERT INTO context_privilege_state(id, enabled) VALUES (1, 1) ON CONFLICT(id) DO UPDATE SET enabled = 1",
+        ).run();
         const result = operation();
-        if (!privilegeUdfAvailable.has(db) && previousDepth === 0) {
+        if (previousDepth === 0) {
             db.prepare("UPDATE context_privilege_state SET enabled = 0 WHERE id = 1").run();
         }
         if (nested) {

package/src/shared/storage-permissions.ts

@@ -0,0 +1,20 @@
+/**
+ * Process-wide storage permission policy resolved from trusted user config.
+ *
+ * Storage is shared by OpenCode and Pi, so all writers consult one setting before
+ * applying POSIX modes. The default preserves the historical owner-only policy.
+ */
+let enforcePrivateStoragePermissions = true;
+
+export function setStoragePrivatePermissionEnforcement(enforce: boolean): void {
+    enforcePrivateStoragePermissions = enforce;
+}
+
+export function shouldEnforcePrivateStoragePermissions(): boolean {
+    return enforcePrivateStoragePermissions;
+}
+
+/** Test-only reset for suites that exercise both permission policies in one process. */
+export function __resetStoragePrivatePermissionEnforcementForTests(): void {
+    enforcePrivateStoragePermissions = true;
+}

package/src/tui/compaction-off.test.ts

@@ -0,0 +1,56 @@
+import { expect, test } from "bun:test";
+import type { SidebarSnapshot } from "../shared/rpc-types";
+import { compactionOffSidebarRows, nativeCompactionContextLabel } from "./compaction-off";
+
+function snapshot(overrides: Partial<SidebarSnapshot> = {}): SidebarSnapshot {
+    return {
+        sessionId: "ses-native-ui",
+        usagePercentage: 63.1,
+        inputTokens: 41_000,
+        contextLimit: 100_000,
+        native_context_usage_percentage: 41,
+        compaction_enabled: false,
+        systemPromptTokens: 0,
+        compartmentCount: 12,
+        archivedCompartmentCount: 3,
+        memoryCount: 5,
+        memoryBlockCount: 2,
+        pendingOpsCount: 4,
+        historianRunning: true,
+        compartmentInProgress: true,
+        sessionNoteCount: 2,
+        readySmartNoteCount: 1,
+        cacheTtl: "5m",
+        lastDreamerRunAt: null,
+        projectIdentity: null,
+        compartmentTokens: 0,
+        factTokens: 0,
+        memoryTokens: 0,
+        docsTokens: 0,
+        profileTokens: 0,
+        conversationTokens: 0,
+        toolCallTokens: 0,
+        toolDefinitionTokens: 0,
+        executeThreshold: 65,
+        ...overrides,
+    };
+}
+
+test("renders raw input-versus-model usage rather than threshold-relative fill", () => {
+    const value = nativeCompactionContextLabel(snapshot());
+
+    expect(value).toBe("Context: 41.0% · native compaction");
+    expect(value).not.toBe("Context: 63.1% · native compaction");
+});
+
+test("keeps historical compartments as a static archived row", () => {
+    const initialRows = compactionOffSidebarRows(snapshot());
+    const activeCountChangedRows = compactionOffSidebarRows(snapshot({ compartmentCount: 99 }));
+
+    expect(initialRows).toEqual([
+        { label: "Memories", value: "5" },
+        { label: "Notes", value: "2" },
+        { label: "Archived compartments", value: "3" },
+    ]);
+    expect(activeCountChangedRows).toEqual(initialRows);
+});

package/src/tui/compaction-off.ts

@@ -0,0 +1,29 @@
+import type { SidebarSnapshot } from "../shared/rpc-types";
+
+export interface CompactionOffSidebarRow {
+    label: "Memories" | "Notes" | "Archived compartments";
+    value: string;
+}
+
+/**
+ * Formats context pressure from the current wire input and the model context
+ * limit. It deliberately does not use the stored Magic Context threshold
+ * percentage, because native compaction acts on the model window instead.
+ */
+export function nativeCompactionContextLabel(snapshot: SidebarSnapshot): string {
+    if (snapshot.contextLimit <= 0) return "Context: unknown · native compaction";
+    const percentage = (snapshot.inputTokens / snapshot.contextLimit) * 100;
+    return `Context: ${percentage.toFixed(1)}% · native compaction`;
+}
+
+export function compactionOffSidebarRows(snapshot: SidebarSnapshot): CompactionOffSidebarRow[] {
+    const rows: CompactionOffSidebarRow[] = [
+        { label: "Memories", value: String(snapshot.memoryCount) },
+        { label: "Notes", value: String(snapshot.sessionNoteCount) },
+    ];
+    const archivedCount = snapshot.archivedCompartmentCount ?? 0;
+    if (archivedCount > 0) {
+        rows.push({ label: "Archived compartments", value: String(archivedCount) });
+    }
+    return rows;
+}

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

@@ -65,6 +65,7 @@ const EMPTY_SNAPSHOT: SidebarSnapshot = {
     sessionNoteCount: 0,
     readySmartNoteCount: 0,
     cacheTtl: "5m",
+    lastTransformError: null,
     lastDreamerRunAt: null,
     projectIdentity: null,
     compartmentTokens: 0,
@@ -194,6 +195,7 @@ export async function loadStatusDetail(
         cacheTtlMs: 0,
         cacheRemainingMs: 0,
         cacheExpired: false,
+        cacheNeverExpires: false,
         executeThreshold: 65,
         executeThresholdMode: "percentage",
         protectedTagCount: 20,
@@ -202,6 +204,10 @@ export async function loadStatusDetail(
         compressionBudget: null,
         compressionUsage: null,
         toastDurationMs: 5000,
+        storage_versions: {
+            context_db_schema_version: null,
+            plugin_supported_version: 0,
+        },
     };
 
     if (!rpcClient) return emptyDetail;

package/src/tui/index.tsx

@@ -2,11 +2,18 @@
 // @ts-nocheck
 import { createMemo } from "solid-js"
 import type { TuiPlugin, TuiPluginApi, TuiThemeCurrent } from "@opencode-ai/plugin/tui"
-import { createSidebarContentSlot, kickRecompProgressRefresh } from "./slots/sidebar-content"
+import {
+    createSidebarContentSlot,
+    kickRecompProgressRefresh,
+    refreshSidebarSnapshot,
+} from "./slots/sidebar-content"
 import packageJson from "../../package.json"
 import { closeRpc, dismissUpgradeReminder, getAnnouncement, getCompartmentCount, getRpcGeneration, initRpcClient, loadEmbedDetail, loadStatusDetail, loadToastDurationMs, markAnnounced, requestRecomp, requestUpgrade, type EmbedDetail, type StatusDetail } from "./data/context-db"
 import { startNotificationSocket, stopNotificationSocket, type SocketNotification } from "./data/notification-socket"
 import { formatThresholdPercent } from "../shared/format-threshold"
+import { compactionOffSidebarRows, nativeCompactionContextLabel } from "./compaction-off"
+import { isCompactionEnabled } from "../config/agent-disable"
+import { loadPluginConfig } from "../config"
 import { detectConflicts } from "../shared/conflict-detector"
 import { fixConflicts } from "../shared/conflict-fixer"
 
@@ -130,6 +137,7 @@ const StatusDialog = (props: { api: TuiPluginApi; s: StatusDetail }) => {
     const theme = createMemo(() => (props.api as any).theme.current)
     const t = () => theme()
     const s = () => props.s
+    const compactionOff = () => s().compaction_enabled === false
 
     // Prefer the RPC-provided model context limit (what the sidebar shows) so the
     // two surfaces never disagree. Fall back to deriving from usage% only when the
@@ -169,7 +177,7 @@ const StatusDialog = (props: { api: TuiPluginApi; s: StatusDetail }) => {
             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)
+        if (!compactionOff() && d.compartmentTokens > 0)
             segs.push({
                 label: "Compartments",
                 tokens: d.compartmentTokens,
@@ -217,15 +225,17 @@ const StatusDialog = (props: { api: TuiPluginApi; s: StatusDetail }) => {
                 <text fg={t().textMuted}>v{packageJson.version}</text>
             </box>
 
-            {/* Context summary line. Mirrors the sidebar header layout
-                ("47.5% / 65%   475K / 1.0M") so users can recognize the
-                same shape in the status dialog. The execute threshold tells
-                them how close they are to compaction triggering. */}
             <box flexDirection="row" justifyContent="space-between" width="100%">
-                <text fg={s().usagePercentage >= 80 ? t().error : s().usagePercentage >= 65 ? t().warning : t().accent}>
-                    <b>{s().usagePercentage.toFixed(1)}%</b> / {formatThresholdPercent(s().executeThreshold)}%{s().executeThresholdClamped ? "*" : ""}
-                </text>
-                <text fg={s().usagePercentage >= 80 ? t().error : s().usagePercentage >= 65 ? t().warning : t().accent}>
+                {compactionOff() ? (
+                    <text fg={t().accent}>
+                        <b>{nativeCompactionContextLabel(s())}</b>
+                    </text>
+                ) : (
+                    <text fg={s().usagePercentage >= 80 ? t().error : s().usagePercentage >= 65 ? t().warning : t().accent}>
+                        <b>{s().usagePercentage.toFixed(1)}%</b> / {formatThresholdPercent(s().executeThreshold)}%{s().executeThresholdClamped ? "*" : ""}
+                    </text>
+                )}
+                <text fg={compactionOff() ? t().accent : s().usagePercentage >= 80 ? t().error : s().usagePercentage >= 65 ? t().warning : t().accent}>
                     {fmt(s().inputTokens)} / {contextLimit() > 0 ? fmt(contextLimit()) : "?"} tokens
                 </text>
             </box>
@@ -259,7 +269,7 @@ const StatusDialog = (props: { api: TuiPluginApi; s: StatusDetail }) => {
 
             {/* Recomp / session-upgrade live progress (full width, only while
                 running or just finished — dogfood 2026-05-30). */}
-            {s().recompProgress && (() => {
+            {!compactionOff() && s().recompProgress && (() => {
                 const p = s().recompProgress!
                 // Label follows the flow that started the run, so a plain
                 // /ctx-recomp never reads as an "Upgrade" (dogfood 2026-06-04).
@@ -295,61 +305,80 @@ const StatusDialog = (props: { api: TuiPluginApi; s: StatusDetail }) => {
                 )
             })()}
 
-            {/* 2-column layout */}
             <box flexDirection="row" width="100%" marginTop={1} gap={4}>
-                {/* Left column */}
-                <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="Total" v={String(s().totalTags)} fg={t().textMuted} />
-                    <box marginTop={1}>
-                        <text fg={t().text}><b>Pending Queue</b></text>
-                    </box>
-                    <R t={t()} l="Drops" v={String(s().pendingOpsCount)} fg={s().pendingOpsCount > 0 ? t().warning : t().textMuted} />
-                    <box marginTop={1}>
-                        <text fg={t().text}><b>Cache TTL</b></text>
-                    </box>
-                    <R t={t()} l="Configured" v={s().cacheTtl} />
-                    <R t={t()} l="Last response" v={s().lastResponseTime > 0 ? `${Math.round(elapsed() / 1000)}s ago` : "never"} />
-                    <R t={t()} l="Remaining" v={s().cacheExpired ? "expired" : `${Math.round(s().cacheRemainingMs / 1000)}s`} fg={s().cacheExpired ? t().warning : t().textMuted} />
-                    <R t={t()} l="Auto-execute" v={s().cacheExpired ? "yes (expired)" : `at TTL or ≥${formatThresholdPercent(s().executeThreshold)}%`} fg={t().textMuted} />
-                    <box marginTop={1}>
-                        <text fg={t().text}><b>Memory</b></text>
-                    </box>
-                    <R t={t()} l="Active" v={String(s().memoryCount)} fg={t().accent} />
-                    <R t={t()} l="Injected" v={String(s().memoryBlockCount)} fg={t().textMuted} />
-                </box>
-                {/* Right column */}
-                <box flexDirection="column" flexGrow={1} flexBasis={0}>
-                    <text fg={t().text}><b>Reductions</b></text>
-                    <R t={t()} l="Execute threshold" v={`${formatThresholdPercent(s().executeThreshold)}%${s().executeThresholdClamped ? "*" : ""}`} />
-                    <R t={t()} l="Last reduce anchor" v={`${fmt(s().lastNudgeTokens)} tok`} />
-                    <box marginTop={1}>
-                        <text fg={t().text}><b>Context Details</b></text>
-                    </box>
-                    <R t={t()} l="Protected tags" v={String(s().protectedTagCount)} fg={t().textMuted} />
-                    <R t={t()} l="Subagent" v={s().isSubagent ? "yes" : "no"} fg={t().textMuted} />
-                    <box marginTop={1}>
-                        <text fg={t().text}><b>History Compression</b></text>
+                {compactionOff() ? (
+                    <box flexDirection="column" flexGrow={1} flexBasis={0}>
+                        <text fg={t().text}><b>Knowledge</b></text>
+                        {compactionOffSidebarRows(s()).map((row) => (
+                            <R
+                                t={t()}
+                                l={row.label}
+                                v={row.value}
+                                fg={row.label === "Memories" ? t().accent : t().textMuted}
+                            />
+                        ))}
+                        {s().readySmartNoteCount > 0 && (
+                            <R t={t()} l="Smart Notes" v={`${s().readySmartNoteCount} ready`} fg={t().accent} />
+                        )}
+                        {s().lastDreamerRunAt && (
+                            <R t={t()} l="Dreamer" v={`last ${relTime(s().lastDreamerRunAt!)}`} fg={t().textMuted} />
+                        )}
                     </box>
-                    {typeof s().boundaryPresent === "boolean" && (
-                        <R t={t()} l="Boundary" v={s().boundaryPresent ? "present" : "absent"} />
-                    )}
-                    {s().coverageOrdinal !== undefined && (
-                        <R t={t()} l="Coverage ordinal" v={s().coverageOrdinal == null ? "none" : String(s().coverageOrdinal)} />
-                    )}
-                    {typeof s().boundaryPresent === "boolean" && (
-                        <R t={t()} l="Compartments" v={String(s().compartmentCount)} />
-                    )}
-                    <R t={t()} l="History block" v={`~${fmt(s().historyBlockTokens)} tok`} />
-                    {s().compressionBudget != null && (
-                        <R t={t()} l="Budget" v={`~${fmt(s().compressionBudget!)} tok (${s().compressionUsage} used)`} />
-                    )}
-                    {s().lastDreamerRunAt && (
-                        <R t={t()} l="Dreamer" v={`last ${relTime(s().lastDreamerRunAt!)}`} fg={t().textMuted} />
-                    )}
-                </box>
+                ) : (
+                    <>
+                        <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="Total" v={String(s().totalTags)} fg={t().textMuted} />
+                            <box marginTop={1}>
+                                <text fg={t().text}><b>Pending Queue</b></text>
+                            </box>
+                            <R t={t()} l="Drops" v={String(s().pendingOpsCount)} fg={s().pendingOpsCount > 0 ? t().warning : t().textMuted} />
+                            <box marginTop={1}>
+                                <text fg={t().text}><b>Cache TTL</b></text>
+                            </box>
+                            <R t={t()} l="Configured" v={s().cacheTtl} />
+                            <R t={t()} l="Last response" v={s().lastResponseTime > 0 ? `${Math.round(elapsed() / 1000)}s ago` : "never"} />
+                            <R t={t()} l="Remaining" v={s().cacheExpired ? "expired" : s().cacheNeverExpires ? "never expires (always-warm lane)" : `${Math.round(s().cacheRemainingMs / 1000)}s`} fg={s().cacheExpired ? t().warning : t().textMuted} />
+                            <R t={t()} l="Auto-execute" v={s().cacheExpired ? "yes (expired)" : s().cacheNeverExpires ? `at ≥${formatThresholdPercent(s().executeThreshold)}%` : `at TTL or ≥${formatThresholdPercent(s().executeThreshold)}%`} fg={t().textMuted} />
+                            <box marginTop={1}>
+                                <text fg={t().text}><b>Memory</b></text>
+                            </box>
+                            <R t={t()} l="Active" v={String(s().memoryCount)} fg={t().accent} />
+                            <R t={t()} l="Injected" v={String(s().memoryBlockCount)} fg={t().textMuted} />
+                        </box>
+                        <box flexDirection="column" flexGrow={1} flexBasis={0}>
+                            <text fg={t().text}><b>Reductions</b></text>
+                            <R t={t()} l="Execute threshold" v={`${formatThresholdPercent(s().executeThreshold)}%${s().executeThresholdClamped ? "*" : ""}`} />
+                            <R t={t()} l="Last reduce anchor" v={`${fmt(s().lastNudgeTokens)} tok`} />
+                            <box marginTop={1}>
+                                <text fg={t().text}><b>Context Details</b></text>
+                            </box>
+                            <R t={t()} l="Protected tags" v={String(s().protectedTagCount)} fg={t().textMuted} />
+                            <R t={t()} l="Subagent" v={s().isSubagent ? "yes" : "no"} fg={t().textMuted} />
+                            <box marginTop={1}>
+                                <text fg={t().text}><b>History Compression</b></text>
+                            </box>
+                            {typeof s().boundaryPresent === "boolean" && (
+                                <R t={t()} l="Boundary" v={s().boundaryPresent ? "present" : "absent"} />
+                            )}
+                            {s().coverageOrdinal !== undefined && (
+                                <R t={t()} l="Coverage ordinal" v={s().coverageOrdinal == null ? "none" : String(s().coverageOrdinal)} />
+                            )}
+                            {typeof s().boundaryPresent === "boolean" && (
+                                <R t={t()} l="Compartments" v={String(s().compartmentCount)} />
+                            )}
+                            <R t={t()} l="History block" v={`~${fmt(s().historyBlockTokens)} tok`} />
+                            {s().compressionBudget != null && (
+                                <R t={t()} l="Budget" v={`~${fmt(s().compressionBudget!)} tok (${s().compressionUsage} used)`} />
+                            )}
+                            {s().lastDreamerRunAt && (
+                                <R t={t()} l="Dreamer" v={`last ${relTime(s().lastDreamerRunAt!)}`} fg={t().textMuted} />
+                            )}
+                        </box>
+                    </>
+                )}
             </box>
 
             {/* Error (full width, conditional) */}
@@ -945,7 +974,21 @@ const tui: TuiPlugin = async (api, _options, meta) => {
     const directory = api.state.path.directory ?? ""
     // A conflicted installation intentionally has no server. Gate before RPC
     // discovery or socket startup so disabled installs perform no idle work.
-    const conflictResult = detectConflicts(directory)
+    // The resolved MC compaction mode is threaded in explicitly via the same
+    // loader + accessor the plugin boot uses, so the TUI never re-derives the
+    // compaction decision from directory alone. On config load failure the
+    // accessor resolves default-on (mode-on), preserving today's conflict
+    // gate rather than silently skipping the check.
+    let pluginConfig: ReturnType<typeof loadPluginConfig> | undefined
+    try {
+        pluginConfig = loadPluginConfig(directory)
+    } catch {
+        // Config load failure: fail toward mode-on (today's behavior) by
+        // leaving pluginConfig undefined so isCompactionEnabled defaults true.
+    }
+    const conflictResult = detectConflicts(directory, {
+        compactionEnabled: isCompactionEnabled(pluginConfig ?? {}),
+    })
     if (conflictResult.hasConflict) {
         showConflictDialog(api, directory, conflictResult.reasons, conflictResult.conflicts)
         return
@@ -1023,6 +1066,11 @@ const tui: TuiPlugin = async (api, _options, meta) => {
         if (action === "show-embed-dialog") {
             return stillActive() && (await showEmbedDialog(api, requestedSessionId))
         }
+        if (action === "refresh-sidebar") {
+            if (!stillActive()) return false
+            refreshSidebarSnapshot()
+            return true
+        }
         if (action === "wrapup-progress-kick") {
             // /ctx-wrapup blocks its command turn and fires no message events, so
             // the sidebar poll would never notice the run. Kick the fast progress