pi-goosedump 0.12.21 → 0.12.22

package/README.md

@@ -92,19 +92,20 @@ 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 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
+`turnsBeforeCompact` is an integer from 0 to 255. `0` disables the turn-based
+trigger. Pi's `compaction.enabled` setting controls all automatic compaction, including
+the turn-based trigger. 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:--` means the turn trigger is
+disabled. The footer 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 scheduler for
+its context threshold. Whichever enabled 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

package/dist/index.ts

@@ -607,6 +607,16 @@ function piKeepRecentTokens(cwd, includeProject) {
   }
   return DEFAULT_COMPACTION_SETTINGS.keepRecentTokens;
 }
+function piCompactionEnabled(cwd, includeProject) {
+  const paths = includeProject ? [projectSettingsPath(cwd), globalSettingsPath()] : [globalSettingsPath()];
+  for (const path of paths) {
+    const compaction = readJsonObject(path).compaction;
+    if (isRecord(compaction) && typeof compaction.enabled === "boolean") {
+      return compaction.enabled;
+    }
+  }
+  return DEFAULT_COMPACTION_SETTINGS.enabled;
+}
 function piReserveTokens(cwd, includeProject) {
   const paths = includeProject ? [projectSettingsPath(cwd), globalSettingsPath()] : [globalSettingsPath()];
   for (const path of paths) {
@@ -845,13 +855,11 @@ async function runSettingsEditor(ctx) {
   const specs = [
     {
       key: "turnsBeforeCompact",
-      description: "LLM turns before compaction; 0 disables.",
       min: TURNS_BEFORE_COMPACT_MIN,
       max: TURNS_BEFORE_COMPACT_MAX
     },
     {
       key: "summaryMaxTokens",
-      description: "Maximum estimated tokens in each summary.",
       min: SUMMARY_MAX_TOKENS_MIN,
       max: SUMMARY_MAX_TOKENS_MAX
     }
@@ -964,11 +972,6 @@ async function runSettingsEditor(ctx) {
             const cursor = selected ? accent("›") : " ";
             content.push(`${cursor} ${renderedValue} ${text(spec.key)}`);
           }
-          const selectedSpec = specs[selectedSetting];
-          if (selectedSpec) {
-            const inherited = scope === "project" && projectSettings[selectedSpec.key] === undefined;
-            content.push("", dim(inherited ? `${selectedSpec.description} Using the Global value.` : selectedSpec.description));
-          }
           const effective = resolveGoosedumpSettings(location, projectTrusted);
           content.push("", dim(`Effective: turns=${formatCompactSetting(effective.turnsBeforeCompact)} · summary=${effectiveSummaryMaxTokens(location, projectTrusted)} tokens`));
         }
@@ -1403,6 +1406,7 @@ function createGoosedumpIntegration(options = {}) {
   const nativeExecutablePath = options.nativeExecutablePath;
   let goosedumpAvailable = false;
   let compactSettings = DEFAULT_GOOSEDUMP_SETTINGS;
+  let piAutoCompactionEnabled = DEFAULT_COMPACTION_SETTINGS.enabled;
   let turnsRemaining = 0;
   let counterTriggered = false;
   let compactionState = { phase: "idle" };
@@ -1448,15 +1452,27 @@ function createGoosedumpIntegration(options = {}) {
       await rememberRunning;
   }
   function syncCompactCounters(ctx) {
-    compactSettings = resolveGoosedumpSettings(ctx.cwd, projectSettingsTrusted(ctx));
+    const projectTrusted = projectSettingsTrusted(ctx);
+    compactSettings = resolveGoosedumpSettings(ctx.cwd, projectTrusted);
+    piAutoCompactionEnabled = piCompactionEnabled(ctx.cwd, projectTrusted);
     const completedTurns = completedTurnsSinceCompaction(ctx.sessionManager.getBranch());
     turnsRemaining = Math.max(0, compactSettings.turnsBeforeCompact - completedTurns);
     counterTriggered = compactSettings.turnsBeforeCompact > 0 && completedTurns >= compactSettings.turnsBeforeCompact;
   }
+  function turnCompactionEnabled() {
+    return shouldOverrideDefaultCompaction && piAutoCompactionEnabled && compactSettings.turnsBeforeCompact > 0;
+  }
+  function turnRequestIsEligible(request) {
+    return request.origin !== "turn" || turnCompactionEnabled() && counterTriggered;
+  }
+  function requeueRequest(request, eligibleSettlement) {
+    const queued = { ...request, eligibleSettlement };
+    return requestIsCurrent(queued) && turnRequestIsEligible(queued) ? { phase: "queued", request: queued } : { phase: "idle" };
+  }
   function updateStatus(ctx) {
     if (!goosedumpAvailable)
       return;
-    const active = shouldOverrideDefaultCompaction && compactSettings.turnsBeforeCompact > 0;
+    const active = turnCompactionEnabled();
     let dotColor = "success";
     if (active) {
       const remainingRatio = turnsRemaining / compactSettings.turnsBeforeCompact;
@@ -1493,7 +1509,7 @@ function createGoosedumpIntegration(options = {}) {
     }, { triggerTurn: true });
   }
   function tryMidRunCounterCompaction(ctx) {
-    if (!goosedumpAvailable || !shouldOverrideDefaultCompaction)
+    if (!goosedumpAvailable || !turnCompactionEnabled())
       return false;
     if (!counterTriggered)
       return false;
@@ -1503,14 +1519,10 @@ function createGoosedumpIntegration(options = {}) {
       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)
-        }
-      });
+    } else if (compactionState.phase === "queued" && compactionState.request.origin === "turn") {
+      setCompactionState(ctx, requeueRequest(compactionState.request, Math.min(compactionState.request.eligibleSettlement, settlementGeneration)));
+    } else {
+      return false;
     }
     return startQueuedCompaction(ctx, { resumeAfter: true, allowActiveRun: true });
   }
@@ -1538,20 +1550,14 @@ function createGoosedumpIntegration(options = {}) {
     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" });
+      setCompactionState(ctx, reason !== "manual" && request ? requeueRequest(request, 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;
   }
   function queueTurnCompaction(ctx, eligibleSettlement) {
-    if (!counterTriggered || compactionState.phase !== "idle")
+    if (!turnCompactionEnabled() || !counterTriggered || compactionState.phase !== "idle")
       return;
     if (!hasCompactableHistory(ctx))
       return;
@@ -1559,6 +1565,7 @@ function createGoosedumpIntegration(options = {}) {
       phase: "queued",
       request: {
         keep: null,
+        origin: "turn",
         sessionGeneration,
         sessionFile: activeSessionFile,
         eligibleSettlement
@@ -1569,7 +1576,9 @@ function createGoosedumpIntegration(options = {}) {
     if (compactionState.phase !== "queued")
       return false;
     const request = compactionState.request;
-    if (!requestIsCurrent(request)) {
+    if (request.origin === "turn")
+      syncCompactCounters(ctx);
+    if (!requestIsCurrent(request) || !turnRequestIsEligible(request)) {
       setCompactionState(ctx, { phase: "idle" });
       return false;
     }
@@ -1636,6 +1645,7 @@ function createGoosedumpIntegration(options = {}) {
       phase: "queued",
       request: {
         keep,
+        origin: "manual",
         sessionGeneration,
         sessionFile: activeSessionFile,
         eligibleSettlement: settlementGeneration + 1
@@ -2000,13 +2010,10 @@ ${lines.join(`
       updateStatus(ctx);
       if (compactionState.phase === "running" && compactionState.owner === "pi") {
         const request = compactionState.request;
-        setCompactionState(ctx, request && requestIsCurrent(request) ? {
-          phase: "queued",
-          request: { ...request, eligibleSettlement: settlementGeneration + 1 }
-        } : { phase: "idle" });
+        setCompactionState(ctx, request ? requeueRequest(request, settlementGeneration + 1) : { phase: "idle" });
         return;
       }
-      if (compactionState.phase === "queued" && !requestIsCurrent(compactionState.request)) {
+      if (compactionState.phase === "queued" && (!requestIsCurrent(compactionState.request) || !turnRequestIsEligible(compactionState.request))) {
         setCompactionState(ctx, { phase: "idle" });
       }
       if (compactionState.phase === "idle") {
@@ -2051,10 +2058,9 @@ ${lines.join(`
       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" });
+      if (request?.origin === "turn")
+        syncCompactCounters(ctx);
+      setCompactionState(ctx, request ? requeueRequest(request, settlementGeneration + 1) : { phase: "idle" });
     });
     pi.on("turn_end", async (event, ctx) => {
       if (isCompletedAssistant(event.message))
@@ -2071,13 +2077,7 @@ ${lines.join(`
       const signal = event.signal;
       if (signal?.aborted) {
         if (compactionState.phase === "queued" && requestIsCurrent(compactionState.request)) {
-          setCompactionState(ctx, event.reason === "manual" ? { phase: "idle" } : {
-            phase: "queued",
-            request: {
-              ...compactionState.request,
-              eligibleSettlement: Math.max(compactionState.request.eligibleSettlement, settlementGeneration + 2)
-            }
-          });
+          setCompactionState(ctx, event.reason === "manual" ? { phase: "idle" } : requeueRequest(compactionState.request, Math.max(compactionState.request.eligibleSettlement, settlementGeneration + 2)));
         }
         return { cancel: true };
       }

package/package.json

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