@henryqw/pi-auto-compact 0.1.1 → 0.1.2

package/README.md

@@ -8,7 +8,19 @@ Pi extension that compacts context before it reaches 50% of current model contex
 pi install npm:@henryqw/pi-auto-compact
 ```
 
-Restart Pi after installation. Remove with:
+Disable Pi's built-in auto-compaction in `~/.pi/agent/settings.json`:
+
+```json
+{
+  "compaction": {
+    "enabled": false
+  }
+}
+```
+
+Restart Pi after installation or settings changes. Trusted project settings in `.pi/settings.json` must not override `compaction.enabled` back to `true`. Manual `/compact` remains available.
+
+Remove with:
 
 ```bash
 pi remove npm:@henryqw/pi-auto-compact
@@ -16,13 +28,14 @@ pi remove npm:@henryqw/pi-auto-compact
 
 ## Behavior
 
+- Refuses activation with an error when Pi's effective `compaction.enabled` setting is not `false`; competing automatic compactors can start duplicate summaries.
 - Checks `turn_start`, tool-call `turn_end`, `context`, and resumed/forked `session_start`.
 - Uses Pi's default `ctx.compact()` summary and session persistence.
 - Keeps newest 15% as temporary emergency context while compaction runs.
 - Sends a follow-up message after compaction so task execution continues.
-- Uses fixed 50% threshold; no configuration needed.
+- Uses fixed 50% threshold; no extension-specific configuration.
 
-`ctx.compact()` aborts current low-level run. Extension starts new run after compaction with the current task resume message.
+`ctx.compact()` aborts current low-level run. Extension hides that empty internal abort message, then starts new run with current task resume message. Other aborts and provider errors remain visible.
 
 ## Development
 
@@ -32,4 +45,4 @@ npm run pack:check
 npm run test:live
 ```
 
-`test:live` uses real Pi plus authenticated model access. It sets a temporary 12K context window, sends a large prompt, and verifies compaction, automatic resume, persisted resume message, and assistant response. Set `PI_AUTO_COMPACT_AUTH_FILE` when auth is not at `~/.pi/agent/auth.json`.
+`test:live` uses real Pi plus authenticated model access. It disables Pi's built-in auto-compaction, sets a temporary 12K context window, sends a large prompt, and verifies extension compaction, automatic resume, persisted resume message, and assistant response. Set `PI_AUTO_COMPACT_AUTH_FILE` when auth is not at `~/.pi/agent/auth.json`.

package/extensions/auto-compact.ts

@@ -1,4 +1,8 @@
-import { estimateTokens } from "@earendil-works/pi-coding-agent";
+import {
+	estimateTokens,
+	getAgentDir,
+	SettingsManager,
+} from "@earendil-works/pi-coding-agent";
 import type {
 	ExtensionAPI,
 	ExtensionContext,
@@ -20,6 +24,10 @@ const COMPACT_THRESHOLD_PERCENT = 50;
 // Emergency context guard keeps recent messages while default compaction runs.
 const KEEP_RECENT_PERCENT = 15;
 const RESUME_MESSAGE = "Auto-compact ran. Continue the current task.";
+const COMPACTION_ABORT_ERROR = "This operation was aborted";
+const ACTIVATION_ERROR =
+	"pi-auto-compact failed to activate: Pi built-in auto-compaction is enabled. " +
+	"Set compaction.enabled to false in Pi settings, then restart Pi.";
 
 /** Estimate current request size using same estimator Pi uses. */
 function estimateTotalTokens(messages: AgentMessage[]): number {
@@ -75,13 +83,17 @@ function hasToolCall(message: AgentMessage): boolean {
 }
 
 export default function (pi: ExtensionAPI) {
+	let active = false;
 	// Prevent turn_start, turn_end, and context from starting duplicate summaries.
 	let compactionPending = false;
+	let compactionAbortExpected = false;
 
 	const runCompaction = (ctx: ExtensionContext) => {
+		compactionAbortExpected = Boolean(ctx.signal && !ctx.signal.aborted);
 		ctx.compact({
 			onComplete: () => {
 				compactionPending = false;
+				compactionAbortExpected = false;
 				// Pi may flush queued input during compaction_end. Wait one macrotask
 				// before checking idle, otherwise follow-up can race that flush.
 				setImmediate(() => {
@@ -90,12 +102,13 @@ export default function (pi: ExtensionAPI) {
 			},
 			onError: () => {
 				compactionPending = false;
+				compactionAbortExpected = false;
 			},
 		});
 	};
 
 	const compactIfNeeded = (ctx: ExtensionContext) => {
-		if (compactionPending) return;
+		if (!active || compactionPending) return;
 
 		const usage = ctx.getContextUsage();
 		if (usage?.percent == null || usage.percent <= COMPACT_THRESHOLD_PERCENT) return;
@@ -104,6 +117,25 @@ export default function (pi: ExtensionAPI) {
 		runCompaction(ctx);
 	};
 
+	// Hide only empty abort produced when ctx.compact() cancels active run.
+	pi.on("message_end", (event, ctx) => {
+		const message = event.message;
+		if (
+			!compactionPending ||
+			!compactionAbortExpected ||
+			!ctx.signal?.aborted ||
+			message.role !== "assistant" ||
+			message.stopReason !== "error" ||
+			message.errorMessage !== COMPACTION_ABORT_ERROR ||
+			message.content.some((part) => part.type !== "text" || part.text !== "")
+		) return;
+
+		compactionAbortExpected = false;
+		return {
+			message: { ...message, stopReason: "stop", errorMessage: undefined },
+		};
+	});
+
 	// Do not use agent_settled here: long tool loops may cross threshold before
 	// the full run settles. These hooks inspect every provider-turn boundary.
 	// Pre-turn catches resumed/queued work before provider request starts.
@@ -118,7 +150,7 @@ export default function (pi: ExtensionAPI) {
 	// Runs before every provider request. Temporary truncation protects request
 	// size while asynchronous default compaction summarizes persisted history.
 	pi.on("context", (event, ctx) => {
-		if (compactionPending) return;
+		if (!active || compactionPending) return;
 
 		const contextWindow = ctx.getContextUsage()?.contextWindow ?? ctx.model?.contextWindow ?? 0;
 		const estimatedTokens = estimateTotalTokens(event.messages);
@@ -137,10 +169,15 @@ export default function (pi: ExtensionAPI) {
 		return { messages: truncated };
 	});
 
-	// Resume/fork can load an already-large session before first turn.
+	// Pi's built-in automatic compaction competes with this extension. Refuse
+	// activation unless effective global/project settings disable it.
 	pi.on("session_start", (event, ctx) => {
-		if (event.reason === "resume" || event.reason === "fork") {
-			compactIfNeeded(ctx);
-		}
+		active = !SettingsManager.create(ctx.cwd, getAgentDir(), {
+			projectTrusted: ctx.isProjectTrusted(),
+		}).getCompactionEnabled();
+		if (!active) throw new Error(ACTIVATION_ERROR);
+
+		// Resume/fork can load an already-large session before first turn.
+		if (event.reason === "resume" || event.reason === "fork") compactIfNeeded(ctx);
 	});
 }

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@henryqw/pi-auto-compact",
-  "version": "0.1.1",
+  "version": "0.1.2",
   "description": "Proactively compact Pi context at 50% and resume the current task.",
   "keywords": [
     "pi-package",
@@ -21,7 +21,7 @@
   "scripts": {
     "test": "node --test test/*.test.ts",
     "test:live": "PI_AUTO_COMPACT_LIVE=1 node --test test/live.test.ts",
-    "typecheck": "tsc --noEmit --target ES2022 --module NodeNext --moduleResolution NodeNext --skipLibCheck extensions/auto-compact.ts test/live.test.ts",
+    "typecheck": "tsc --noEmit --allowImportingTsExtensions --target ES2022 --module NodeNext --moduleResolution NodeNext --skipLibCheck extensions/auto-compact.ts test/*.test.ts",
     "pack:check": "npm pack --dry-run"
   },
   "peerDependencies": {