@cortexkit/opencode-magic-context 0.37.0 → 0.38.1

package/src/shared/harness-provider-map.ts

@@ -16,6 +16,12 @@
  * their exported functions remain distinct deliberately. A future OMP catalog
  * rename must not silently change plain-Pi behavior (or vice versa).
  *
+ * The OpenCode Zen gateway is the one place the two harnesses diverge: OpenCode
+ * and plain Pi both name it `opencode`, while OMP exposes the same gateway as
+ * `opencode-zen`. Only the OMP map carries that pair; plain Pi keeps `opencode`
+ * as an identity. `opencode-go` is a distinct gateway (the "go" variant at
+ * opencode.ai/zen/go) and stays unmapped on both harnesses.
+ *
  * The mapping is intentionally not a one-to-one provider identity. Both
  * harnesses also expose plain `openai` and `google` providers for direct API
  * keys, while the canonical prefix does not record whether a subscription or
@@ -43,11 +49,13 @@ const PI_TO_CANONICAL_PROVIDER: Readonly<Record<string, string>> = {
 const CANONICAL_TO_OMP_PROVIDER: Readonly<Record<string, string>> = {
     openai: "openai-codex",
     google: "google-antigravity",
+    opencode: "opencode-zen",
 };
 
 const OMP_TO_CANONICAL_PROVIDER: Readonly<Record<string, string>> = {
     "openai-codex": "openai",
     "google-antigravity": "google",
+    "opencode-zen": "opencode",
 };
 
 /** Remap only the provider prefix (text before the first "/"), preserving the

package/src/shared/models-dev-cache.test.ts

@@ -7,6 +7,7 @@ import {
     getModelsDevCacheState,
     getSdkContextLimit,
     getSdkInputLimit,
+    getSdkWindowGeometry,
     refreshModelLimitsAfterAuthOnce,
     refreshModelLimitsFromApi,
     resetAuthRewarmLatchForTest,
@@ -148,6 +149,30 @@ describe("models-dev-cache (SDK-only)", () => {
         clearModelsDevCache();
     });
 
+    test("honors the reporter's default output_reserve on the SDK geometry path", async () => {
+        await refreshModelLimitsFromApi(
+            makeClient([
+                {
+                    id: "openai-codex",
+                    models: {
+                        "gpt-5.6-sol": {
+                            limit: { context: 400_000, input: 272_000, output: 128_000 },
+                        },
+                    },
+                },
+            ]),
+        );
+        setOutputReserveConfig({ default: 16_384 });
+
+        const geometry = getSdkWindowGeometry("openai-codex", "gpt-5.6-sol");
+        expect(geometry?.usableSoft).toBe(272_000 - 16_384);
+        expect(geometry?.derivation).toMatchObject({
+            window: 272_000,
+            reserve: 16_384,
+            reserveSource: "output_config",
+        });
+    });
+
     test("resolves from the SDK and prefers limit.input over limit.context", async () => {
         // github-copilot / codex shape: input is the max prompt, context the total
         // window. Pressure math must use the input cap (OpenCode's own overflow.ts

package/src/shared/models-dev-cache.ts

@@ -211,10 +211,11 @@ function modelKeyLookupOrder(providerID: string, modelID: string): string[] {
     return [...new Set(candidates)];
 }
 
-function configuredOutputReserve(
-    config: OutputReserveConfig | undefined,
+/** Resolve the user-tier output reservation for one runtime model. */
+export function resolveOutputReserve(
     providerID: string,
     modelID: string,
+    config: OutputReserveConfig | undefined = outputReserveConfig,
 ): number | undefined {
     if (typeof config === "number")
         return Number.isFinite(config) && config >= 0 ? config : undefined;
@@ -259,7 +260,7 @@ export function resolveLimit(
     if (input !== undefined && (context === undefined || input < context)) return input;
     if (context === undefined) return undefined;
 
-    const configuredReserve = configuredOutputReserve(reserveConfig, providerID, modelID);
+    const configuredReserve = resolveOutputReserve(providerID, modelID, reserveConfig);
     let reserve: number;
     if (configuredReserve !== undefined) {
         reserve = configuredReserve;
@@ -523,7 +524,7 @@ export function getSdkWindowGeometry(
         },
         {
             overlay: resolveWindowOverlayFacts(providerID, modelID, getWindowOverlay()),
-            reserveConfig: outputReserveConfig,
+            outputReserveOverride: resolveOutputReserve(providerID, modelID),
             harness: options?.harness ?? "opencode",
             contextCap:
                 promptOnlyDetected === undefined && isFinitePositive(detectedContextLimit)

package/src/shared/rpc-server.ts

@@ -185,6 +185,7 @@ export class MagicContextRpcServer {
                     port: this.port,
                     pid: process.pid,
                     started_at: this.startedAt,
+                    kind: "OpenCode server",
                     token: this.token,
                     instance_id: this.instanceId,
                 }),

package/src/shared/rpc-types.ts

@@ -9,6 +9,20 @@ import type {
 } from "../features/magic-context/dreamer/task-registry";
 import type { LoggerDiagnostics } from "./logger";
 
+export interface TailHygieneStatus {
+    /** Tokens in active, non-protected tail content that the agent can reclaim. */
+    u: number;
+    /** Tokens in rendered-tail content eligible for hygiene accounting in the same scan. */
+    t: number;
+    /** Reclaimable-to-eligible token ratio, clamped to 0–1 and shared by both nudge mechanisms. */
+    severity: number;
+    /** False until a fresh scan runs after existing tail content changes, preventing stale measurements. */
+    evaluable: boolean;
+    generationInvalidated: boolean;
+    baselineGeneration: number;
+    computedAt: number;
+}
+
 export interface SidebarSnapshot {
     sessionId: string;
     usagePercentage: number;
@@ -78,6 +92,8 @@ export interface SidebarSnapshot {
      * shows this as "Tool Definitions".
      */
     toolDefinitionTokens: number;
+    /** Persisted reclaimable (U) and eligible (T) token counts used by both nudge mechanisms. */
+    tailHygiene?: TailHygieneStatus;
     /**
      * Effective execute-threshold percentage for this session's active model,
      * after per-model resolution and the tokens→percentage conversion (when

package/src/shared/rpc-utils.test.ts

@@ -6,6 +6,7 @@ import type { readFileSync } from "node:fs";
 import {
     __resetRpcIdentityTestHooks,
     __setRpcIdentityTestHooks,
+    classifyProcessKind,
     discoverLivePiProcessIds,
     inspectLivePiProcesses,
     isPidAlive,
@@ -54,6 +55,30 @@ afterEach(() => {
     __resetRpcIdentityTestHooks();
 });
 
+describe("classifyProcessKind", () => {
+    test("classifies OpenCode server, OpenCode instance, Pi, and unknown commands", () => {
+        expect(classifyProcessKind("/usr/local/bin/opencode serve --hostname 127.0.0.1")).toBe(
+            "OpenCode server",
+        );
+        expect(classifyProcessKind("node /opt/opencode/bin/opencode --continue")).toBe(
+            "OpenCode instance (TUI/CLI)",
+        );
+        expect(
+            classifyProcessKind(
+                "bun /workspace/node_modules/@mariozechner/pi-coding-agent/dist/cli.js",
+            ),
+        ).toBe("Pi");
+        expect(classifyProcessKind("/usr/bin/other --flag")).toBe("process");
+        expect(classifyProcessKind(null)).toBe("process");
+    });
+
+    test("recognizes serve flags and Windows-style executable paths", () => {
+        expect(classifyProcessKind("opencode --serve=true")).toBe("OpenCode server");
+        expect(classifyProcessKind("C:\\Tools\\opencode.exe")).toBe("OpenCode instance (TUI/CLI)");
+        expect(classifyProcessKind("pi.cmd --model test")).toBe("Pi");
+    });
+});
+
 describe("discoverLivePiProcessIds", () => {
     test("finds Pi-family harness commands while excluding the current process", () => {
         __setRpcIdentityTestHooks({

package/src/shared/rpc-utils.ts

@@ -3,10 +3,16 @@ import { createHash } from "node:crypto";
 import { readFileSync } from "node:fs";
 import { join } from "node:path";
 
+export type ProcessKind = "OpenCode server" | "OpenCode instance (TUI/CLI)" | "Pi" | "process";
+
 export interface RpcPortFileRecord {
     port: number;
     pid: number;
     started_at: number;
+    /** Optional producer-provided kind; older records omit it. */
+    kind?: string;
+    /** Compatibility with discovery records that used the harness name. */
+    harness?: string;
     /**
      * Per-process bearer token. The server requires it on all non-health RPC
      * calls so a random local process or browser-origin script that merely
@@ -224,6 +230,78 @@ function readPsProcessCommand(pid: number): string | null {
     }
 }
 
+/** Reuse the platform-gated command probes used by PID identity checks. */
+export function readProcessCommand(pid: number): string | null {
+    if (!Number.isInteger(pid) || pid <= 0) return null;
+    return rpcIdentityPlatform === "linux"
+        ? readLinuxProcessCommand(pid)
+        : rpcIdentityPlatform === "win32"
+          ? (readWindowsProcess(pid).command ?? null)
+          : readPsProcessCommand(pid);
+}
+
+function executableName(token: string | undefined): string {
+    return (
+        (token ?? "")
+            .replace(/^['"]|['"]$/g, "")
+            .split("/")
+            .at(-1) ?? ""
+    );
+}
+
+function commandTokens(command: string): string[] {
+    return command
+        .toLowerCase()
+        .replaceAll("\\", "/")
+        .replaceAll("\u0000", " ")
+        .split(/\s+/)
+        .map((token) => token.replace(/^['"]|['"]$/g, ""))
+        .filter(Boolean);
+}
+
+function commandHasOpenCodeExecutable(tokens: readonly string[]): number {
+    return tokens.findIndex((token) => {
+        const executable = executableName(token).replace(/\.(?:exe|cmd)$/, "");
+        return executable === "opencode" || executable.endsWith("/opencode");
+    });
+}
+
+function commandHasPiExecutable(tokens: readonly string[]): boolean {
+    for (let index = 0; index < tokens.length; index += 1) {
+        const executable = executableName(tokens[index]).replace(/\.(?:exe|cmd)$/, "");
+        if (["pi", "omp", "oh-my-pi"].includes(executable)) return true;
+        if (["node", "bun", "deno"].includes(executable)) {
+            const script = executableName(tokens[index + 1]).replace(/\.(?:exe|cmd)$/, "");
+            if (
+                ["pi", "pi.js", "pi.mjs", "pi.cjs"].includes(script) ||
+                tokens[index + 1]?.includes("pi-coding-agent")
+            ) {
+                return true;
+            }
+        }
+    }
+    return false;
+}
+
+/** Classify a process command without changing the liveness decision. */
+export function classifyProcessKind(command: string | null | undefined): ProcessKind {
+    if (!command) return "process";
+    const tokens = commandTokens(command);
+    const openCodeIndex = commandHasOpenCodeExecutable(tokens);
+    if (openCodeIndex >= 0) {
+        const args = tokens.slice(openCodeIndex + 1);
+        if (
+            args.some(
+                (token) => token === "serve" || token === "--serve" || token.startsWith("--serve="),
+            )
+        ) {
+            return "OpenCode server";
+        }
+        return "OpenCode instance (TUI/CLI)";
+    }
+    return commandHasPiExecutable(tokens) ? "Pi" : "process";
+}
+
 function commandLooksLikeOpenCode(command: string): boolean {
     const normalized = command.toLowerCase();
     return OPEN_CODE_COMMAND_MARKERS.some((marker) => normalized.includes(marker));
@@ -394,6 +472,8 @@ export function parseRpcPortFile(content: string, fallbackPid = 0): RpcPortFileR
                 port,
                 pid,
                 started_at: Number.isFinite(startedAt) ? startedAt : 0,
+                kind: typeof parsed.kind === "string" ? parsed.kind : undefined,
+                harness: typeof parsed.harness === "string" ? parsed.harness : undefined,
                 token: typeof parsed.token === "string" ? parsed.token : undefined,
                 instance_id:
                     typeof parsed.instance_id === "string" ? parsed.instance_id : undefined,

package/src/shared/tail-hygiene-status.ts

@@ -0,0 +1,57 @@
+import type { Channel1State } from "../hooks/magic-context/ctx-reduce-nudge";
+import type { TailHygieneStatus } from "./rpc-types";
+
+export interface WireTailHygieneBaseline {
+    u?: number;
+    t?: number;
+    severity?: number;
+    evaluable?: boolean;
+    generation_invalidated?: boolean;
+    baseline_generation?: number;
+    computed_at_ms?: number;
+}
+
+function finiteNumber(value: unknown, fallback = 0): number {
+    return typeof value === "number" && Number.isFinite(value) ? value : fallback;
+}
+
+/** Normalize either renderer authority's persisted baseline without dropping valid zeros. */
+export function resolveTailHygieneStatus(
+    tsBaseline: Channel1State | undefined,
+    rustBaseline?: WireTailHygieneBaseline | null,
+): TailHygieneStatus | undefined {
+    if (rustBaseline !== undefined && rustBaseline !== null) {
+        const t = Math.max(0, finiteNumber(rustBaseline.t));
+        const u = Math.min(t, Math.max(0, finiteNumber(rustBaseline.u)));
+        return {
+            u,
+            t,
+            severity: Math.min(
+                1,
+                Math.max(0, finiteNumber(rustBaseline.severity, u / Math.max(t, 1))),
+            ),
+            evaluable: rustBaseline.evaluable === true,
+            generationInvalidated: rustBaseline.generation_invalidated === true,
+            baselineGeneration: Math.max(0, finiteNumber(rustBaseline.baseline_generation)),
+            computedAt: Math.max(0, finiteNumber(rustBaseline.computed_at_ms)),
+        };
+    }
+    if (tsBaseline === undefined) return undefined;
+    const t = Math.max(0, tsBaseline.baselineT + tsBaseline.turnDeltaT);
+    const u = Math.min(t, Math.max(0, tsBaseline.baselineU + tsBaseline.turnDeltaU));
+    return {
+        u,
+        t,
+        severity: Math.min(1, Math.max(0, u / Math.max(t, 1))),
+        evaluable: tsBaseline.evaluable && !tsBaseline.generationInvalidated,
+        generationInvalidated: tsBaseline.generationInvalidated,
+        baselineGeneration: Math.max(0, tsBaseline.baselineGeneration),
+        computedAt: Math.max(0, tsBaseline.computedAt),
+    };
+}
+
+export function formatTailHygiene(status: TailHygieneStatus): string {
+    const percentage = (status.severity * 100).toFixed(1);
+    const state = status.evaluable ? "" : " · held until baseline refresh";
+    return `${percentage}% · ${status.u.toLocaleString()} / ${status.t.toLocaleString()} tok${state}`;
+}

package/src/shared/window-geometry.test.ts

@@ -2,7 +2,7 @@ import { afterEach, describe, expect, test } from "bun:test";
 import { mkdtempSync, readFileSync, rmSync, writeFileSync } from "node:fs";
 import { tmpdir } from "node:os";
 import { join } from "node:path";
-import { resolveLimit } from "./models-dev-cache";
+import { resolveLimit, resolveOutputReserve } from "./models-dev-cache";
 import {
     deriveWindowGeometry,
     formatWindowDerivationLine,
@@ -240,6 +240,39 @@ describe("window geometry", () => {
         expect(result?.usableSoft).toBe(1_016_576);
     });
 
+    test("output_reserve forms override a pre-carved input and overlay output facts", () => {
+        const data = overlay("openai-codex", "gpt-5.6-sol", {
+            "output.enforced": fact({ kind: "stated", value: 68_000 }),
+        });
+        const cases = [
+            16_384,
+            { default: 16_384 },
+            { default: 32_000, "openai-codex/gpt-5.6-sol": 16_384 },
+        ] as const;
+
+        for (const reserveConfig of cases) {
+            const result = deriveWindowGeometry(
+                "openai-codex",
+                "gpt-5.6-sol",
+                { context: 400_000, input: 272_000, output: 128_000 },
+                {
+                    overlay: resolveWindowOverlayFacts("openai-codex", "gpt-5.6-sol", data),
+                    outputReserveOverride: resolveOutputReserve(
+                        "openai-codex",
+                        "gpt-5.6-sol",
+                        reserveConfig,
+                    ),
+                },
+            );
+            expect(result?.usableSoft).toBe(272_000 - 16_384);
+            expect(result?.derivation).toMatchObject({
+                window: 272_000,
+                reserve: 16_384,
+                reserveSource: "output_config",
+            });
+        }
+    });
+
     test("provider hook wins over overlay, while overlay beats catalog", () => {
         const data = overlay("provider", "model", {
             "window.enforced": fact({ kind: "stated", value: 300_000 }),

package/src/shared/window-geometry.ts

@@ -3,7 +3,7 @@ import { join } from "node:path";
 import { getDataDir } from "./data-path";
 import { modelRefLookupOrder } from "./harness-provider-map";
 import { sessionLog } from "./logger";
-import type { ModelLimit, OutputReserveConfig } from "./models-dev-cache";
+import type { ModelLimit } from "./models-dev-cache";
 
 export const WINDOW_OVERLAY_SCHEMA = "fusiform-window-overlay/v1";
 export const PROMPT_WALL_MARGIN = 4_096;
@@ -88,7 +88,8 @@ export interface DeriveWindowGeometryOptions {
     overlay?: ResolvedWindowOverlayFacts;
     /** A provider/auth hook has higher precedence than the overlay, field by field. */
     providerLimit?: ModelLimit;
-    reserveConfig?: OutputReserveConfig;
+    /** Resolved user override; higher precedence than catalog, overlay, and geometry defaults. */
+    outputReserveOverride?: number;
     harness?: "opencode" | "pi";
     /** Detected overflow remains the final downward cap regardless of other sources. */
     contextCap?: number;
@@ -139,32 +140,6 @@ function isFinitePositive(value: unknown): value is number {
     return typeof value === "number" && Number.isFinite(value) && value > 0;
 }
 
-function modelKeyLookupOrder(providerID: string, modelID: string): string[] {
-    const candidates = [...modelRefLookupOrder(`${providerID}/${modelID}`), modelID];
-    const colon = modelID.lastIndexOf(":");
-    if (colon > 0) {
-        const bareModel = modelID.slice(0, colon);
-        candidates.push(...modelRefLookupOrder(`${providerID}/${bareModel}`), bareModel);
-    }
-    return [...new Set(candidates)];
-}
-
-function configuredOutputReserve(
-    config: OutputReserveConfig | undefined,
-    providerID: string,
-    modelID: string,
-): number | undefined {
-    if (typeof config === "number") {
-        return Number.isFinite(config) && config >= 0 ? config : undefined;
-    }
-    if (!config) return undefined;
-    for (const candidate of modelKeyLookupOrder(providerID, modelID)) {
-        const value = config[candidate];
-        if (typeof value === "number" && Number.isFinite(value) && value >= 0) return value;
-    }
-    return Number.isFinite(config.default) && config.default >= 0 ? config.default : undefined;
-}
-
 /** Convert the ratified tagged numeric union into the conservative scalar used by derivation. */
 export function scalarizeFact(value: WindowOverlayFactValue): number | undefined {
     if (value.kind === "stated") return isFinitePositive(value.value) ? value.value : undefined;
@@ -509,25 +484,46 @@ export function deriveWindowGeometry(
               : (PROVIDER_GEOMETRY[providerID] ?? "shared_upfront");
     const geometryOverride = geometryFact?.kind === "stated" ? geometryFact.value : undefined;
 
+    const preCarvedInput =
+        isFinitePositive(input) && (!isFinitePositive(softContext) || input < softContext);
+    const outputReserveOverride =
+        typeof options.outputReserveOverride === "number" &&
+        Number.isFinite(options.outputReserveOverride) &&
+        options.outputReserveOverride >= 0
+            ? options.outputReserveOverride
+            : undefined;
+    let derivationWindow = softContext ?? input;
     let usableSoft: number;
     let softReserve = 0;
     let reserveSource: WindowReserveSource = "none";
-    if (isFinitePositive(input) && (!isFinitePositive(softContext) || input < softContext)) {
+    if (outputReserveOverride !== undefined) {
+        // An explicit user reserve owns the usable-window carve. When the
+        // provider also publishes a smaller input cap, use that cap as the
+        // window; treating the cap as final would silently ignore the config.
+        const reserveWindow = preCarvedInput ? input : (softContext ?? input);
+        if (!isFinitePositive(reserveWindow)) return undefined;
+        derivationWindow = reserveWindow;
+        softReserve = outputReserveOverride;
+        reserveSource = "output_config";
+        const floor = Math.max(MIN_PLAUSIBLE_CONTEXT_LIMIT, reserveWindow * 0.5);
+        const flooredReserve = Math.min(softReserve, Math.max(0, reserveWindow - floor));
+        if (flooredReserve < softReserve) {
+            logGeometryClampOnce(
+                `soft-floor|${providerID}/${modelID}|${softReserve}|${flooredReserve}`,
+                `output reserve clamped by the half-window floor for ${providerID}/${modelID}: reserve ${softReserve} → ${flooredReserve}`,
+                options.log,
+            );
+        }
+        softReserve = flooredReserve;
+        usableSoft = Math.floor(reserveWindow - softReserve);
+    } else if (preCarvedInput) {
         usableSoft = input;
         if (isFinitePositive(softContext)) {
             softReserve = Math.max(0, softContext - input);
             reserveSource = "output_catalog";
         }
     } else if (isFinitePositive(softContext)) {
-        const configuredReserve = configuredOutputReserve(
-            options.reserveConfig,
-            providerID,
-            modelID,
-        );
-        if (configuredReserve !== undefined) {
-            softReserve = configuredReserve;
-            reserveSource = "output_config";
-        } else if (
+        if (
             geometry === "separate" &&
             (options.overlay === undefined ||
                 options.harness === "pi" ||
@@ -591,13 +587,14 @@ export function deriveWindowGeometry(
         usableHard = usableSoft;
     }
 
+    const resolvedWindow = derivationWindow ?? usableSoft;
     return {
         usableSoft,
         usableHard,
         geometry,
         derivation: {
-            window: Math.floor(softContext ?? usableSoft),
-            reserve: Math.floor(Math.max(0, (softContext ?? usableSoft) - usableSoft)),
+            window: Math.floor(resolvedWindow),
+            reserve: Math.floor(Math.max(0, resolvedWindow - usableSoft)),
             reserveSource,
             geometry,
         },

package/src/tui/index.tsx

@@ -11,6 +11,7 @@ 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 { formatTailHygiene } from "../shared/tail-hygiene-status"
 import { formatWindowDerivationLine } from "../shared/window-geometry"
 import { compactionOffSidebarRows, nativeCompactionContextLabel } from "./compaction-off"
 import { isCompactionEnabled } from "../config/agent-disable"
@@ -202,7 +203,7 @@ const StatusDialog = (props: { api: TuiPluginApi; s: StatusDetail }) => {
             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 })
+            segs.push({ label: "Conversation*", tokens: d.conversationTokens, color: COLORS.conversation })
         if (d.toolCallTokens > 0)
             segs.push({ label: "Tool Calls", tokens: d.toolCallTokens, color: COLORS.toolCalls })
         if (d.toolDefinitionTokens > 0)
@@ -271,6 +272,15 @@ const StatusDialog = (props: { api: TuiPluginApi; s: StatusDetail }) => {
                         </box>
                     )
                 })}
+                <text fg={t().textMuted}>* Conversation includes Reasoning; hygiene excludes it</text>
+                {s().tailHygiene !== undefined && (
+                    <R
+                        t={t()}
+                        l="Hygiene"
+                        v={formatTailHygiene(s().tailHygiene!)}
+                        fg={s().tailHygiene!.evaluable ? t().accent : t().warning}
+                    />
+                )}
             </box>
 
             {/* Recomp / session-upgrade live progress (full width, only while
@@ -346,7 +356,7 @@ const StatusDialog = (props: { api: TuiPluginApi; s: StatusDetail }) => {
                             </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="Remaining" v={s().cacheExpired ? "expired" : s().cacheNeverExpires ? "never (MC never assumes expiry — external cache-keep)" : `${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>

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

@@ -5,6 +5,7 @@ import packageJson from "../../../package.json"
 import { badgeTextColor } from '../badge-contrast';
 import { loadSidebarSnapshot, type SidebarSnapshot } from "../data/context-db"
 import { formatThresholdPercent } from "../../shared/format-threshold"
+import { formatTailHygiene } from "../../shared/tail-hygiene-status"
 import { compactionOffSidebarRows, nativeCompactionContextLabel } from "../compaction-off"
 import {
     computeEffectiveOrder,
@@ -239,7 +240,7 @@ const TokenBreakdown = (props: {
             key: "conv",
             tokens: s.conversationTokens,
             color: COLORS.conversation,
-            label: "Conversation",
+            label: "Conversation*",
         })
 
         // Tool Calls = tool_use/tool_result/tool/tool-invocation parts in messages
@@ -320,6 +321,7 @@ const TokenBreakdown = (props: {
                             </box>
                         )
                     })}
+                    <text fg={props.theme.textMuted}>* includes Reasoning; hygiene excludes it</text>
                 </box>
             )}
         </box>
@@ -787,16 +789,26 @@ const SidebarContent = (props: {
                                     <b>{s()!.usagePercentage.toFixed(1)}%</b> / {formatThresholdPercent(s()!.executeThreshold)}%{s()!.executeThresholdClamped ? "*" : ""}
                                 </text>
                             )}
-                            {/* Right: absolute token usage vs the model's
-                                full context window (separate from the
-                                execute threshold so users still know how
-                                much headroom remains beyond compaction). */}
+                            {/* Right: absolute token usage against the usable
+                                scheduler window — the same denominator as the
+                                percentage and nudge/trigger scheduling. */}
                             <text fg={contextSummaryColor()}>
                                 {compactTokens(s()!.inputTokens)} / {compactTokens(s()!.contextLimit)}
                             </text>
                         </box>
                     )}
                     <TokenBreakdown theme={props.theme} snapshot={s()!} collapsed={collapsed()} />
+                    {!collapsed() && (
+                        <text fg={props.theme.textMuted}>Conversation includes reasoning estimates; hygiene excludes reasoning.</text>
+                    )}
+                    {s()!.tailHygiene !== undefined && (
+                        <StatRow
+                            theme={props.theme}
+                            label="Hygiene"
+                            value={formatTailHygiene(s()!.tailHygiene!)}
+                            warning={!s()!.tailHygiene!.evaluable}
+                        />
+                    )}
                 </box>
             )}
 

package/src/tui/tui-compiled-runtime-imports.test.ts

@@ -49,6 +49,9 @@ describe("compiled TUI runtime imports", () => {
      *  Built from the shared list so the test cannot cover fewer modules than the
      *  build rewrites. */
     async function loadExportSets(): Promise<Record<string, Set<string>>> {
+        // @opentui/core/testing subclasses a core export during module initialization;
+        // warm core before the parallel imports so Bun cannot expose its TDZ.
+        await import("@opentui/core");
         const entries = await Promise.all(
             TUI_RUNTIME_SPECIFIERS.map(
                 async (specifier) =>