pi-goosedump 0.12.39 → 0.12.41

package/README.md

@@ -9,10 +9,11 @@ management, and compaction. Tools use the `goose_` prefix.
 pi install npm:pi-goosedump
 ```
 
-Bundled native binaries: Linux x64, macOS arm64, Windows x64.
+Bundled native binaries: Linux x64 and arm64, macOS arm64, and Windows x64.
 
-On unsupported platforms, Pi keeps its normal compaction behavior and goosedump
-tools report that they are unavailable. Local models download on first use.
+Unsupported platforms are rejected when the extension loads. A missing packaged binary is treated as
+a broken installation instead of falling back to a `goosedump` executable on `PATH`. Local models
+download on first use.
 
 ## Tools
 
@@ -91,8 +92,8 @@ The footer shows the remaining turn count in hexadecimal.
 - `keep:N` leaves the last N user turns verbatim.
 - Manual requests wait until Pi is idle.
 - Memory learning runs in the background after a successful compaction.
-- If the turn limit expires during a tool loop, compaction waits until the agent
-  run settles, so no in-flight operation is aborted.
+- If the turn limit expires during a tool loop, Pi saves the current batch,
+  compacts at that turn boundary, and resumes automatically.
 - Goosedump failures fall back to Pi's compactor.
 
 ## License

package/dist/index.ts

@@ -1,9 +1,6 @@
 // SPDX-License-Identifier: Apache-2.0
 // Copyright (C) Jarkko Sakkinen 2026
 
-// src/integration.ts
-import { execFileSync } from "node:child_process";
-
 // src/cli.ts
 import { execFile } from "node:child_process";
 import { existsSync } from "node:fs";
@@ -34,7 +31,6 @@ var TURNS_BEFORE_COMPACT_MIN = 0;
 var TURNS_BEFORE_COMPACT_MAX = 255;
 var SUMMARY_MAX_TOKENS_MIN = 512;
 var SUMMARY_MAX_TOKENS_MAX = 65536;
-var GOOSEDUMP_UNAVAILABLE_MESSAGE = "goosedump is not available. Install with: npm install @jarkkojs/goosedump";
 var GOOSE_PROVIDERS = [
   "pi",
   "claude",
@@ -63,9 +59,6 @@ function missingSessionId(tool, provider = "pi") {
   }
   return textResult(`session is required for ${tool} when no current session is available`);
 }
-function goosedumpUnavailableResult() {
-  return textResult(GOOSEDUMP_UNAVAILABLE_MESSAGE);
-}
 function compactStartedMessage(keep, queued = false) {
   const action = queued ? "Compaction queued with goosedump" : "Compacting with goosedump";
   return keep !== null ? `${action}; keeping the last ${keep} user turn${keep === 1 ? "" : "s"}.` : `${action} up to Pi's token-based cut.`;
@@ -181,6 +174,12 @@ function parsePiMessages(output) {
         role: "user",
         content: flattenPiContent(entry.content)
       });
+    } else if (entry.type === "compaction") {
+      messages.push({
+        id: entry.id ?? "",
+        role: "compactionSummary",
+        content: entry.summary ?? ""
+      });
     } else if (entry.type === "branch_summary") {
       messages.push({
         id: entry.id ?? "",
@@ -283,33 +282,40 @@ ${m.content}`).join(`
 
 // src/cli.ts
 var require2 = createRequire(import.meta.url);
-function resolveGoosedumpBinary() {
-  return require2.resolve("@jarkkojs/goosedump/bin/goosedump.js");
-}
-function resolveNativeGoosedumpBinary() {
-  const target = `${process.platform}-${process.arch}`;
-  let packageName;
-  let binaryName = "goosedump";
+function nativeGoosedumpPackage(target) {
   switch (target) {
     case "linux-x64":
-      packageName = "@jarkkojs/goosedump-linux-x64";
-      break;
+      return { packageName: "@jarkkojs/goosedump-linux-x64", binaryName: "goosedump" };
+    case "linux-arm64":
+      return { packageName: "@jarkkojs/goosedump-linux-arm64", binaryName: "goosedump" };
     case "darwin-arm64":
-      packageName = "@jarkkojs/goosedump-darwin-arm64";
-      break;
+      return { packageName: "@jarkkojs/goosedump-darwin-arm64", binaryName: "goosedump" };
     case "win32-x64":
-      packageName = "@jarkkojs/goosedump-win32-x64";
-      binaryName = "goosedump.exe";
-      break;
+      return { packageName: "@jarkkojs/goosedump-win32-x64", binaryName: "goosedump.exe" };
     default:
       throw new Error(`unsupported platform architecture: ${target}`);
   }
-  const wrapperRequire = createRequire(resolveGoosedumpBinary());
-  const packageDir = dirname(wrapperRequire.resolve(`${packageName}/package.json`));
-  const binaryPath = join(packageDir, "bin", binaryName);
-  if (!existsSync(binaryPath))
-    throw new Error(`binary not found: ${binaryPath}`);
-  return binaryPath;
+}
+function resolveGoosedumpBinary() {
+  try {
+    return require2.resolve("@jarkkojs/goosedump/bin/goosedump.js");
+  } catch (cause) {
+    throw new Error("broken pi-goosedump installation: cannot resolve the @jarkkojs/goosedump dependency", { cause });
+  }
+}
+function resolveNativeGoosedumpBinary() {
+  const target = `${process.platform}-${process.arch}`;
+  const { packageName, binaryName } = nativeGoosedumpPackage(target);
+  try {
+    const wrapperRequire = createRequire(resolveGoosedumpBinary());
+    const packageDir = dirname(wrapperRequire.resolve(`${packageName}/package.json`));
+    const binaryPath = join(packageDir, "bin", binaryName);
+    if (!existsSync(binaryPath))
+      throw new Error(`binary not found: ${binaryPath}`);
+    return binaryPath;
+  } catch (cause) {
+    throw new Error(`broken pi-goosedump installation: cannot resolve the packaged binary ${packageName} for ${target}`, { cause });
+  }
 }
 function runGoosedumpAsync(args, signal, executablePath = resolveNativeGoosedumpBinary()) {
   return new Promise((resolve, reject) => {
@@ -384,12 +390,16 @@ async function goosedumpMemoryStatus(signal, executablePath) {
 async function goosedumpListSessions(signal, executablePath) {
   const args = ["session", "list", "--json"];
   const output = await runGoosedumpAsync(args, signal, executablePath);
+  let parsed;
   try {
-    const parsed = JSON.parse(output.stdout);
-    return Array.isArray(parsed) ? parsed : [];
-  } catch {
-    return [];
+    parsed = JSON.parse(output.stdout);
+  } catch (error) {
+    throw new Error("invalid goosedump session list JSON", { cause: error });
+  }
+  if (!Array.isArray(parsed)) {
+    throw new Error("invalid goosedump session list JSON: expected an array");
   }
+  return parsed;
 }
 async function goosedumpRemoveSession(target, signal, executablePath) {
   const args = ["session", "remove", target, "--yes"];
@@ -520,13 +530,32 @@ function readJsonObjectStrict(path) {
     throw new Error(`${path} must contain a JSON object`);
   return parsed;
 }
+function replaceFileAtomically(temporaryPath, path) {
+  if (process.platform !== "win32" || !existsSync2(path)) {
+    renameSync(temporaryPath, path);
+    return;
+  }
+  const backupPath = `${path}.${randomUUID()}.bak`;
+  renameSync(path, backupPath);
+  try {
+    renameSync(temporaryPath, path);
+  } catch (error) {
+    try {
+      renameSync(backupPath, path);
+    } catch {}
+    throw error;
+  }
+  try {
+    unlinkSync(backupPath);
+  } catch {}
+}
 function writeJsonObjectAtomically(path, value) {
   mkdirSync(dirname2(path), { recursive: true });
   const temporaryPath = `${path}.${randomUUID()}.tmp`;
   try {
     writeFileSync(temporaryPath, `${JSON.stringify(value, null, 2)}
 `, { flag: "wx" });
-    renameSync(temporaryPath, path);
+    replaceFileAtomically(temporaryPath, path);
   } catch (error) {
     try {
       unlinkSync(temporaryPath);
@@ -784,10 +813,10 @@ function isCompactionCancellation(error) {
 class CompactionRuntime {
   overrideDefaultCompaction;
   nativeExecutablePath;
-  isAvailable;
   enqueueRemember;
   compactSettings = DEFAULT_GOOSEDUMP_SETTINGS;
   piAutoCompactionEnabled = DEFAULT_COMPACTION_SETTINGS2.enabled;
+  piCompactionReserveTokens = DEFAULT_COMPACTION_SETTINGS2.reserveTokens;
   turnsRemaining = 0;
   counterTriggered = false;
   compactionState = { phase: "idle" };
@@ -796,12 +825,15 @@ class CompactionRuntime {
   operationGeneration = 0;
   activeSessionFile = null;
   sessionActive = false;
+  activePi = null;
   constructor(deps) {
     this.overrideDefaultCompaction = deps.overrideDefaultCompaction;
     this.nativeExecutablePath = deps.nativeExecutablePath;
-    this.isAvailable = deps.isAvailable;
     this.enqueueRemember = deps.enqueueRemember;
   }
+  setActivePi(pi) {
+    this.activePi = pi;
+  }
   requestCompaction(ctx, keep) {
     if (this.compactionState.phase !== "idle")
       return "busy";
@@ -814,7 +846,8 @@ class CompactionRuntime {
         origin: "manual",
         sessionGeneration: this.sessionGeneration,
         sessionFile: this.activeSessionFile,
-        eligibleSettlement: this.settlementGeneration + 1
+        eligibleSettlement: this.settlementGeneration + 1,
+        resumeAfter: false
       }
     });
     return this.startQueuedCompaction(ctx) ? "started" : "queued";
@@ -823,13 +856,12 @@ class CompactionRuntime {
     const projectTrusted = projectSettingsTrusted(ctx);
     this.compactSettings = resolveGoosedumpSettings(ctx.cwd, projectTrusted);
     this.piAutoCompactionEnabled = piCompactionEnabled(ctx.cwd, projectTrusted);
+    this.piCompactionReserveTokens = piReserveTokens(ctx.cwd, projectTrusted);
     const completedTurns = completedTurnsSinceCompaction(ctx.sessionManager.getBranch());
     this.turnsRemaining = Math.max(0, this.compactSettings.turnsBeforeCompact - completedTurns);
     this.counterTriggered = this.compactSettings.turnsBeforeCompact > 0 && completedTurns >= this.compactSettings.turnsBeforeCompact;
   }
   updateStatus(ctx) {
-    if (!this.isAvailable())
-      return;
     const active = this.turnCompactionEnabled();
     let dotColor = "success";
     if (active) {
@@ -855,7 +887,7 @@ class CompactionRuntime {
     this.syncCompactCounters(ctx);
     this.updateStatus(ctx);
     this.queueTurnCompaction(ctx, 1);
-    this.deferQueuedCompaction(ctx);
+    this.startQueuedCompaction(ctx);
   }
   endSession() {
     this.sessionGeneration += 1;
@@ -873,12 +905,18 @@ class CompactionRuntime {
     this.setCompactionState(ctx, request ? this.requeueRequest(request, this.settlementGeneration + 1) : { phase: "idle" });
   }
   onTurnEnd(event, ctx) {
-    if (isCompletedAssistant(event.message))
+    if (!isCompletedAssistant(event.message))
+      return;
+    const resumeAfter = event.toolResults.length > 0 && !ctx.hasPendingMessages();
+    if (this.overrideDefaultCompaction) {
       this.noteCompletedTurn(ctx);
+      const eligibleSettlement = this.settlementGeneration + 1;
+      this.queueTurnCompaction(ctx, eligibleSettlement, resumeAfter);
+      this.queueThresholdCompaction(ctx, eligibleSettlement, resumeAfter);
+    }
+    this.interruptToolLoopForQueuedCompaction(ctx, resumeAfter);
   }
   onAgentSettled(ctx) {
-    if (!this.isAvailable() || !this.overrideDefaultCompaction)
-      return;
     this.settlementGeneration += 1;
     this.syncCompactCounters(ctx);
     this.updateStatus(ctx);
@@ -894,11 +932,11 @@ class CompactionRuntime {
       this.queueTurnCompaction(ctx, this.settlementGeneration);
     }
     if (this.compactionState.phase === "queued" && this.compactionState.request.eligibleSettlement <= this.settlementGeneration) {
-      this.deferQueuedCompaction(ctx);
+      this.startQueuedCompaction(ctx);
     }
   }
   async onSessionBeforeCompact(event, ctx) {
-    if (!this.overrideDefaultCompaction || !this.isAvailable())
+    if (!this.overrideDefaultCompaction)
       return;
     const signal = event.signal;
     if (signal?.aborted) {
@@ -1042,8 +1080,6 @@ class CompactionRuntime {
       this.compactionState = { phase: "idle" };
     this.resetCompactCounters(ctx);
     this.updateStatus(ctx);
-    if (!this.isAvailable())
-      return;
     const compactionEntry = event.compactionEntry;
     if (!event.fromExtension || !compactionEntry || !isRecord(compactionEntry.details) || compactionEntry.details.source !== "goosedump") {
       return;
@@ -1068,6 +1104,7 @@ class CompactionRuntime {
     const projectTrusted = projectSettingsTrusted(ctx);
     this.compactSettings = resolveGoosedumpSettings(ctx.cwd, projectTrusted);
     this.piAutoCompactionEnabled = piCompactionEnabled(ctx.cwd, projectTrusted);
+    this.piCompactionReserveTokens = piReserveTokens(ctx.cwd, projectTrusted);
     this.turnsRemaining = this.compactSettings.turnsBeforeCompact;
     this.counterTriggered = false;
   }
@@ -1086,11 +1123,48 @@ class CompactionRuntime {
     this.updateStatus(ctx);
   }
   noteCompletedTurn(ctx) {
-    if (!this.isAvailable() || !this.overrideDefaultCompaction)
+    if (!this.overrideDefaultCompaction)
       return;
     this.syncCompactCounters(ctx);
     this.updateStatus(ctx);
-    this.queueTurnCompaction(ctx, this.settlementGeneration + 1);
+  }
+  resumeAfterSuccessfulCompaction(ctx, resume) {
+    if (!resume || !this.activePi || ctx.hasPendingMessages())
+      return;
+    this.activePi.sendMessage({
+      customType: "goosedump-autocompact-resume",
+      content: "The session was compacted to reduce context size. Continue the task you were working on from where you left off.",
+      display: false
+    }, { triggerTurn: true });
+  }
+  interruptToolLoopForQueuedCompaction(ctx, resumeAfter) {
+    if (!resumeAfter || this.compactionState.phase !== "queued")
+      return;
+    const request = this.compactionState.request;
+    if (!this.requestIsCurrent(request))
+      return;
+    this.compactionState = {
+      phase: "queued",
+      request: { ...request, resumeAfter: true }
+    };
+    ctx.abort();
+  }
+  queueThresholdCompaction(ctx, eligibleSettlement, resumeAfter) {
+    const usage = ctx.getContextUsage();
+    if (!this.piAutoCompactionEnabled || this.piCompactionReserveTokens <= 0 || usage?.tokens === null || usage?.tokens === undefined || usage.tokens < usage.contextWindow - this.piCompactionReserveTokens || this.compactionState.phase !== "idle" || !hasCompactableHistory(ctx)) {
+      return;
+    }
+    this.setCompactionState(ctx, {
+      phase: "queued",
+      request: {
+        keep: null,
+        origin: "threshold",
+        sessionGeneration: this.sessionGeneration,
+        sessionFile: this.activeSessionFile,
+        eligibleSettlement,
+        resumeAfter
+      }
+    });
   }
   requestIsCurrent(request) {
     return request.sessionGeneration === this.sessionGeneration && request.sessionFile === this.activeSessionFile;
@@ -1111,7 +1185,7 @@ class CompactionRuntime {
   requestHasCompactableHistory(ctx, keep) {
     return keep === null ? hasCompactableHistory(ctx) : keepBoundaryId(ctx.sessionManager.getBranch(), keep) !== undefined;
   }
-  queueTurnCompaction(ctx, eligibleSettlement) {
+  queueTurnCompaction(ctx, eligibleSettlement, resumeAfter = false) {
     if (!this.turnCompactionEnabled() || !this.counterTriggered || this.compactionState.phase !== "idle") {
       return;
     }
@@ -1124,7 +1198,8 @@ class CompactionRuntime {
         origin: "turn",
         sessionGeneration: this.sessionGeneration,
         sessionFile: this.activeSessionFile,
-        eligibleSettlement
+        eligibleSettlement,
+        resumeAfter
       }
     });
   }
@@ -1138,7 +1213,7 @@ class CompactionRuntime {
       this.setCompactionState(ctx, { phase: "idle" });
       return false;
     }
-    if (ctx.hasPendingMessages())
+    if (request.origin !== "turn" && ctx.hasPendingMessages())
       return false;
     if (!ctx.isIdle())
       return false;
@@ -1149,6 +1224,7 @@ class CompactionRuntime {
     const operation = ++this.operationGeneration;
     const generation = request.sessionGeneration;
     const sessionFile = request.sessionFile;
+    const resumeAfter = request.resumeAfter;
     this.setCompactionState(ctx, {
       phase: "running",
       request,
@@ -1163,6 +1239,7 @@ class CompactionRuntime {
         if (!this.runningOperationIsCurrent(operation, generation, sessionFile))
           return;
         this.setCompactionState(ctx, { phase: "idle" });
+        this.resumeAfterSuccessfulCompaction(ctx, resumeAfter);
       },
       onError: (error) => {
         if (!this.runningOperationIsCurrent(operation, generation, sessionFile))
@@ -1179,17 +1256,6 @@ class CompactionRuntime {
     });
     return true;
   }
-  deferQueuedCompaction(ctx) {
-    if (this.compactionState.phase !== "queued")
-      return;
-    const request = this.compactionState.request;
-    setImmediate(() => {
-      if (this.compactionState.phase !== "queued" || this.compactionState.request !== request || !this.contextIsCurrent(ctx)) {
-        return;
-      }
-      this.startQueuedCompaction(ctx);
-    });
-  }
 }
 
 // src/policy.ts
@@ -1343,7 +1409,12 @@ function renderToolRoutingPolicy(options = {}) {
 }
 
 // src/tools.ts
-import { defineTool } from "@earendil-works/pi-coding-agent";
+import {
+  DEFAULT_MAX_BYTES,
+  DEFAULT_MAX_LINES,
+  defineTool,
+  truncateHead
+} from "@earendil-works/pi-coding-agent";
 import { Type } from "@sinclair/typebox";
 function historyProviderParam() {
   return Type.Optional(Type.Union(GOOSE_PROVIDERS.map((provider) => Type.Literal(provider)), {
@@ -1378,6 +1449,17 @@ function goosedumpErrorResult(err) {
   const message = err instanceof Error ? err.message : String(err);
   return textResult(`goosedump error: ${message}`);
 }
+function boundedHistoryResult(text) {
+  const output = truncateHead(text, {
+    maxBytes: DEFAULT_MAX_BYTES,
+    maxLines: DEFAULT_MAX_LINES
+  });
+  if (!output.truncated)
+    return textResult(text);
+  return textResult(`${output.content}
+
+[Output truncated: showing ${output.outputLines} of ${output.totalLines} lines ` + `and ${output.outputBytes} of ${output.totalBytes} bytes. ` + "Use goose_get with fewer IDs or a narrower goose_grep pattern.]");
+}
 function resolveHistoryTarget(ctx, tool, params) {
   const provider = params.provider ?? "pi";
   const target = resolveTarget(ctx, provider, params.session);
@@ -1401,13 +1483,11 @@ function gooseToolMeta(name) {
   };
 }
 var GOOSE_MEMORY_TYPES = ["decision", "fact", "preference", "procedure", "lesson"];
-function defineGooseTool(isAvailable, name, parameters, handler) {
+function defineGooseTool(name, parameters, handler) {
   return defineTool({
     ...gooseToolMeta(name),
     parameters,
     async execute(_id, params, signal, _onUpdate, ctx) {
-      if (!isAvailable())
-        return goosedumpUnavailableResult();
       try {
         return await handler(params, signal, ctx);
       } catch (err) {
@@ -1417,8 +1497,8 @@ function defineGooseTool(isAvailable, name, parameters, handler) {
   });
 }
 function registerGooseTools(pi, deps) {
-  const { isAvailable, nativeExecutablePath, enqueueRemember, requestCompaction } = deps;
-  pi.registerTool(defineGooseTool(isAvailable, "goose_remember", Type.Object({ ...historyTargetParams() }), async (params, _signal, ctx) => {
+  const { nativeExecutablePath, enqueueRemember, requestCompaction } = deps;
+  pi.registerTool(defineGooseTool("goose_remember", Type.Object({ ...historyTargetParams() }), async (params, _signal, ctx) => {
     const resolved = resolveHistoryTarget(ctx, "goose_remember", params);
     if (!resolved.ok)
       return resolved.result;
@@ -1429,7 +1509,7 @@ function registerGooseTools(pi, deps) {
     });
     return textResult(`Memory learning queued for ${resolved.target}.`);
   }));
-  pi.registerTool(defineGooseTool(isAvailable, "goose_recall", Type.Object({
+  pi.registerTool(defineGooseTool("goose_recall", Type.Object({
     query: Type.String({ description: PARAM_DESCRIPTIONS.memoryQuery }),
     type: Type.Optional(Type.Union(GOOSE_MEMORY_TYPES.map((type) => Type.Literal(type)), { description: PARAM_DESCRIPTIONS.memoryType })),
     allProjects: Type.Optional(Type.Boolean({
@@ -1459,7 +1539,7 @@ function registerGooseTools(pi, deps) {
       return textResult(`No durable memory for "${params.query}"`);
     return textResult(formatMemoryHits(hits));
   }));
-  pi.registerTool(defineGooseTool(isAvailable, "goose_forget", Type.Object({
+  pi.registerTool(defineGooseTool("goose_forget", Type.Object({
     target: Type.String({
       description: PARAM_DESCRIPTIONS.forgetTarget
     })
@@ -1470,8 +1550,8 @@ function registerGooseTools(pi, deps) {
     const res = await goosedumpMemoryForget(params.target.trim(), signal, nativeExecutablePath);
     return textResult(res);
   }));
-  pi.registerTool(defineGooseTool(isAvailable, "goose_memory_status", Type.Object({}), async (_params, signal) => textResult(await goosedumpMemoryStatus(signal, nativeExecutablePath))));
-  pi.registerTool(defineGooseTool(isAvailable, "goose_search", Type.Object({
+  pi.registerTool(defineGooseTool("goose_memory_status", Type.Object({}), async (_params, signal) => textResult(await goosedumpMemoryStatus(signal, nativeExecutablePath))));
+  pi.registerTool(defineGooseTool("goose_search", Type.Object({
     query: Type.String({ description: PARAM_DESCRIPTIONS.searchQuery }),
     ...historyBranchParams(),
     page: Type.Optional(Type.Integer({
@@ -1493,7 +1573,7 @@ function registerGooseTools(pi, deps) {
 
 ${text}`);
   }));
-  pi.registerTool(defineGooseTool(isAvailable, "goose_get", Type.Object({
+  pi.registerTool(defineGooseTool("goose_get", Type.Object({
     ids: Type.Array(Type.String(), {
       minItems: 1,
       description: PARAM_DESCRIPTIONS.entryIds
@@ -1507,9 +1587,9 @@ ${text}`);
     if (messages.length === 0) {
       return textResult("No entries found for the given IDs.");
     }
-    return textResult(formatMessagesFull(messages));
+    return boundedHistoryResult(formatMessagesFull(messages));
   }));
-  pi.registerTool(defineGooseTool(isAvailable, "goose_grep", Type.Object({
+  pi.registerTool(defineGooseTool("goose_grep", Type.Object({
     pattern: Type.String({ description: PARAM_DESCRIPTIONS.pattern }),
     ...historyBranchParams()
   }), async (params, signal, ctx) => {
@@ -1520,9 +1600,9 @@ ${text}`);
     if (messages.length === 0) {
       return textResult(`No matches for "${params.pattern}"`);
     }
-    return textResult(formatMessagesCompact(messages));
+    return boundedHistoryResult(formatMessagesCompact(messages));
   }));
-  pi.registerTool(defineGooseTool(isAvailable, "goose_compact", Type.Object({
+  pi.registerTool(defineGooseTool("goose_compact", Type.Object({
     keep: Type.Optional(Type.Integer({
       minimum: 1,
       description: PARAM_DESCRIPTIONS.keep
@@ -1537,7 +1617,7 @@ ${text}`);
     }
     return textResult(compactStartedMessage(keep, result === "queued"));
   }));
-  pi.registerTool(defineGooseTool(isAvailable, "goose_sessions", Type.Object({
+  pi.registerTool(defineGooseTool("goose_sessions", Type.Object({
     action: Type.Optional(Type.Union([Type.Literal("list"), Type.Literal("delete")], {
       default: "list",
       description: PARAM_DESCRIPTIONS.sessionsAction
@@ -1550,19 +1630,22 @@ ${text}`);
     const action = params.action ?? "list";
     const provider = params.provider ?? "pi";
     const currentTarget = currentSessionTarget(ctx);
+    const sessions = await goosedumpListSessions(signal, nativeExecutablePath);
+    const cwdSessions = sessions.filter((s) => s.cwd === ctx.cwd && s.provider === provider);
     if (action === "delete") {
       if (!params.session) {
         return textResult("goose_sessions error: session ID is required for action: delete");
       }
       const target = formatTarget(provider, params.session);
+      if (!cwdSessions.some((session) => session.id === params.session)) {
+        return textResult(`Cannot delete session ${target}: not found for ${ctx.cwd}.`);
+      }
       if (currentTarget && target === currentTarget) {
         return textResult("Cannot delete the active session.");
       }
       await goosedumpRemoveSession(target, signal, nativeExecutablePath);
       return textResult(`Deleted session ${target}`);
     }
-    const sessions = await goosedumpListSessions(signal, nativeExecutablePath);
-    const cwdSessions = sessions.filter((s) => s.cwd === ctx.cwd && s.provider === provider);
     if (cwdSessions.length === 0) {
       return textResult(`No ${provider} sessions found for ${ctx.cwd}`);
     }
@@ -1866,7 +1949,7 @@ async function runSettingsEditor(ctx) {
     }
   });
 }
-async function runSearchPanel(ctx, query) {
+async function runSearchPanel(ctx, query, executablePath) {
   const OVERLAY_WIDTH = 84;
   const VIEWPORT = 18;
   const PAGE_SIZE = 5;
@@ -1883,7 +1966,7 @@ async function runSearchPanel(ctx, query) {
     let detailScroll = 0;
     async function runSearch() {
       try {
-        const first = await goosedumpSearch(target, query, { scope: "lineage", page: 1 });
+        const first = await goosedumpSearch(target, query, { scope: "lineage", page: 1 }, undefined, executablePath);
         if (first.length === 0) {
           entries = [];
           error = `No results for "${query}"`;
@@ -1893,7 +1976,7 @@ async function runSearchPanel(ctx, query) {
         }
         const all = [...first];
         for (let page = 2;page <= 10; page += 1) {
-          const result = await goosedumpSearch(target, query, { scope: "lineage", page });
+          const result = await goosedumpSearch(target, query, { scope: "lineage", page }, undefined, executablePath);
           if (result.length === 0)
             break;
           all.push(...result);
@@ -1907,6 +1990,8 @@ async function runSearchPanel(ctx, query) {
       } catch (err) {
         entries = [];
         error = err instanceof Error ? err.message : String(err);
+      } finally {
+        tui.requestRender();
       }
     }
     if (!target) {
@@ -1916,7 +2001,7 @@ async function runSearchPanel(ctx, query) {
     }
     async function loadDetail(id) {
       try {
-        const messages = await goosedumpShow(target, { ids: [id] });
+        const messages = await goosedumpShow(target, { ids: [id] }, undefined, executablePath);
         const content = messages.length > 0 ? messages[0].content : "No content for this entry.";
         detailLines = wrapTextWithAnsi(content, wrapWidth);
         detailScroll = 0;
@@ -1924,6 +2009,8 @@ async function runSearchPanel(ctx, query) {
       } catch (err) {
         const message = err instanceof Error ? err.message : String(err);
         ctx.ui.notify(`goosedump error: ${message}`, "error");
+      } finally {
+        tui.requestRender();
       }
     }
     return {
@@ -2019,7 +2106,6 @@ async function runSearchPanel(ctx, query) {
           if (!entry)
             return;
           loadDetail(entry.id);
-          tui.requestRender();
           return;
         }
       },
@@ -2034,6 +2120,21 @@ async function runSearchPanel(ctx, query) {
     }
   });
 }
+function countSessionDescendants(childrenMap, target) {
+  const seen = new Set([target]);
+  const pending = [...childrenMap.get(target) ?? []];
+  while (pending.length > 0) {
+    const session = pending.pop();
+    if (!session)
+      continue;
+    const key = `${session.provider}:${session.id}`;
+    if (seen.has(key))
+      continue;
+    seen.add(key);
+    pending.push(...childrenMap.get(key) ?? []);
+  }
+  return seen.size - 1;
+}
 async function runSessionsPanel(ctx, executablePath) {
   const OVERLAY_WIDTH = 84;
   const VIEWPORT = 18;
@@ -2082,6 +2183,7 @@ async function runSessionsPanel(ctx, executablePath) {
     let error = null;
     let selected = 0;
     let scroll = 0;
+    let deletionPending = false;
     function rebuildDisplayList() {
       displayList = flattenTree(roots, childrenMap, expandedNodes, 0);
     }
@@ -2098,7 +2200,7 @@ async function runSessionsPanel(ctx, executablePath) {
         sessions = cwdSessions;
         childrenMap = buildChildrenMap(sessions);
         const sessionKeys = new Set(sessions.map((s) => `${s.provider}:${s.id}`));
-        roots = sessions.filter((s) => s.parent === null);
+        roots = sessions.filter((s) => s.parent === null || !sessionKeys.has(`${s.provider}:${s.parent}`));
         expandedNodes = new Set([...expandedNodes].filter((key) => sessionKeys.has(key)));
         rebuildDisplayList();
         if (sessions.length === 0) {
@@ -2120,6 +2222,8 @@ async function runSessionsPanel(ctx, executablePath) {
     }
     loadSessions();
     async function deleteSelected() {
+      if (deletionPending)
+        return;
       const row = displayList[selected];
       if (!row)
         return;
@@ -2129,13 +2233,21 @@ async function runSessionsPanel(ctx, executablePath) {
         ctx.ui.notify("Cannot delete the active session.", "error");
         return;
       }
+      deletionPending = true;
       try {
+        const descendants = countSessionDescendants(childrenMap, target);
+        const confirmed = await ctx.ui.confirm("Permanently delete session?", `Permanently remove ${target} and all descendants (${descendants} shown)? This cannot be undone.`);
+        tui.requestRender();
+        if (!confirmed)
+          return;
         await goosedumpRemoveSession(target, undefined, executablePath);
         ctx.ui.notify(`Deleted session ${s.id}`, "info");
         await loadSessions();
       } catch (err) {
         const message = err instanceof Error ? err.message : String(err);
         ctx.ui.notify(`Failed to delete session: ${message}`, "error");
+      } finally {
+        deletionPending = false;
       }
     }
     return {
@@ -2260,8 +2372,7 @@ async function runSessionsPanel(ctx, executablePath) {
 function createGoosedumpIntegration(options = {}) {
   const shouldRegisterTool = options.registerTool ?? true;
   const shouldOverrideDefaultCompaction = options.overrideDefaultCompaction ?? true;
-  const nativeExecutablePath = options.nativeExecutablePath;
-  let goosedumpAvailable = false;
+  const nativeExecutablePath = options.nativeExecutablePath ?? resolveNativeGoosedumpBinary();
   const rememberQueue = [];
   let rememberRunning = null;
   function enqueueRemember(target, reportError) {
@@ -2297,31 +2408,22 @@ function createGoosedumpIntegration(options = {}) {
     while (rememberRunning)
       await rememberRunning;
   }
-  function checkGoosedump() {
-    try {
-      execFileSync(process.execPath, [resolveGoosedumpBinary(), "--version"], { stdio: "ignore" });
-      return true;
-    } catch {
-      return false;
-    }
-  }
   const compaction = new CompactionRuntime({
     overrideDefaultCompaction: shouldOverrideDefaultCompaction,
     nativeExecutablePath,
-    isAvailable: () => goosedumpAvailable,
     enqueueRemember
   });
   function register(pi) {
+    compaction.setActivePi(pi);
     if (shouldRegisterTool) {
       registerGooseTools(pi, {
-        isAvailable: () => goosedumpAvailable,
         nativeExecutablePath,
         enqueueRemember,
         requestCompaction: (ctx, keep) => compaction.requestCompaction(ctx, keep)
       });
     }
     pi.on("before_agent_start", (event) => {
-      if (!shouldRegisterTool || !goosedumpAvailable)
+      if (!shouldRegisterTool)
         return;
       return {
         systemPrompt: `${event.systemPrompt}
@@ -2330,10 +2432,6 @@ ${renderToolRoutingPolicy()}`
       };
     });
     pi.on("session_start", async (_event, ctx) => {
-      goosedumpAvailable = checkGoosedump();
-      if (!goosedumpAvailable) {
-        ctx.ui.notify("goosedump was not found. Install with: npm install @jarkkojs/goosedump", "error");
-      }
       notifyInvalidSettings(ctx);
       compaction.beginSession(ctx);
     });
@@ -2363,10 +2461,6 @@ ${renderToolRoutingPolicy()}`
       maybePi.registerCommand?.(name, {
         description,
         handler: async (args, ctx) => {
-          if (!goosedumpAvailable) {
-            ctx.ui.notify(GOOSEDUMP_UNAVAILABLE_MESSAGE, "error");
-            return;
-          }
           try {
             await handler(args, ctx);
           } catch (err) {
@@ -2408,7 +2502,7 @@ ${renderToolRoutingPolicy()}`
       const query = args.trim() || (await ctx.ui.input("Search query:", ""))?.trim() || "";
       if (query.length === 0)
         return;
-      await runSearchPanel(ctx, query);
+      await runSearchPanel(ctx, query, nativeExecutablePath);
     });
     registerGooseCommand("goose-sessions", "List, resume, or delete sessions for the current working directory", async (_args, ctx) => {
       await runSessionsPanel(ctx, nativeExecutablePath);

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "pi-goosedump",
-  "version": "0.12.39",
+  "version": "0.12.41",
   "description": "Pi extension for goosedump session search, durable memory, session management, and compaction",
   "keywords": [
     "compaction",
@@ -38,7 +38,7 @@
   },
   "dependencies": {
     "@earendil-works/pi-tui": "^0.82.1",
-    "@jarkkojs/goosedump": "^0.12.39",
+    "@jarkkojs/goosedump": "^0.12.41",
     "@sinclair/typebox": "^0.34.49"
   },
   "devDependencies": {