@henryqw/pi-auto-compact 0.2.0 → 0.2.2

package/README.md

@@ -41,10 +41,10 @@ Threshold must be at least 25% and below 100%; lower values are not meaningful.
 ## 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`.
+- Checks `turn_start`, tool-call `turn_end`, `agent_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.
+- Sends a follow-up message after mid-task compaction so task execution continues; final-answer compaction stays idle.
 - Compacts above configured `autoCompactThreshold` percentage (50% by default).
 
 `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.

package/extensions/auto-compact.ts

@@ -13,13 +13,14 @@ import type {
 type AgentMessage = Parameters<typeof estimateTokens>[0];
 
 /**
- * Proactive compaction runs at three points:
+ * Proactive compaction runs at four points:
  * - turn_start: catch sessions already over threshold before next request.
  * - turn_end: catch growth caused by tool results before next LLM turn.
+ * - agent_end: catch growth from the final provider turn.
  * - context: last-resort guard with a temporary keep-recent context.
  *
- * Pi's ctx.compact() aborts active low-level run internally. Its completion
- * callback sends follow-up user message, which resumes task after summary.
+ * Pi's ctx.compact() aborts active low-level run internally. Mid-task
+ * compaction sends a follow-up user message to resume work after summary.
  */
 const DEFAULT_COMPACT_THRESHOLD_PERCENT = 50;
 const MIN_COMPACT_THRESHOLD_PERCENT = 25;
@@ -119,16 +120,17 @@ function hasToolCall(message: AgentMessage): boolean {
 export default function (pi: ExtensionAPI) {
 	let active = false;
 	let autoCompactThreshold = DEFAULT_COMPACT_THRESHOLD_PERCENT;
-	// Prevent turn_start, turn_end, and context from starting duplicate summaries.
+	// Prevent lifecycle hooks from starting duplicate summaries.
 	let compactionPending = false;
 	let compactionAbortExpected = false;
 
-	const runCompaction = (ctx: ExtensionContext) => {
+	const runCompaction = (ctx: ExtensionContext, resumeTask = true) => {
 		compactionAbortExpected = Boolean(ctx.signal && !ctx.signal.aborted);
 		ctx.compact({
 			onComplete: () => {
 				compactionPending = false;
 				compactionAbortExpected = false;
+				if (!resumeTask) return;
 				// Pi may flush queued input during compaction_end. Wait one macrotask
 				// before checking idle, otherwise follow-up can race that flush.
 				setImmediate(() => {
@@ -142,14 +144,14 @@ export default function (pi: ExtensionAPI) {
 		});
 	};
 
-	const compactIfNeeded = (ctx: ExtensionContext) => {
+	const compactIfNeeded = (ctx: ExtensionContext, resumeTask = true) => {
 		if (!active || compactionPending) return;
 
 		const usage = ctx.getContextUsage();
 		if (usage?.percent == null || usage.percent <= autoCompactThreshold) return;
 
 		compactionPending = true;
-		runCompaction(ctx);
+		runCompaction(ctx, resumeTask);
 	};
 
 	// Hide only empty abort produced when ctx.compact() cancels active run.
@@ -176,12 +178,14 @@ export default function (pi: ExtensionAPI) {
 	// Pre-turn catches resumed/queued work before provider request starts.
 	pi.on("turn_start", (_event, ctx) => compactIfNeeded(ctx));
 
-	// Only tool-call turns need mid-run compaction. Final answers should not
-	// receive an unsolicited continuation message.
+	// Only tool-call turns need mid-run compaction.
 	pi.on("turn_end", (event, ctx) => {
 		if (hasToolCall(event.message)) compactIfNeeded(ctx);
 	});
 
+	// Catch threshold crossings caused by the final provider turn.
+	pi.on("agent_end", (_event, ctx) => compactIfNeeded(ctx, false));
+
 	// Runs before every provider request. Temporary truncation protects request
 	// size while asynchronous default compaction summarizes persisted history.
 	pi.on("context", (event, ctx) => {

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@henryqw/pi-auto-compact",
-  "version": "0.2.0",
+  "version": "0.2.2",
   "description": "Proactively compact Pi context at a configurable threshold and resume the current task.",
   "keywords": [
     "pi-package",