@pinet/model-aware-compaction 0.2.8 → 0.2.10

package/README.md

@@ -37,7 +37,7 @@ Rules are evaluated in order. `*` wildcards are supported, such as `example-prox
 
 ## Behavior
 
-After each `agent_end`, the extension reads `ctx.getContextUsage()` and the active `ctx.model`. Waiting for `agent_end` is important: tool-using runs can emit several `turn_end` events, and Pi's `ctx.compact()` aborts an active agent operation before compacting. Triggering only after the complete model/tool loop has settled prevents compaction from discarding pending tool work. When usage first exceeds the matching rule's `activeContextTokens`, the extension calls `ctx.compact()`. It prevents duplicate calls while compaction is in flight and re-arms after usage drops below the threshold, the model changes, a session starts, or compaction fails.
+After each `agent_settled`, the extension reads `ctx.getContextUsage()` and the active `ctx.model`. Pi can still auto-compact, retry, or process queued follow-ups after `agent_end`; waiting for `agent_settled` prevents proactive compaction from racing that automatic lifecycle. When usage first exceeds the matching rule's `activeContextTokens`, the extension calls `ctx.compact()`. It skips branches whose latest entry is already a compaction, prevents duplicate calls while compaction is in flight, and treats an `Already compacted` callback as an idempotent outcome. The threshold re-arms after usage drops below the limit, the model changes, a session starts, or another compaction failure occurs.
 
 Run `/model-aware-compaction-status` to inspect the active model, usage, matched threshold, state, and loaded rules.
 

package/dist/index.js

@@ -10,9 +10,9 @@ export default function modelAwareCompaction(pi) {
     };
     pi.on("session_start", rearm);
     pi.on("model_select", rearm);
-    // ctx.compact() aborts an active agent operation. Wait for the complete
-    // model/tool loop to settle so compaction cannot discard pending tool work.
-    pi.on("agent_end", (_event, rawCtx) => {
+    // agent_end may still be followed by Pi's automatic compaction and retry.
+    // Wait until the full operation settles so proactive compaction cannot race it.
+    pi.on("agent_settled", (_event, rawCtx) => {
         const ctx = rawCtx;
         const config = loadConfig(ctx.cwd);
         const usage = ctx.getContextUsage?.();
@@ -29,6 +29,10 @@ export default function modelAwareCompaction(pi) {
         }
         if (!decision.shouldCompact || !ctx.compact || !decision.modelKey || decision.limit === null)
             return;
+        if (ctx.sessionManager.getBranch().at(-1)?.type === "compaction") {
+            triggeredModelKey = decision.modelKey;
+            return;
+        }
         inFlight = true;
         triggeredModelKey = decision.modelKey;
         const details = `model=${decision.modelKey} tokens=${usage?.tokens ?? "unknown"} limit=${decision.limit}`;
@@ -49,6 +53,8 @@ export default function modelAwareCompaction(pi) {
             },
             onError: (error) => {
                 inFlight = false;
+                if (error.message === "Already compacted")
+                    return;
                 triggeredModelKey = null;
                 console.error(`${LOG_PREFIX} failed ${details}: ${error.message}`);
                 if (config.debug && ctx.hasUI)

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@pinet/model-aware-compaction",
-  "version": "0.2.8",
+  "version": "0.2.10",
   "type": "module",
   "description": "Pi extension for proactive model-aware context compaction thresholds",
   "author": "Will Porcellini <5994936+gugu91@users.noreply.github.com>",