@cortexkit/opencode-magic-context 0.37.0 → 0.38.0

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

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>
             )}