gsd-pi 2.80.0-dev.0d763dc29 → 2.80.0-dev.2be7caf18

package/packages/pi-coding-agent/src/core/agent-session.ts

@@ -2211,6 +2211,9 @@ export class AgentSession {
 					})();
 				},
 				getSystemPrompt: () => this.systemPrompt,
+				setCompactionThresholdOverride: (percent) => {
+					this.settingsManager.setCompactionThresholdOverride(percent);
+				},
 			},
 		);
 	}

package/packages/pi-coding-agent/src/core/compaction/compaction.ts

@@ -86,6 +86,13 @@ export interface CompactionSettings {
 	enabled: boolean;
 	reserveTokens: number;
 	keepRecentTokens: number;
+	/**
+	 * Optional percent-of-context-window threshold (0 < value < 1). When set,
+	 * `shouldCompact()` fires once `contextTokens > contextWindow * thresholdPercent`,
+	 * overriding the absolute `reserveTokens` calculation. Lets host integrations
+	 * (e.g. GSD) express compaction policy as a fraction independent of model size.
+	 */
+	thresholdPercent?: number;
 }
 
 export const DEFAULT_COMPACTION_SETTINGS: CompactionSettings = {
@@ -185,9 +192,20 @@ export function estimateContextTokens(messages: AgentMessage[]): ContextUsageEst
 
 /**
  * Check if compaction should trigger based on context usage.
+ *
+ * When `thresholdPercent` is set (and within (0, 1)), it overrides the absolute
+ * `reserveTokens` calculation: compaction fires at `contextWindow * thresholdPercent`.
+ * Otherwise the legacy `contextWindow - reserveTokens` headroom is used.
  */
 export function shouldCompact(contextTokens: number, contextWindow: number, settings: CompactionSettings): boolean {
 	if (!settings.enabled) return false;
+	if (
+		settings.thresholdPercent !== undefined &&
+		settings.thresholdPercent > 0 &&
+		settings.thresholdPercent < 1
+	) {
+		return contextTokens > contextWindow * settings.thresholdPercent;
+	}
 	return contextTokens > contextWindow - settings.reserveTokens;
 }
 

package/packages/pi-coding-agent/src/core/compaction-threshold.test.ts

@@ -0,0 +1,121 @@
+// pi-coding-agent / Regression tests for compaction threshold percent (#5475)
+
+import assert from "node:assert/strict";
+import { describe, it } from "node:test";
+
+import { shouldCompact, type CompactionSettings } from "./compaction/compaction.js";
+import { SettingsManager } from "./settings-manager.js";
+
+const REGISTRY_DEFAULTS: CompactionSettings = {
+	enabled: true,
+	reserveTokens: 16_384,
+	keepRecentTokens: 20_000,
+};
+
+describe("shouldCompact — thresholdPercent (#5475)", () => {
+	it("uses absolute reserveTokens when thresholdPercent is unset (legacy behavior)", () => {
+		// 200K window, 16384 reserve → fires at 183_617 tokens
+		assert.equal(shouldCompact(183_616, 200_000, REGISTRY_DEFAULTS), false);
+		assert.equal(shouldCompact(183_617, 200_000, REGISTRY_DEFAULTS), true);
+	});
+
+	it("uses thresholdPercent when set, ignoring reserveTokens", () => {
+		const settings: CompactionSettings = { ...REGISTRY_DEFAULTS, thresholdPercent: 0.7 };
+		// 200K * 0.7 = 140_000 → fires above that
+		assert.equal(shouldCompact(140_000, 200_000, settings), false);
+		assert.equal(shouldCompact(140_001, 200_000, settings), true);
+		// reserveTokens-based math would have said false at 183_616 — the percent override changes that
+		assert.equal(shouldCompact(150_000, 200_000, settings), true);
+	});
+
+	it("falls back to reserveTokens when thresholdPercent is out of range", () => {
+		// Defense in depth: reject 0, 1, negative, NaN, Infinity
+		for (const bad of [0, 1, -0.1, 1.5, Number.NaN, Number.POSITIVE_INFINITY]) {
+			const settings: CompactionSettings = { ...REGISTRY_DEFAULTS, thresholdPercent: bad };
+			assert.equal(
+				shouldCompact(183_616, 200_000, settings),
+				false,
+				`bad=${bad} should fall back to reserveTokens math`,
+			);
+			assert.equal(shouldCompact(183_617, 200_000, settings), true, `bad=${bad}`);
+		}
+	});
+
+	it("respects enabled=false regardless of thresholdPercent", () => {
+		const settings: CompactionSettings = {
+			...REGISTRY_DEFAULTS,
+			enabled: false,
+			thresholdPercent: 0.5,
+		};
+		assert.equal(shouldCompact(199_999, 200_000, settings), false);
+	});
+
+	it("scales with contextWindow — same percent, different windows", () => {
+		const settings: CompactionSettings = { ...REGISTRY_DEFAULTS, thresholdPercent: 0.8 };
+		// 100K window: fires above 80_000
+		assert.equal(shouldCompact(80_000, 100_000, settings), false);
+		assert.equal(shouldCompact(80_001, 100_000, settings), true);
+		// 1M window: fires above 800_000
+		assert.equal(shouldCompact(800_000, 1_000_000, settings), false);
+		assert.equal(shouldCompact(800_001, 1_000_000, settings), true);
+	});
+});
+
+describe("SettingsManager — compaction threshold override (#5475)", () => {
+	it("getCompactionThresholdPercent returns undefined by default", () => {
+		const sm = SettingsManager.inMemory({});
+		assert.equal(sm.getCompactionThresholdPercent(), undefined);
+		assert.equal(sm.getCompactionSettings().thresholdPercent, undefined);
+	});
+
+	it("setCompactionThresholdOverride applies in-memory and is exposed via getCompactionSettings", () => {
+		const sm = SettingsManager.inMemory({});
+		sm.setCompactionThresholdOverride(0.7);
+		assert.equal(sm.getCompactionThresholdPercent(), 0.7);
+		assert.equal(sm.getCompactionSettings().thresholdPercent, 0.7);
+	});
+
+	it("setCompactionThresholdOverride(undefined) clears a prior override", () => {
+		const sm = SettingsManager.inMemory({});
+		sm.setCompactionThresholdOverride(0.7);
+		sm.setCompactionThresholdOverride(undefined);
+		assert.equal(sm.getCompactionThresholdPercent(), undefined);
+		assert.equal(sm.getCompactionSettings().thresholdPercent, undefined);
+	});
+
+	it("setCompactionThresholdOverride preserves other compaction fields (enabled, reserveTokens)", () => {
+		const sm = SettingsManager.inMemory({
+			compaction: { enabled: true, reserveTokens: 30_000, keepRecentTokens: 25_000 },
+		});
+		sm.setCompactionThresholdOverride(0.6);
+		const settings = sm.getCompactionSettings();
+		assert.equal(settings.enabled, true);
+		assert.equal(settings.reserveTokens, 30_000);
+		assert.equal(settings.keepRecentTokens, 25_000);
+		assert.equal(settings.thresholdPercent, 0.6);
+	});
+
+	it("setCompactionThresholdOverride works when no compaction config exists yet", () => {
+		const sm = SettingsManager.inMemory({});
+		sm.setCompactionThresholdOverride(0.85);
+		assert.equal(sm.getCompactionThresholdPercent(), 0.85);
+		// Other compaction fields fall back to their defaults
+		const settings = sm.getCompactionSettings();
+		assert.equal(settings.enabled, true);
+		assert.equal(typeof settings.reserveTokens, "number");
+		assert.equal(typeof settings.keepRecentTokens, "number");
+	});
+});
+
+describe("end-to-end — getCompactionSettings + shouldCompact (#5475)", () => {
+	it("70% threshold on a 200K window fires at the documented bug-report value (140_001 not 183_617)", () => {
+		const sm = SettingsManager.inMemory({});
+		sm.setCompactionThresholdOverride(0.7);
+		const settings = sm.getCompactionSettings();
+
+		assert.equal(shouldCompact(140_000, 200_000, settings), false);
+		assert.equal(shouldCompact(140_001, 200_000, settings), true);
+		// Pre-fix behavior would have required 183_617 — verify we no longer wait that long
+		assert.equal(shouldCompact(150_000, 200_000, settings), true);
+	});
+});

package/packages/pi-coding-agent/src/core/extensions/runner.test.ts

@@ -141,6 +141,7 @@ describe("ExtensionRunner.emitToolCall", () => {
 			getContextUsage: () => undefined,
 			compact: () => {},
 			getSystemPrompt: () => "",
+			setCompactionThresholdOverride: () => {},
 		});
 
 		const errors: any[] = [];
@@ -220,6 +221,7 @@ describe("ExtensionRunner.createContext", () => {
 			getContextUsage: () => undefined,
 			compact: () => {},
 			getSystemPrompt: () => "",
+			setCompactionThresholdOverride: () => {},
 		});
 
 		const errors: any[] = [];

package/packages/pi-coding-agent/src/core/extensions/runner.ts

@@ -235,6 +235,7 @@ export class ExtensionRunner {
 	private getContextUsageFn: () => ContextUsage | undefined = () => undefined;
 	private compactFn: (options?: CompactOptions) => void = () => {};
 	private getSystemPromptFn: () => string = () => "";
+	private setCompactionThresholdOverrideFn: (percent: number | undefined) => void = () => {};
 	private newSessionHandler: NewSessionHandler = async () => {
 		throw new Error("Command context not yet bound: newSession is unavailable during early lifecycle");
 	};
@@ -428,6 +429,7 @@ export class ExtensionRunner {
 		this.getContextUsageFn = contextActions.getContextUsage;
 		this.compactFn = contextActions.compact;
 		this.getSystemPromptFn = contextActions.getSystemPrompt;
+		this.setCompactionThresholdOverrideFn = contextActions.setCompactionThresholdOverride;
 
 		// Flush provider registrations queued during extension loading
 		for (const { name, config } of this.runtime.pendingProviderRegistrations) {
@@ -714,6 +716,7 @@ export class ExtensionRunner {
 			getContextUsage: () => this.getContextUsageFn(),
 			compact: (options) => this.compactFn(options),
 			getSystemPrompt: () => this.getSystemPromptFn(),
+			setCompactionThresholdOverride: (percent) => this.setCompactionThresholdOverrideFn(percent),
 		};
 	}
 

package/packages/pi-coding-agent/src/core/extensions/types.ts

@@ -289,6 +289,12 @@ export interface ExtensionContext {
 	compact(options?: CompactOptions): void;
 	/** Get the current effective system prompt. */
 	getSystemPrompt(): string;
+	/**
+	 * Set or clear an in-memory compaction threshold-percent override (0 < value < 1).
+	 * Pass `undefined` to clear. The override is not persisted; host integrations
+	 * are expected to re-apply on each session_start.
+	 */
+	setCompactionThresholdOverride(percent: number | undefined): void;
 }
 
 /**
@@ -1741,6 +1747,7 @@ export interface ExtensionContextActions {
 	getContextUsage: () => ContextUsage | undefined;
 	compact: (options?: CompactOptions) => void;
 	getSystemPrompt: () => string;
+	setCompactionThresholdOverride: (percent: number | undefined) => void;
 }
 
 /**

package/packages/pi-coding-agent/src/core/settings-manager.ts

@@ -15,6 +15,13 @@ export interface CompactionSettings {
 	enabled?: boolean; // default: true
 	reserveTokens?: number; // default: 16384
 	keepRecentTokens?: number; // default: 20000
+	/**
+	 * Optional percent-of-context-window trigger (0 < value < 1). When set,
+	 * compaction fires at `contextWindow * thresholdPercent` and overrides
+	 * `reserveTokens`. Typically set as a runtime override by host integrations
+	 * (see `setCompactionThresholdOverride`) and not persisted by users directly.
+	 */
+	thresholdPercent?: number;
 }
 
 export interface BranchSummarySettings {
@@ -812,11 +819,42 @@ export class SettingsManager {
 		return this.settings.compaction?.keepRecentTokens ?? COMPACTION_KEEP_RECENT_TOKENS;
 	}
 
-	getCompactionSettings(): { enabled: boolean; reserveTokens: number; keepRecentTokens: number } {
+	getCompactionThresholdPercent(): number | undefined {
+		return this.settings.compaction?.thresholdPercent;
+	}
+
+	/**
+	 * Set or clear an in-memory compaction threshold-percent override.
+	 *
+	 * Applied to `this.settings` only; never persisted to disk. Pass `undefined`
+	 * to clear a previously set override (necessary for idempotent re-sync from
+	 * host integrations whose preference may have been removed).
+	 *
+	 * Direct mutation is used instead of `applyOverrides()` because deep-merge
+	 * semantics skip `undefined` values, which would prevent clearing.
+	 */
+	setCompactionThresholdOverride(percent: number | undefined): void {
+		if (!this.settings.compaction) {
+			this.settings.compaction = {};
+		}
+		if (percent === undefined) {
+			delete this.settings.compaction.thresholdPercent;
+		} else {
+			this.settings.compaction.thresholdPercent = percent;
+		}
+	}
+
+	getCompactionSettings(): {
+		enabled: boolean;
+		reserveTokens: number;
+		keepRecentTokens: number;
+		thresholdPercent?: number;
+	} {
 		return {
 			enabled: this.getCompactionEnabled(),
 			reserveTokens: this.getCompactionReserveTokens(),
 			keepRecentTokens: this.getCompactionKeepRecentTokens(),
+			thresholdPercent: this.getCompactionThresholdPercent(),
 		};
 	}
 

package/packages/pi-coding-agent/src/modes/interactive/interactive-mode.ts

@@ -1378,6 +1378,9 @@ export class InteractiveMode {
 				})();
 			},
 			getSystemPrompt: () => this.session.systemPrompt,
+			setCompactionThresholdOverride: (percent) => {
+				this.session.settingsManager.setCompactionThresholdOverride(percent);
+			},
 		});
 
 		// Set up the extension shortcut handler on the default editor