pi-goosedump 0.12.20 → 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

@@ -525,21 +525,21 @@ function resolveTarget(ctx, provider, contextId) {
 }
 var GOOSE_PROVIDERS = ["pi", "claude", "codex", "crush", "gemini", "goose", "opencode"];
 var HISTORY_TARGET_GUIDELINE = "Use the current Pi session by default; non-Pi providers require an explicit session ID.";
-function historyProviderParam(operation) {
+function historyProviderParam() {
   return Type.Optional(Type.Union(GOOSE_PROVIDERS.map((provider) => Type.Literal(provider)), {
     default: "pi",
-    description: `Source provider whose sessions to ${operation}. Defaults to pi. Non-pi providers have no current session, so they require an explicit session id.`
+    description: "Source provider. Defaults to pi. Non-Pi providers have no current session, so they require an explicit session ID."
   }));
 }
 function historySessionParam() {
   return Type.Optional(Type.String({
-    description: "Context/session ID. Defaults to the current Pi session for pi; required when provider is not pi."
+    description: "Session ID. Defaults to the current Pi session for pi; required when provider is not pi."
   }));
 }
 function historyScopeParam() {
   return Type.Optional(Type.Union([Type.Literal("lineage"), Type.Literal("all")], {
     default: "lineage",
-    description: "Scope: lineage (current branch) or all entries in the session"
+    description: "lineage (current branch, default) or all session entries"
   }));
 }
 async function goosedumpCompact(target, options, signal, executablePath) {
@@ -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
@@ -1649,14 +1659,14 @@ function createGoosedumpIntegration(options = {}) {
       pi.registerTool(defineTool({
         name: "goose_remember",
         label: "goose_remember",
-        description: "Queue local gpt-oss-20b memory extraction and BGE embedding in the background. Defaults to the current Pi session.",
+        description: "Queue local memory extraction and embedding in the background. Defaults to the current Pi session.",
         promptSnippet: "Persist important context from the current or another session into durable memory",
         promptGuidelines: [
           "Use goose_remember after a milestone when important facts, decisions, preferences, procedures, or lessons should be retained.",
           "Defaults to the current Pi session; pass provider/session when targeting a different session."
         ],
         parameters: Type.Object({
-          provider: historyProviderParam("read"),
+          provider: historyProviderParam(),
           session: historySessionParam()
         }),
         async execute(_id, params, _signal, _onUpdate, ctx) {
@@ -1677,7 +1687,7 @@ function createGoosedumpIntegration(options = {}) {
       pi.registerTool(defineTool({
         name: "goose_recall",
         label: "goose_recall",
-        description: "Recall project-scoped memory. Lexical and entity matches come first; BGE vector matches fill remaining slots. Returns bounded records with provenance; history includes superseded statements.",
+        description: "Recall project-scoped memory. Lexical and entity matches come first; vector matches fill remaining slots. Returns bounded records with provenance; history includes superseded statements.",
         promptSnippet: "Recall durable context from earlier sessions",
         promptGuidelines: [
           "Use goose_recall for decisions, evidence, and context that may have disappeared from the current session.",
@@ -1728,7 +1738,7 @@ function createGoosedumpIntegration(options = {}) {
       pi.registerTool(defineTool({
         name: "goose_forget",
         label: "goose_forget",
-        description: "Forget/remove durable context entries from goosedump memory.",
+        description: "Remove durable context entries from goosedump memory.",
         promptSnippet: "Remove obsolete entries from durable memory store",
         promptGuidelines: [
           "Use goose_forget to delete stale, inaccurate, or obsolete entries from durable memory.",
@@ -1778,7 +1788,7 @@ function createGoosedumpIntegration(options = {}) {
       pi.registerTool(defineTool({
         name: "goose_search",
         label: "goose_search",
-        description: "Search coding agent session history by ranked relevance. Returns compact entry overviews with entry IDs; use goose_get to expand specific IDs to full content. Defaults to the current Pi session.",
+        description: "Search session history by ranked relevance. Returns compact entry overviews with entry IDs; use goose_get to expand. Defaults to the current Pi session.",
         promptSnippet: "Search session history by ranked relevance",
         promptGuidelines: [
           "Use goose_search to find relevant context in this or another coding agent's session history.",
@@ -1788,7 +1798,7 @@ function createGoosedumpIntegration(options = {}) {
         ],
         parameters: Type.Object({
           query: Type.String({ description: "Search query to rank messages by relevance" }),
-          provider: historyProviderParam("search"),
+          provider: historyProviderParam(),
           session: historySessionParam(),
           scope: historyScopeParam(),
           page: Type.Optional(Type.Integer({
@@ -1824,7 +1834,7 @@ function createGoosedumpIntegration(options = {}) {
       pi.registerTool(defineTool({
         name: "goose_get",
         label: "goose_get",
-        description: "Expand specific entry IDs (from goose_search or goose_grep) to their full content. Defaults to the current Pi session.",
+        description: "Expand entry IDs from goose_search or goose_grep to full content. Defaults to the current Pi session.",
         promptSnippet: "Expand session entries by ID to full content",
         promptGuidelines: [
           "Use goose_get to expand entry IDs returned by goose_search or goose_grep into their full content.",
@@ -1837,7 +1847,7 @@ function createGoosedumpIntegration(options = {}) {
             minItems: 1,
             description: "Entry IDs to expand (show full content)"
           }),
-          provider: historyProviderParam("read"),
+          provider: historyProviderParam(),
           session: historySessionParam(),
           scope: historyScopeParam()
         }),
@@ -1873,7 +1883,7 @@ function createGoosedumpIntegration(options = {}) {
         ],
         parameters: Type.Object({
           pattern: Type.String({ description: "Glob pattern to filter messages (e.g. *rand*)" }),
-          provider: historyProviderParam("grep"),
+          provider: historyProviderParam(),
           session: historySessionParam(),
           scope: historyScopeParam()
         }),
@@ -1899,7 +1909,7 @@ function createGoosedumpIntegration(options = {}) {
       pi.registerTool(defineTool({
         name: "goose_compact",
         label: "goose_compact",
-        description: "Trigger a goosedump compaction of the current session now, optionally keeping the last N user turns verbatim while summarizing everything before. Compaction runs asynchronously via Pi's compaction flow.",
+        description: "Compact the current session now, optionally keeping the last N user turns verbatim. Runs asynchronously via Pi's compaction flow.",
         promptSnippet: "Compact session history; optionally keep recent user turns",
         promptGuidelines: [
           "Use goose_compact to compact the session proactively with goosedump when context is large or nearing limits.",
@@ -1928,7 +1938,7 @@ function createGoosedumpIntegration(options = {}) {
       pi.registerTool(defineTool({
         name: "goose_sessions",
         label: "goose_sessions",
-        description: "List or delete session IDs for the current working directory.",
+        description: "List or delete sessions for the current working directory.",
         promptSnippet: "List or delete coding agent sessions for current directory",
         promptGuidelines: [
           "Use goose_sessions to discover sessions in the current directory or delete a non-active session.",
@@ -1940,7 +1950,7 @@ function createGoosedumpIntegration(options = {}) {
             default: "list",
             description: "Action: list (default) or delete"
           })),
-          provider: historyProviderParam("list"),
+          provider: historyProviderParam(),
           session: Type.Optional(Type.String({
             description: "Session ID to delete (required for action: delete)"
           }))
@@ -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 };
       }
@@ -2257,7 +2257,7 @@ ${lines.join(`
       }
     });
     maybePi.registerCommand?.("goose-compact", {
-      description: "Compact now with goosedump; optionally keep the last N user turns",
+      description: "Compact the current session now; optionally keep the last N user turns",
       handler: async (args, ctx) => {
         if (!goosedumpAvailable) {
           ctx.ui.notify(GOOSEDUMP_UNAVAILABLE_MESSAGE, "error");
@@ -2309,7 +2309,7 @@ ${lines.join(`
       }
     });
     maybePi.registerCommand?.("goose-sessions", {
-      description: "Manage and switch between sessions for the current working directory",
+      description: "List, resume, or delete sessions for the current working directory",
       handler: async (_args, ctx) => {
         if (!goosedumpAvailable) {
           ctx.ui.notify(GOOSEDUMP_UNAVAILABLE_MESSAGE, "error");
@@ -2324,7 +2324,7 @@ ${lines.join(`
       }
     });
     maybePi.registerCommand?.("goose-forget", {
-      description: "Forget/remove an entry from goosedump durable memory",
+      description: "Remove a durable memory entry or remembered session",
       handler: async (args, ctx) => {
         if (!goosedumpAvailable) {
           ctx.ui.notify(GOOSEDUMP_UNAVAILABLE_MESSAGE, "error");
@@ -2347,7 +2347,7 @@ ${lines.join(`
       }
     });
     maybePi.registerCommand?.("goose-memory-status", {
-      description: "Show durable memory status and health stats",
+      description: "Show durable memory storage health and type counts",
       handler: async (_args, ctx) => {
         if (!goosedumpAvailable) {
           ctx.ui.notify(GOOSEDUMP_UNAVAILABLE_MESSAGE, "error");

package/package.json

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