pi-goosedump 0.12.16 → 0.12.18

package/README.md

@@ -93,17 +93,17 @@ Optional settings live under `goosedump` in:
 ```
 
 `turnsBeforeCompact` is an integer from 0 to 255. `0` disables scheduled
-compaction. Each completed model response counts as one turn, including responses
-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.
+compaction. Each fully settled agent run counts as one turn; intermediate model
+responses that call tools do not. 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.
 
 `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

@@ -590,11 +590,26 @@ function currentSessionTarget(ctx) {
 function isCompactionEntry(entry) {
   return entry.type === "compaction";
 }
+var COMPLETED_AGENT_RUN_ENTRY = "goosedump-completed-agent-run";
 function isMessageEntry(entry) {
   return entry.type === "message";
 }
-function isCompletedAssistant(message) {
-  return message.role === "assistant" && message.stopReason !== "error" && message.stopReason !== "aborted";
+function isTerminalAssistant(message) {
+  if (message.role !== "assistant")
+    return false;
+  if (message.stopReason !== "stop" && message.stopReason !== "length")
+    return false;
+  return !(Array.isArray(message.content) && message.content.some((part) => isRecord(part) && part.type === "toolCall"));
+}
+function completedAgentRunData(entry) {
+  if (entry.type !== "custom" || entry.customType !== COMPLETED_AGENT_RUN_ENTRY)
+    return;
+  if (!isRecord(entry.data) || entry.data.version !== 1)
+    return;
+  const startedAfterEntryId = entry.data.startedAfterEntryId;
+  if (startedAfterEntryId !== null && typeof startedAfterEntryId !== "string")
+    return;
+  return { version: 1, startedAfterEntryId };
 }
 var SUMMARIZABLE_ENTRY_TYPES = new Set(["message", "custom_message", "branch_summary"]);
 function piKeepRecentTokens(cwd, includeProject) {
@@ -666,7 +681,7 @@ function activeHistoryStartIndex(branchEntries) {
   const compaction = latestCompaction(branchEntries);
   return compaction ? compactionBoundaryStartIndex(branchEntries, compaction) : 0;
 }
-function completedTurnsSinceCompaction(branchEntries) {
+function completedRunsSinceCompaction(branchEntries) {
   let start = 0;
   for (let i = branchEntries.length - 1;i >= 0; i -= 1) {
     if (isCompactionEntry(branchEntries[i])) {
@@ -674,10 +689,27 @@ function completedTurnsSinceCompaction(branchEntries) {
       break;
     }
   }
+  const firstMarkerIndex = branchEntries.findIndex((entry, index) => index >= start && completedAgentRunData(entry) !== undefined);
+  if (firstMarkerIndex < 0) {
+    let completed2 = 0;
+    for (let i = start;i < branchEntries.length; i += 1) {
+      const entry = branchEntries[i];
+      if (isMessageEntry(entry) && isTerminalAssistant(entry.message))
+        completed2 += 1;
+    }
+    return completed2;
+  }
+  const firstMarker = completedAgentRunData(branchEntries[firstMarkerIndex]);
+  const boundaryIndex = firstMarker?.startedAfterEntryId ? branchEntries.findIndex((entry) => entry.id === firstMarker.startedAfterEntryId) : start - 1;
+  const legacyEnd = boundaryIndex >= start ? boundaryIndex + 1 : start;
   let completed = 0;
-  for (let i = start;i < branchEntries.length; i += 1) {
+  for (let i = start;i < legacyEnd; i += 1) {
     const entry = branchEntries[i];
-    if (isMessageEntry(entry) && isCompletedAssistant(entry.message))
+    if (isMessageEntry(entry) && isTerminalAssistant(entry.message))
+      completed += 1;
+  }
+  for (let i = firstMarkerIndex;i < branchEntries.length; i += 1) {
+    if (completedAgentRunData(branchEntries[i]) !== undefined)
       completed += 1;
   }
   return completed;
@@ -845,7 +877,7 @@ async function runSettingsEditor(ctx) {
   const specs = [
     {
       key: "turnsBeforeCompact",
-      description: "LLM turns before compaction; 0 disables.",
+      description: "Completed agent runs before compaction; 0 disables.",
       min: TURNS_BEFORE_COMPACT_MIN,
       max: TURNS_BEFORE_COMPACT_MAX
     },
@@ -1411,7 +1443,8 @@ function createGoosedumpIntegration(options = {}) {
   let operationGeneration = 0;
   let activeSessionFile = null;
   let sessionActive = false;
-  let agentEndObserved = true;
+  let agentRunObserved = false;
+  let agentRunStartEntryId = null;
   const rememberQueue = [];
   let rememberRunning = null;
   function enqueueRemember(target, reportError) {
@@ -1449,9 +1482,9 @@ function createGoosedumpIntegration(options = {}) {
   }
   function syncCompactCounters(ctx) {
     compactSettings = resolveGoosedumpSettings(ctx.cwd, projectSettingsTrusted(ctx));
-    const completedTurns = completedTurnsSinceCompaction(ctx.sessionManager.getBranch());
-    turnsRemaining = Math.max(0, compactSettings.turnsBeforeCompact - completedTurns);
-    counterTriggered = compactSettings.turnsBeforeCompact > 0 && completedTurns >= compactSettings.turnsBeforeCompact;
+    const completedRuns = completedRunsSinceCompaction(ctx.sessionManager.getBranch());
+    turnsRemaining = Math.max(0, compactSettings.turnsBeforeCompact - completedRuns);
+    counterTriggered = compactSettings.turnsBeforeCompact > 0 && completedRuns >= compactSettings.turnsBeforeCompact;
   }
   function updateStatus(ctx) {
     if (!goosedumpAvailable)
@@ -1476,7 +1509,7 @@ function createGoosedumpIntegration(options = {}) {
     compactionState = state;
     updateStatus(ctx);
   }
-  function noteCompletedTurn(ctx) {
+  function noteCompletedRun(ctx) {
     if (!goosedumpAvailable || !shouldOverrideDefaultCompaction)
       return;
     syncCompactCounters(ctx);
@@ -1503,6 +1536,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;
   }
@@ -1545,7 +1591,7 @@ function createGoosedumpIntegration(options = {}) {
       operation,
       sessionGeneration: generation,
       sessionFile,
-      hookActive: false
+      hookClaimed: false
     });
     ctx.compact({
       onComplete: () => {
@@ -1564,6 +1610,17 @@ function createGoosedumpIntegration(options = {}) {
     });
     return true;
   }
+  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";
@@ -1946,8 +2003,8 @@ ${lines.join(`
       if (compactionState.phase === "idle") {
         queueTurnCompaction(ctx, settlementGeneration);
       }
-      if (agentEndObserved && compactionState.phase === "queued" && compactionState.request.eligibleSettlement <= settlementGeneration) {
-        startQueuedCompaction(ctx);
+      if (compactionState.phase === "queued" && compactionState.request.eligibleSettlement <= settlementGeneration) {
+        deferQueuedCompaction(ctx);
       }
     }
     pi.on("session_start", async (_event, ctx) => {
@@ -1955,47 +2012,72 @@ ${lines.join(`
       settlementGeneration = 0;
       activeSessionFile = ctx.sessionManager.getSessionFile?.() ?? null;
       sessionActive = true;
-      agentEndObserved = true;
+      agentRunObserved = false;
+      agentRunStartEntryId = null;
       compactionState = { phase: "idle" };
       goosedumpAvailable = checkGoosedump(ctx);
       notifyInvalidSettings(ctx);
       syncCompactCounters(ctx);
       updateStatus(ctx);
       queueTurnCompaction(ctx, 1);
+      deferQueuedCompaction(ctx);
     });
     pi.on("session_shutdown", async () => {
       sessionGeneration += 1;
       settlementGeneration = 0;
       activeSessionFile = null;
       sessionActive = false;
-      agentEndObserved = true;
+      agentRunObserved = false;
+      agentRunStartEntryId = null;
       compactionState = { phase: "idle" };
     });
-    pi.on("agent_start", async () => {
-      agentEndObserved = false;
-    });
-    pi.on("agent_end", async () => {
-      agentEndObserved = true;
+    pi.on("session_tree", async (_event, ctx) => {
+      sessionGeneration += 1;
+      settlementGeneration = 0;
+      activeSessionFile = ctx.sessionManager.getSessionFile?.() ?? null;
+      sessionActive = true;
+      agentRunObserved = false;
+      agentRunStartEntryId = null;
+      compactionState = { phase: "idle" };
+      syncCompactCounters(ctx);
+      updateStatus(ctx);
+      queueTurnCompaction(ctx, 1);
+      deferQueuedCompaction(ctx);
     });
-    pi.on("turn_end", async (event, ctx) => {
-      if (isCompletedAssistant(event.message))
-        noteCompletedTurn(ctx);
+    pi.on("agent_start", async (_event, ctx) => {
+      if (!agentRunObserved) {
+        agentRunObserved = true;
+        agentRunStartEntryId = ctx.sessionManager.getBranch().at(-1)?.id ?? null;
+      }
+      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("agent_settled", async (_event, ctx) => {
+      if (agentRunObserved) {
+        const countRun = shouldOverrideDefaultCompaction && compactSettings.turnsBeforeCompact > 0;
+        if (countRun) {
+          pi.appendEntry(COMPLETED_AGENT_RUN_ENTRY, {
+            version: 1,
+            startedAfterEntryId: agentRunStartEntryId
+          });
+        }
+        agentRunObserved = false;
+        agentRunStartEntryId = null;
+        if (countRun)
+          noteCompletedRun(ctx);
+      }
       handleAgentSettled(ctx);
     });
     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") {
-          setCompactionState(ctx, { phase: "idle" });
-        }
-        return;
-      }
-      if (event.signal.aborted) {
+      const signal = event.signal;
+      if (signal?.aborted) {
         if (compactionState.phase === "queued" && requestIsCurrent(compactionState.request)) {
           setCompactionState(ctx, event.reason === "manual" ? { phase: "idle" } : {
             phase: "queued",
@@ -2005,6 +2087,22 @@ ${lines.join(`
             }
           });
         }
+        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;
@@ -2013,7 +2111,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;
@@ -2021,7 +2119,7 @@ ${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;
@@ -2035,9 +2133,12 @@ ${lines.join(`
           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;
         if ((request?.keep ?? null) === null && messagesToSummarize.length === 0 && turnPrefixMessages.length === 0) {
@@ -2061,11 +2162,11 @@ ${lines.join(`
               operation,
               sessionGeneration: generation,
               sessionFile,
-              hookActive: true
+              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 };
         }
@@ -2085,8 +2186,12 @@ ${lines.join(`
         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 };
+        }
         if (ctx.hasUI) {
           const message = err instanceof Error ? err.message : String(err);
           ctx.ui.notify(`goosedump compaction failed; falling back to Pi compaction: ${message}`, "error");
@@ -2094,14 +2199,14 @@ ${lines.join(`
         return;
       } finally {
         if (runningOperationIsCurrent(operation, generation, sessionFile)) {
-          setCompactionState(ctx, owner === "pi" && event.reason === "manual" ? { phase: "idle" } : {
+          setCompactionState(ctx, {
             phase: "running",
             request,
             owner,
             operation,
             sessionGeneration: generation,
             sessionFile,
-            hookActive: false
+            hookClaimed: true
           });
         }
       }
@@ -2114,7 +2219,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)

package/package.json

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