fix(trigger): projection only counts reasoning as droppable when the clearing path can drop it (#274)

Author: ualtinok

packages/pi-plugin/src/context-handler.ts

@@ -3842,6 +3842,9 @@ function maybeFireHistorian(args: {
 			}
 		}
 
+		// Pi's cleared thinking is safe to project for every provider: its
+		// serializers omit empty thinking blocks, unlike OpenCode's
+		// canonical-Anthropic-only empty-sentinel path.
 		const trigger = checkCompartmentTrigger(
 			db,
 			sessionId,
@@ -3859,6 +3862,7 @@ function maybeFireHistorian(args: {
 				return { messages, absoluteMessageCount: messages.length };
 			},
 			args.taggerFloor,
+			{ canClearReasoning: true },
 		);
 
 		if (!trigger.shouldFire) {

packages/plugin/src/hooks/magic-context/compartment-trigger.test.ts

@@ -469,6 +469,68 @@ describe("checkCompartmentTrigger", () => {
         expect(result).toEqual({ shouldFire: false });
     });
 
+    it("projects aged reasoning only when the provider can clear it from the wire", () => {
+        // Match issue #274's shape: at 36.8% usage, 70% of tagged bytes are
+        // aged reasoning. Counting it as reclaimable projects 11.0%, below the
+        // 16.2% post-drop target; a provider that cannot clear it must instead
+        // fire the historian at the real 36.8% pressure.
+        useTempDataHome("compartment-trigger-unavailable-reasoning-");
+        const sessionId = "ses-unavailable-reasoning";
+        createOpenCodeDb(sessionId, [
+            { id: "m-1", role: "user", text: "a ".repeat(3500) },
+            { id: "m-2", role: "assistant", text: "done" },
+            { id: "m-3", role: "user", text: "b ".repeat(3500) },
+            { id: "m-4", role: "assistant", text: "done" },
+            { id: "m-5", role: "user", text: "c ".repeat(3500) },
+            { id: "m-6", role: "assistant", text: "done" },
+            { id: "m-7", role: "user", text: "protected tail 1" },
+            { id: "m-8", role: "user", text: "protected tail 2" },
+            { id: "m-9", role: "user", text: "protected tail 3" },
+            { id: "m-10", role: "user", text: "protected tail 4" },
+            { id: "m-11", role: "user", text: "protected tail 5" },
+        ]);
+        const db = openDatabase();
+        // Total tagged bytes = 1,000; tag 1's 700 reasoning bytes are old
+        // enough for clearing because tag 51 establishes the age cutoff.
+        insertTag(db, sessionId, "m-1", "message", 299, 1, 700);
+        insertTag(db, sessionId, "m-11", "message", 1, 51);
+        const runTrigger = (reasoningProjection: {
+            providerID?: string;
+            canClearReasoning?: boolean;
+        }) =>
+            checkCompartmentTrigger(
+                db,
+                sessionId,
+                makeSessionMeta(sessionId, 36.8),
+                { percentage: 36.8, inputTokens: 736_000 },
+                36.8,
+                21.6,
+                6500,
+                50,
+                undefined,
+                undefined,
+                undefined,
+                undefined,
+                undefined,
+                reasoningProjection,
+            );
+
+        // Mutation direction: removing the provider gate would count the 700
+        // reasoning bytes, project 11.0%, and make this assertion fail.
+        expect(runTrigger({ providerID: "opencode" })).toMatchObject({
+            shouldFire: true,
+            reason: "projected_headroom",
+        });
+        // Anthropic safely clears reasoning through its empty-content sentinel,
+        // so the aged bytes stay projected as reclaimable and suppress this fire.
+        expect(runTrigger({ providerID: "anthropic" })).toEqual({ shouldFire: false });
+        // Pi clears typed thinking for every provider, so its explicit shared
+        // trigger capability retains the same projection on an OpenCode-like id.
+        expect(runTrigger({ providerID: "opencode", canClearReasoning: true })).toEqual({
+            shouldFire: false,
+        });
+    });
+
     it("does not force-fire at 80% when pending drops are enough to bring usage below target", () => {
         useTempDataHome("compartment-trigger-force-skip-");
         createOpenCodeDb("ses-force-skip", [

packages/plugin/src/hooks/magic-context/compartment-trigger.ts

@@ -31,6 +31,7 @@ import {
     type RawMessage,
 } from "./read-session-raw";
 import { estimateTrueRawMessageTokens } from "./read-session-true-raw-tokens";
+import { modelAcceptsEmptyContent } from "./sentinel";
 
 const PROACTIVE_TRIGGER_OFFSET_PERCENTAGE = 2;
 const POST_DROP_TARGET_RATIO = 0.75;
@@ -77,6 +78,16 @@ export interface InMemoryTailSource {
     absoluteMessageCount: number;
 }
 
+/**
+ * Wire capability for projecting reclaimable reasoning bytes. OpenCode derives
+ * this from the provider's empty-sentinel support; Pi overrides it because its
+ * serializers safely omit cleared thinking for every provider.
+ */
+export interface ReasoningProjectionCapability {
+    providerID?: string;
+    canClearReasoning?: boolean;
+}
+
 /**
  * Deferred tail conversion for callers that have already tagged the live wire.
  * The trigger's cheap gate can use the caller-provided tag floor without building
@@ -207,8 +218,9 @@ function estimateProjectedPostDropPercentage(
     sessionId: string,
     usage: ContextUsage,
     activeTags: readonly TagEntry[],
-    clearReasoningAge?: number,
-    clearedReasoningThroughTag?: number,
+    clearReasoningAge: number | undefined,
+    clearedReasoningThroughTag: number | undefined,
+    canClearReasoning: boolean,
 ): number | null {
     // Denominator must include both text/tool bytes and reasoning bytes to match the numerator
     const totalActiveBytes = activeTags.reduce(
@@ -234,7 +246,11 @@ function estimateProjectedPostDropPercentage(
     //    projected as droppable here. The tiered emergency drop fires only at ≥85%,
     //    which is above this trigger's window, so it is intentionally not modeled.)
     const maxTag = activeTags.reduce((max, t) => Math.max(max, t.tagNumber), 0);
-    if (clearReasoningAge !== undefined && clearedReasoningThroughTag !== undefined) {
+    if (
+        canClearReasoning &&
+        clearReasoningAge !== undefined &&
+        clearedReasoningThroughTag !== undefined
+    ) {
         const reasoningAgeCutoff = maxTag - clearReasoningAge;
         for (const tag of activeTags) {
             if (tag.type !== "message") continue;
@@ -418,6 +434,7 @@ export function checkCompartmentTrigger(
     contextLimit?: number,
     inMemoryTail?: InMemoryTailSource | LazyInMemoryTailSource,
     taggerFloorOverride?: number,
+    reasoningProjection?: ReasoningProjectionCapability,
 ): CompartmentTriggerResult {
     if (sessionMeta.compartmentInProgress) {
         sessionLog(
@@ -588,13 +605,21 @@ export function checkCompartmentTrigger(
         return { shouldFire: false };
     }
 
+    // Never project reclaimed reasoning unless this harness can actually clear
+    // it from the provider wire. The OpenCode fallback shares the sentinel
+    // predicate with the postprocess clearing path; Pi explicitly supplies its
+    // own provider-independent capability.
+    const canClearReasoning =
+        reasoningProjection?.canClearReasoning ??
+        modelAcceptsEmptyContent(reasoningProjection?.providerID);
     const projectedPostDropPercentage = estimateProjectedPostDropPercentage(
         db,
         sessionId,
         usage,
         preloadedActiveTags ?? getActiveTagsBySession(db, sessionId),
         clearReasoningAge,
         sessionMeta.clearedReasoningThroughTag,
+        canClearReasoning,
     );
     const relativePostDropTarget = executeThresholdPercentage * POST_DROP_TARGET_RATIO;
 

packages/plugin/src/hooks/magic-context/transform.ts

@@ -1600,6 +1600,7 @@ export function createTransform(deps: TransformDeps) {
                     boundaryContextLimit,
                     inMemoryTail,
                     taggerFloor,
+                    { providerID: resolvedProviderID },
                 );
                 if (triggerResult.shouldFire) {
                     sessionLog(