@retaw106/mmc-oc 0.0.0-stage → 1.2.2

package/src/shared/user-facing-codes.test.ts

@@ -0,0 +1,82 @@
+import { describe, expect, test } from "bun:test";
+import { readFileSync } from "node:fs";
+import { resolve } from "node:path";
+import {
+    type CapabilityRefusal,
+    renderCapabilityRefusal,
+    renderUserFacingFailure,
+    USER_FACING_FAILURES,
+} from "./user-facing-codes";
+
+describe("user-facing failure codes", () => {
+    test("keeps the closed table unique and renders one calm sentence plus one action", () => {
+        const entries = Object.values(USER_FACING_FAILURES);
+        expect(new Set(entries.map((entry) => entry.code)).size).toBe(entries.length);
+        for (const [key, entry] of Object.entries(USER_FACING_FAILURES)) {
+            expect(entry.code).toMatch(/^MC-[CHDERSM]\d{2}$/);
+            expect(entry.sentence).toEndWith(".");
+            expect(entry.action).toEndWith(".");
+            expect(renderUserFacingFailure(key as keyof typeof USER_FACING_FAILURES)).toBe(
+                `${entry.sentence} ${entry.action} (${entry.code})`,
+            );
+        }
+    });
+
+    test("uses actionable command and configuration guidance in markdown and plain text", () => {
+        expect(renderUserFacingFailure("configuration_warning")).toContain(
+            "Fix the configuration warning shown in /mmc-status, then restart. (MC-S03)",
+        );
+        expect(renderUserFacingFailure("partial_history_unavailable")).toContain(
+            "Run /mmc-recomp without a range. (MC-C06)",
+        );
+    });
+
+    test("renders every capability refusal without internal vocabulary", () => {
+        const capabilities: CapabilityRefusal[] = [
+            "memory_write",
+            "memory_access",
+            "note_change",
+            "note_access",
+            "context_cleanup",
+            "partial_history",
+            "history_compression",
+            "context_service",
+        ];
+        for (const capability of capabilities) {
+            const rendered = renderCapabilityRefusal(capability);
+            expect(rendered).toMatch(/\(MC-C\d{2}\)$/);
+            for (const forbidden of ["authority", "MODULE", "drain", "facade", "changefeed"]) {
+                expect(rendered).not.toContain(forbidden);
+            }
+        }
+    });
+
+    test("source fence keeps raw exceptions out of user-facing reply builders", () => {
+        const builders = [
+            "hooks/magic-context/compartment-runner-validation.ts",
+            "hooks/magic-context/compartment-runner-recomp.ts",
+            "hooks/magic-context/compartment-runner-partial-recomp.ts",
+            "hooks/magic-context/recomp-orchestrator.ts",
+            "shared/status-detail-text.ts",
+            "../../pi-plugin/src/commands/ctx-status.ts",
+        ];
+        const allowedLogFragments = ["command notification delivery failed"];
+        const violations: string[] = [];
+        for (const relativePath of builders) {
+            const path = resolve(import.meta.dir, "..", relativePath);
+            const lines = readFileSync(path, "utf8").split("\n");
+            lines.forEach((line, index) => {
+                if (
+                    !/(error\.message|String\((?:err|error)\)|describeError\([^)]*\)\.brief)/.test(
+                        line,
+                    )
+                ) {
+                    return;
+                }
+                if (allowedLogFragments.some((fragment) => line.includes(fragment))) return;
+                violations.push(`${relativePath}:${index + 1}: ${line.trim()}`);
+            });
+        }
+        expect(violations).toEqual([]);
+    });
+});

package/src/shared/user-facing-codes.ts

@@ -0,0 +1,180 @@
+export const USER_FACING_FAILURES = {
+    historian_unavailable: {
+        code: "MC-H01",
+        sentence: "History compression could not finish this turn.",
+        action: "It will retry automatically.",
+    },
+    hidden_cleanup_unbound: {
+        code: "MC-H02",
+        sentence: "Some finished background sessions could not be removed from this host.",
+        action: "They are removed automatically the next time Magic Context runs inside a registered OpenCode service.",
+    },
+    historian_saved_history_misaligned: {
+        code: "MC-H03",
+        sentence:
+            "History compression is paused because this session's saved summaries no longer line up with its messages.",
+        action: "Run /mmc-recomp to rebuild them.",
+    },
+    history_boundary_unresolved: {
+        code: "MC-H04",
+        sentence:
+            "This request was not sent: the message that marks where this session's history summary ends is missing from the OpenCode store, and without it the request is larger than the model's context window.",
+        action: "Run /mmc-recomp to rebuild the history summary.",
+    },
+    history_over_window_unmanaged: {
+        code: "MC-H06",
+        sentence:
+            "This request was not sent: this session's history is larger than the model's context window, and Magic Context does not have a summary of it yet to send in its place.",
+        action: "Send your message again once history compression has caught up, or switch to a model with a larger context window.",
+    },
+    frozen_history_over_window: {
+        code: "MC-H07",
+        sentence:
+            "This request was not sent: the conversation is larger than the context window the provider reported, and the compressed history Magic Context has ready does not fit either.",
+        action: "Run /mmc-flush to compress it now, then send your message again.",
+    },
+    historian_window_too_small: {
+        code: "MC-H05",
+        sentence:
+            "History compression is paused because the history model's context window is too small for its instructions.",
+        action: "Set historian.model in magic-context.jsonc to a model with a larger context window.",
+    },
+    recomp_unavailable: {
+        code: "MC-R01",
+        sentence: "History compression could not be rebuilt.",
+        action: "Run /mmc-recomp again.",
+    },
+    status_unavailable: {
+        code: "MC-S01",
+        sentence: "Magic Context status is temporarily unavailable.",
+        action: "Retry /mmc-status in a moment.",
+    },
+    transform_update_failed: {
+        code: "MC-S02",
+        sentence: "The last context update did not finish.",
+        action: "Send another message to retry.",
+    },
+    transform_pass_degraded: {
+        code: "MC-S06",
+        sentence:
+            "This request was not sent: Magic Context could not finish preparing it, and without that preparation it could be far larger than the previous request.",
+        action: "Send your message again.",
+    },
+    configuration_warning: {
+        code: "MC-S03",
+        sentence: "Some configuration settings could not be applied.",
+        action: "Fix the configuration warning shown in /mmc-status, then restart.",
+    },
+    status_log_unavailable: {
+        code: "MC-S04",
+        sentence: "Some diagnostic details could not be saved.",
+        action: "Retry /mmc-status in a moment.",
+    },
+    memory_writes_paused: {
+        code: "MC-C01",
+        sentence: "Memory writes are paused while the engine syncs.",
+        action: "Retry in a moment.",
+    },
+    memory_access_unavailable: {
+        code: "MC-C02",
+        sentence: "Memory access is temporarily unavailable.",
+        action: "Retry in a moment.",
+    },
+    note_changes_paused: {
+        code: "MC-C03",
+        sentence: "Note changes are paused while the engine syncs.",
+        action: "Retry in a moment.",
+    },
+    note_access_unavailable: {
+        code: "MC-C04",
+        sentence: "Notes are temporarily unavailable.",
+        action: "Retry in a moment.",
+    },
+    context_cleanup_paused: {
+        code: "MC-C05",
+        sentence: "Context cleanup is paused while the engine syncs.",
+        action: "Retry in a moment.",
+    },
+    partial_history_unavailable: {
+        code: "MC-C06",
+        sentence: "Partial history compression is not available in the current mode.",
+        action: "Run /mmc-recomp without a range.",
+    },
+    history_compression_paused: {
+        code: "MC-C09",
+        sentence: "History compression is paused while the engine syncs.",
+        action: "Retry in a moment.",
+    },
+    history_compression_needs_message: {
+        code: "MC-C12",
+        sentence: "History compression has not seen this session since Magic Context reconnected.",
+        action: "Send a message in this session first, then run /mmc-wrapup again.",
+    },
+    context_service_unavailable: {
+        code: "MC-C10",
+        sentence: "Magic Context is temporarily unavailable.",
+        action: "Retry in a moment.",
+    },
+    compaction_marker_missing: {
+        code: "MC-C11",
+        sentence:
+            "The history boundary marker is missing from the OpenCode store, so requests carry the full session.",
+        action: "It is retried on every message; if this persists, run `/mmc-flush`.",
+    },
+    memory_mirror_stalled: {
+        code: "MC-M01",
+        sentence: "Memory synchronization stopped before the host mirror caught up.",
+        action: "Send another message to resume it, or run `ck doctor drain-authority`.",
+    },
+    memory_authority_mismatch: {
+        code: "MC-M02",
+        sentence: "Memory authority is inconsistent between the host and module.",
+        action: "Run `ck doctor drain-authority` before changing Rust mode.",
+    },
+} as const;
+
+export type UserFacingFailureKey = keyof typeof USER_FACING_FAILURES;
+
+export type UserFacingTextStyle = "markdown" | "plain";
+
+export function renderUserFacingFailure(
+    key: UserFacingFailureKey,
+    style: UserFacingTextStyle = "markdown",
+): string {
+    const failure = USER_FACING_FAILURES[key];
+    const action = style === "plain" ? failure.action.replaceAll("`", "") : failure.action;
+    return `${failure.sentence} ${action} (${failure.code})`;
+}
+
+export function userFacingFailureCode(key: UserFacingFailureKey): string {
+    return USER_FACING_FAILURES[key].code;
+}
+
+export type CapabilityRefusal =
+    | "memory_write"
+    | "memory_access"
+    | "note_change"
+    | "note_access"
+    | "context_cleanup"
+    | "partial_history"
+    | "history_compression"
+    | "context_service";
+
+const CAPABILITY_FAILURES: Record<CapabilityRefusal, UserFacingFailureKey> = {
+    memory_write: "memory_writes_paused",
+    memory_access: "memory_access_unavailable",
+    note_change: "note_changes_paused",
+    note_access: "note_access_unavailable",
+    context_cleanup: "context_cleanup_paused",
+    partial_history: "partial_history_unavailable",
+    history_compression: "history_compression_paused",
+    context_service: "context_service_unavailable",
+};
+
+export function renderCapabilityRefusal(capability: CapabilityRefusal): string {
+    return renderUserFacingFailure(CAPABILITY_FAILURES[capability]);
+}
+
+export function capabilityRefusalCode(capability: CapabilityRefusal): string {
+    return userFacingFailureCode(CAPABILITY_FAILURES[capability]);
+}

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

@@ -0,0 +1,405 @@
+import { afterEach, describe, expect, test } from "bun:test";
+import { readFileSync, rmSync, writeFileSync } from "node:fs";
+import { tmpdir } from "node:os";
+import { join } from "node:path";
+import { resolveLimit, resolveOutputReserve } from "./models-dev-cache";
+import { createTestTempDirFromPath } from "./test-temp-dir";
+import {
+    applyProvenInputFloor,
+    deriveWindowGeometry,
+    formatCompactTokens,
+    formatWindowDerivationLine,
+    parseWindowOverlay,
+    placeholderFilteredOutput,
+    readWindowOverlayFile,
+    resolveWindowOverlayFacts,
+    scalarizeFact,
+    type WindowOverlay,
+    type WindowOverlayFact,
+} from "./window-geometry";
+
+const fixture = JSON.parse(
+    readFileSync(new URL("./__fixtures__/window-overlay.v1.json", import.meta.url), "utf8"),
+) as unknown;
+const parsedFixture = parseWindowOverlay(fixture).overlay as WindowOverlay;
+const tempDirs: string[] = [];
+
+function fact(
+    value: WindowOverlayFact["value"],
+    overrides: Partial<WindowOverlayFact> = {},
+): WindowOverlayFact {
+    return {
+        value,
+        grade: "measured",
+        units: "provider",
+        boundary: "Observed",
+        source_ref: "test",
+        observed_at: "2026-08-13T00:00:00Z",
+        ...overrides,
+    };
+}
+
+function overlay(
+    provider: string,
+    model: string,
+    facts: Record<string, WindowOverlayFact>,
+): WindowOverlay {
+    return {
+        schema: "fusiform-window-overlay/v1",
+        generated_at: "2026-08-13T00:00:00Z",
+        minted_provider_ids: [],
+        cells: [{ provider_id: provider, model_id: model, facts }],
+    };
+}
+
+afterEach(() => {
+    for (const path of tempDirs.splice(0)) rmSync(path, { recursive: true, force: true });
+});
+
+describe("Fusiform overlay v1", () => {
+    test("scalarizes every tagged union conservatively", () => {
+        expect(scalarizeFact({ kind: "stated", value: 272_000 })).toBe(272_000);
+        expect(scalarizeFact({ kind: "bracket", at_least: 340_000, below: 372_001 })).toBe(340_000);
+        expect(scalarizeFact({ kind: "bracket", below: 372_001 })).toBeUndefined();
+        expect(scalarizeFact({ kind: "unknown", why: "never_measured" })).toBeUndefined();
+    });
+
+    test("preserves a half-open bracket and derives exactly from at_least", () => {
+        const halfOpen = parseWindowOverlay({
+            schema: "fusiform-window-overlay/v1",
+            generated_at: "2026-08-13T00:00:00Z",
+            minted_provider_ids: [],
+            cells: [
+                {
+                    provider_id: "openai-chatgpt-oauth",
+                    model_id: "gpt-5.6-sol",
+                    facts: {
+                        "window.advertised": fact({ kind: "stated", value: 272_000 }),
+                        "window.enforced": fact({ kind: "bracket", at_least: 340_000 }),
+                    },
+                },
+            ],
+        }).overlay;
+        const parsedValue = halfOpen?.cells[0]?.facts["window.enforced"]?.value;
+        expect(parsedValue).toEqual({ kind: "bracket", at_least: 340_000 });
+        expect(parsedValue && "below" in parsedValue).toBe(false);
+        const halfOpenResult = deriveWindowGeometry(
+            "openai-chatgpt-oauth",
+            "gpt-5.6-sol",
+            { context: 272_000, output: 128_000 },
+            {
+                overlay: resolveWindowOverlayFacts("openai-chatgpt-oauth", "gpt-5.6-sol", halfOpen),
+            },
+        );
+        const statedResult = deriveWindowGeometry(
+            "openai-chatgpt-oauth",
+            "gpt-5.6-sol",
+            { context: 272_000, output: 128_000 },
+            {
+                overlay: resolveWindowOverlayFacts(
+                    "openai-chatgpt-oauth",
+                    "gpt-5.6-sol",
+                    overlay("openai-chatgpt-oauth", "gpt-5.6-sol", {
+                        "window.enforced": fact({ kind: "stated", value: 340_000 }),
+                    }),
+                ),
+            },
+        );
+        expect(halfOpenResult).toEqual(statedResult);
+    });
+
+    test("specific cells override wildcard facts per fact", () => {
+        const data: WindowOverlay = {
+            schema: "fusiform-window-overlay/v1",
+            generated_at: "2026-08-13T00:00:00Z",
+            minted_provider_ids: [],
+            cells: [
+                {
+                    provider_id: "ollama-cloud",
+                    model_id: "*",
+                    facts: {
+                        "output.enforced": fact({ kind: "stated", value: 65_536 }),
+                        geometry: fact({ kind: "stated", value: "shared_upfront" }),
+                    },
+                },
+                {
+                    provider_id: "ollama-cloud",
+                    model_id: "deepseek-v4",
+                    facts: {
+                        "output.enforced": fact({ kind: "stated", value: 32_000 }),
+                    },
+                },
+            ],
+        };
+        const facts = resolveWindowOverlayFacts("ollama-cloud", "deepseek-v4", data)?.facts;
+        expect(scalarizeFact(facts?.["output.enforced"]?.value as never)).toBe(32_000);
+        expect(facts?.geometry?.value).toEqual({ kind: "stated", value: "shared_upfront" });
+    });
+
+    test("refuses an unrecognized schema before considering familiar cells", () => {
+        const v2 = {
+            ...(fixture as Record<string, unknown>),
+            schema: "fusiform-window-overlay/v2",
+        };
+        const parsed = parseWindowOverlay(v2);
+        expect(parsed.overlay).toBeUndefined();
+        expect(parsed.refusal).toContain("unrecognized schema");
+    });
+
+    test("skips bad cells once and keeps valid cells", () => {
+        const badCell = {
+            provider_id: "bad",
+            model_id: "model",
+            facts: { "window.enforced": { value: { kind: "stated", value: 1_000_000 } } },
+        };
+        const parsed = parseWindowOverlay({
+            ...(fixture as Record<string, unknown>),
+            cells: [badCell, ...(fixture as { cells: unknown[] }).cells],
+        });
+        expect(parsed.badCells).toBe(1);
+        expect(parsed.overlay?.cells.length).toBe(parsedFixture.cells.length);
+    });
+
+    test("a missing file is silent and a bad file logs one summary", () => {
+        const dir = createTestTempDirFromPath(join(tmpdir(), "window-overlay-test-"));
+        tempDirs.push(dir);
+        const logs: string[] = [];
+        expect(
+            readWindowOverlayFile(join(dir, "missing.json"), (message) => logs.push(message)),
+        ).toBeUndefined();
+        expect(logs).toEqual([]);
+        const path = join(dir, "bad.json");
+        writeFileSync(path, JSON.stringify({ ...(fixture as object), schema: "v2" }));
+        expect(readWindowOverlayFile(path, (message) => logs.push(message))).toBeUndefined();
+        expect(logs).toHaveLength(1);
+    });
+});
+
+describe("window geometry", () => {
+    test("filters placeholders independently in both directions", () => {
+        expect(placeholderFilteredOutput(0, 1_000_000)).toBeUndefined();
+        expect(placeholderFilteredOutput(1_000_000, 1_000_000)).toBeUndefined();
+        expect(placeholderFilteredOutput(1_000_001, 1_000_000)).toBeUndefined();
+        expect(placeholderFilteredOutput(65_536, 1_000_000)).toBe(65_536);
+        expect(
+            deriveWindowGeometry("xai", "mixed", {
+                context: 500_000,
+                input: 300_000,
+                output: 500_000,
+            })?.usableSoft,
+        ).toBe(300_000);
+    });
+
+    test("fixture table yields the 65% execution bases from the spec", () => {
+        const cases = [
+            ["openai-chatgpt-oauth", "gpt-5.6", 272_000, 128_000, 200_200],
+            ["anthropic", "claude-opus-5", 1_000_000, 128_000, 629_200],
+            // Producer batch downgraded google's geometry to considered-unknown
+            // (Google's docs contradict the separate-quota reading), so the
+            // derivation demotes to shared_upfront and reserves OpenCode's
+            // actual request cap B = min(65_536, 32_000):
+            // floor(0.65 * (1_048_576 - 32_000)) — not the no-reserve 681_574.
+            ["google", "gemini-3.5-flash", 1_048_576, 65_536, 660_774],
+            ["xai", "grok-4.6", 500_000, 500_000, 304_200],
+            ["ollama-cloud", "deepseek-v4-flash", 1_048_576, 384_000, 660_774],
+            ["moonshotai", "kimi-k3", 1_048_576, 1_048_576, 660_774],
+        ] as const;
+        for (const [provider, model, context, output, expectedExecute] of cases) {
+            const result = deriveWindowGeometry(
+                provider,
+                model,
+                { context, output },
+                {
+                    overlay: resolveWindowOverlayFacts(provider, model, parsedFixture),
+                },
+            );
+            expect(Math.floor((result?.usableSoft ?? 0) * 0.65)).toBe(expectedExecute);
+        }
+    });
+
+    test("grok derives from geometry, window, and default output without an enforced output", () => {
+        const facts = resolveWindowOverlayFacts("xai", "grok-4.6", parsedFixture);
+        expect(facts?.facts["output.enforced"]).toBeUndefined();
+        const result = deriveWindowGeometry(
+            "xai",
+            "grok-4.6",
+            { context: 500_000, output: 500_000 },
+            { overlay: facts },
+        );
+        expect(result?.geometry).toBe("shared_truncating");
+        expect(result?.usableSoft).toBe(468_000);
+    });
+
+    test("kimi reserves its default output instead of placeholder advertised output", () => {
+        const result = deriveWindowGeometry(
+            "moonshotai",
+            "kimi-k3",
+            { context: 1_048_576, output: 1_048_576 },
+            {
+                overlay: resolveWindowOverlayFacts("moonshotai", "kimi-k3", parsedFixture),
+            },
+        );
+        expect(result?.derivation.reserve).toBe(32_000);
+        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 }),
+            "output.enforced": fact({ kind: "stated", value: 20_000 }),
+        });
+        const overlayOnly = deriveWindowGeometry(
+            "provider",
+            "model",
+            { context: 200_000, output: 10_000 },
+            { overlay: resolveWindowOverlayFacts("provider", "model", data) },
+        );
+        const hooked = deriveWindowGeometry(
+            "provider",
+            "model",
+            { context: 200_000, output: 10_000 },
+            {
+                overlay: resolveWindowOverlayFacts("provider", "model", data),
+                providerLimit: { context: 400_000, output: 30_000 },
+            },
+        );
+        expect(overlayOnly?.derivation.window).toBe(300_000);
+        expect(hooked?.derivation.window).toBe(400_000);
+        expect(hooked?.derivation.reserve).toBe(30_000);
+    });
+
+    test("keeps shared-upfront emergency headroom below the separate absolute wall", () => {
+        const result = deriveWindowGeometry(
+            "openai-codex",
+            "gpt-5.6-sol",
+            { context: 272_000, output: 128_000 },
+            { providerLimit: { context: 272_000 }, harness: "pi" },
+        );
+
+        expect(result?.usableSoft).toBe(204_000);
+        expect(result?.usableHard).toBe(204_000);
+        expect(result?.usableHard).toBeLessThan(result?.derivation.absoluteWall ?? 0);
+        expect(result?.derivation.absoluteWall).toBe(272_000);
+        expect((result?.derivation.absoluteWall ?? 0) - (result?.usableHard ?? 0)).toBe(
+            result?.derivation.reserve,
+        );
+        expect(result?.derivation.windowSource).toBe("provider");
+    });
+
+    test("bounds proof at trusted absolute walls but retains the static-catalog escape hatch", () => {
+        const trusted = deriveWindowGeometry(
+            "openai-codex",
+            "gpt-5.6-sol",
+            { context: 272_000, output: 128_000 },
+            { providerLimit: { context: 272_000 }, harness: "pi" },
+        );
+        expect(trusted).toBeDefined();
+        const raisedWithinWall = applyProvenInputFloor(trusted!, 255_834);
+        expect(raisedWithinWall.geometry.usableSoft).toBe(255_834);
+        expect(raisedWithinWall.geometry.usableHard).toBe(204_000);
+        const refused = applyProvenInputFloor(trusted!, 593_717);
+        expect(refused.refused).toEqual({ reading: 593_717, absoluteWall: 272_000 });
+        expect(refused.geometry.usableSoft).toBe(204_000);
+        expect(refused.geometry.usableHard).toBe(204_000);
+
+        const staticFallback = deriveWindowGeometry("custom", "model", { context: 30_000 });
+        expect(staticFallback).toBeDefined();
+        const escaped = applyProvenInputFloor(staticFallback!, 90_000);
+        expect(escaped.refused).toBeUndefined();
+        expect(escaped.geometry.usableSoft).toBe(90_000);
+        expect(escaped.geometry.usableHard).toBe(90_000);
+        expect(escaped.geometry.derivation.absoluteWall).toBe(90_000);
+    });
+
+    test("clamps an inversion and logs it", () => {
+        const logs: string[] = [];
+        const result = deriveWindowGeometry(
+            "provider",
+            "model",
+            { context: 200_000, input: 190_000, output: 10_000 },
+            {
+                providerLimit: { context: 192_000, input: 190_000, output: 10_000 },
+                log: (message) => logs.push(message),
+            },
+        );
+        expect(result?.usableHard).toBe(result?.usableSoft);
+        expect(logs).toHaveLength(1);
+        expect(logs[0]).toContain("clamped");
+    });
+
+    test("keeps no-overlay usableSoft byte-identical to legacy resolveLimit", () => {
+        const corpus = [
+            ["openai", "real", { context: 200_000, output: 32_000 }],
+            ["openai", "zero", { context: 200_000, output: 0 }],
+            ["xai", "placeholder", { context: 500_000, output: 500_000 }],
+            ["google", "separate", { context: 1_000_000, output: 65_536 }],
+            ["anthropic", "input", { context: 1_000_000, input: 900_000, output: 128_000 }],
+        ] as const;
+        for (const [provider, model, limit] of corpus) {
+            const result = deriveWindowGeometry(provider, model, limit);
+            expect(result?.usableSoft).toBe(resolveLimit(limit, provider, model));
+        }
+    });
+
+    test("prints one line without the internal geometry tag or a second percentage", () => {
+        const result = deriveWindowGeometry("openai", "model", {
+            context: 204_000,
+            output: 30_600,
+        }) as NonNullable<ReturnType<typeof deriveWindowGeometry>>;
+        const line = formatWindowDerivationLine(105_900, result);
+        // The headline row above this line already carries the percentage, and
+        // the bracketed geometry mode is window-geometry's own vocabulary.
+        expect(line).not.toContain("%");
+        expect(line).not.toContain("[");
+        expect(line).not.toContain("—");
+        expect(line).toBe(
+            `105.9k / ${formatCompactTokens(result.usableSoft)} usable · window ${formatCompactTokens(result.derivation.window)} · ${formatCompactTokens(result.derivation.reserve)} output reserve`,
+        );
+    });
+
+    test("fits one line at the dialog's narrowest content width", () => {
+        // The narrowest dialog content width is 56 columns (an 88-column dialog
+        // less its padding); a longer line wraps onto a second row. The 1m
+        // window with a 128k output reserve is the shape the dialog shows.
+        const result = deriveWindowGeometry("openai", "model", {
+            context: 1_000_000,
+            output: 128_000,
+        }) as NonNullable<ReturnType<typeof deriveWindowGeometry>>;
+        const line = formatWindowDerivationLine(533_700, result);
+        expect(line).toBe("533.7k / 872k usable · window 1m · 128k output reserve");
+        expect(line.length).toBeLessThanOrEqual(56);
+    });
+});