pi-goosedump 0.12.15 → 0.12.16

package/README.md

@@ -97,10 +97,11 @@ compaction. Each completed model response counts as one turn, including response
 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. 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 turn or
-tool request waits until the agent run is fully settled. A failed or cancelled
+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.
 

package/dist/index.ts

@@ -1411,6 +1411,7 @@ function createGoosedumpIntegration(options = {}) {
   let operationGeneration = 0;
   let activeSessionFile = null;
   let sessionActive = false;
+  let agentEndObserved = true;
   const rememberQueue = [];
   let rememberRunning = null;
   function enqueueRemember(target, reportError) {
@@ -1467,9 +1468,14 @@ function createGoosedumpIntegration(options = {}) {
     }
     const dot = ctx.ui.theme.fg(dotColor, "●");
     const counter = active ? Math.max(0, turnsRemaining).toString(16).toUpperCase().padStart(2, "0") : "--";
-    const label = ctx.ui.theme.fg("text", `${ctx.ui.theme.bold?.("GD") ?? "GD"}:${counter}`);
+    const activity = compactionState.phase === "queued" ? " queued" : compactionState.phase === "running" ? " compacting" : "";
+    const label = ctx.ui.theme.fg("text", `${ctx.ui.theme.bold?.("GD") ?? "GD"}:${counter}${activity}`);
     ctx.ui.setStatus("goosedump", `${dot} ${label}`);
   }
+  function setCompactionState(ctx, state) {
+    compactionState = state;
+    updateStatus(ctx);
+  }
   function noteCompletedTurn(ctx) {
     if (!goosedumpAvailable || !shouldOverrideDefaultCompaction)
       return;
@@ -1505,35 +1511,34 @@ function createGoosedumpIntegration(options = {}) {
       return;
     if (!hasCompactableHistory(ctx))
       return;
-    compactionState = {
+    setCompactionState(ctx, {
       phase: "queued",
       request: {
         keep: null,
-        origin: "turn",
         sessionGeneration,
         sessionFile: activeSessionFile,
         eligibleSettlement
       }
-    };
+    });
   }
   function startQueuedCompaction(ctx) {
     if (compactionState.phase !== "queued")
       return false;
     const request = compactionState.request;
     if (!requestIsCurrent(request)) {
-      compactionState = { phase: "idle" };
+      setCompactionState(ctx, { phase: "idle" });
       return false;
     }
     if (!ctx.isIdle() || ctx.hasPendingMessages())
       return false;
     if (!requestHasCompactableHistory(ctx, request.keep)) {
-      compactionState = { phase: "idle" };
+      setCompactionState(ctx, { phase: "idle" });
       return false;
     }
     const operation = ++operationGeneration;
     const generation = request.sessionGeneration;
     const sessionFile = request.sessionFile;
-    compactionState = {
+    setCompactionState(ctx, {
       phase: "running",
       request,
       owner: "extension",
@@ -1541,17 +1546,17 @@ function createGoosedumpIntegration(options = {}) {
       sessionGeneration: generation,
       sessionFile,
       hookActive: false
-    };
+    });
     ctx.compact({
       onComplete: () => {
         if (!runningOperationIsCurrent(operation, generation, sessionFile))
           return;
-        compactionState = { phase: "idle" };
+        setCompactionState(ctx, { phase: "idle" });
       },
       onError: (error) => {
         if (!runningOperationIsCurrent(operation, generation, sessionFile))
           return;
-        compactionState = { phase: "idle" };
+        setCompactionState(ctx, { phase: "idle" });
         const message = error instanceof Error ? error.message : String(error);
         if (ctx.hasUI)
           ctx.ui.notify(`goosedump compaction failed: ${message}`, "error");
@@ -1559,21 +1564,20 @@ function createGoosedumpIntegration(options = {}) {
     });
     return true;
   }
-  function requestCompaction(ctx, keep, origin) {
+  function requestCompaction(ctx, keep) {
     if (compactionState.phase !== "idle")
       return "busy";
     if (!requestHasCompactableHistory(ctx, keep))
       return "nothing-to-compact";
-    compactionState = {
+    setCompactionState(ctx, {
       phase: "queued",
       request: {
         keep,
-        origin,
         sessionGeneration,
         sessionFile: activeSessionFile,
         eligibleSettlement: settlementGeneration + 1
       }
-    };
+    });
     return startQueuedCompaction(ctx) ? "started" : "queued";
   }
   function register(pi) {
@@ -1848,7 +1852,7 @@ function createGoosedumpIntegration(options = {}) {
           if (!goosedumpAvailable)
             return goosedumpUnavailableResult();
           const keep = params.keep ?? null;
-          const result = requestCompaction(ctx, keep, "tool");
+          const result = requestCompaction(ctx, keep);
           if (result === "busy")
             return textResult("Compaction already in progress.");
           if (result === "nothing-to-compact") {
@@ -1930,19 +1934,19 @@ ${lines.join(`
       settlementGeneration += 1;
       if (compactionState.phase === "running" && compactionState.owner === "pi") {
         const request = compactionState.request;
-        compactionState = request && requestIsCurrent(request) ? {
+        setCompactionState(ctx, request && requestIsCurrent(request) ? {
           phase: "queued",
           request: { ...request, eligibleSettlement: settlementGeneration + 1 }
-        } : { phase: "idle" };
+        } : { phase: "idle" });
         return;
       }
       if (compactionState.phase === "queued" && !requestIsCurrent(compactionState.request)) {
-        compactionState = { phase: "idle" };
+        setCompactionState(ctx, { phase: "idle" });
       }
       if (compactionState.phase === "idle") {
         queueTurnCompaction(ctx, settlementGeneration);
       }
-      if (compactionState.phase === "queued" && compactionState.request.eligibleSettlement <= settlementGeneration) {
+      if (agentEndObserved && compactionState.phase === "queued" && compactionState.request.eligibleSettlement <= settlementGeneration) {
         startQueuedCompaction(ctx);
       }
     }
@@ -1951,6 +1955,7 @@ ${lines.join(`
       settlementGeneration = 0;
       activeSessionFile = ctx.sessionManager.getSessionFile?.() ?? null;
       sessionActive = true;
+      agentEndObserved = true;
       compactionState = { phase: "idle" };
       goosedumpAvailable = checkGoosedump(ctx);
       notifyInvalidSettings(ctx);
@@ -1963,8 +1968,15 @@ ${lines.join(`
       settlementGeneration = 0;
       activeSessionFile = null;
       sessionActive = false;
+      agentEndObserved = true;
       compactionState = { phase: "idle" };
     });
+    pi.on("agent_start", async () => {
+      agentEndObserved = false;
+    });
+    pi.on("agent_end", async () => {
+      agentEndObserved = true;
+    });
     pi.on("turn_end", async (event, ctx) => {
       if (isCompletedAssistant(event.message))
         noteCompletedTurn(ctx);
@@ -1979,27 +1991,19 @@ ${lines.join(`
         if (compactionState.phase === "running")
           return { cancel: true };
         if (compactionState.phase === "queued") {
-          if (compactionState.request.origin !== "turn")
-            return { cancel: true };
-          compactionState = {
-            phase: "queued",
-            request: {
-              ...compactionState.request,
-              eligibleSettlement: Math.max(compactionState.request.eligibleSettlement, settlementGeneration + 2)
-            }
-          };
+          setCompactionState(ctx, { phase: "idle" });
         }
         return;
       }
       if (event.signal.aborted) {
         if (compactionState.phase === "queued" && requestIsCurrent(compactionState.request)) {
-          compactionState = event.reason === "manual" ? { phase: "idle" } : {
+          setCompactionState(ctx, event.reason === "manual" ? { phase: "idle" } : {
             phase: "queued",
             request: {
               ...compactionState.request,
               eligibleSettlement: Math.max(compactionState.request.eligibleSettlement, settlementGeneration + 2)
             }
-          };
+          });
         }
         return;
       }
@@ -2024,7 +2028,7 @@ ${lines.join(`
         generation = sessionGeneration;
         sessionFile = activeSessionFile;
         owner = "pi";
-        compactionState = {
+        setCompactionState(ctx, {
           phase: "running",
           request,
           owner,
@@ -2032,7 +2036,7 @@ ${lines.join(`
           sessionGeneration: generation,
           sessionFile,
           hookActive: true
-        };
+        });
       }
       try {
         const { messagesToSummarize, turnPrefixMessages } = event.preparation;
@@ -2049,7 +2053,16 @@ ${lines.join(`
           }
           keep = undefined;
           if (runningOperationIsCurrent(operation, generation, sessionFile)) {
-            compactionState = { ...compactionState, request: null };
+            request = null;
+            setCompactionState(ctx, {
+              phase: "running",
+              request,
+              owner,
+              operation,
+              sessionGeneration: generation,
+              sessionFile,
+              hookActive: true
+            });
           }
         }
         const compaction = await buildGoosedumpCompaction(target, event.preparation, event.branchEntries, effectiveSummaryMaxTokens(ctx.cwd, projectSettingsTrusted(ctx)), keep, event.signal, nativeExecutablePath);
@@ -2059,7 +2072,7 @@ ${lines.join(`
         if (compaction && "cancel" in compaction) {
           if (ctx.hasUI)
             ctx.ui.notify(compaction.reason, "info");
-          return owner === "pi" && event.reason === "manual" ? { cancel: true } : undefined;
+          return;
         }
         const warning = compaction?.details?.warning;
         if (warning && ctx.hasUI) {
@@ -2067,23 +2080,29 @@ ${lines.join(`
         }
         if (compaction)
           return { compaction };
-        return owner === "pi" && event.reason === "manual" ? { cancel: true } : undefined;
+        return;
       } catch (err) {
         if (!runningOperationIsCurrent(operation, generation, sessionFile)) {
           return { cancel: true };
         }
         if (event.signal.aborted)
           return { cancel: true };
-        const useFallback = owner === "extension" || event.reason !== "manual";
         if (ctx.hasUI) {
           const message = err instanceof Error ? err.message : String(err);
-          const action = useFallback ? "; falling back to Pi compaction" : "";
-          ctx.ui.notify(`goosedump compaction failed${action}: ${message}`, "error");
+          ctx.ui.notify(`goosedump compaction failed; falling back to Pi compaction: ${message}`, "error");
         }
-        return useFallback ? undefined : { cancel: true };
+        return;
       } finally {
         if (runningOperationIsCurrent(operation, generation, sessionFile)) {
-          compactionState = owner === "pi" && event.reason === "manual" ? { phase: "idle" } : { ...compactionState, hookActive: false };
+          setCompactionState(ctx, owner === "pi" && event.reason === "manual" ? { phase: "idle" } : {
+            phase: "running",
+            request,
+            owner,
+            operation,
+            sessionGeneration: generation,
+            sessionFile,
+            hookActive: false
+          });
         }
       }
     });
@@ -2158,7 +2177,7 @@ ${lines.join(`
             return;
           }
         }
-        const result = requestCompaction(ctx, keep, "command");
+        const result = requestCompaction(ctx, keep);
         if (result === "busy") {
           ctx.ui.notify("Compaction already in progress", "info");
         } else if (result === "nothing-to-compact") {

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "pi-goosedump",
-  "version": "0.12.15",
+  "version": "0.12.16",
   "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.15",
+    "@jarkkojs/goosedump": "^0.12.16",
     "@sinclair/typebox": "^0.34.49"
   },
   "devDependencies": {