pi-goosedump 0.12.15 → 0.12.17

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

@@ -1467,9 +1467,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;
@@ -1497,6 +1502,19 @@ function createGoosedumpIntegration(options = {}) {
   function runningOperationIsCurrent(operation, generation, sessionFile) {
     return generation === sessionGeneration && sessionFile === activeSessionFile && compactionState.phase === "running" && compactionState.operation === operation;
   }
+  function releasePiCompactionOnAbort(ctx, signal, operation, generation, sessionFile, request, reason) {
+    signal?.addEventListener("abort", () => {
+      if (!runningOperationIsCurrent(operation, generation, sessionFile))
+        return;
+      setCompactionState(ctx, reason !== "manual" && request && requestIsCurrent(request) ? {
+        phase: "queued",
+        request: {
+          ...request,
+          eligibleSettlement: Math.max(request.eligibleSettlement, settlementGeneration + 2)
+        }
+      } : { phase: "idle" });
+    }, { once: true });
+  }
   function requestHasCompactableHistory(ctx, keep) {
     return keep === null ? hasCompactableHistory(ctx) : keepBoundaryId(ctx.sessionManager.getBranch(), keep) !== undefined;
   }
@@ -1505,53 +1523,52 @@ 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",
       operation,
       sessionGeneration: generation,
       sessionFile,
-      hookActive: false
-    };
+      hookClaimed: 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 +1576,31 @@ function createGoosedumpIntegration(options = {}) {
     });
     return true;
   }
-  function requestCompaction(ctx, keep, origin) {
+  function deferQueuedCompaction(ctx) {
+    if (compactionState.phase !== "queued")
+      return;
+    const request = compactionState.request;
+    setImmediate(() => {
+      if (compactionState.phase !== "queued" || compactionState.request !== request || !contextIsCurrent(ctx)) {
+        return;
+      }
+      startQueuedCompaction(ctx);
+    });
+  }
+  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 +1875,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,20 +1957,20 @@ ${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) {
-        startQueuedCompaction(ctx);
+        deferQueuedCompaction(ctx);
       }
     }
     pi.on("session_start", async (_event, ctx) => {
@@ -1957,6 +1984,7 @@ ${lines.join(`
       syncCompactCounters(ctx);
       updateStatus(ctx);
       queueTurnCompaction(ctx, 1);
+      deferQueuedCompaction(ctx);
     });
     pi.on("session_shutdown", async () => {
       sessionGeneration += 1;
@@ -1965,6 +1993,15 @@ ${lines.join(`
       sessionActive = false;
       compactionState = { phase: "idle" };
     });
+    pi.on("agent_start", async (_event, ctx) => {
+      if (compactionState.phase !== "running" || compactionState.owner !== "pi")
+        return;
+      const request = compactionState.request;
+      setCompactionState(ctx, request && requestIsCurrent(request) ? {
+        phase: "queued",
+        request: { ...request, eligibleSettlement: settlementGeneration + 1 }
+      } : { phase: "idle" });
+    });
     pi.on("turn_end", async (event, ctx) => {
       if (isCompletedAssistant(event.message))
         noteCompletedTurn(ctx);
@@ -1975,32 +2012,33 @@ ${lines.join(`
     pi.on("session_before_compact", async (event, ctx) => {
       if (!shouldOverrideDefaultCompaction || !goosedumpAvailable)
         return;
-      if (event.customInstructions?.trim()) {
-        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)
-            }
-          };
-        }
-        return;
-      }
-      if (event.signal.aborted) {
+      const signal = event.signal;
+      if (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 { cancel: true };
+      }
+      if (event.customInstructions?.trim()) {
+        if (compactionState.phase === "running")
+          return { cancel: true };
+        const operation2 = ++operationGeneration;
+        setCompactionState(ctx, {
+          phase: "running",
+          request: null,
+          owner: "pi",
+          operation: operation2,
+          sessionGeneration,
+          sessionFile: activeSessionFile,
+          hookClaimed: true
+        });
+        releasePiCompactionOnAbort(ctx, signal, operation2, sessionGeneration, activeSessionFile, null, event.reason);
         return;
       }
       let operation;
@@ -2009,7 +2047,7 @@ ${lines.join(`
       let request;
       let owner;
       if (compactionState.phase === "running") {
-        if (compactionState.hookActive || compactionState.owner === "pi") {
+        if (compactionState.hookClaimed || compactionState.owner === "pi") {
           return { cancel: true };
         }
         operation = compactionState.operation;
@@ -2017,22 +2055,25 @@ ${lines.join(`
         sessionFile = compactionState.sessionFile;
         request = compactionState.request;
         owner = "extension";
-        compactionState = { ...compactionState, hookActive: true };
+        compactionState = { ...compactionState, hookClaimed: true };
       } else {
         request = compactionState.phase === "queued" && requestIsCurrent(compactionState.request) ? compactionState.request : null;
         operation = ++operationGeneration;
         generation = sessionGeneration;
         sessionFile = activeSessionFile;
         owner = "pi";
-        compactionState = {
+        setCompactionState(ctx, {
           phase: "running",
           request,
           owner,
           operation,
           sessionGeneration: generation,
           sessionFile,
-          hookActive: true
-        };
+          hookClaimed: true
+        });
+      }
+      if (owner === "pi") {
+        releasePiCompactionOnAbort(ctx, signal, operation, generation, sessionFile, request, event.reason);
       }
       try {
         const { messagesToSummarize, turnPrefixMessages } = event.preparation;
@@ -2049,17 +2090,26 @@ ${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,
+              hookClaimed: true
+            });
           }
         }
-        const compaction = await buildGoosedumpCompaction(target, event.preparation, event.branchEntries, effectiveSummaryMaxTokens(ctx.cwd, projectSettingsTrusted(ctx)), keep, event.signal, nativeExecutablePath);
+        const compaction = await buildGoosedumpCompaction(target, event.preparation, event.branchEntries, effectiveSummaryMaxTokens(ctx.cwd, projectSettingsTrusted(ctx)), keep, signal, nativeExecutablePath);
         if (!runningOperationIsCurrent(operation, generation, sessionFile)) {
           return { cancel: true };
         }
         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 +2117,33 @@ ${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)
+        if (signal?.aborted) {
+          if (owner === "pi" && event.reason === "manual") {
+            setCompactionState(ctx, { phase: "idle" });
+          }
           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, {
+            phase: "running",
+            request,
+            owner,
+            operation,
+            sessionGeneration: generation,
+            sessionFile,
+            hookClaimed: true
+          });
         }
       }
     });
@@ -2095,7 +2155,9 @@ ${lines.join(`
       if (compactionState.phase === "queued" && compactionState.request.keep !== null && ctx.hasUI) {
         ctx.ui.notify("Queued keep request was superseded by another compaction.", "info");
       }
-      compactionState = { phase: "idle" };
+      const extensionOwned = compactionState.phase === "running" && compactionState.owner === "extension";
+      if (!extensionOwned)
+        compactionState = { phase: "idle" };
       syncCompactCounters(ctx);
       updateStatus(ctx);
       if (!goosedumpAvailable)
@@ -2158,7 +2220,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.17",
   "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.17",
     "@sinclair/typebox": "^0.34.49"
   },
   "devDependencies": {