pi-goosedump 0.9.14 → 0.10.1

package/README.md

@@ -20,6 +20,8 @@ If the goosedump binary cannot be resolved, the extension disables itself.
 
 - **goose_search:** ranks messages by query relevance; returns compact entry
   overviews with IDs.
+- **goose_recall:** searches durable memory harvested from earlier compactions,
+  scoped to the current working directory by default.
 - **goose_get:** expands specific entry IDs to their full content.
 - **goose_grep:** filters messages by glob pattern; returns compact entries
   with IDs.
@@ -35,6 +37,7 @@ current branch) or `all`. Targets are always provider-qualified
 
 ```
 goose_search({ query: "bug fix" })
+goose_recall({ query: "prior architecture decision" })
 goose_search({ query: "auth", scope: "all", page: 2 })
 goose_get({ ids: ["entry-a", "entry-b"] })
 goose_get({ ids: ["entry-a"], provider: "claude", session: "1f6b1eba-…" })
@@ -71,9 +74,12 @@ section and are optional (defaults shown):
 ```
 
 `turnsBeforeCompact` sets how many LLM turns elapse before goosedump triggers
-compaction, as an integer 0–255. `0` disables the counter; when enabled, the
-footer status shows `GD: XX` counting down in hex (e.g. `GD: 0A`), or
-`GD: 00` when the counter is disabled.
+compaction, as an integer 0–255. `0` disables the counter. The settings editor
+can clear the project value to inherit Global again, and writes updates atomically.
+The countdown is reconstructed from the active session after Pi restarts or
+resumes, rather than restarting at the configured value. When enabled, the footer
+shows `GD: XX` counting down in hex (e.g. `GD: 0A`); `GD: 00` is armed and waiting
+to compact, while `GD: --` means disabled.
 
 ### Compaction flow
 
@@ -88,13 +94,14 @@ header line, then runs `goosedump compact` over the replacement range:
   compaction.
 - `--until` is the first entry Pi is keeping (`firstKeptEntryId`).
 
-goosedump composes the structured summary itself — including merging any prior
-summary — and emits a native Pi compaction entry, from which the extension
-extracts the `summary` field. A `keep:N` override (via `/goose-compact` or the
-`goose_compact` tool) replaces Pi's token-based cut with a turn-based one:
-summarize everything before the Nth-from-last user entry and keep the tail
-verbatim. Fewer than N user turns cancels with a notice. On completion Pi
-notifies the token reduction.
+goosedump composes the structured summary itself and emits a native Pi
+compaction entry, from which the extension extracts the `summary` field. The
+extension prepends Pi's previous compaction summary when present, so prior goals,
+progress, and context survive incremental compactions. A `keep:N` override (via
+`/goose-compact` or the `goose_compact` tool) replaces Pi's token-based cut with
+a turn-based one: summarize everything before the Nth-from-last user entry in the
+active, uncompacted history and keep the tail verbatim. Fewer than N active user
+turns cancels with a notice. On completion Pi notifies the token reduction.
 
 ## License
 

package/index.ts

@@ -18,6 +18,7 @@ import {
 } from '@earendil-works/pi-coding-agent';
 
 import { execFile, execFileSync } from 'node:child_process';
+import { randomUUID } from 'node:crypto';
 import {
   closeSync,
   existsSync,
@@ -25,6 +26,8 @@ import {
   openSync,
   readFileSync,
   readSync,
+  renameSync,
+  unlinkSync,
   writeFileSync,
 } from 'node:fs';
 import { createRequire } from 'node:module';
@@ -55,6 +58,17 @@ interface GoosedumpMessage {
   content: string;
 }
 
+interface GoosedumpMemoryHit {
+  hash: string;
+  kind: string;
+  text: string;
+  score: number;
+  provider: string;
+  context_id: string;
+  entry_id: string;
+  path: string;
+}
+
 // A `content` part of a pi-native message line.
 interface PiPartJson {
   type: string;
@@ -115,6 +129,30 @@ function readJsonObject(path: string): Record<string, unknown> {
   }
 }
 
+function readJsonObjectStrict(path: string): Record<string, unknown> {
+  if (!existsSync(path)) return {};
+
+  const parsed = JSON.parse(readFileSync(path, 'utf8')) as unknown;
+  if (!isRecord(parsed)) throw new Error(`${path} must contain a JSON object`);
+  return parsed;
+}
+
+function writeJsonObjectAtomically(path: string, value: Record<string, unknown>): void {
+  mkdirSync(dirname(path), { recursive: true });
+  const temporaryPath = `${path}.${randomUUID()}.tmp`;
+  try {
+    writeFileSync(temporaryPath, `${JSON.stringify(value, null, 2)}\n`, { flag: 'wx' });
+    renameSync(temporaryPath, path);
+  } catch (error) {
+    try {
+      unlinkSync(temporaryPath);
+    } catch {
+      // The temporary file was either never created or has already been renamed.
+    }
+    throw error;
+  }
+}
+
 function readGoosedumpSettingsFrom(path: string): Partial<GoosedumpSettings> {
   const raw = readJsonObject(path).goosedump;
   if (!isRecord(raw)) return {};
@@ -140,9 +178,33 @@ function resolveGoosedumpSettings(cwd: string): GoosedumpSettings {
   };
 }
 
+function notifyInvalidSettings(ctx: ExtensionContext): void {
+  for (const path of [globalSettingsPath(), projectSettingsPath(ctx.cwd)]) {
+    try {
+      readJsonObjectStrict(path);
+    } catch (error) {
+      const message = error instanceof Error ? error.message : String(error);
+      if (ctx.hasUI) ctx.ui.notify(`goosedump settings error: ${message}`, 'error');
+    }
+  }
+}
+
 function readScopedGoosedumpSettings(cwd: string, scope: SettingsScope): GoosedumpSettings {
   const path = scope === 'global' ? globalSettingsPath() : projectSettingsPath(cwd);
-  return { ...DEFAULT_GOOSEDUMP_SETTINGS, ...readGoosedumpSettingsFrom(path) };
+  const raw = readJsonObjectStrict(path).goosedump;
+  if (!isRecord(raw)) return { ...DEFAULT_GOOSEDUMP_SETTINGS };
+
+  const settings: Partial<GoosedumpSettings> = {};
+  const value = raw.turnsBeforeCompact;
+  if (
+    typeof value === 'number' &&
+    Number.isSafeInteger(value) &&
+    value >= TURNS_BEFORE_COMPACT_MIN &&
+    value <= TURNS_BEFORE_COMPACT_MAX
+  ) {
+    settings.turnsBeforeCompact = value;
+  }
+  return { ...DEFAULT_GOOSEDUMP_SETTINGS, ...settings };
 }
 
 function writeScopedGoosedumpSetting(
@@ -152,11 +214,26 @@ function writeScopedGoosedumpSetting(
   value: number,
 ): void {
   const path = scope === 'global' ? globalSettingsPath() : projectSettingsPath(cwd);
-  const root = readJsonObject(path);
+  const root = readJsonObjectStrict(path);
   const goosedump = isRecord(root.goosedump) ? root.goosedump : {};
   root.goosedump = { ...goosedump, [key]: value };
-  mkdirSync(dirname(path), { recursive: true });
-  writeFileSync(path, `${JSON.stringify(root, null, 2)}\n`);
+  writeJsonObjectAtomically(path, root);
+}
+
+function clearScopedGoosedumpSetting(
+  cwd: string,
+  scope: SettingsScope,
+  key: GoosedumpSettingKey,
+): void {
+  const path = scope === 'global' ? globalSettingsPath() : projectSettingsPath(cwd);
+  const root = readJsonObjectStrict(path);
+  if (!isRecord(root.goosedump)) return;
+
+  const goosedump = { ...root.goosedump };
+  delete goosedump[key];
+  if (Object.keys(goosedump).length === 0) delete root.goosedump;
+  else root.goosedump = goosedump;
+  writeJsonObjectAtomically(path, root);
 }
 
 function formatCompactSetting(value: number): string {
@@ -234,6 +311,32 @@ function parsePiMessages(output: string): GoosedumpMessage[] {
   return messages;
 }
 
+function parseMemoryHits(output: string): GoosedumpMemoryHit[] {
+  const value = JSON.parse(output) as unknown;
+  if (!Array.isArray(value)) throw new Error('goosedump recall returned invalid JSON');
+  return value.filter(
+    (item): item is GoosedumpMemoryHit =>
+      isRecord(item) &&
+      typeof item.hash === 'string' &&
+      typeof item.kind === 'string' &&
+      typeof item.text === 'string' &&
+      typeof item.score === 'number' &&
+      typeof item.provider === 'string' &&
+      typeof item.context_id === 'string' &&
+      typeof item.entry_id === 'string' &&
+      typeof item.path === 'string',
+  );
+}
+
+function formatMemoryHits(hits: GoosedumpMemoryHit[]): string {
+  return hits
+    .map(
+      (hit) =>
+        `[${hit.hash}] ${hit.kind} (${hit.provider}:${hit.context_id}/${hit.entry_id})\n${hit.text}`,
+    )
+    .join('\n\n---\n\n');
+}
+
 const ANSI_SGR = new RegExp(String.fromCharCode(27) + '\\[[0-9;]*m', 'g');
 
 function compactLine(content: string): string {
@@ -315,8 +418,9 @@ function runGoosedumpAsync(args: string[], signal?: AbortSignal): Promise<string
 
 // Read only the first line of a file without loading the whole transcript.
 function readFirstLine(path: string): string | null {
-  const fd = openSync(path, 'r');
+  let fd: number | undefined;
   try {
+    fd = openSync(path, 'r');
     const buf = Buffer.alloc(8192);
     const bytesRead = readSync(fd, buf, 0, buf.length, 0);
     if (bytesRead < 0) return null;
@@ -326,7 +430,7 @@ function readFirstLine(path: string): string | null {
   } catch {
     return null;
   } finally {
-    closeSync(fd);
+    if (fd !== undefined) closeSync(fd);
   }
 }
 
@@ -367,6 +471,18 @@ function goosedumpShow(
   return parsePiMessages(runGoosedump(args));
 }
 
+async function goosedumpRecall(
+  query: string,
+  options: { provider?: string; path?: string; limit?: number } = {},
+  signal?: AbortSignal,
+): Promise<GoosedumpMemoryHit[]> {
+  const args = ['recall', query, '--limit', String(options.limit ?? 5)];
+  if (options.provider) args.push('--provider', options.provider);
+  if (options.path) args.push('--path', options.path);
+  const output = await runGoosedumpAsync(args, signal);
+  return parseMemoryHits(output);
+}
+
 // Resolve a goosedump 0.9 `provider:id` target. An explicit contextId is the
 // target id already; for pi it falls back to the current session. Other
 // providers have no current session and require an explicit id.
@@ -524,17 +640,10 @@ function hasCompactableHistory(ctx: ExtensionContext): boolean {
   if (branch.length === 0) return false;
   if (branch[branch.length - 1].type === 'compaction') return false;
 
-  let boundaryStart = 0;
-  for (let i = branch.length - 1; i >= 0; i -= 1) {
-    const entry = branch[i];
-    if (isCompactionEntry(entry)) {
-      const keptIndex = branch.findIndex((e) => e.id === entry.firstKeptEntryId);
-      boundaryStart = keptIndex >= 0 ? keptIndex : i + 1;
-      break;
-    }
-  }
+  const boundaryStart = activeHistoryStartIndex(branch);
 
   const cut = findCutPoint(branch, boundaryStart, branch.length, piKeepRecentTokens(ctx.cwd));
+
   if (!branch[cut.firstKeptEntryIndex]?.id) return false;
 
   const historyEnd = cut.isSplitTurn ? cut.turnStartIndex : cut.firstKeptEntryIndex;
@@ -549,32 +658,71 @@ function hasCompactableHistory(ctx: ExtensionContext): boolean {
   return false;
 }
 
-// Resolution of the `keep:N` boundary: scan the active lineage from the newest
-// entry backward, count user turns (those whose message role is `user`), and
-// return the id of the Nth-from-last user entry — the earliest entry to keep.
-// Returns undefined when there are fewer than `keep` user turns (nothing to
-// summarize without orphaning the kept tail) or when every entry would be kept.
+function latestCompaction(branchEntries: SessionEntry[]): CompactionEntry | undefined {
+  for (let i = branchEntries.length - 1; i >= 0; i -= 1) {
+    const entry = branchEntries[i];
+    if (isCompactionEntry(entry)) return entry;
+  }
+  return undefined;
+}
+
+function compactionBoundaryStartIndex(
+  branchEntries: SessionEntry[],
+  compaction: CompactionEntry,
+): number {
+  const keptIndex = branchEntries.findIndex((entry) => entry.id === compaction.firstKeptEntryId);
+  if (keptIndex >= 0) return keptIndex;
+
+  const compactionIndex = branchEntries.findIndex((entry) => entry.id === compaction.id);
+  return compactionIndex >= 0 ? compactionIndex + 1 : 0;
+}
+
+function activeHistoryStartIndex(branchEntries: SessionEntry[]): number {
+  const compaction = latestCompaction(branchEntries);
+  return compaction ? compactionBoundaryStartIndex(branchEntries, compaction) : 0;
+}
+
+function completedTurnsSinceCompaction(branchEntries: SessionEntry[]): number {
+  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) {
+    const entry = branchEntries[i];
+    if (isMessageEntry(entry) && entry.message.role === 'assistant') completed += 1;
+  }
+  return completed;
+}
+
+// Resolution of the `keep:N` boundary: scan only the active, uncompacted
+// history from newest to oldest. Kept messages from the prior compaction remain
+// eligible, while history represented by its summary is never selected again.
 function keepBoundaryId(branchEntries: SessionEntry[], keep: number): string | undefined {
+  const historyStart = activeHistoryStartIndex(branchEntries);
   let seen = 0;
-  for (let i = branchEntries.length - 1; i >= 0; i -= 1) {
+  for (let i = branchEntries.length - 1; i >= historyStart; i -= 1) {
     const entry = branchEntries[i];
     if (isMessageEntry(entry) && entry.message.role === 'user') {
       seen += 1;
-      if (seen === keep) {
-        return i === 0 ? undefined : entry.id;
-      }
+      if (seen === keep) return i === historyStart ? undefined : entry.id;
     }
   }
   return undefined;
 }
 
-function latestCompactionBefore(
+function latestCompactionForRange(
   branchEntries: SessionEntry[],
   untilIndex: number,
 ): CompactionEntry | undefined {
-  for (let i = untilIndex - 1; i >= 0; i -= 1) {
+  for (let i = branchEntries.length - 1; i >= 0; i -= 1) {
     const entry = branchEntries[i];
-    if (isCompactionEntry(entry)) return entry;
+    if (!isCompactionEntry(entry)) continue;
+    if (compactionBoundaryStartIndex(branchEntries, entry) < untilIndex) return entry;
   }
   return undefined;
 }
@@ -584,17 +732,8 @@ function compactionStartId(
   previousCompaction: CompactionEntry,
   untilIndex: number,
 ): string | undefined {
-  const keptIndex = branchEntries.findIndex(
-    (entry) => entry.id === previousCompaction.firstKeptEntryId,
-  );
-  if (keptIndex >= 0 && keptIndex < untilIndex) return previousCompaction.firstKeptEntryId;
-
-  const compactionIndex = branchEntries.findIndex((entry) => entry.id === previousCompaction.id);
-  if (compactionIndex >= 0 && compactionIndex + 1 < untilIndex) {
-    return branchEntries[compactionIndex + 1].id;
-  }
-
-  return undefined;
+  const boundaryStart = compactionBoundaryStartIndex(branchEntries, previousCompaction);
+  return boundaryStart < untilIndex ? branchEntries[boundaryStart]?.id : undefined;
 }
 
 function buildCompactRange(
@@ -604,7 +743,7 @@ function buildCompactRange(
   const untilIndex = branchEntries.findIndex((entry) => entry.id === firstKeptEntryId);
   if (untilIndex < 0) return undefined;
 
-  const previousCompaction = latestCompactionBefore(branchEntries, untilIndex);
+  const previousCompaction = latestCompactionForRange(branchEntries, untilIndex);
   const from = previousCompaction
     ? compactionStartId(branchEntries, previousCompaction, untilIndex)
     : undefined;
@@ -614,6 +753,14 @@ function buildCompactRange(
     : { scope: 'lineage', until: firstKeptEntryId };
 }
 
+function mergeCompactionSummary(
+  previousSummary: string | undefined,
+  generatedSummary: string,
+): string {
+  const previous = previousSummary?.trim();
+  return previous ? `${previous}\n\n${generatedSummary}` : generatedSummary;
+}
+
 async function buildGoosedumpCompaction(
   target: string,
   preparation: {
@@ -642,8 +789,9 @@ async function buildGoosedumpCompaction(
   const range = buildCompactRange(branchEntries, firstKeptEntryId);
   if (!range) return undefined;
 
-  const summary = await goosedumpCompact(target, range, signal);
-  if (!summary) return undefined;
+  const generatedSummary = await goosedumpCompact(target, range, signal);
+  if (!generatedSummary) return undefined;
+  const summary = mergeCompactionSummary(preparation.previousSummary, generatedSummary);
 
   return {
     summary,
@@ -670,23 +818,30 @@ class NumberInputSubmenu implements Component {
   private readonly hint: (text: string) => string;
   private readonly onSubmitValue: (value: number) => void;
   private readonly onCancelEdit: () => void;
+  private readonly onClearValue?: () => void;
   private readonly onInvalidValue: (message: string) => void;
   private readonly title: string;
-  private readonly currentValue: number;
+  private readonly currentValue: number | null;
   private readonly min: number;
   private readonly max: number;
 
   constructor(
     title: string,
-    currentValue: number,
+    currentValue: number | null,
     onSubmit: (value: number) => void,
     onCancel: () => void,
-    options?: { min?: number; max?: number; onInvalid?: (message: string) => void },
+    options?: {
+      min?: number;
+      max?: number;
+      onClear?: () => void;
+      onInvalid?: (message: string) => void;
+    },
   ) {
     this.title = title;
     this.currentValue = currentValue;
     this.onSubmitValue = onSubmit;
     this.onCancelEdit = onCancel;
+    this.onClearValue = options?.onClear;
     this.onInvalidValue = options?.onInvalid ?? (() => {});
     this.min = options?.min ?? 0;
     this.max = options?.max ?? 255;
@@ -698,7 +853,8 @@ class NumberInputSubmenu implements Component {
     if (kb.matches(data, 'tui.select.confirm') || data === '\n') {
       const value = this.input.getValue();
       if (value === '') {
-        this.onCancelEdit();
+        if (this.onClearValue) this.onClearValue();
+        else this.onCancelEdit();
         return;
       }
       if (!/^\d+$/.test(value)) {
@@ -729,11 +885,17 @@ class NumberInputSubmenu implements Component {
 
   render(width: number): string[] {
     return [
-      this.hint(`  ${this.title} · current ${this.currentValue} · ${this.min}-${this.max}`),
+      this.hint(
+        `  ${this.title} · current ${this.currentValue ?? 'inherit'} · ${this.min}-${this.max}`,
+      ),
       '',
       ...this.input.render(width),
       '',
-      this.hint('  enter submit  ·  esc cancel'),
+      this.hint(
+        this.onClearValue
+          ? '  empty inherit  ·  enter submit  ·  esc cancel'
+          : '  enter submit  ·  esc cancel',
+      ),
     ];
   }
 }
@@ -759,26 +921,37 @@ async function runSettingsEditor(ctx: ExtensionContext): Promise<void> {
 
       function buildSettingItems(): SettingItem[] {
         const global = readScopedGoosedumpSettings(location, 'global');
-        const project = readScopedGoosedumpSettings(location, 'project');
-        const settingsByScope = { global, project } satisfies Record<
-          SettingsScope,
-          GoosedumpSettings
-        >;
+        const projectPath = projectSettingsPath(location);
+        const projectRaw = readJsonObjectStrict(projectPath).goosedump;
+        const projectValue =
+          isRecord(projectRaw) &&
+          typeof projectRaw.turnsBeforeCompact === 'number' &&
+          Number.isSafeInteger(projectRaw.turnsBeforeCompact) &&
+          projectRaw.turnsBeforeCompact >= TURNS_BEFORE_COMPACT_MIN &&
+          projectRaw.turnsBeforeCompact <= TURNS_BEFORE_COMPACT_MAX
+            ? projectRaw.turnsBeforeCompact
+            : undefined;
 
         return (['global', 'project'] as const).map((scope) => ({
           id: `${scope}:turnsBeforeCompact`,
           label: settingLabel(scope, 'turnsBeforeCompact'),
-          description: 'LLM turns before compaction; 0 disables.',
-          currentValue: String(settingsByScope[scope].turnsBeforeCompact),
+          description:
+            scope === 'project'
+              ? 'LLM turns before compaction; empty inherits Global.'
+              : 'LLM turns before compaction; 0 disables.',
+          currentValue: String(
+            scope === 'project' ? (projectValue ?? '') : global.turnsBeforeCompact,
+          ),
           submenu: (currentValue, subDone) =>
             new NumberInputSubmenu(
               settingLabel(scope, 'turnsBeforeCompact'),
-              Number(currentValue),
+              currentValue === '' ? null : Number(currentValue),
               (value) => subDone(String(value)),
               () => subDone(),
               {
                 min: TURNS_BEFORE_COMPACT_MIN,
                 max: TURNS_BEFORE_COMPACT_MAX,
+                onClear: scope === 'project' ? () => subDone('') : undefined,
                 onInvalid: (message) => ctx.ui.notify(message, 'error'),
               },
             ),
@@ -792,6 +965,19 @@ async function runSettingsEditor(ctx: ExtensionContext): Promise<void> {
           getSettingsListTheme(),
           (id, newValue) => {
             const [scope, key] = id.split(':') as [SettingsScope, GoosedumpSettingKey];
+            if (scope === 'project' && newValue === '') {
+              try {
+                clearScopedGoosedumpSetting(location, scope, key);
+                settingsList.updateValue(id, '');
+                ctx.ui.notify(`${settingLabel(scope, key)} inherits Global`, 'info');
+                tui.requestRender();
+              } catch (error) {
+                const message = error instanceof Error ? error.message : String(error);
+                ctx.ui.notify(`goosedump settings error: ${message}`, 'error');
+              }
+              return;
+            }
+
             const parsed = Number(newValue);
             if (
               !Number.isSafeInteger(parsed) ||
@@ -799,9 +985,18 @@ async function runSettingsEditor(ctx: ExtensionContext): Promise<void> {
               parsed > TURNS_BEFORE_COMPACT_MAX
             )
               return;
-            writeScopedGoosedumpSetting(location, scope, key, parsed);
-            settingsList.updateValue(id, newValue);
-            ctx.ui.notify(`${settingLabel(scope, key)} = ${formatCompactSetting(parsed)}`, 'info');
+            try {
+              writeScopedGoosedumpSetting(location, scope, key, parsed);
+              settingsList.updateValue(id, newValue);
+              ctx.ui.notify(
+                `${settingLabel(scope, key)} = ${formatCompactSetting(parsed)}`,
+                'info',
+              );
+              tui.requestRender();
+            } catch (error) {
+              const message = error instanceof Error ? error.message : String(error);
+              ctx.ui.notify(`goosedump settings error: ${message}`, 'error');
+            }
             tui.requestRender();
           },
           () => {
@@ -1080,47 +1275,33 @@ export function createGoosedumpIntegration(
 
   let goosedumpAvailable = false;
   let compactSettings = DEFAULT_GOOSEDUMP_SETTINGS;
-  let settingsSignature = '';
   let turnsRemaining = 0;
   let counterTriggered = false;
   let compactionQueued = false;
   let pendingKeep: number | null = null;
 
-  function compactSettingsSignature(settings: GoosedumpSettings): string {
-    return String(settings.turnsBeforeCompact);
-  }
-
-  function resetCompactCounters(cwd: string): void {
-    compactSettings = resolveGoosedumpSettings(cwd);
-    settingsSignature = compactSettingsSignature(compactSettings);
-    turnsRemaining = compactSettings.turnsBeforeCompact;
-    counterTriggered = false;
-    pendingKeep = null;
-  }
-
-  function reloadCompactSettings(cwd: string): void {
-    const next = resolveGoosedumpSettings(cwd);
-    const nextSignature = compactSettingsSignature(next);
-    if (nextSignature !== settingsSignature) resetCompactCounters(cwd);
+  function syncCompactCounters(ctx: ExtensionContext, clearPending = false): void {
+    compactSettings = resolveGoosedumpSettings(ctx.cwd);
+    const completedTurns = completedTurnsSinceCompaction(ctx.sessionManager.getBranch());
+    turnsRemaining = Math.max(0, compactSettings.turnsBeforeCompact - completedTurns);
+    counterTriggered =
+      compactSettings.turnsBeforeCompact > 0 &&
+      completedTurns >= compactSettings.turnsBeforeCompact;
+    if (clearPending) pendingKeep = null;
   }
 
   function updateStatus(ctx: ExtensionContext): void {
     if (!goosedumpAvailable) return;
     const active = shouldOverrideDefaultCompaction && compactSettings.turnsBeforeCompact > 0;
-    const count = active ? Math.max(0, turnsRemaining) : 0;
-    ctx.ui.setStatus(
-      'goosedump',
-      ctx.ui.theme.fg('text', `GD: ${count.toString(16).toUpperCase().padStart(2, '0')}`),
-    );
+    const counter = active
+      ? Math.max(0, turnsRemaining).toString(16).toUpperCase().padStart(2, '0')
+      : '--';
+    ctx.ui.setStatus('goosedump', ctx.ui.theme.fg('text', `GD: ${counter}`));
   }
 
   function noteCompletedTurn(ctx: ExtensionContext): void {
     if (!goosedumpAvailable || !shouldOverrideDefaultCompaction) return;
-    reloadCompactSettings(ctx.cwd);
-    if (compactSettings.turnsBeforeCompact > 0) {
-      turnsRemaining -= 1;
-      if (turnsRemaining <= 0) counterTriggered = true;
-    }
+    syncCompactCounters(ctx);
     updateStatus(ctx);
   }
 
@@ -1169,6 +1350,65 @@ export function createGoosedumpIntegration(
 
   function register(pi: ExtensionAPI): void {
     if (shouldRegisterTool) {
+      pi.registerTool(
+        defineTool({
+          name: 'goose_recall',
+          label: 'goose_recall',
+          description:
+            'Recall durable context harvested from earlier compactions. Searches the current project by default and returns full remembered entries with provenance.',
+          promptSnippet: 'Recall durable context from earlier sessions',
+          promptGuidelines: [
+            'Use goose_recall for decisions, evidence, and context that may have disappeared from the current session.',
+            'Results include their original provider, session, entry, and working-directory provenance.',
+            'The current project is searched by default; set allProjects only when cross-project context is appropriate.',
+          ],
+          parameters: Type.Object({
+            query: Type.String({ description: 'Persistent-memory search query' }),
+            provider: Type.Optional(
+              Type.Union(
+                GOOSE_PROVIDERS.map((provider) => Type.Literal(provider)),
+                {
+                  description: 'Optional source-provider filter',
+                },
+              ),
+            ),
+            allProjects: Type.Optional(
+              Type.Boolean({
+                default: false,
+                description: 'Search memory from every working directory',
+              }),
+            ),
+            limit: Type.Optional(
+              Type.Integer({
+                minimum: 1,
+                maximum: 20,
+                default: 5,
+                description: 'Maximum remembered entries to return',
+              }),
+            ),
+          }),
+          async execute(_id, params, signal, _onUpdate, ctx): Promise<AgentToolResult<void>> {
+            if (!goosedumpAvailable) return goosedumpUnavailableResult();
+            try {
+              const hits = await goosedumpRecall(
+                params.query,
+                {
+                  provider: params.provider,
+                  path: params.allProjects ? undefined : ctx.cwd,
+                  limit: params.limit,
+                },
+                signal,
+              );
+              if (hits.length === 0) return textResult(`No durable memory for "${params.query}"`);
+              return textResult(formatMemoryHits(hits));
+            } catch (err) {
+              const message = err instanceof Error ? err.message : String(err);
+              return textResult(`goosedump error: ${message}`);
+            }
+          },
+        }),
+      );
+
       pi.registerTool(
         defineTool({
           name: 'goose_search',
@@ -1362,13 +1602,13 @@ export function createGoosedumpIntegration(
       if (ctx.hasPendingMessages()) return;
       if (!hasCompactableHistory(ctx)) return;
 
-      resetCompactCounters(ctx.cwd);
+      syncCompactCounters(ctx, true);
       updateStatus(ctx);
       compactionQueued = true;
       ctx.compact({
         onComplete: () => {
           compactionQueued = false;
-          resetCompactCounters(ctx.cwd);
+          syncCompactCounters(ctx, true);
           updateStatus(ctx);
           if (resumeAfter && !ctx.hasPendingMessages()) {
             pi.sendMessage(
@@ -1384,7 +1624,7 @@ export function createGoosedumpIntegration(
         },
         onError: (error) => {
           compactionQueued = false;
-          resetCompactCounters(ctx.cwd);
+          syncCompactCounters(ctx, true);
           updateStatus(ctx);
           const message = error instanceof Error ? error.message : String(error);
           if (ctx.hasUI) ctx.ui.notify(`goosedump compact failed: ${message}`, 'error');
@@ -1394,7 +1634,8 @@ export function createGoosedumpIntegration(
 
     pi.on('session_start', async (_event, ctx) => {
       goosedumpAvailable = checkGoosedump(ctx);
-      resetCompactCounters(ctx.cwd);
+      notifyInvalidSettings(ctx);
+      syncCompactCounters(ctx, true);
       updateStatus(ctx);
     });
 
@@ -1458,7 +1699,7 @@ export function createGoosedumpIntegration(
     pi.on('session_compact', async (event, ctx) => {
       if (!goosedumpAvailable || !shouldOverrideDefaultCompaction) return;
 
-      resetCompactCounters(ctx.cwd);
+      syncCompactCounters(ctx, true);
       updateStatus(ctx);
 
       const compactionEntry = event.compactionEntry;
@@ -1496,7 +1737,7 @@ export function createGoosedumpIntegration(
 
         try {
           await runSettingsEditor(ctx);
-          reloadCompactSettings(ctx.cwd);
+          syncCompactCounters(ctx);
           updateStatus(ctx);
         } catch (err) {
           const message = err instanceof Error ? err.message : String(err);
@@ -1517,11 +1758,15 @@ export function createGoosedumpIntegration(
         // the last N user turns verbatim and summarizes everything before; with
         // no argument goosedump summarizes up to Pi's token-based cut.
         let keep: number | null = null;
-        if (typeof args === 'string') {
+        if (typeof args === 'string' && args.trim()) {
           const match = args.trim().match(/^keep:(\d+)$/);
-          if (match) keep = Number(match[1]);
-          if (match && (keep === null || keep < 1)) {
-            ctx.ui.notify('keep:N requires N >= 1', 'error');
+          if (!match) {
+            ctx.ui.notify('Usage: /goose-compact [keep:N], where N >= 1', 'error');
+            return;
+          }
+          keep = Number(match[1]);
+          if (!Number.isSafeInteger(keep) || keep < 1) {
+            ctx.ui.notify('keep:N requires a safe integer N >= 1', 'error');
             return;
           }
         }

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "pi-goosedump",
-  "version": "0.9.14",
+  "version": "0.10.1",
   "description": "Pi extension for goosedump-backed session-history search, entry expansion, and compaction",
   "keywords": [
     "compaction",