@monotykamary/pi-vcc 0.3.16

package/tests/load-messages.test.ts

@@ -0,0 +1,49 @@
+import { describe, it, expect } from "bun:test";
+import { mkdtempSync, writeFileSync, rmSync } from "fs";
+import { tmpdir } from "os";
+import { join } from "path";
+import { loadAllMessages } from "../src/core/load-messages";
+
+describe("loadAllMessages", () => {
+  it("loads all message entries when no lineage filter is provided", () => {
+    const dir = mkdtempSync(join(tmpdir(), "pi-vcc-load-all-"));
+    const file = join(dir, "session.jsonl");
+    try {
+      const lines = [
+        JSON.stringify({ type: "session", id: "s1" }),
+        JSON.stringify({ type: "message", id: "m1", message: { role: "user", content: "u1" } }),
+        JSON.stringify({ type: "custom", id: "c1", customType: "x", data: {} }),
+        JSON.stringify({ type: "message", id: "m2", message: { role: "assistant", content: [{ type: "text", text: "a1" }] } }),
+        JSON.stringify({ type: "message", id: "m3", message: { role: "toolResult", toolName: "read", content: [{ type: "text", text: "ok" }] } }),
+      ];
+      writeFileSync(file, lines.join("\n") + "\n", "utf8");
+
+      const loaded = loadAllMessages(file, false);
+      expect(loaded.rendered).toHaveLength(3);
+      expect(loaded.rawMessages).toHaveLength(3);
+      expect(loaded.rendered.map((e) => e.index)).toEqual([0, 1, 2]);
+    } finally {
+      rmSync(dir, { recursive: true, force: true });
+    }
+  });
+
+  it("filters messages by allowed lineage entry IDs and preserves original message index", () => {
+    const dir = mkdtempSync(join(tmpdir(), "pi-vcc-load-filter-"));
+    const file = join(dir, "session.jsonl");
+    try {
+      const lines = [
+        JSON.stringify({ type: "message", id: "m1", message: { role: "user", content: "u1" } }),
+        JSON.stringify({ type: "message", id: "m2", message: { role: "assistant", content: [{ type: "text", text: "a1" }] } }),
+        JSON.stringify({ type: "message", id: "m3", message: { role: "user", content: "u2" } }),
+      ];
+      writeFileSync(file, lines.join("\n") + "\n", "utf8");
+
+      const loaded = loadAllMessages(file, false, new Set(["m2"]));
+      expect(loaded.rendered).toHaveLength(1);
+      expect(loaded.rawMessages).toHaveLength(1);
+      expect(loaded.rendered[0].index).toBe(1);
+    } finally {
+      rmSync(dir, { recursive: true, force: true });
+    }
+  });
+});

package/tests/model-threshold-hook.test.ts

@@ -0,0 +1,377 @@
+import { describe, test, expect, beforeEach, afterEach, beforeAll, afterAll } from "bun:test";
+import { existsSync, unlinkSync, writeFileSync, readFileSync, mkdtempSync, rmSync } from "fs";
+import { tmpdir } from "os";
+import { join } from "path";
+import { registerBeforeCompactHook, PI_VCC_COMPACT_INSTRUCTION } from "../src/hooks/before-compact";
+
+let tmpDir: string;
+let CONFIG_PATH: string;
+
+beforeAll(() => {
+  tmpDir = mkdtempSync(join(tmpdir(), "pi-vcc-test-"));
+  CONFIG_PATH = join(tmpDir, "pi-vcc-config.json");
+  process.env.PI_VCC_CONFIG_PATH = CONFIG_PATH;
+});
+
+afterAll(() => {
+  delete process.env.PI_VCC_CONFIG_PATH;
+  rmSync(tmpDir, { recursive: true, force: true });
+});
+
+function createMockPi(model?: { id: string; provider?: string; contextWindow?: number }) {
+  let handler: ((event: any, ctx: any) => any) | undefined;
+  const notifyCalls: Array<{ msg: string; level: string }> = [];
+  const ctx = {
+    hasUI: true,
+    model: model ?? undefined,
+    ui: {
+      notify: (msg: string, level: string) => {
+        notifyCalls.push({ msg, level });
+      },
+    },
+  } as any;
+  return {
+    pi: {
+      on: (eventName: string, h: (e: any, c: any) => any) => {
+        if (eventName === "session_before_compact") handler = h;
+      },
+    } as any,
+    invoke: (event: any) => handler!(event, ctx),
+    notifyCalls,
+  };
+}
+
+function setConfig(cfg: Record<string, unknown>) {
+  writeFileSync(CONFIG_PATH, JSON.stringify(cfg));
+}
+
+function makeEvent(branchEntries: any[], customInstructions?: string, tokensBefore = 100000) {
+  return {
+    type: "session_before_compact",
+    customInstructions,
+    branchEntries,
+    preparation: {
+      previousSummary: undefined,
+      fileOps: { read: [], written: [], edited: [] },
+      tokensBefore,
+    },
+    signal: new AbortController().signal,
+  };
+}
+
+const msg = (id: string, role: "user" | "assistant" | "toolResult", content = "x") => ({
+  id,
+  type: "message",
+  message: { role, content },
+});
+
+describe("session_before_compact: per-model threshold", () => {
+  afterEach(() => {
+    if (existsSync(CONFIG_PATH)) unlinkSync(CONFIG_PATH);
+  });
+
+  test("cancels when context is below per-model threshold (provider/modelId)", () => {
+    setConfig({
+      debug: false,
+      overrideDefaultCompaction: true,
+      modelThresholds: {
+        "neuralwatt/GLM-5.1": { reserveTokens: 32768 },
+      },
+    });
+    const { pi, invoke, notifyCalls } = createMockPi({
+      id: "GLM-5.1",
+      provider: "neuralwatt",
+      contextWindow: 200000,
+    });
+    registerBeforeCompactHook(pi);
+
+    // 100k tokens < 200k - 32768 = 167232 → below threshold
+    const entries = [
+      msg("m1", "user", "hello"),
+      msg("m2", "assistant", "hi"),
+      msg("m3", "user", "do work"),
+      msg("m4", "assistant", "done"),
+    ];
+    const result = invoke(makeEvent(entries, undefined, 100000));
+    expect(result).toEqual({ cancel: true });
+    expect(notifyCalls.length).toBeGreaterThanOrEqual(1);
+    expect(notifyCalls[0].msg).toContain("Skipped compaction");
+  });
+
+  test("allows compaction when context exceeds per-model threshold", () => {
+    setConfig({
+      debug: false,
+      overrideDefaultCompaction: true,
+      modelThresholds: {
+        "neuralwatt/GLM-5.1": { reserveTokens: 32768 },
+      },
+    });
+    const { pi, invoke } = createMockPi({
+      id: "GLM-5.1",
+      provider: "neuralwatt",
+      contextWindow: 200000,
+    });
+    registerBeforeCompactHook(pi);
+
+    // 180k tokens > 200k - 32768 = 167232 → above threshold
+    const entries = [
+      msg("m1", "user", "hello"),
+      msg("m2", "assistant", "hi"),
+      msg("m3", "user", "do work"),
+      msg("m4", "assistant", "done"),
+    ];
+    const result = invoke(makeEvent(entries, undefined, 180000));
+    // Not cancelled — pi-vcc proceeds with its own summary
+    expect(result.cancel).toBeUndefined();
+    expect(result.compaction).toBeDefined();
+  });
+
+  test("cancels when context is below globalThreshold with compactPercent", () => {
+    // compactPercent: 65 → reserve = 128000 * 0.35 = 44800 → threshold = 83200
+    setConfig({
+      debug: false,
+      overrideDefaultCompaction: true,
+      globalThreshold: { compactPercent: 65 },
+    });
+    const { pi, invoke } = createMockPi({
+      id: "some-model",
+      provider: "some-provider",
+      contextWindow: 128000,
+    });
+    registerBeforeCompactHook(pi);
+
+    // 50k tokens < 83200 → below threshold
+    const entries = [
+      msg("m1", "user", "hello"),
+      msg("m2", "assistant", "hi"),
+      msg("m3", "user", "do work"),
+      msg("m4", "assistant", "done"),
+    ];
+    const result = invoke(makeEvent(entries, undefined, 50000));
+    expect(result).toEqual({ cancel: true });
+  });
+
+  test("allows compaction when context exceeds globalThreshold with compactPercent", () => {
+    // compactPercent: 65 → reserve = 128000 * 0.35 = 44800 → threshold = 83200
+    setConfig({
+      debug: false,
+      overrideDefaultCompaction: true,
+      globalThreshold: { compactPercent: 65 },
+    });
+    const { pi, invoke } = createMockPi({
+      id: "some-model",
+      provider: "some-provider",
+      contextWindow: 128000,
+    });
+    registerBeforeCompactHook(pi);
+
+    // 100k tokens > 83200 → above threshold
+    const entries = [
+      msg("m1", "user", "hello"),
+      msg("m2", "assistant", "hi"),
+      msg("m3", "user", "do work"),
+      msg("m4", "assistant", "done"),
+    ];
+    const result = invoke(makeEvent(entries, undefined, 100000));
+    expect(result.cancel).toBeUndefined();
+    expect(result.compaction).toBeDefined();
+  });
+
+  test("cancels when context is below modelThreshold with compactPercent", () => {
+    // compactPercent: 80 → reserve = 200000 * 0.20 = 40000 → threshold = 160000
+    setConfig({
+      debug: false,
+      overrideDefaultCompaction: true,
+      modelThresholds: {
+        "neuralwatt/GLM-5.1": { compactPercent: 80 },
+      },
+    });
+    const { pi, invoke } = createMockPi({
+      id: "GLM-5.1",
+      provider: "neuralwatt",
+      contextWindow: 200000,
+    });
+    registerBeforeCompactHook(pi);
+
+    // 100k tokens < 160000 → below threshold
+    const entries = [
+      msg("m1", "user", "hello"),
+      msg("m2", "assistant", "hi"),
+      msg("m3", "user", "do work"),
+      msg("m4", "assistant", "done"),
+    ];
+    const result = invoke(makeEvent(entries, undefined, 100000));
+    expect(result).toEqual({ cancel: true });
+  });
+
+  test("globalThreshold with compactPercent falls back from defaultThreshold", () => {
+    setConfig({
+      debug: false,
+      overrideDefaultCompaction: true,
+      defaultThreshold: { reserveTokens: 16384 },
+    });
+    const { pi, invoke } = createMockPi({
+      id: "some-model",
+      provider: "some-provider",
+      contextWindow: 128000,
+    });
+    registerBeforeCompactHook(pi);
+
+    // 50k tokens < 128k - 16384 = 111616 → below threshold
+    const entries = [
+      msg("m1", "user", "hello"),
+      msg("m2", "assistant", "hi"),
+    ];
+    const result = invoke(makeEvent(entries, undefined, 50000));
+    expect(result).toEqual({ cancel: true });
+  });
+
+  test("cancels when context is below defaultThreshold", () => {
+    setConfig({
+      debug: false,
+      overrideDefaultCompaction: true,
+      defaultThreshold: { reserveTokens: 16384 },
+    });
+    const { pi, invoke } = createMockPi({
+      id: "some-model",
+      provider: "some-provider",
+      contextWindow: 128000,
+    });
+    registerBeforeCompactHook(pi);
+
+    // 50k tokens < 128k - 16384 = 111616 → below threshold
+    const entries = [
+      msg("m1", "user", "hello"),
+      msg("m2", "assistant", "hi"),
+      msg("m3", "user", "do work"),
+      msg("m4", "assistant", "done"),
+    ];
+    const result = invoke(makeEvent(entries, undefined, 50000));
+    expect(result).toEqual({ cancel: true });
+  });
+
+  test("does NOT cancel on /pi-vcc even when below threshold", () => {
+    setConfig({
+      debug: false,
+      overrideDefaultCompaction: true,
+      modelThresholds: {
+        "neuralwatt/GLM-5.1": { reserveTokens: 32768 },
+      },
+    });
+    const { pi, invoke } = createMockPi({
+      id: "GLM-5.1",
+      provider: "neuralwatt",
+      contextWindow: 200000,
+    });
+    registerBeforeCompactHook(pi);
+
+    // Below threshold, but explicit /pi-vcc command — should NOT cancel
+    const entries = [
+      msg("m1", "user", "hello"),
+      msg("m2", "assistant", "hi"),
+      msg("m3", "user", "do work"),
+      msg("m4", "assistant", "done"),
+    ];
+    const result = invoke(makeEvent(entries, PI_VCC_COMPACT_INSTRUCTION, 100000));
+    // Not cancelled — explicit /pi-vcc bypasses threshold check
+    expect(result.cancel).toBeUndefined();
+    expect(result.compaction).toBeDefined();
+  });
+
+  test("does not cancel when no modelThresholds configured", () => {
+    setConfig({
+      debug: false,
+      overrideDefaultCompaction: true,
+    });
+    const { pi, invoke } = createMockPi({
+      id: "GLM-5.1",
+      provider: "neuralwatt",
+      contextWindow: 200000,
+    });
+    registerBeforeCompactHook(pi);
+
+    // No modelThresholds → no threshold override → fall through to normal flow
+    const entries = [
+      msg("m1", "user", "hello"),
+      msg("m2", "assistant", "hi"),
+      msg("m3", "user", "do work"),
+      msg("m4", "assistant", "done"),
+    ];
+    const result = invoke(makeEvent(entries, undefined, 100000));
+    // Not cancelled by threshold check (may be cancelled by other logic)
+    expect(result.cancel === true).toBe(false);
+  });
+
+  test("does not cancel when model is undefined", () => {
+    setConfig({
+      debug: false,
+      overrideDefaultCompaction: true,
+      modelThresholds: {
+        "GLM-5.1": { reserveTokens: 32768 },
+      },
+    });
+    // No model provided — ctx.model is undefined
+    const { pi, invoke } = createMockPi(undefined);
+    registerBeforeCompactHook(pi);
+
+    const entries = [
+      msg("m1", "user", "hello"),
+      msg("m2", "assistant", "hi"),
+      msg("m3", "user", "do work"),
+      msg("m4", "assistant", "done"),
+    ];
+    const result = invoke(makeEvent(entries, undefined, 100000));
+    // No model → can't check threshold → fall through to normal flow
+    expect(result.cancel === true).toBe(false);
+  });
+
+  test("threshold check also applies when overrideDefaultCompaction is false", () => {
+    setConfig({
+      debug: false,
+      overrideDefaultCompaction: false,
+      modelThresholds: {
+        "neuralwatt/GLM-5.1": { reserveTokens: 32768 },
+      },
+    });
+    const { pi, invoke } = createMockPi({
+      id: "GLM-5.1",
+      provider: "neuralwatt",
+      contextWindow: 200000,
+    });
+    registerBeforeCompactHook(pi);
+
+    // Below threshold → cancel, even though pi-vcc wouldn't handle the summary
+    const entries = [
+      msg("m1", "user", "hello"),
+      msg("m2", "assistant", "hi"),
+    ];
+    const result = invoke(makeEvent(entries, undefined, 100000));
+    expect(result).toEqual({ cancel: true });
+  });
+
+  test("modelId-only key matches when provider/modelId does not", () => {
+    setConfig({
+      debug: false,
+      overrideDefaultCompaction: true,
+      modelThresholds: {
+        "GLM-5.1": { reserveTokens: 32768 },
+      },
+    });
+    const { pi, invoke } = createMockPi({
+      id: "GLM-5.1",
+      provider: "neuralwatt",
+      contextWindow: 200000,
+    });
+    registerBeforeCompactHook(pi);
+
+    // Should match on modelId-only key
+    const entries = [
+      msg("m1", "user", "hello"),
+      msg("m2", "assistant", "hi"),
+      msg("m3", "user", "do work"),
+      msg("m4", "assistant", "done"),
+    ];
+    const result = invoke(makeEvent(entries, undefined, 100000));
+    expect(result).toEqual({ cancel: true });
+  });
+});

package/tests/model-threshold.test.ts

@@ -0,0 +1,223 @@
+import { describe, test, expect } from "bun:test";
+import { getModelThreshold, resolveReserveTokens, type PiVccSettings, type ModelThreshold } from "../src/core/settings";
+
+const t = (reserveTokens: number, keepRecentTokens?: number): ModelThreshold => ({
+  reserveTokens,
+  ...(keepRecentTokens !== undefined ? { keepRecentTokens } : {}),
+});
+
+describe("getModelThreshold", () => {
+  test("returns undefined when no modelThresholds and no defaultThreshold", () => {
+    const settings: PiVccSettings = {
+      overrideDefaultCompaction: true,
+      debug: false,
+    };
+    expect(getModelThreshold(settings, { id: "GLM-5.1", provider: "neuralwatt" })).toBeUndefined();
+  });
+
+  test("returns undefined when model is undefined and no defaultThreshold", () => {
+    const settings: PiVccSettings = {
+      overrideDefaultCompaction: true,
+      debug: false,
+      modelThresholds: { "neuralwatt/GLM-5.1": t(32768) },
+    };
+    expect(getModelThreshold(settings, undefined)).toBeUndefined();
+  });
+
+  test("returns defaultThreshold when model doesn't match any key", () => {
+    const settings: PiVccSettings = {
+      overrideDefaultCompaction: true,
+      debug: false,
+      modelThresholds: { "neuralwatt/GLM-5.1": t(32768) },
+      defaultThreshold: t(8192),
+    };
+    expect(getModelThreshold(settings, { id: "other-model", provider: "other" })).toEqual(t(8192));
+  });
+
+  test("returns defaultThreshold when model is undefined", () => {
+    const settings: PiVccSettings = {
+      overrideDefaultCompaction: true,
+      debug: false,
+      defaultThreshold: t(8192),
+    };
+    expect(getModelThreshold(settings, undefined)).toEqual(t(8192));
+  });
+
+  test("matches on provider/modelId key", () => {
+    const threshold = t(32768, 40000);
+    const settings: PiVccSettings = {
+      overrideDefaultCompaction: true,
+      debug: false,
+      modelThresholds: {
+        "neuralwatt/zai-org/GLM-5.1-FP8": threshold,
+      },
+      defaultThreshold: t(8192),
+    };
+    expect(getModelThreshold(settings, { id: "zai-org/GLM-5.1-FP8", provider: "neuralwatt" })).toEqual(threshold);
+  });
+
+  test("matches on modelId-only key when provider/modelId not found", () => {
+    const threshold = t(16384);
+    const settings: PiVccSettings = {
+      overrideDefaultCompaction: true,
+      debug: false,
+      modelThresholds: {
+        "zai-org/GLM-5.1-FP8": threshold,
+      },
+      defaultThreshold: t(8192),
+    };
+    // provider/modelId doesn't match, but modelId does
+    expect(getModelThreshold(settings, { id: "zai-org/GLM-5.1-FP8", provider: "other-provider" })).toEqual(threshold);
+  });
+
+  test("provider/modelId takes precedence over modelId-only key", () => {
+    const providerThreshold = t(32768);
+    const modelIdThreshold = t(16384);
+    const settings: PiVccSettings = {
+      overrideDefaultCompaction: true,
+      debug: false,
+      modelThresholds: {
+        "neuralwatt/GLM-5.1": providerThreshold,
+        "GLM-5.1": modelIdThreshold,
+      },
+    };
+    expect(getModelThreshold(settings, { id: "GLM-5.1", provider: "neuralwatt" })).toEqual(providerThreshold);
+  });
+
+  test("falls through to modelId-only when provider is absent", () => {
+    const threshold = t(16384);
+    const settings: PiVccSettings = {
+      overrideDefaultCompaction: true,
+      debug: false,
+      modelThresholds: {
+        "GLM-5.1": threshold,
+      },
+    };
+    expect(getModelThreshold(settings, { id: "GLM-5.1" })).toEqual(threshold);
+  });
+
+  test("falls through to defaultThreshold when neither key matches", () => {
+    const settings: PiVccSettings = {
+      overrideDefaultCompaction: true,
+      debug: false,
+      modelThresholds: {
+        "neuralwatt/GLM-5.1": t(32768),
+      },
+      defaultThreshold: t(8192),
+    };
+    expect(getModelThreshold(settings, { id: "Kimi-K2.6", provider: "neuralwatt" })).toEqual(t(8192));
+  });
+
+  test("returns globalThreshold when model doesn't match any key", () => {
+    const threshold: ModelThreshold = { compactPercent: 65 };
+    const settings: PiVccSettings = {
+      overrideDefaultCompaction: true,
+      debug: false,
+      modelThresholds: { "neuralwatt/GLM-5.1": t(32768) },
+      globalThreshold: threshold,
+    };
+    expect(getModelThreshold(settings, { id: "other-model", provider: "other" })).toEqual(threshold);
+  });
+
+  test("globalThreshold takes precedence over defaultThreshold", () => {
+    const settings: PiVccSettings = {
+      overrideDefaultCompaction: true,
+      debug: false,
+      globalThreshold: t(65536),
+      defaultThreshold: t(8192),
+    };
+    expect(getModelThreshold(settings, { id: "unknown", provider: "other" })).toEqual(t(65536));
+  });
+
+  test("returns globalThreshold when model is undefined", () => {
+    const threshold: ModelThreshold = { compactPercent: 70 };
+    const settings: PiVccSettings = {
+      overrideDefaultCompaction: true,
+      debug: false,
+      globalThreshold: threshold,
+    };
+    expect(getModelThreshold(settings, undefined)).toEqual(threshold);
+  });
+
+  test("falls back to defaultThreshold when globalThreshold is not set", () => {
+    const settings: PiVccSettings = {
+      overrideDefaultCompaction: true,
+      debug: false,
+      defaultThreshold: t(8192),
+    };
+    expect(getModelThreshold(settings, { id: "unknown", provider: "other" })).toEqual(t(8192));
+  });
+
+  test("works with multiple modelThresholds entries", () => {
+    const settings: PiVccSettings = {
+      overrideDefaultCompaction: true,
+      debug: false,
+      modelThresholds: {
+        "neuralwatt/zai-org/GLM-5.1-FP8": t(32768),
+        "neuralwatt/moonshotai/Kimi-K2.6": t(65536),
+        "makora/deepseek-ai/DeepSeek-V4-Pro": t(32768),
+      },
+      defaultThreshold: t(16384),
+    };
+
+    expect(getModelThreshold(settings, { id: "zai-org/GLM-5.1-FP8", provider: "neuralwatt" })).toEqual(t(32768));
+    expect(getModelThreshold(settings, { id: "moonshotai/Kimi-K2.6", provider: "neuralwatt" })).toEqual(t(65536));
+    expect(getModelThreshold(settings, { id: "deepseek-ai/DeepSeek-V4-Pro", provider: "makora" })).toEqual(t(32768));
+    expect(getModelThreshold(settings, { id: "unknown-model", provider: "other" })).toEqual(t(16384));
+  });
+});
+
+describe("resolveReserveTokens", () => {
+  test("returns reserveTokens when set", () => {
+    expect(resolveReserveTokens({ reserveTokens: 32768 }, 128000)).toBe(32768);
+  });
+
+  test("returns undefined when neither reserveTokens nor compactPercent is set", () => {
+    expect(resolveReserveTokens({}, 128000)).toBeUndefined();
+  });
+
+  test("returns undefined when only keepRecentTokens is set", () => {
+    expect(resolveReserveTokens({ keepRecentTokens: 20000 }, 128000)).toBeUndefined();
+  });
+
+  test("computes reserveTokens from compactPercent", () => {
+    // compactPercent: 65 on 128k window → reserve = 128000 * (1 - 65/100) = 44800
+    expect(resolveReserveTokens({ compactPercent: 65 }, 128000)).toBe(44800);
+  });
+
+  test("compactPercent: 50 → reserve is exactly half", () => {
+    expect(resolveReserveTokens({ compactPercent: 50 }, 200000)).toBe(100000);
+  });
+
+  test("compactPercent: 80 → reserve is 20%", () => {
+    expect(resolveReserveTokens({ compactPercent: 80 }, 200000)).toBe(40000);
+  });
+
+  test("reserveTokens takes precedence over compactPercent", () => {
+    expect(resolveReserveTokens({ reserveTokens: 32768, compactPercent: 65 }, 128000)).toBe(32768);
+  });
+
+  test("returns undefined for compactPercent < 1", () => {
+    expect(resolveReserveTokens({ compactPercent: 0 }, 128000)).toBeUndefined();
+  });
+
+  test("returns undefined for compactPercent > 99", () => {
+    expect(resolveReserveTokens({ compactPercent: 100 }, 128000)).toBeUndefined();
+  });
+
+  test("returns undefined when contextWindow is 0", () => {
+    expect(resolveReserveTokens({ compactPercent: 65 }, 0)).toBeUndefined();
+  });
+
+  test("reserveTokens still works when contextWindow is 0", () => {
+       expect(resolveReserveTokens({ reserveTokens: 32768 }, 0)).toBe(32768);
+  });
+
+  test("compactPercent = 1 → reserve is 99% of contextWindow", () => {
+    expect(resolveReserveTokens({ compactPercent: 1 }, 128000)).toBe(126720);
+  });
+
+  test("compactPercent = 99 → reserve is 1% of contextWindow", () => {
+    expect(resolveReserveTokens({ compactPercent: 99 }, 128000)).toBe(1280);
+  });
+});