pi-goosedump 0.12.66 → 0.12.69

package/dist/index.ts

@@ -7,7 +7,7 @@ import { randomUUID as randomUUID2 } from "node:crypto";
 // src/cli.ts
 import { Type as Type2 } from "typebox";
 import { Value as Value2 } from "typebox/value";
-import { execFile } from "node:child_process";
+import { spawn } from "node:child_process";
 import { accessSync, constants as fsConstants, existsSync, readFileSync as readFileSync2, statSync } from "node:fs";
 import { createRequire } from "node:module";
 import { dirname, isAbsolute, join } from "node:path";
@@ -167,7 +167,8 @@ var GOOSE_PROVIDERS = [
 var SUMMARIZABLE_ENTRY_TYPES = new Set(["message", "custom_message", "branch_summary"]);
 
 // src/util.ts
-import { readFileSync } from "node:fs";
+import { closeSync, openSync, readFileSync, readSync } from "node:fs";
+import { StringDecoder } from "node:string_decoder";
 function isRecord(value) {
   return typeof value === "object" && value !== null && !Array.isArray(value);
 }
@@ -187,14 +188,56 @@ 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.`;
 }
+var FIRST_LINE_BUFFER_SIZE = 4096;
+var MAX_FIRST_LINE_BYTES = 64 * 1024;
 function readFirstLine(path) {
+  let fd = null;
   try {
-    const content = readFileSync(path, "utf8");
-    const newline = content.indexOf(`
+    fd = openSync(path, "r");
+    const buffer = Buffer.alloc(FIRST_LINE_BUFFER_SIZE);
+    const decoder = new StringDecoder("utf8");
+    let totalText = "";
+    let offset = 0;
+    while (offset < MAX_FIRST_LINE_BYTES) {
+      const bytesRead = readSync(fd, buffer, 0, FIRST_LINE_BUFFER_SIZE, offset);
+      if (bytesRead === 0)
+        break;
+      offset += bytesRead;
+      const chunk = decoder.write(buffer.subarray(0, bytesRead));
+      const newline = chunk.indexOf(`
 `);
-    return newline < 0 ? content : content.slice(0, newline);
-  } catch {
+      if (newline >= 0) {
+        totalText += chunk.slice(0, newline);
+        return totalText.endsWith("\r") ? totalText.slice(0, -1) : totalText;
+      }
+      totalText += chunk;
+      if (bytesRead < FIRST_LINE_BUFFER_SIZE)
+        break;
+    }
+    totalText += decoder.end();
+    const finalNewline = totalText.indexOf(`
+`);
+    const line = finalNewline >= 0 ? totalText.slice(0, finalNewline) : totalText;
+    if (line.length > 0) {
+      return line.endsWith("\r") ? line.slice(0, -1) : line;
+    }
     return null;
+  } catch {
+    try {
+      const content = readFileSync(path, "utf8");
+      const newline = content.indexOf(`
+`);
+      const line = newline < 0 ? content : content.slice(0, newline);
+      return line.length > 0 ? line.endsWith("\r") ? line.slice(0, -1) : line : null;
+    } catch {
+      return null;
+    }
+  } finally {
+    if (fd !== null) {
+      try {
+        closeSync(fd);
+      } catch {}
+    }
   }
 }
 function formatTarget(provider, id) {
@@ -470,18 +513,66 @@ function resolveNativeGoosedumpBinary(environment = process.env) {
   }
 }
 function runGoosedumpAsync(args, signal, executablePath = resolveNativeGoosedumpBinary()) {
+  if (signal?.aborted)
+    return Promise.reject(signal.reason);
   return new Promise((resolve, reject) => {
-    execFile(executablePath, args, {
-      encoding: "utf-8",
-      maxBuffer: 16 * 1024 * 1024,
-      signal,
-      ...process.platform === "linux" ? { env: { ...process.env, APPIMAGE_EXTRACT_AND_RUN: "1" } } : {}
-    }, (err, stdout, stderr) => {
-      if (err) {
-        const message = stderr.trim() || err.message;
-        reject(new Error(message));
+    const processGroup = process.platform !== "win32";
+    const output = { stdout: "", stderr: "" };
+    const bytes = { stdout: 0, stderr: 0 };
+    let child;
+    let failure;
+    const abort = () => {
+      if (child?.pid === undefined)
+        return;
+      try {
+        if (processGroup)
+          process.kill(-child.pid, "SIGTERM");
+        else
+          child.kill("SIGTERM");
+      } catch (error) {
+        if (error.code !== "ESRCH") {
+          failure = new Error("failed to stop goosedump process", { cause: error });
+        }
+      }
+    };
+    const capture = (stream, chunk) => {
+      if (failure)
+        return;
+      bytes[stream] += Buffer.byteLength(chunk);
+      if (bytes[stream] > 16 * 1024 * 1024) {
+        failure = new Error(`goosedump ${stream} exceeded the 16 MiB buffer limit`);
+        abort();
+      } else {
+        output[stream] += chunk;
+      }
+    };
+    signal?.addEventListener("abort", abort, { once: true });
+    try {
+      child = spawn(executablePath, args, {
+        detached: processGroup,
+        signal,
+        stdio: ["ignore", "pipe", "pipe"],
+        ...process.platform === "linux" ? { env: { ...process.env, APPIMAGE_EXTRACT_AND_RUN: "1" } } : {}
+      });
+    } catch (error) {
+      signal?.removeEventListener("abort", abort);
+      reject(error);
+      return;
+    }
+    child.stdout?.setEncoding("utf8");
+    child.stderr?.setEncoding("utf8");
+    child.stdout?.on("data", (chunk) => capture("stdout", chunk));
+    child.stderr?.on("data", (chunk) => capture("stderr", chunk));
+    child.on("error", (error) => {
+      failure ??= error;
+    });
+    child.once("close", (code, exitSignal) => {
+      signal?.removeEventListener("abort", abort);
+      if (failure || code !== 0) {
+        const message = output.stderr.trim() || failure?.message || `goosedump exited with ${exitSignal ?? `code ${code}`}`;
+        reject(new Error(message, { cause: failure }));
       } else {
-        resolve({ stdout, stderr });
+        resolve(output);
       }
     });
   });
@@ -597,7 +688,12 @@ async function goosedumpCompact(target, options, signal, executablePath) {
   return { summary: output.stdout.trim(), warning: output.stderr.trim() };
 }
 function currentSessionTarget(ctx) {
-  const sessionFile = ctx.sessionManager.getSessionFile();
+  const sessionManager = ctx.sessionManager;
+  const inMemoryId = sessionManager?.getSessionId?.() ?? sessionManager?.getHeader?.()?.id;
+  if (typeof inMemoryId === "string" && inMemoryId.trim().length > 0) {
+    return formatTarget("pi", inMemoryId.trim());
+  }
+  const sessionFile = sessionManager?.getSessionFile?.();
   if (!sessionFile)
     return null;
   const line = readFirstLine(sessionFile);
@@ -605,8 +701,8 @@ function currentSessionTarget(ctx) {
     return null;
   try {
     const entry = JSON.parse(line);
-    if (entry.type === "session" && typeof entry.id === "string") {
-      return formatTarget("pi", entry.id);
+    if (entry.type === "session" && typeof entry.id === "string" && entry.id.trim().length > 0) {
+      return formatTarget("pi", entry.id.trim());
     }
   } catch {
     return null;
@@ -618,7 +714,7 @@ function currentSessionTarget(ctx) {
 import { DEFAULT_COMPACTION_SETTINGS as DEFAULT_COMPACTION_SETTINGS2 } from "@earendil-works/pi-coding-agent";
 
 // src/compaction.ts
-import { findCutPoint } from "@earendil-works/pi-coding-agent";
+import { findCutPoint, sessionEntryToContextMessages } from "@earendil-works/pi-coding-agent";
 
 // src/settings.ts
 import { DEFAULT_COMPACTION_SETTINGS } from "@earendil-works/pi-coding-agent";
@@ -733,9 +829,6 @@ function writeJsonObjectAtomically(path, value) {
     throw error;
   }
 }
-function readGoosedumpSettingsFrom(path) {
-  return pickValidGoosedumpSettings(readJsonObject(path).goosedump);
-}
 function goosedumpSettingValidationMessage(key) {
   const spec = GOOSEDUMP_SETTING_SPECS[key];
   if (spec.kind === "boolean")
@@ -756,13 +849,33 @@ function validateGoosedumpSettings(path) {
     }
   }
 }
-function resolveGoosedumpSettings(cwd, includeProject) {
-  return {
+var isNumberValue = (value) => typeof value === "number";
+var isBooleanValue = (value) => typeof value === "boolean";
+function resolveWorkspaceSettings(cwd, includeProject) {
+  const globalObj = readJsonObject(globalSettingsPath());
+  const projectObj = includeProject ? readJsonObject(projectSettingsPath(cwd)) : undefined;
+  const goosedump = {
     ...DEFAULT_GOOSEDUMP_SETTINGS,
-    ...readGoosedumpSettingsFrom(globalSettingsPath()),
-    ...includeProject ? readGoosedumpSettingsFrom(projectSettingsPath(cwd)) : {}
+    ...pickValidGoosedumpSettings(globalObj.goosedump),
+    ...projectObj ? pickValidGoosedumpSettings(projectObj.goosedump) : {}
+  };
+  const projectCompaction = isRecord(projectObj?.compaction) ? projectObj.compaction : undefined;
+  const globalCompaction = isRecord(globalObj.compaction) ? globalObj.compaction : undefined;
+  const enabled = (isBooleanValue(projectCompaction?.enabled) ? projectCompaction.enabled : undefined) ?? (isBooleanValue(globalCompaction?.enabled) ? globalCompaction.enabled : undefined) ?? DEFAULT_COMPACTION_SETTINGS.enabled;
+  const keepRecentTokens = (isNumberValue(projectCompaction?.keepRecentTokens) ? projectCompaction.keepRecentTokens : undefined) ?? (isNumberValue(globalCompaction?.keepRecentTokens) ? globalCompaction.keepRecentTokens : undefined) ?? DEFAULT_COMPACTION_SETTINGS.keepRecentTokens;
+  const reserveTokens = (isNumberValue(projectCompaction?.reserveTokens) ? projectCompaction.reserveTokens : undefined) ?? (isNumberValue(globalCompaction?.reserveTokens) ? globalCompaction.reserveTokens : undefined) ?? DEFAULT_COMPACTION_SETTINGS.reserveTokens;
+  return {
+    goosedump,
+    compaction: {
+      enabled,
+      keepRecentTokens,
+      reserveTokens
+    }
   };
 }
+function resolveGoosedumpSettings(cwd, includeProject) {
+  return resolveWorkspaceSettings(cwd, includeProject).goosedump;
+}
 function notifyInvalidSettings(ctx) {
   const paths = [
     globalSettingsPath(),
@@ -819,30 +932,13 @@ function clearScopedGoosedumpSetting(cwd, scope, key) {
 function formatCompactSetting(value) {
   return value === 0 ? "disabled" : String(value);
 }
-var isNumberValue = (value) => typeof value === "number";
-var isBooleanValue = (value) => typeof value === "boolean";
-function piCompactionValue(cwd, includeProject, key, is, fallback) {
-  const paths = includeProject ? [projectSettingsPath(cwd), globalSettingsPath()] : [globalSettingsPath()];
-  for (const path of paths) {
-    const compaction = readJsonObject(path).compaction;
-    const value = isRecord(compaction) ? compaction[key] : undefined;
-    if (is(value))
-      return value;
-  }
-  return fallback;
-}
 function piKeepRecentTokens(cwd, includeProject) {
-  return piCompactionValue(cwd, includeProject, "keepRecentTokens", isNumberValue, DEFAULT_COMPACTION_SETTINGS.keepRecentTokens);
-}
-function piCompactionEnabled(cwd, includeProject) {
-  return piCompactionValue(cwd, includeProject, "enabled", isBooleanValue, DEFAULT_COMPACTION_SETTINGS.enabled);
-}
-function piReserveTokens(cwd, includeProject) {
-  return piCompactionValue(cwd, includeProject, "reserveTokens", isNumberValue, DEFAULT_COMPACTION_SETTINGS.reserveTokens);
+  return resolveWorkspaceSettings(cwd, includeProject).compaction.keepRecentTokens;
 }
 function effectiveSummaryMaxTokens(cwd, includeProject) {
-  const configured = resolveGoosedumpSettings(cwd, includeProject).summaryMaxTokens;
-  const reserveTokens = piReserveTokens(cwd, includeProject);
+  const settings = resolveWorkspaceSettings(cwd, includeProject);
+  const configured = settings.goosedump.summaryMaxTokens;
+  const reserveTokens = settings.compaction.reserveTokens;
   if (reserveTokens <= 0)
     return configured;
   return Math.max(1, Math.min(configured, Math.floor(reserveTokens * 0.8)));
@@ -858,6 +954,11 @@ function isMessageEntry(entry) {
 function isCompletedAssistant(message) {
   return message.role === "assistant" && message.stopReason !== "error" && message.stopReason !== "aborted";
 }
+function hasCompactionMessage(entry) {
+  if (entry.type === "compaction")
+    return false;
+  return sessionEntryToContextMessages(entry).length > 0;
+}
 function hasCompactableHistory(ctx) {
   const branch = ctx.sessionManager.getBranch();
   if (branch.length === 0)
@@ -868,17 +969,10 @@ function hasCompactableHistory(ctx) {
   const cut = findCutPoint(branch, boundaryStart, branch.length, piKeepRecentTokens(ctx.cwd, projectSettingsTrusted(ctx)));
   if (!branch[cut.firstKeptEntryIndex]?.id)
     return false;
-  const historyEnd = cut.isSplitTurn ? cut.turnStartIndex : cut.firstKeptEntryIndex;
-  for (let i = boundaryStart;i < historyEnd; i += 1) {
-    if (SUMMARIZABLE_ENTRY_TYPES.has(branch[i].type))
+  for (let i = boundaryStart;i < cut.firstKeptEntryIndex; i += 1) {
+    if (hasCompactionMessage(branch[i]))
       return true;
   }
-  if (cut.isSplitTurn) {
-    for (let i = cut.turnStartIndex;i < cut.firstKeptEntryIndex; i += 1) {
-      if (SUMMARIZABLE_ENTRY_TYPES.has(branch[i].type))
-        return true;
-    }
-  }
   return false;
 }
 function latestCompaction(branchEntries) {
@@ -901,16 +995,11 @@ function activeHistoryStartIndex(branchEntries) {
   return compaction ? compactionBoundaryStartIndex(branchEntries, compaction) : 0;
 }
 function completedTurnsSinceCompaction(branchEntries) {
-  let start = 0;
-  for (let i = branchEntries.length - 1;i >= 0; i -= 1) {
-    if (isCompactionEntry(branchEntries[i])) {
-      start = i + 1;
-      break;
-    }
-  }
   let completed = 0;
-  for (let i = start;i < branchEntries.length; i += 1) {
+  for (let i = branchEntries.length - 1;i >= 0; i -= 1) {
     const entry = branchEntries[i];
+    if (isCompactionEntry(entry))
+      break;
     if (isMessageEntry(entry) && isCompletedAssistant(entry.message))
       completed += 1;
   }
@@ -929,26 +1018,21 @@ function keepBoundaryId(branchEntries, keep) {
   }
   return;
 }
-function latestCompactionForRange(branchEntries, untilIndex) {
-  for (let i = branchEntries.length - 1;i >= 0; i -= 1) {
-    const entry = branchEntries[i];
-    if (!isCompactionEntry(entry))
-      continue;
-    if (compactionBoundaryStartIndex(branchEntries, entry) < untilIndex)
-      return entry;
-  }
-  return;
-}
-function compactionStartId(branchEntries, previousCompaction, untilIndex) {
-  const boundaryStart = compactionBoundaryStartIndex(branchEntries, previousCompaction);
-  return boundaryStart < untilIndex ? branchEntries[boundaryStart]?.id : undefined;
-}
 function buildCompactRange(branchEntries, firstKeptEntryId) {
   const untilIndex = branchEntries.findIndex((entry) => entry.id === firstKeptEntryId);
   if (untilIndex < 0)
     return;
-  const previousCompaction = latestCompactionForRange(branchEntries, untilIndex);
-  const from = previousCompaction ? compactionStartId(branchEntries, previousCompaction, untilIndex) : undefined;
+  let from;
+  for (let i = Math.min(untilIndex - 1, branchEntries.length - 1);i >= 0; i -= 1) {
+    const entry = branchEntries[i];
+    if (!isCompactionEntry(entry))
+      continue;
+    const boundaryStart = compactionBoundaryStartIndex(branchEntries, entry);
+    if (boundaryStart < untilIndex) {
+      from = branchEntries[boundaryStart]?.id;
+      break;
+    }
+  }
   return from && from !== firstKeptEntryId ? { scope: "lineage", from, until: firstKeptEntryId } : { scope: "lineage", until: firstKeptEntryId };
 }
 async function buildGoosedumpCompaction(target, preparation, branchEntries, summaryMaxTokens, keep, signal, executablePath) {
@@ -993,6 +1077,11 @@ function isCompactionCancellation(error) {
   const code = error.code;
   return error.name === "AbortError" || code === "ABORT_ERR" || isCompactionCancellationMessage(error.message);
 }
+function isSessionTooSmallError(error) {
+  if (!(error instanceof Error))
+    return false;
+  return /nothing to compact|session too small|already compacted/i.test(error.message);
+}
 
 class CompactionRuntime {
   overrideDefaultCompaction;
@@ -1004,6 +1093,7 @@ class CompactionRuntime {
   piCompactionReserveTokens = DEFAULT_COMPACTION_SETTINGS2.reserveTokens;
   turnsRemaining = 0;
   counterTriggered = false;
+  smallSessionDisarmed = false;
   compactionState = { phase: "idle" };
   sessionGeneration = 0;
   settlementGeneration = 0;
@@ -1023,6 +1113,7 @@ class CompactionRuntime {
     this.activePi = pi;
   }
   requestCompaction(ctx, keep) {
+    this.smallSessionDisarmed = false;
     if (this.compactionState.phase !== "idle")
       return "busy";
     if (!this.requestHasCompactableHistory(ctx, keep))
@@ -1042,14 +1133,17 @@ class CompactionRuntime {
   }
   syncCompactCounters(ctx) {
     const projectTrusted = projectSettingsTrusted(ctx);
-    this.compactSettings = resolveGoosedumpSettings(ctx.cwd, projectTrusted);
-    this.piAutoCompactionEnabled = piCompactionEnabled(ctx.cwd, projectTrusted);
-    this.piCompactionReserveTokens = piReserveTokens(ctx.cwd, projectTrusted);
+    const resolved = resolveWorkspaceSettings(ctx.cwd, projectTrusted);
+    this.compactSettings = resolved.goosedump;
+    this.piAutoCompactionEnabled = resolved.compaction.enabled;
+    this.piCompactionReserveTokens = resolved.compaction.reserveTokens;
     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 (!ctx.hasUI)
+      return;
     const active = this.turnCompactionEnabled();
     let dotColor = "success";
     if (active) {
@@ -1060,10 +1154,17 @@ class CompactionRuntime {
         dotColor = "warning";
       }
     }
-    const dot = ctx.ui.theme.fg(dotColor, "●");
     const counter = active ? Math.max(0, this.turnsRemaining).toString(16).toUpperCase().padStart(2, "0") : "--";
     const activity = this.compactionState.phase === "queued" ? " queued" : this.compactionState.phase === "running" ? " compacting" : "";
-    const label = ctx.ui.theme.fg("text", `${ctx.ui.theme.bold?.("GD") ?? "GD"}:${counter}${activity}`);
+    let dot = "●";
+    let label = `GD:${counter}${activity}`;
+    try {
+      if (ctx.ui?.theme) {
+        dot = ctx.ui.theme.fg(dotColor, "●");
+        const boldGd = ctx.ui.theme.bold?.("GD") ?? "GD";
+        label = ctx.ui.theme.fg("text", `${boldGd}:${counter}${activity}`);
+      }
+    } catch {}
     ctx.ui.setStatus("goosedump", `${dot} ${label}`);
   }
   beginSession(ctx) {
@@ -1072,6 +1173,7 @@ class CompactionRuntime {
     this.activeSessionFile = ctx.sessionManager.getSessionFile?.() ?? null;
     this.sessionActive = true;
     this.compactionState = { phase: "idle" };
+    this.smallSessionDisarmed = false;
     this.expectedTurnBoundaryAbort = false;
     this.syncCompactCounters(ctx);
     this.updateStatus(ctx);
@@ -1084,6 +1186,7 @@ class CompactionRuntime {
     this.activeSessionFile = null;
     this.sessionActive = false;
     this.compactionState = { phase: "idle" };
+    this.smallSessionDisarmed = false;
     this.expectedTurnBoundaryAbort = false;
   }
   onAgentStart(ctx) {
@@ -1308,11 +1411,13 @@ class CompactionRuntime {
   }
   resetCompactCounters(ctx) {
     const projectTrusted = projectSettingsTrusted(ctx);
-    this.compactSettings = resolveGoosedumpSettings(ctx.cwd, projectTrusted);
-    this.piAutoCompactionEnabled = piCompactionEnabled(ctx.cwd, projectTrusted);
-    this.piCompactionReserveTokens = piReserveTokens(ctx.cwd, projectTrusted);
+    const resolved = resolveWorkspaceSettings(ctx.cwd, projectTrusted);
+    this.compactSettings = resolved.goosedump;
+    this.piAutoCompactionEnabled = resolved.compaction.enabled;
+    this.piCompactionReserveTokens = resolved.compaction.reserveTokens;
     this.turnsRemaining = this.compactSettings.turnsBeforeCompact;
     this.counterTriggered = false;
+    this.smallSessionDisarmed = false;
   }
   turnCompactionEnabled() {
     return this.overrideDefaultCompaction && this.piAutoCompactionEnabled && this.compactSettings.turnsBeforeCompact > 0;
@@ -1331,6 +1436,7 @@ class CompactionRuntime {
   noteCompletedTurn(ctx) {
     if (!this.overrideDefaultCompaction)
       return;
+    this.smallSessionDisarmed = false;
     this.syncCompactCounters(ctx);
     this.updateStatus(ctx);
   }
@@ -1390,14 +1496,19 @@ class CompactionRuntime {
     }, { once: true });
   }
   requestHasCompactableHistory(ctx, keep) {
-    return keep === null ? hasCompactableHistory(ctx) : keepBoundaryId(ctx.sessionManager.getBranch(), keep) !== undefined;
+    if (!hasCompactableHistory(ctx))
+      return false;
+    return keep === null || keepBoundaryId(ctx.sessionManager.getBranch(), keep) !== undefined;
   }
   queueTurnCompaction(ctx, eligibleSettlement, resumeAfter = false) {
-    if (!this.turnCompactionEnabled() || !this.counterTriggered || this.compactionState.phase !== "idle") {
+    if (!this.turnCompactionEnabled() || !this.counterTriggered || this.smallSessionDisarmed || this.compactionState.phase !== "idle") {
       return;
     }
-    if (!hasCompactableHistory(ctx))
+    if (!hasCompactableHistory(ctx)) {
+      this.counterTriggered = false;
+      this.smallSessionDisarmed = true;
       return;
+    }
     this.setCompactionState(ctx, {
       phase: "queued",
       request: {
@@ -1425,6 +1536,10 @@ class CompactionRuntime {
     if (!ctx.isIdle())
       return false;
     if (!this.requestHasCompactableHistory(ctx, request.keep)) {
+      if (request.origin === "turn") {
+        this.counterTriggered = false;
+        this.smallSessionDisarmed = true;
+      }
       this.setCompactionState(ctx, { phase: "idle" });
       return false;
     }
@@ -1453,8 +1568,12 @@ class CompactionRuntime {
           return;
         this.setCompactionState(ctx, { phase: "idle" });
         this.syncCompactCounters(ctx);
+        if (isSessionTooSmallError(error)) {
+          this.counterTriggered = false;
+          this.smallSessionDisarmed = true;
+        }
         this.updateStatus(ctx);
-        if (isCompactionCancellation(error))
+        if (isCompactionCancellation(error) || isSessionTooSmallError(error))
           return;
         const message = error instanceof Error ? error.message : String(error);
         if (ctx.hasUI)
@@ -1576,13 +1695,22 @@ var MEMORY_ACTIVITY_STATUS_KEY = "goosedump-memory-activity";
 function showMemoryActivity(ctx) {
   if (!ctx.hasUI)
     return;
-  const dot = ctx.ui.theme.fg("accent", "●");
-  const label = ctx.ui.theme.fg("muted", "remembering");
+  let dot = "●";
+  let label = "remembering";
+  try {
+    if (ctx.ui?.theme) {
+      dot = ctx.ui.theme.fg("accent", "●");
+      label = ctx.ui.theme.fg("muted", "remembering");
+    }
+  } catch {}
   ctx.ui.setStatus(MEMORY_ACTIVITY_STATUS_KEY, `${dot} ${label}`);
 }
 function hideMemoryActivity(ctx) {
-  if (ctx.hasUI)
-    ctx.ui.setStatus(MEMORY_ACTIVITY_STATUS_KEY, undefined);
+  if (ctx.hasUI) {
+    try {
+      ctx.ui.setStatus(MEMORY_ACTIVITY_STATUS_KEY, undefined);
+    } catch {}
+  }
 }
 
 // src/policy.ts

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "pi-goosedump",
-  "version": "0.12.66",
+  "version": "0.12.69",
   "description": "Pi extension for goosedump session search, durable memory, session management, and compaction",
   "keywords": [
     "compaction",
@@ -37,7 +37,7 @@
     "ci:test": "npm test"
   },
   "dependencies": {
-    "@jarkkojs/goosedump-api": "^0.12.66"
+    "@jarkkojs/goosedump-api": "^0.12.69"
   },
   "devDependencies": {
     "@earendil-works/pi-coding-agent": "^0.84.2",