pi-goosedump 0.10.4 → 0.10.6

package/README.md

@@ -1,69 +1,62 @@
 # pi-goosedump
 
-`pi-goosedump` is a pi extension for goosedump-backed session-history search,
-entry expansion, and compaction. It exposes goosedump tools under the `goose_`
-prefix and replaces Pi's default LLM compaction with goosedump-generated
-summaries.
+`pi-goosedump` adds goosedump-backed session-history search, durable-memory
+recall, entry expansion, and compaction to Pi. Its tools use the `goose_`
+prefix.
 
-## Installation
+## Install
 
-```bash
+```sh
 pi install npm:pi-goosedump
 ```
 
-This installs `pi-goosedump` and its main dependency `@jarkkojs/goosedump`,
-which includes platform-specific native binaries for Linux x64, macOS arm64,
-and Windows x64.
-If the goosedump binary cannot be resolved, the extension disables itself.
+The package installs `@jarkkojs/goosedump`, including native binaries for Linux
+x64, macOS arm64, and Windows x64. If no compatible binary is available, the
+extension keeps Pi's normal compaction behavior and its goosedump features
+report that they are unavailable.
 
 ## Tools
 
-- **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.
-- **goose_compact:** triggers a goosedump compaction now, optionally keeping
-  the last N user turns verbatim while summarizing everything before.
-
-The read tools (`goose_search`, `goose_get`, `goose_grep`) each accept an
-optional `provider` (default `pi`; also `claude`, `codex`, `crush`, `gemini`,
-`goose`, `opencode`) and `session` id. `session` defaults to the current Pi
-session for `pi` and is required otherwise. `scope` is `lineage` (default,
-current branch) or `all`. Targets are always provider-qualified
-(`provider:id`); a bare id is never sent to goosedump.
+- **`goose_search`** ranks session messages and returns compact overviews with
+  entry IDs.
+- **`goose_get`** expands entry IDs returned by `goose_search` or `goose_grep`.
+- **`goose_grep`** filters session messages with a glob pattern.
+- **`goose_recall`** searches memory harvested by earlier compactions. It
+  searches the current working directory by default and returns full entries
+  with provenance.
+- **`goose_compact`** starts asynchronous compaction of the current Pi session.
+  Set `keep` to preserve the last N user turns verbatim.
 
-```
+The session-history tools accept an optional `provider` (`pi` by default),
+`session`, and `scope` (`lineage` by default or `all`). The current Pi session
+is used when both provider and session are omitted. Non-Pi providers require an
+explicit session ID. Targets sent to goosedump are always provider-qualified.
+
+Examples:
+
+```text
 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-…" })
-goose_grep({ pattern: "*rand*" })
+goose_grep({ pattern: "*timeout*" })
+goose_recall({ query: "prior architecture decision" })
 goose_compact({ keep: 2 })
 ```
 
 ## Commands
 
-- **`/goose-search [query]`:** search the current session history; accepts a
-  query argument or prompts inline when bare. Shows ranked results in a
-  scrollable panel; press enter to expand an entry to its full content.
-- **`/goose-compact [keep:N]`:** compact now with goosedump. With `keep:N`
-  (N ≥ 1) the last N user turns stay verbatim and everything before is
-  summarized; with no argument goosedump summarizes up to Pi's token-based cut.
-- **`/goose-settings`:** edit the global and project compaction settings.
+- **`/goose-search [query]`** searches the current session. A bare command opens
+  an inline prompt; selecting a result expands it.
+- **`/goose-compact [keep:N]`** compacts now. With `keep:N`, the last N user
+  turns remain verbatim; without it, Pi chooses the cut point.
+- **`/goose-settings`** edits global and project compaction settings.
 
 ## Settings
 
-`pi-goosedump` reads optional JSON settings from:
+Optional settings live under `goosedump` in:
 
-- `~/.pi/agent/settings.json` — Global
-- `.pi/settings.json` — Project
-
-Project settings override global settings. All settings live in a `goosedump`
-section and are optional (defaults shown):
+- `~/.pi/agent/settings.json` for global settings.
+- `.pi/settings.json` for project overrides.
 
 ```json
 {
@@ -73,37 +66,24 @@ 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. 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
-
-pi-goosedump hooks Pi's `session_before_compact` event — fired by manual
-`/compact`, the turn counter above, and Pi's own auto-compaction — and
-substitutes a goosedump summary for Pi's LLM summary. It resolves the current
-session to its goosedump context by reading the `id` field from the session
-header line, then runs `goosedump compact` over the replacement range:
-
-- `--from` is the entry following the most recent prior compaction (so the
-  summary starts where the previous one left off); omitted on the first
-  compaction.
-- `--until` is the first entry Pi is keeping (`firstKeptEntryId`).
-
-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.
+`turnsBeforeCompact` is an integer from 0 to 255. `0` disables scheduled
+compaction. The countdown is restored when a session resumes and appears in the
+footer as hexadecimal: `GD: 0A` means ten turns remain, `GD: 00` is ready to
+compact, and `GD: --` is disabled. Clearing the project value restores the
+global setting.
+
+## Compaction behavior
+
+The extension replaces Pi's normal summary during manual, scheduled, and
+automatic compaction. It preserves the previous compaction summary and asks
+goosedump to summarize only the newly compacted range. A `keep:N` request
+instead keeps the last N active user turns; it is cancelled when no earlier
+history is available to summarize.
+
+Compactions with custom instructions continue to use Pi's normal compactor. If
+goosedump fails, the extension reports the error and falls back to Pi. Successful
+compactions report memory-learning warnings without discarding the summary.
 
 ## License
 
-`pi-goosedump` is licensed under `Apache-2.0`. See [LICENSE](LICENSE) for more
-information.
+`pi-goosedump` is licensed under `Apache-2.0`. See [LICENSE](LICENSE).

package/index.ts

@@ -50,6 +50,9 @@ import {
 import { Type } from '@sinclair/typebox';
 
 const require = createRequire(import.meta.url);
+const BRANCH_SUMMARY_PREFIX =
+  'The following is a summary of a branch that this conversation came back from:\n\n<summary>\n';
+const BRANCH_SUMMARY_SUFFIX = '</summary>';
 
 // One rendered message after normalizing a context into pi's native JSONL.
 interface GoosedumpMessage {
@@ -58,6 +61,11 @@ interface GoosedumpMessage {
   content: string;
 }
 
+interface GoosedumpCommandOutput {
+  stdout: string;
+  stderr: string;
+}
+
 interface GoosedumpMemoryHit {
   hash: string;
   kind: string;
@@ -67,6 +75,7 @@ interface GoosedumpMemoryHit {
   context_id: string;
   entry_id: string;
   path: string;
+  source_path: string;
 }
 
 // A `content` part of a pi-native message line.
@@ -85,6 +94,7 @@ interface PiEntryJson {
   type?: string;
   id?: string;
   message?: { role?: string; content?: PiPartJson[] | string };
+  content?: PiPartJson[] | string;
   summary?: string;
 }
 
@@ -102,6 +112,15 @@ const DEFAULT_GOOSEDUMP_SETTINGS: GoosedumpSettings = {
 const TURNS_BEFORE_COMPACT_MIN = 0;
 const TURNS_BEFORE_COMPACT_MAX = 255;
 
+function isTurnsBeforeCompact(value: unknown): value is number {
+  return (
+    typeof value === 'number' &&
+    Number.isSafeInteger(value) &&
+    value >= TURNS_BEFORE_COMPACT_MIN &&
+    value <= TURNS_BEFORE_COMPACT_MAX
+  );
+}
+
 function piAgentDir(): string {
   return process.env.PI_CODING_AGENT_DIR ?? join(homedir(), '.pi', 'agent');
 }
@@ -132,7 +151,13 @@ 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;
+  let parsed: unknown;
+  try {
+    parsed = JSON.parse(readFileSync(path, 'utf8')) as unknown;
+  } catch (error) {
+    const message = error instanceof Error ? error.message : String(error);
+    throw new Error(`${path}: ${message}`);
+  }
   if (!isRecord(parsed)) throw new Error(`${path} must contain a JSON object`);
   return parsed;
 }
@@ -159,17 +184,26 @@ function readGoosedumpSettingsFrom(path: string): Partial<GoosedumpSettings> {
 
   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;
-  }
+  if (isTurnsBeforeCompact(value)) settings.turnsBeforeCompact = value;
   return settings;
 }
 
+function validateGoosedumpSettings(path: string): void {
+  const root = readJsonObjectStrict(path);
+  if (root.goosedump === undefined) return;
+  if (!isRecord(root.goosedump)) {
+    throw new Error(`${path}: goosedump must be a JSON object`);
+  }
+
+  const value = root.goosedump.turnsBeforeCompact;
+  if (value !== undefined && !isTurnsBeforeCompact(value)) {
+    throw new Error(
+      `${path}: goosedump.turnsBeforeCompact must be an integer from ` +
+        `${TURNS_BEFORE_COMPACT_MIN} to ${TURNS_BEFORE_COMPACT_MAX}`,
+    );
+  }
+}
+
 function resolveGoosedumpSettings(cwd: string): GoosedumpSettings {
   return {
     ...DEFAULT_GOOSEDUMP_SETTINGS,
@@ -181,7 +215,7 @@ function resolveGoosedumpSettings(cwd: string): GoosedumpSettings {
 function notifyInvalidSettings(ctx: ExtensionContext): void {
   for (const path of [globalSettingsPath(), projectSettingsPath(ctx.cwd)]) {
     try {
-      readJsonObjectStrict(path);
+      validateGoosedumpSettings(path);
     } catch (error) {
       const message = error instanceof Error ? error.message : String(error);
       if (ctx.hasUI) ctx.ui.notify(`goosedump settings error: ${message}`, 'error');
@@ -196,14 +230,7 @@ function readScopedGoosedumpSettings(cwd: string, scope: SettingsScope): Goosedu
 
   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;
-  }
+  if (isTurnsBeforeCompact(value)) settings.turnsBeforeCompact = value;
   return { ...DEFAULT_GOOSEDUMP_SETTINGS, ...settings };
 }
 
@@ -290,11 +317,10 @@ function flattenPiContent(content: PiPartJson[] | string | undefined): string {
   return content.map(flattenPiPart).filter(Boolean).join('\n');
 }
 
-// goosedump 0.9 renders `show`/`grep`/`search` in a provider's native format.
-// Passing `--as-provider pi` normalizes every provider's output to pi's JSONL,
-// so one parser covers all sources: each `{"type":"message"}` line becomes a
-// `GoosedumpMessage` with its `content[]` parts flattened to readable text.
-function parsePiMessages(output: string): GoosedumpMessage[] {
+// goosedump renders `show`/`grep`/`search` in a provider's native format.
+// Passing `--as-provider pi` normalizes every provider's output to Pi JSONL, so
+// one parser covers all sources, including Pi-native context entries.
+export function parsePiMessages(output: string): GoosedumpMessage[] {
   const messages: GoosedumpMessage[] = [];
   for (const line of output.split('\n')) {
     if (!line) continue;
@@ -304,9 +330,22 @@ function parsePiMessages(output: string): GoosedumpMessage[] {
     } catch {
       continue;
     }
-    if (entry.type !== 'message' || !entry.message) continue;
-    const content = flattenPiContent(entry.message.content);
-    messages.push({ id: entry.id ?? '', role: entry.message.role ?? 'unknown', content });
+    if (entry.type === 'message' && entry.message) {
+      const content = flattenPiContent(entry.message.content);
+      messages.push({ id: entry.id ?? '', role: entry.message.role ?? 'unknown', content });
+    } else if (entry.type === 'custom_message') {
+      messages.push({
+        id: entry.id ?? '',
+        role: 'user',
+        content: flattenPiContent(entry.content),
+      });
+    } else if (entry.type === 'branch_summary') {
+      messages.push({
+        id: entry.id ?? '',
+        role: 'user',
+        content: `${BRANCH_SUMMARY_PREFIX}${entry.summary ?? ''}${BRANCH_SUMMARY_SUFFIX}`,
+      });
+    }
   }
   return messages;
 }
@@ -324,7 +363,8 @@ function parseMemoryHits(output: string): GoosedumpMemoryHit[] {
       typeof item.provider === 'string' &&
       typeof item.context_id === 'string' &&
       typeof item.entry_id === 'string' &&
-      typeof item.path === 'string',
+      typeof item.path === 'string' &&
+      typeof item.source_path === 'string',
   );
 }
 
@@ -332,7 +372,7 @@ function formatMemoryHits(hits: GoosedumpMemoryHit[]): string {
   return hits
     .map(
       (hit) =>
-        `[${hit.hash}] ${hit.kind} (${hit.provider}:${hit.context_id}/${hit.entry_id})\n${hit.text}`,
+        `[${hit.hash}] ${hit.kind} (${hit.provider}:${hit.context_id}/${hit.entry_id})\nWorking directory: ${hit.path}\nSource: ${hit.source_path}\n${hit.text}`,
     )
     .join('\n\n---\n\n');
 }
@@ -394,7 +434,7 @@ function runGoosedump(args: string[]): string {
 // Non-blocking variant for the compact path: goosedump compact runs an ML
 // model and can take many seconds, so execFileSync would freeze Pi's event
 // loop (and its compaction spinner). execFile keeps the loop free to render.
-function runGoosedumpAsync(args: string[], signal?: AbortSignal): Promise<string> {
+function runGoosedumpAsync(args: string[], signal?: AbortSignal): Promise<GoosedumpCommandOutput> {
   return new Promise((resolve, reject) => {
     execFile(
       process.execPath,
@@ -409,7 +449,7 @@ function runGoosedumpAsync(args: string[], signal?: AbortSignal): Promise<string
           const message = stderr.trim() || err.message;
           reject(new Error(message));
         } else {
-          resolve(stdout);
+          resolve({ stdout, stderr });
         }
       },
     );
@@ -475,12 +515,12 @@ async function goosedumpRecall(
   query: string,
   options: { provider?: string; path?: string; limit?: number } = {},
   signal?: AbortSignal,
-): Promise<GoosedumpMemoryHit[]> {
+): Promise<{ hits: GoosedumpMemoryHit[]; warning: string }> {
   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);
+  return { hits: parseMemoryHits(output.stdout), warning: output.stderr.trim() };
 }
 
 // Resolve a goosedump 0.9 `provider:id` target. An explicit contextId is the
@@ -537,23 +577,25 @@ async function goosedumpCompact(
   target: string,
   options: { scope?: string; from?: string; until: string },
   signal?: AbortSignal,
-): Promise<string> {
+): Promise<{ summary: string; warning: string }> {
   const scope = options.scope ?? 'lineage';
   const args = ['compact', target, '--scope', scope];
   if (options.from) args.push('--from', options.from);
   args.push('--until', options.until);
 
   const output = await runGoosedumpAsync(args, signal);
-  for (const line of output.split('\n')) {
+  for (const line of output.stdout.split('\n')) {
     if (!line) continue;
     try {
       const entry = JSON.parse(line) as PiEntryJson;
-      if (entry.type === 'compaction' && typeof entry.summary === 'string') return entry.summary;
+      if (entry.type === 'compaction' && typeof entry.summary === 'string') {
+        return { summary: entry.summary, warning: output.stderr.trim() };
+      }
     } catch {
       continue;
     }
   }
-  return output.trim();
+  return { summary: output.stdout.trim(), warning: output.stderr.trim() };
 }
 
 export interface GoosedumpIntegrationOptions {
@@ -574,6 +616,7 @@ interface GoosedumpCompactionDetails {
   from?: string;
   until: string;
   fileOps: unknown;
+  warning?: string;
 }
 
 export interface GoosedumpIntegration {
@@ -610,11 +653,19 @@ function isCompactionEntry(entry: SessionEntry): entry is CompactionEntry {
 
 function isMessageEntry(entry: SessionEntry): entry is SessionEntry & {
   type: 'message';
-  message: { role?: string };
+  message: { role?: string; stopReason?: string };
 } {
   return entry.type === 'message';
 }
 
+function isCompletedAssistant(message: { role?: string; stopReason?: string }): boolean {
+  return (
+    message.role === 'assistant' &&
+    message.stopReason !== 'error' &&
+    message.stopReason !== 'aborted'
+  );
+}
+
 // Entry types that sessionEntryToContextMessages turns into context messages;
 // only these count toward "is there anything to summarize".
 const SUMMARIZABLE_ENTRY_TYPES = new Set(['message', 'custom_message', 'branch_summary']);
@@ -631,6 +682,38 @@ function piKeepRecentTokens(cwd: string): number {
   return DEFAULT_COMPACTION_SETTINGS.keepRecentTokens;
 }
 
+function piCompactionEnabled(cwd: string): boolean {
+  for (const path of [projectSettingsPath(cwd), globalSettingsPath()]) {
+    const compaction = readJsonObject(path).compaction;
+    if (isRecord(compaction) && typeof compaction.enabled === 'boolean') {
+      return compaction.enabled;
+    }
+  }
+  return DEFAULT_COMPACTION_SETTINGS.enabled;
+}
+
+function piReserveTokens(cwd: string): number {
+  for (const path of [projectSettingsPath(cwd), globalSettingsPath()]) {
+    const compaction = readJsonObject(path).compaction;
+    if (isRecord(compaction) && typeof compaction.reserveTokens === 'number') {
+      return compaction.reserveTokens;
+    }
+  }
+  return DEFAULT_COMPACTION_SETTINGS.reserveTokens;
+}
+
+const SUMMARY_TOKEN_BUDGET_RATIO = 0.8;
+const OMITTED_SUMMARY_CONTEXT = '\n\n[Earlier compaction context omitted]\n\n';
+
+function piAutoCompactionPending(ctx: ExtensionContext): boolean {
+  const usage = ctx.getContextUsage();
+  if (!usage || usage.tokens === null) return false;
+
+  return (
+    piCompactionEnabled(ctx.cwd) && usage.tokens > usage.contextWindow - piReserveTokens(ctx.cwd)
+  );
+}
+
 // Predict whether ctx.compact() would throw "Nothing to compact" or "Already
 // compacted": mirrors prepareCompaction's guards over the active lineage so
 // plugin-triggered compaction can skip the call instead of surfacing pi's
@@ -694,7 +777,7 @@ function completedTurnsSinceCompaction(branchEntries: SessionEntry[]): number {
   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;
+    if (isMessageEntry(entry) && isCompletedAssistant(entry.message)) completed += 1;
   }
   return completed;
 }
@@ -753,12 +836,59 @@ function buildCompactRange(
     : { scope: 'lineage', until: firstKeptEntryId };
 }
 
+function utf8Prefix(text: string, maxBytes: number): string {
+  const prefix: string[] = [];
+  let bytes = 0;
+  for (const char of text) {
+    const charBytes = Buffer.byteLength(char);
+    if (bytes + charBytes > maxBytes) break;
+    prefix.push(char);
+    bytes += charBytes;
+  }
+  return prefix.join('');
+}
+
+function utf8Suffix(text: string, maxBytes: number): string {
+  const suffix: string[] = [];
+  let bytes = 0;
+  for (const char of Array.from(text).reverse()) {
+    const charBytes = Buffer.byteLength(char);
+    if (bytes + charBytes > maxBytes) break;
+    suffix.push(char);
+    bytes += charBytes;
+  }
+  return suffix.reverse().join('');
+}
+
+function truncateSummary(summary: string, maxBytes: number): string {
+  const text = summary.trim();
+  if (Buffer.byteLength(text) <= maxBytes) return text;
+
+  const markerBytes = Buffer.byteLength(OMITTED_SUMMARY_CONTEXT);
+  if (maxBytes <= markerBytes) return utf8Prefix(text, maxBytes);
+
+  const retainedBytes = maxBytes - markerBytes;
+  const headBytes = Math.ceil(retainedBytes / 2);
+  const tailBytes = Math.floor(retainedBytes / 2);
+  return `${utf8Prefix(text, headBytes)}${OMITTED_SUMMARY_CONTEXT}${utf8Suffix(text, tailBytes)}`;
+}
+
 function mergeCompactionSummary(
   previousSummary: string | undefined,
   generatedSummary: string,
+  reserveTokens: number,
 ): string {
+  // A token always represents at least one UTF-8 byte. Capping bytes is
+  // conservative, but unlike a chars/token estimate it cannot undercount text.
+  const maxBytes = Math.max(1, Math.floor(reserveTokens * SUMMARY_TOKEN_BUDGET_RATIO));
+  const generated = truncateSummary(generatedSummary, maxBytes);
   const previous = previousSummary?.trim();
-  return previous ? `${previous}\n\n${generatedSummary}` : generatedSummary;
+  const separator = '\n\n';
+  const generatedBytes = Buffer.byteLength(generated);
+  if (!previous || generatedBytes + Buffer.byteLength(separator) >= maxBytes) return generated;
+
+  const previousBytes = maxBytes - generatedBytes - Buffer.byteLength(separator);
+  return `${truncateSummary(previous, previousBytes)}${separator}${generated}`;
 }
 
 async function buildGoosedumpCompaction(
@@ -770,6 +900,7 @@ async function buildGoosedumpCompaction(
     fileOps: unknown;
   },
   branchEntries: SessionEntry[],
+  reserveTokens: number,
   keep?: number,
   signal?: AbortSignal,
 ): Promise<
@@ -789,9 +920,13 @@ async function buildGoosedumpCompaction(
   const range = buildCompactRange(branchEntries, firstKeptEntryId);
   if (!range) return undefined;
 
-  const generatedSummary = await goosedumpCompact(target, range, signal);
-  if (!generatedSummary) return undefined;
-  const summary = mergeCompactionSummary(preparation.previousSummary, generatedSummary);
+  const generated = await goosedumpCompact(target, range, signal);
+  if (!generated.summary) return undefined;
+  const summary = mergeCompactionSummary(
+    preparation.previousSummary,
+    generated.summary,
+    reserveTokens,
+  );
 
   return {
     summary,
@@ -804,6 +939,7 @@ async function buildGoosedumpCompaction(
       from: range.from,
       until: range.until,
       fileOps: preparation.fileOps,
+      warning: generated.warning || undefined,
     },
   };
 }
@@ -924,11 +1060,7 @@ async function runSettingsEditor(ctx: ExtensionContext): Promise<void> {
         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
+          isRecord(projectRaw) && isTurnsBeforeCompact(projectRaw.turnsBeforeCompact)
             ? projectRaw.turnsBeforeCompact
             : undefined;
 
@@ -979,12 +1111,7 @@ async function runSettingsEditor(ctx: ExtensionContext): Promise<void> {
             }
 
             const parsed = Number(newValue);
-            if (
-              !Number.isSafeInteger(parsed) ||
-              parsed < TURNS_BEFORE_COMPACT_MIN ||
-              parsed > TURNS_BEFORE_COMPACT_MAX
-            )
-              return;
+            if (!isTurnsBeforeCompact(parsed)) return;
             try {
               writeScopedGoosedumpSetting(location, scope, key, parsed);
               settingsList.updateValue(id, newValue);
@@ -1278,6 +1405,7 @@ export function createGoosedumpIntegration(
   let turnsRemaining = 0;
   let counterTriggered = false;
   let compactionQueued = false;
+  let compactionHookActive = false;
   let pendingKeep: number | null = null;
 
   function syncCompactCounters(ctx: ExtensionContext, clearPending = false): void {
@@ -1328,7 +1456,7 @@ export function createGoosedumpIntegration(
     ctx: ExtensionContext,
     keep: number | null,
   ): 'started' | 'busy' | 'nothing-to-compact' {
-    if (compactionQueued) return 'busy';
+    if (compactionQueued || compactionHookActive) return 'busy';
     if (keep === null && !hasCompactableHistory(ctx)) return 'nothing-to-compact';
 
     compactionQueued = true;
@@ -1390,7 +1518,7 @@ export function createGoosedumpIntegration(
           async execute(_id, params, signal, _onUpdate, ctx): Promise<AgentToolResult<void>> {
             if (!goosedumpAvailable) return goosedumpUnavailableResult();
             try {
-              const hits = await goosedumpRecall(
+              const { hits, warning } = await goosedumpRecall(
                 params.query,
                 {
                   provider: params.provider,
@@ -1399,6 +1527,7 @@ export function createGoosedumpIntegration(
                 },
                 signal,
               );
+              if (warning && ctx.hasUI) ctx.ui.notify(warning, 'warning');
               if (hits.length === 0) return textResult(`No durable memory for "${params.query}"`);
               return textResult(formatMemoryHits(hits));
             } catch (err) {
@@ -1601,6 +1730,10 @@ export function createGoosedumpIntegration(
       if (!counterTriggered || compactionQueued) return;
       if (ctx.hasPendingMessages()) return;
       if (!hasCompactableHistory(ctx)) return;
+      // Pi checks this threshold immediately after agent_end. Let that native
+      // path invoke our session_before_compact hook instead of starting a
+      // competing manual compaction.
+      if (!resumeAfter && piAutoCompactionPending(ctx)) return;
 
       syncCompactCounters(ctx, true);
       updateStatus(ctx);
@@ -1640,7 +1773,7 @@ export function createGoosedumpIntegration(
     });
 
     pi.on('turn_end', async (event, ctx) => {
-      noteCompletedTurn(ctx);
+      if (isCompletedAssistant(event.message)) noteCompletedTurn(ctx);
       // A turn with tool results means the agent loop would keep going; compact
       // between turns and resume so the run's progress is not lost.
       if (event.toolResults.length > 0) maybeAutoCompact(ctx, true);
@@ -1667,12 +1800,19 @@ export function createGoosedumpIntegration(
       const target = currentSessionTarget(ctx);
       if (!target) return;
 
+      // Pi checks reserveTokens immediately after agent_end. A turn-driven
+      // ctx.compact() can reach this hook at the same time; let the first
+      // compaction proceed and cancel the duplicate before both append entries.
+      if (compactionHookActive) return { cancel: true };
+      compactionHookActive = true;
+
       try {
         const keep = pendingKeep ?? undefined;
         const compaction = await buildGoosedumpCompaction(
           target,
           event.preparation,
           event.branchEntries,
+          piReserveTokens(ctx.cwd),
           keep,
           event.signal,
         );
@@ -1680,6 +1820,10 @@ export function createGoosedumpIntegration(
           if (ctx.hasUI) ctx.ui.notify(compaction.reason, 'info');
           return { cancel: true };
         }
+        const warning = compaction?.details?.warning;
+        if (warning && ctx.hasUI) {
+          ctx.ui.notify(warning, 'warning');
+        }
         return compaction ? { compaction } : undefined;
       } catch (err) {
         if (event.signal.aborted) return { cancel: true };
@@ -1692,6 +1836,7 @@ export function createGoosedumpIntegration(
         }
         return undefined;
       } finally {
+        compactionHookActive = false;
         pendingKeep = null;
       }
     });

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "pi-goosedump",
-  "version": "0.10.4",
+  "version": "0.10.6",
   "description": "Pi extension for goosedump-backed session-history search, entry expansion, and compaction",
   "keywords": [
     "compaction",
@@ -33,7 +33,7 @@
   },
   "dependencies": {
     "@earendil-works/pi-tui": "^0.78.0",
-    "@jarkkojs/goosedump": "^0.10.4",
+    "@jarkkojs/goosedump": "^0.10.6",
     "@sinclair/typebox": "^0.34.49"
   },
   "devDependencies": {