pi-goosedump 0.12.17 → 0.12.19

package/README.md

@@ -98,12 +98,14 @@ that call tools. The countdown is restored when a session resumes and appears in
 the footer with a status dot (green when >25% turns remain, yellow when ≤25%, red
 when ≤12.5%) followed by a hexadecimal countdown. `● GD:0A` means ten turns
 remain, `● GD:00` is ready to compact, and `● GD:--` is disabled. The footer
-adds `queued` while compaction is waiting for the active agent run to settle and
-`compacting` while the summary is being built. Pi remains the sole scheduler for
-its normal context threshold. Whichever limit is reached first compacts once,
-and every successful compaction resets the countdown. A failed or cancelled
-compaction leaves the counter armed at zero and is not retried in the same
-settlement.
+adds `queued` while compaction is waiting to start and `compacting` while the
+summary is being built. When the counter hits zero mid tool-loop, compaction
+starts immediately after the current tool batch is persisted and the task is
+resumed automatically. When the counter hits zero on a terminal turn, compaction
+starts after the agent has settled. Pi remains the sole scheduler for its normal
+context threshold. Whichever limit is reached first compacts once, and every
+successful compaction resets the countdown. A failed or cancelled compaction
+leaves the counter armed at zero and retries on the next tool turn or settlement.
 
 `summaryMaxTokens` is an integer from 512 to 65536 (default 4096). The effective
 summary budget is the lower of this value and 80% of Pi's `compaction.reserveTokens`,

package/dist/index.ts

@@ -1411,6 +1411,8 @@ function createGoosedumpIntegration(options = {}) {
   let operationGeneration = 0;
   let activeSessionFile = null;
   let sessionActive = false;
+  let activePi = null;
+  let resumeAfterCompaction = false;
   const rememberQueue = [];
   let rememberRunning = null;
   function enqueueRemember(target, reportError) {
@@ -1482,6 +1484,37 @@ function createGoosedumpIntegration(options = {}) {
     updateStatus(ctx);
     queueTurnCompaction(ctx, settlementGeneration + 1);
   }
+  function resumeAfterSuccessfulCompaction(ctx, resume) {
+    if (!resume || !activePi || ctx.hasPendingMessages())
+      return;
+    activePi.sendMessage({
+      customType: "goosedump-autocompact-resume",
+      content: "The session was compacted to reduce context size. Continue the task you were working on from where you left off.",
+      display: false
+    }, { triggerTurn: true });
+  }
+  function tryMidRunCounterCompaction(ctx) {
+    if (!goosedumpAvailable || !shouldOverrideDefaultCompaction)
+      return false;
+    if (!counterTriggered)
+      return false;
+    if (ctx.hasPendingMessages())
+      return false;
+    if (!hasCompactableHistory(ctx))
+      return false;
+    if (compactionState.phase === "idle") {
+      queueTurnCompaction(ctx, settlementGeneration);
+    } else if (compactionState.phase === "queued") {
+      setCompactionState(ctx, {
+        phase: "queued",
+        request: {
+          ...compactionState.request,
+          eligibleSettlement: Math.min(compactionState.request.eligibleSettlement, settlementGeneration)
+        }
+      });
+    }
+    return startQueuedCompaction(ctx, { resumeAfter: true, allowActiveRun: true });
+  }
   function checkGoosedump(ctx) {
     try {
       execFileSync(process.execPath, [resolveGoosedumpBinary(), "--version"], { stdio: "ignore" });
@@ -1533,7 +1566,7 @@ function createGoosedumpIntegration(options = {}) {
       }
     });
   }
-  function startQueuedCompaction(ctx) {
+  function startQueuedCompaction(ctx, options2 = {}) {
     if (compactionState.phase !== "queued")
       return false;
     const request = compactionState.request;
@@ -1541,7 +1574,9 @@ function createGoosedumpIntegration(options = {}) {
       setCompactionState(ctx, { phase: "idle" });
       return false;
     }
-    if (!ctx.isIdle() || ctx.hasPendingMessages())
+    if (ctx.hasPendingMessages())
+      return false;
+    if (!options2.allowActiveRun && !ctx.isIdle())
       return false;
     if (!requestHasCompactableHistory(ctx, request.keep)) {
       setCompactionState(ctx, { phase: "idle" });
@@ -1550,6 +1585,8 @@ function createGoosedumpIntegration(options = {}) {
     const operation = ++operationGeneration;
     const generation = request.sessionGeneration;
     const sessionFile = request.sessionFile;
+    const resumeAfter = options2.resumeAfter === true;
+    resumeAfterCompaction = resumeAfter;
     setCompactionState(ctx, {
       phase: "running",
       request,
@@ -1563,12 +1600,20 @@ function createGoosedumpIntegration(options = {}) {
       onComplete: () => {
         if (!runningOperationIsCurrent(operation, generation, sessionFile))
           return;
+        const shouldResume = resumeAfterCompaction;
+        resumeAfterCompaction = false;
         setCompactionState(ctx, { phase: "idle" });
+        syncCompactCounters(ctx);
+        updateStatus(ctx);
+        resumeAfterSuccessfulCompaction(ctx, shouldResume);
       },
       onError: (error) => {
         if (!runningOperationIsCurrent(operation, generation, sessionFile))
           return;
+        resumeAfterCompaction = false;
         setCompactionState(ctx, { phase: "idle" });
+        syncCompactCounters(ctx);
+        updateStatus(ctx);
         const message = error instanceof Error ? error.message : String(error);
         if (ctx.hasUI)
           ctx.ui.notify(`goosedump compaction failed: ${message}`, "error");
@@ -1604,6 +1649,7 @@ function createGoosedumpIntegration(options = {}) {
     return startQueuedCompaction(ctx) ? "started" : "queued";
   }
   function register(pi) {
+    activePi = pi;
     if (shouldRegisterTool) {
       pi.registerTool(defineTool({
         name: "goose_remember",
@@ -1955,6 +2001,8 @@ ${lines.join(`
       if (!goosedumpAvailable || !shouldOverrideDefaultCompaction)
         return;
       settlementGeneration += 1;
+      syncCompactCounters(ctx);
+      updateStatus(ctx);
       if (compactionState.phase === "running" && compactionState.owner === "pi") {
         const request = compactionState.request;
         setCompactionState(ctx, request && requestIsCurrent(request) ? {
@@ -1978,6 +2026,7 @@ ${lines.join(`
       settlementGeneration = 0;
       activeSessionFile = ctx.sessionManager.getSessionFile?.() ?? null;
       sessionActive = true;
+      resumeAfterCompaction = false;
       compactionState = { phase: "idle" };
       goosedumpAvailable = checkGoosedump(ctx);
       notifyInvalidSettings(ctx);
@@ -1991,8 +2040,21 @@ ${lines.join(`
       settlementGeneration = 0;
       activeSessionFile = null;
       sessionActive = false;
+      resumeAfterCompaction = false;
       compactionState = { phase: "idle" };
     });
+    pi.on("session_tree", async (_event, ctx) => {
+      sessionGeneration += 1;
+      settlementGeneration = 0;
+      activeSessionFile = ctx.sessionManager.getSessionFile?.() ?? null;
+      sessionActive = true;
+      resumeAfterCompaction = false;
+      compactionState = { phase: "idle" };
+      syncCompactCounters(ctx);
+      updateStatus(ctx);
+      queueTurnCompaction(ctx, 1);
+      deferQueuedCompaction(ctx);
+    });
     pi.on("agent_start", async (_event, ctx) => {
       if (compactionState.phase !== "running" || compactionState.owner !== "pi")
         return;
@@ -2005,6 +2067,8 @@ ${lines.join(`
     pi.on("turn_end", async (event, ctx) => {
       if (isCompletedAssistant(event.message))
         noteCompletedTurn(ctx);
+      if (event.toolResults.length > 0)
+        tryMidRunCounterCompaction(ctx);
     });
     pi.on("agent_settled", async (_event, ctx) => {
       handleAgentSettled(ctx);
@@ -2148,6 +2212,7 @@ ${lines.join(`
       }
     });
     pi.on("session_compact", async (event, ctx) => {
+      resumeAfterCompaction = false;
       if (!shouldOverrideDefaultCompaction)
         return;
       if (!contextIsCurrent(ctx))

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "pi-goosedump",
-  "version": "0.12.17",
+  "version": "0.12.19",
   "description": "Pi extension for goosedump session search, durable memory, and compaction",
   "keywords": [
     "compaction",
@@ -38,7 +38,7 @@
   },
   "dependencies": {
     "@earendil-works/pi-tui": "^0.82.1",
-    "@jarkkojs/goosedump": "^0.12.17",
+    "@jarkkojs/goosedump": "^0.12.19",
     "@sinclair/typebox": "^0.34.49"
   },
   "devDependencies": {