@monotykamary/pi-vcc 0.3.16 → 0.3.17

package/npm-shrinkwrap.json

@@ -1,12 +1,12 @@
 {
   "name": "@monotykamary/pi-vcc",
-  "version": "0.3.15",
+  "version": "0.3.17",
   "lockfileVersion": 3,
   "requires": true,
   "packages": {
     "": {
       "name": "@monotykamary/pi-vcc",
-      "version": "0.3.15",
+      "version": "0.3.17",
       "devDependencies": {
         "knip": "6.14.1",
         "typescript": "6.0.3"

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@monotykamary/pi-vcc",
-  "version": "0.3.16",
+  "version": "0.3.17",
   "description": "Algorithmic conversation compactor for pi - transcript-preserving structured summaries, no LLM calls",
   "main": "index.ts",
   "keywords": [

package/src/hooks/before-compact.ts

@@ -1,8 +1,7 @@
 import type { ExtensionAPI } from "@earendil-works/pi-coding-agent";
 import { writeFileSync } from "fs";
 import { compile, type CompileInput } from "../core/summarize";
-import { loadSettings, getModelThreshold, resolveReserveTokens, type PiVccSettings } from "../core/settings";
-import { isProactiveTriggerActive } from "./proactive-threshold";
+import { loadSettings, type PiVccSettings } from "../core/settings";
 import { triggerInvisibleContinue } from "../core/invisible-continue";
 import type { PiVccCompactionDetails } from "../details";
 
@@ -279,34 +278,23 @@ export const registerBeforeCompactHook = (pi: ExtensionAPI) => {
     const { preparation, branchEntries, customInstructions } = event;
     const settings = loadSettings();
 
-    // Per-model threshold check — applies regardless of which compactor handles
-    // the actual summary. When pi-core's global threshold triggers compaction
-    // but the current model's per-model threshold hasn't been crossed yet,
-    // cancel to avoid compacting prematurely.
+    // Per-model threshold guard was previously applied here, cancelling
+    // compaction when context was below the per-model threshold. This
+    // blocked manual /compact from working because session_before_compact
+    // carries no "reason" field — manual and auto compactions are
+    // indistinguishable (both have customInstructions: undefined).
     //
-    // This is NOT applied to explicit /pi-vcc commands — if the user asked
-    // for a compaction, honor it.
+    // The per-model threshold is now served entirely by the proactive
+    // trigger (in proactive-threshold.ts), which fires on agent_end /
+    // model_select when the per-model threshold is crossed. This correctly
+    // compacts earlier than pi-core's global threshold without needing to
+    // cancel any compaction here.
+    //
+    // If pi-core's global threshold fires before the per-model threshold
+    // is crossed, the compaction proceeds — slightly premature from the
+    // per-model threshold's perspective, but this is preferable to blocking
+    // an explicit user action (/compact).
     const isPiVcc = customInstructions === PI_VCC_COMPACT_INSTRUCTION;
-    if (!isPiVcc && !isProactiveTriggerActive()) {
-      const threshold = getModelThreshold(settings, ctx.model);
-      if (threshold) {
-        const contextWindow = ctx.model?.contextWindow ?? 0;
-        const reserve = resolveReserveTokens(threshold, contextWindow);
-        if (reserve != null && contextWindow > 0) {
-          const effectiveThreshold = contextWindow - reserve;
-          if (preparation.tokensBefore <= effectiveThreshold) {
-            try {
-              const pct = Math.round((preparation.tokensBefore / contextWindow) * 100);
-              ctx?.ui?.notify?.(
-                `pi-vcc: Skipped compaction — ${pct}% of context window used (threshold: ${formatTokens(effectiveThreshold)} tok)`,
-                "info",
-              );
-            } catch {}
-            return { cancel: true };
-          }
-        }
-      }
-    }
 
     // Always handle explicit /pi-vcc marker.
     // Otherwise, only handle when user opted in via settings.

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

@@ -19,7 +19,7 @@ afterAll(() => {
 });
 
 function createMockPi(model?: { id: string; provider?: string; contextWindow?: number }) {
-  let handler: ((event: any, ctx: any) => any) | undefined;
+  const handlers: Record<string, ((e: any, c: any) => any)[]> = {};
   const notifyCalls: Array<{ msg: string; level: string }> = [];
   const ctx = {
     hasUI: true,
@@ -30,15 +30,19 @@ function createMockPi(model?: { id: string; provider?: string; contextWindow?: n
       },
     },
   } 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,
+  const pi = {
+    on: (eventName: string, h: (e: any, c: any) => any) => {
+      if (!handlers[eventName]) handlers[eventName] = [];
+      handlers[eventName].push(h);
+    },
+  } as any;
+  const emit = (eventName: string, event: any = {}) => {
+    const hs = handlers[eventName] ?? [];
+    let result: any;
+    for (const h of hs) result = h(event, ctx);
+    return result;
   };
+  return { pi, ctx, emit, notifyCalls };
 }
 
 function setConfig(cfg: Record<string, unknown>) {
@@ -70,7 +74,12 @@ describe("session_before_compact: per-model threshold", () => {
     if (existsSync(CONFIG_PATH)) unlinkSync(CONFIG_PATH);
   });
 
-  test("cancels when context is below per-model threshold (provider/modelId)", () => {
+  test("compaction proceeds when context is below per-model threshold", () => {
+    // The threshold guard was removed because session_before_compact carries no
+    // reason field — manual /compact and auto-compaction are indistinguishable.
+    // The proactive trigger handles compacting earlier than pi-core's global
+    // threshold; this hook no longer blocks compaction that arrives before the
+    // per-model threshold.
     setConfig({
       debug: false,
       overrideDefaultCompaction: true,
@@ -78,27 +87,27 @@ describe("session_before_compact: per-model threshold", () => {
         "neuralwatt/GLM-5.1": { reserveTokens: 32768 },
       },
     });
-    const { pi, invoke, notifyCalls } = createMockPi({
+    const { pi, ctx, emit } = createMockPi({
       id: "GLM-5.1",
       provider: "neuralwatt",
       contextWindow: 200000,
     });
     registerBeforeCompactHook(pi);
 
-    // 100k tokens < 200k - 32768 = 167232 → below threshold
+    // 100k tokens < 200k - 32768 = 167232 → below threshold, but proceeds
     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");
+    const result = emit("session_before_compact", makeEvent(entries, undefined, 100000));
+    // No longer cancelled — threshold guard removed
+    expect(result.cancel).toBeUndefined();
+    expect(result.compaction).toBeDefined();
   });
 
-  test("allows compaction when context exceeds per-model threshold", () => {
+  test("compaction proceeds when context exceeds per-model threshold", () => {
     setConfig({
       debug: false,
       overrideDefaultCompaction: true,
@@ -106,7 +115,7 @@ describe("session_before_compact: per-model threshold", () => {
         "neuralwatt/GLM-5.1": { reserveTokens: 32768 },
       },
     });
-    const { pi, invoke } = createMockPi({
+    const { pi, ctx, emit } = createMockPi({
       id: "GLM-5.1",
       provider: "neuralwatt",
       contextWindow: 200000,
@@ -120,64 +129,38 @@ describe("session_before_compact: per-model threshold", () => {
       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
+    const result = emit("session_before_compact", makeEvent(entries, undefined, 180000));
     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", () => {
+  test("compaction proceeds with globalThreshold compactPercent", () => {
     // compactPercent: 65 → reserve = 128000 * 0.35 = 44800 → threshold = 83200
     setConfig({
       debug: false,
       overrideDefaultCompaction: true,
       globalThreshold: { compactPercent: 65 },
     });
-    const { pi, invoke } = createMockPi({
+    const { pi, ctx, emit } = createMockPi({
       id: "some-model",
       provider: "some-provider",
       contextWindow: 128000,
     });
     registerBeforeCompactHook(pi);
 
-    // 100k tokens > 83200 → above threshold
+    // 50k tokens < 83200 → below threshold, but proceeds
     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));
+    const result = emit("session_before_compact", makeEvent(entries, undefined, 50000));
     expect(result.cancel).toBeUndefined();
     expect(result.compaction).toBeDefined();
   });
 
-  test("cancels when context is below modelThreshold with compactPercent", () => {
+  test("compaction proceeds with modelThreshold compactPercent", () => {
     // compactPercent: 80 → reserve = 200000 * 0.20 = 40000 → threshold = 160000
     setConfig({
       debug: false,
@@ -186,68 +169,48 @@ describe("session_before_compact: per-model threshold", () => {
         "neuralwatt/GLM-5.1": { compactPercent: 80 },
       },
     });
-    const { pi, invoke } = createMockPi({
+    const { pi, ctx, emit } = createMockPi({
       id: "GLM-5.1",
       provider: "neuralwatt",
       contextWindow: 200000,
     });
     registerBeforeCompactHook(pi);
 
-    // 100k tokens < 160000 → below threshold
+    // 100k tokens < 160000 → below threshold, but proceeds
     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 });
+    const result = emit("session_before_compact", makeEvent(entries, undefined, 100000));
+    expect(result.cancel).toBeUndefined();
+    expect(result.compaction).toBeDefined();
   });
 
-  test("cancels when context is below defaultThreshold", () => {
+  test("compaction proceeds with defaultThreshold", () => {
     setConfig({
       debug: false,
       overrideDefaultCompaction: true,
       defaultThreshold: { reserveTokens: 16384 },
     });
-    const { pi, invoke } = createMockPi({
+    const { pi, ctx, emit } = createMockPi({
       id: "some-model",
       provider: "some-provider",
       contextWindow: 128000,
     });
     registerBeforeCompactHook(pi);
 
-    // 50k tokens < 128k - 16384 = 111616 → below threshold
+    // 50k tokens < 128k - 16384 = 111616 → below threshold, but proceeds
     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 });
+    const result = emit("session_before_compact", makeEvent(entries, undefined, 50000));
+    expect(result.cancel).toBeUndefined();
+    expect(result.compaction).toBeDefined();
   });
 
   test("does NOT cancel on /pi-vcc even when below threshold", () => {
@@ -258,51 +221,48 @@ describe("session_before_compact: per-model threshold", () => {
         "neuralwatt/GLM-5.1": { reserveTokens: 32768 },
       },
     });
-    const { pi, invoke } = createMockPi({
+    const { pi, ctx, emit } = createMockPi({
       id: "GLM-5.1",
       provider: "neuralwatt",
       contextWindow: 200000,
     });
     registerBeforeCompactHook(pi);
 
-    // Below threshold, but explicit /pi-vcc command — should NOT cancel
+    // Below threshold, but explicit /pi-vcc command
     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
+    const result = emit("session_before_compact", makeEvent(entries, PI_VCC_COMPACT_INSTRUCTION, 100000));
     expect(result.cancel).toBeUndefined();
     expect(result.compaction).toBeDefined();
   });
 
-  test("does not cancel when no modelThresholds configured", () => {
+  test("compaction proceeds when no modelThresholds configured", () => {
     setConfig({
       debug: false,
       overrideDefaultCompaction: true,
     });
-    const { pi, invoke } = createMockPi({
+    const { pi, ctx, emit } = 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)
+    const result = emit("session_before_compact", makeEvent(entries, undefined, 100000));
     expect(result.cancel === true).toBe(false);
   });
 
-  test("does not cancel when model is undefined", () => {
+  test("compaction proceeds when model is undefined", () => {
     setConfig({
       debug: false,
       overrideDefaultCompaction: true,
@@ -310,8 +270,7 @@ describe("session_before_compact: per-model threshold", () => {
         "GLM-5.1": { reserveTokens: 32768 },
       },
     });
-    // No model provided — ctx.model is undefined
-    const { pi, invoke } = createMockPi(undefined);
+    const { pi, ctx, emit } = createMockPi(undefined);
     registerBeforeCompactHook(pi);
 
     const entries = [
@@ -320,12 +279,11 @@ describe("session_before_compact: per-model threshold", () => {
       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
+    const result = emit("session_before_compact", makeEvent(entries, undefined, 100000));
     expect(result.cancel === true).toBe(false);
   });
 
-  test("threshold check also applies when overrideDefaultCompaction is false", () => {
+  test("compaction proceeds with overrideDefaultCompaction false", () => {
     setConfig({
       debug: false,
       overrideDefaultCompaction: false,
@@ -333,45 +291,21 @@ describe("session_before_compact: per-model threshold", () => {
         "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({
+    const { pi, ctx, emit } = createMockPi({
       id: "GLM-5.1",
       provider: "neuralwatt",
       contextWindow: 200000,
     });
     registerBeforeCompactHook(pi);
 
-    // Should match on modelId-only key
+    // Below threshold, overrideDefaultCompaction: false → pi-vcc doesn't
+    // handle the summary, but also doesn't cancel (threshold guard removed)
     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 });
+    const result = emit("session_before_compact", makeEvent(entries, undefined, 100000));
+    // Not cancelled — returns undefined (pi-vcc doesn't handle it)
+    expect(result).toBeUndefined();
   });
 });

package/tests/threshold-integration.test.ts

@@ -5,9 +5,10 @@
  * - When proactive trigger calls ctx.compact(), session_before_compact
  *   must NOT cancel the compaction even if tokensBefore differs from
  *   getContextUsage().
- * - When the global threshold triggers compaction but the model can
- *   handle more (per-model threshold not crossed), session_before_compact
- *   must cancel.
+ * - The per-model threshold guard was removed from session_before_compact
+ *   because the event carries no "reason" field — manual /compact and
+ *   auto-compaction are indistinguishable. The proactive trigger handles
+ *   the "compact earlier than pi-core" direction.
  */
 import { describe, test, expect, afterEach, beforeAll, afterAll } from "bun:test";
 import { existsSync, unlinkSync, writeFileSync, mkdtempSync, rmSync } from "fs";
@@ -100,11 +101,6 @@ describe("integration: proactive trigger + before-compact", () => {
   });
 
   test("proactive trigger then before-compact: does NOT cancel when proactiveTriggerActive", () => {
-    // Scenario: agent_end fires, getContextUsage says 110k tokens,
-    // per-model threshold is 95232 (128k - 32768). Proactive triggers compact.
-    // Then session_before_compact fires with tokensBefore = 94000
-    // (slightly different due to estimation).
-    // Without the proactiveTriggerActive guard, this would be cancelled.
     setConfig({
       debug: false,
       overrideDefaultCompaction: true,
@@ -119,13 +115,9 @@ describe("integration: proactive trigger + before-compact", () => {
     registerProactiveThresholdHook(pi);
     registerBeforeCompactHook(pi);
 
-    // Step 1: agent_end fires → proactive trigger calls ctx.compact()
     emit("agent_end", { type: "agent_end", messages: [] });
     expect(compactCalls).toHaveLength(1);
 
-    // Step 2: session_before_compact fires with tokensBefore = 94000
-    // (below the 95232 threshold — but we should NOT cancel because
-    // we ourselves triggered this compaction)
     const entries = [
       msg("m1", "user", "hello"),
       msg("m2", "assistant", "hi"),
@@ -136,14 +128,14 @@ describe("integration: proactive trigger + before-compact", () => {
 
     // Should NOT cancel — proactiveTriggerActive is true
     expect(result?.cancel).toBeUndefined();
-    // Should proceed with compaction (pi-vcc's own summary)
     expect(result?.compaction).toBeDefined();
   });
 
-  test("global trigger + before-compact: CANCELS when per-model threshold not crossed and no proactive trigger", () => {
-    // Scenario: pi-core's global threshold triggers compaction,
-    // but the model's per-model threshold hasn't been crossed.
-    // No proactive trigger was set — this is pi-core's own initiative.
+  test("global trigger + before-compact: compaction proceeds (threshold guard removed)", () => {
+    // Previously: pi-core's global threshold triggers compaction below the
+    // per-model threshold → cancelled. Now: the threshold guard is removed
+    // because manual /compact can't be distinguished from auto-compaction,
+    // so compaction proceeds.
     setConfig({
       debug: false,
       overrideDefaultCompaction: true,
@@ -151,24 +143,23 @@ describe("integration: proactive trigger + before-compact", () => {
         "neuralwatt/GLM-5.1": { reserveTokens: 32768 },
       },
     });
-    const { pi, ctx, emit, compactCalls } = createMockPi(
+    const { pi, ctx, emit } = createMockPi(
       { id: "GLM-5.1", provider: "neuralwatt", contextWindow: 128000 },
-      // getContextUsage says 80k — well below per-model threshold
       { tokens: 80000, contextWindow: 128000, percent: 63 },
     );
     registerProactiveThresholdHook(pi);
     registerBeforeCompactHook(pi);
 
-    // No agent_end fired (global threshold triggered this)
     const entries = [
       msg("m1", "user", "hello"),
       msg("m2", "assistant", "hi"),
       msg("m3", "user", "do work"),
       msg("m4", "assistant", "done"),
     ];
-    // tokensBefore = 90k < 95232 — should cancel
     const result = emit("session_before_compact", makeBeforeCompactEvent(entries, undefined, 90000));
-    expect(result).toEqual({ cancel: true });
+    // No longer cancelled — threshold guard removed
+    expect(result?.cancel).toBeUndefined();
+    expect(result?.compaction).toBeDefined();
   });
 
   test("proactiveTriggerActive is cleared after session_compact", () => {
@@ -186,16 +177,13 @@ describe("integration: proactive trigger + before-compact", () => {
     registerProactiveThresholdHook(pi);
     registerBeforeCompactHook(pi);
 
-    // Step 1: proactive trigger
     emit("agent_end", { type: "agent_end", messages: [] });
     expect(compactCalls).toHaveLength(1);
 
-    // Step 2: compaction completes
     emit("session_compact", { type: "session_compact", compactionEntry: {} });
 
-    // Step 3: now a subsequent session_before_compact (e.g., from pi-core
-    // also triggering) with tokensBelow below threshold — should CANCEL
-    // because proactiveTriggerActive was cleared by session_compact
+    // After session_compact, proactiveTriggerActive is cleared.
+    // But the threshold guard is also removed, so compaction proceeds.
     const entries = [
       msg("m1", "user", "hello"),
       msg("m2", "assistant", "hi"),
@@ -203,10 +191,11 @@ describe("integration: proactive trigger + before-compact", () => {
       msg("m4", "assistant", "done"),
     ];
     const result = emit("session_before_compact", makeBeforeCompactEvent(entries, undefined, 90000));
-    expect(result).toEqual({ cancel: true });
+    expect(result?.cancel).toBeUndefined();
+    expect(result?.compaction).toBeDefined();
   });
 
-  test("explicit /pi-vcc bypasses both the proactive flag AND threshold guard", () => {
+  test("explicit /pi-vcc proceeds regardless of context level", () => {
     setConfig({
       debug: false,
       overrideDefaultCompaction: true,
@@ -216,19 +205,18 @@ describe("integration: proactive trigger + before-compact", () => {
     });
     const { pi, ctx, emit } = createMockPi(
       { id: "GLM-5.1", provider: "neuralwatt", contextWindow: 128000 },
-      { tokens: 50000, contextWindow: 128000, percent: 39 },
+      { tokens: 5000, contextWindow: 128000, percent: 4 },
     );
     registerProactiveThresholdHook(pi);
     registerBeforeCompactHook(pi);
 
-    // Direct /pi-vcc with tokens well below threshold — should still proceed
     const entries = [
       msg("m1", "user", "hello"),
       msg("m2", "assistant", "hi"),
       msg("m3", "user", "do work"),
       msg("m4", "assistant", "done"),
     ];
-    const result = emit("session_before_compact", makeBeforeCompactEvent(entries, "__pi_vcc__", 50000));
+    const result = emit("session_before_compact", makeBeforeCompactEvent(entries, "__pi_vcc__", 5000));
     expect(result?.cancel).toBeUndefined();
     expect(result?.compaction).toBeDefined();
   });
@@ -241,10 +229,6 @@ describe("integration: proactive trigger + before-compact with overrideDefaultCo
   });
 
   test("proactive trigger fires, before-compact doesn't cancel, then pi-core handles summary", () => {
-    // When overrideDefaultCompaction: false, pi-vcc doesn't handle the summary
-    // for non-/pi-vcc compactions. But the threshold guard and proactive trigger
-    // should still work — the threshold guard controls WHEN compaction triggers,
-    // and pi-core handles the actual summary.
     setConfig({
       debug: false,
       overrideDefaultCompaction: false,
@@ -259,14 +243,9 @@ describe("integration: proactive trigger + before-compact with overrideDefaultCo
     registerProactiveThresholdHook(pi);
     registerBeforeCompactHook(pi);
 
-    // agent_end fires → proactive trigger
     emit("agent_end", { type: "agent_end", messages: [] });
     expect(compactCalls).toHaveLength(1);
 
-    // session_before_compact fires: threshold is crossed (tokensBefore = 110k
-    // > 95232), and our guard allows it because proactiveTriggerActive.
-    // Then overrideDefaultCompaction: false means pi-vcc returns undefined,
-    // letting pi-core handle the summary.
     const entries = [
       msg("m1", "user", "hello"),
       msg("m2", "assistant", "hi"),
@@ -275,11 +254,10 @@ describe("integration: proactive trigger + before-compact with overrideDefaultCo
     ];
     const result = emit("session_before_compact", makeBeforeCompactEvent(entries, undefined, 110000));
     // pi-vcc doesn't handle it (overrideDefaultCompaction: false) → returns undefined
-    // pi-core will handle the summary
     expect(result).toBeUndefined();
   });
 
-  test("threshold guard cancels even with overrideDefaultCompaction: false", () => {
+  test("compaction proceeds even with overrideDefaultCompaction: false (threshold guard removed)", () => {
     setConfig({
       debug: false,
       overrideDefaultCompaction: false,
@@ -294,15 +272,16 @@ describe("integration: proactive trigger + before-compact with overrideDefaultCo
     registerProactiveThresholdHook(pi);
     registerBeforeCompactHook(pi);
 
-    // No proactive trigger (context below threshold)
-    // Pi-core's global threshold triggers compaction, but per-model threshold
-    // says the model can handle more → cancel
+    // Previously this would cancel (threshold guard). Now: compaction
+    // proceeds (threshold guard removed).
     const entries = [
       msg("m1", "user", "hello"),
       msg("m2", "assistant", "hi"),
     ];
     const result = emit("session_before_compact", makeBeforeCompactEvent(entries, undefined, 80000));
-    expect(result).toEqual({ cancel: true });
+    // No longer cancelled — returns undefined (pi-vcc doesn't handle it,
+    // but doesn't block it either)
+    expect(result).toBeUndefined();
   });
 });
 
@@ -326,11 +305,9 @@ describe("integration: cooldown prevents double compaction", () => {
     );
     registerProactiveThresholdHook(pi);
 
-    // agent_end triggers compact and sets cooldown
     emit("agent_end", { type: "agent_end", messages: [] });
     expect(compactCalls).toHaveLength(1);
 
-    // model_select fires on same turn — blocked by cooldown
     emit("model_select", { type: "model_select" });
     expect(compactCalls).toHaveLength(1);
   });
@@ -352,7 +329,6 @@ describe("integration: cooldown prevents double compaction", () => {
     emit("agent_end", { type: "agent_end", messages: [] });
     expect(compactCalls).toHaveLength(1);
 
-    // No session_compact between — cooldown still active
     emit("agent_end", { type: "agent_end", messages: [] });
     expect(compactCalls).toHaveLength(1);
   });