pi-goosedump 0.1.3 → 0.2.1

package/README.md

@@ -20,19 +20,19 @@ Once installed, pi-goosedump registers a tool and a slash command:
 
 The agent can browse session history with:
 
-| Action   | Description                                |
-| -------- | ------------------------------------------ |
-| `list`   | List all available sessions                |
-| `search` | Search within a session with regex pattern |
-| `expand` | Show full content for specific entry IDs   |
-| `view`   | View the full session transcript           |
+| Action   | Description                              |
+| -------- | ---------------------------------------- |
+| `list`   | List all available sessions              |
+| `search` | Rank messages by query relevance         |
+| `expand` | Show full content for specific entry IDs |
+| `view`   | View the full session transcript         |
 
 Examples:
 
 ```
 goosedump({ action: "list" })
 goosedump({ action: "search", contextId: "abc123", query: "bug fix" })
-goosedump({ action: "expand", contextId: "abc123", ids: [0, 3, 5] })
+goosedump({ action: "expand", contextId: "abc123", ids: ["entry-a", "entry-b"] })
 goosedump({ action: "view", contextId: "abc123" })
 ```
 
@@ -40,6 +40,13 @@ goosedump({ action: "view", contextId: "abc123" })
 
 Opens an interactive session browser.
 
+### Compaction
+
+pi-goosedump hooks Pi's `/compact` and auto-compaction flow. It uses
+`goosedump compact pi <session>` with Pi's compaction range (`--from`,
+`--until`, and `--scope`) so the generated summary matches the entries Pi is
+about to replace.
+
 ## License
 
 `pi-goosedump` is licensed under `MIT`. See [LICENSE](LICENSE) for more

package/index.ts

@@ -3,34 +3,37 @@
 
 import type {
   AgentToolResult,
+  CompactionEntry,
+  CompactionResult,
   ExtensionAPI,
   ExtensionContext,
+  SessionEntry,
 } from '@earendil-works/pi-coding-agent';
 
 import { defineTool } from '@earendil-works/pi-coding-agent';
 
 import { execFileSync } from 'node:child_process';
-import { existsSync } from 'node:fs';
+import { existsSync, readFileSync } from 'node:fs';
+import { createRequire } from 'node:module';
 import { homedir } from 'node:os';
-import { join } from 'node:path';
+import { basename, join } from 'node:path';
 
 import { Key, matchesKey, truncateToWidth, visibleWidth } from '@earendil-works/pi-tui';
 import { Type } from '@sinclair/typebox';
 
-const GOOSEDUMP_VERSION = [0, 1, 0] as const;
+const require = createRequire(import.meta.url);
+
+const GOOSEDUMP_VERSION = [0, 2, 1] as const;
 
 interface GoosedumpListing {
   id: string;
-  created: string;
-  modified: string;
-  entryCount: number;
 }
 
 interface GoosedumpMessage {
   id: string;
   role: string;
   content: string;
-  timestamp: string;
+  score?: number;
 }
 
 interface GoosedumpContextResult {
@@ -91,17 +94,14 @@ function hasMinimumVersion(version: string, minimum: readonly [number, number, n
 
 function parseListings(output: string): GoosedumpListing[] {
   const listings: GoosedumpListing[] = [];
-  // Format: <id> <created> <entryCount> entries <modified>
-  const regex = /^(\S+)\s+(\S+\s+\S+)\s+(\d+)\s+entries?\s+(.+)$/gm;
-  let match: RegExpExecArray | null;
-
-  while ((match = regex.exec(output)) !== null) {
-    listings.push({
-      id: match[1],
-      created: match[2],
-      entryCount: parseInt(match[3], 10),
-      modified: match[4],
-    });
+  const lines = output.split('\n');
+
+  for (const line of lines) {
+    if (line === 'Sessions:' || line.trim() === '') continue;
+    const match = line.match(/^  (\S+)/);
+    if (match) {
+      listings.push({ id: match[1] });
+    }
   }
 
   return listings;
@@ -109,41 +109,46 @@ function parseListings(output: string): GoosedumpListing[] {
 
 function parseMessages(output: string): GoosedumpMessage[] {
   const messages: GoosedumpMessage[] = [];
-  // Format from goosedump plain output: [id] role: content
   const lines = output.split('\n');
-  let currentId = '';
-  let currentRole = '';
+  let currentMsg: GoosedumpMessage | null = null;
   let contentLines: string[] = [];
-  let currentTimestamp = '';
 
   for (const line of lines) {
-    const headerMatch = line.match(/^\[([^\]]+)\]\s+(user|assistant|tool|system)\s*(\([^)]+\))?:/);
-    if (headerMatch) {
-      if (currentId) {
-        messages.push({
-          id: currentId,
-          role: currentRole,
-          content: contentLines.join('\n').trim(),
-          timestamp: currentTimestamp,
-        });
+    if (line.startsWith('results for ')) continue;
+
+    const entryMatch = line.match(/^entryId:\s+(\S+)\s+\((.+)\)$/);
+    if (entryMatch) {
+      if (currentMsg) {
+        currentMsg.content = contentLines.join('\n').trim();
+        messages.push(currentMsg);
+      }
+      currentMsg = {
+        id: entryMatch[1],
+        role: entryMatch[2],
+        content: '',
+      };
+      contentLines = [];
+      continue;
+    }
+
+    if (currentMsg) {
+      const indentedMatch = line.match(/^  (.+)$/);
+      if (indentedMatch) {
+        const content = indentedMatch[1];
+        if (content.startsWith('score: ')) {
+          const scoreVal = parseFloat(content.slice(7));
+          if (!isNaN(scoreVal)) currentMsg.score = scoreVal;
+          continue;
+        }
+        if (/^\.\.\.\(\d+ lines (?:above|below)\)$/.test(content)) continue;
+        contentLines.push(content);
       }
-      currentId = headerMatch[1];
-      currentRole = headerMatch[2];
-      currentTimestamp = headerMatch[3]?.replace(/[()]/g, '') ?? '';
-      contentLines = [line.slice(headerMatch[0].length).trim()];
-    } else if (currentId) {
-      if (line.startsWith('---') && messages.length > 0) continue;
-      contentLines.push(line);
     }
   }
 
-  if (currentId) {
-    messages.push({
-      id: currentId,
-      role: currentRole,
-      content: contentLines.join('\n').trim(),
-      timestamp: currentTimestamp,
-    });
+  if (currentMsg) {
+    currentMsg.content = contentLines.join('\n').trim();
+    messages.push(currentMsg);
   }
 
   return messages;
@@ -161,10 +166,26 @@ function formatMessagesFull(messages: GoosedumpMessage[]): string {
   return messages.map((m) => `[${m.id}] ${m.role}:\n${m.content}`).join('\n\n---\n\n');
 }
 
-function goosedumpList(): GoosedumpListing[] {
-  const output = execFileSync(process.execPath, [binaryPath(), 'pi'], {
+function runGoosedump(args: string[]): string {
+  return execFileSync(process.execPath, [binaryPath(), ...args], {
     encoding: 'utf-8',
   });
+}
+
+function parsePageInfo(output: string, fallbackPage: number): { page: number; totalPages: number } {
+  const match = output.match(/\(page\s+(\d+)\s+of\s+(\d+)\):/i);
+  if (!match) {
+    return { page: fallbackPage, totalPages: 1 };
+  }
+
+  return {
+    page: Number(match[1]),
+    totalPages: Number(match[2]),
+  };
+}
+
+function goosedumpList(): GoosedumpListing[] {
+  const output = runGoosedump(['list', 'pi']);
   return parseListings(output);
 }
 
@@ -179,56 +200,76 @@ function goosedumpContext(
     page?: number;
   } = {},
 ): GoosedumpContextResult {
-  const args = ['pi', contextId];
+  const scope = options.scope ?? 'lineage';
+  const hasQuery = typeof options.grep === 'string';
+  const args = hasQuery
+    ? options.rank === false
+      ? ['grep', 'pi', contextId, options.grep ?? '']
+      : ['search', 'pi', contextId, options.grep ?? '']
+    : ['show', 'pi', contextId];
 
-  if (options.scope && options.scope !== 'lineage') {
-    args.push('--scope', options.scope);
-  }
-  if (options.grep) {
-    args.push('--grep', options.grep);
-  }
   if (options.compact) {
-    args.push('--compact');
+    args.push('--clip');
   }
   if (options.ids) {
     args.push('--ids', options.ids);
   }
-  if (options.rank && options.grep) {
-    args.push('--rank');
-    if (options.page && options.page > 1) {
-      args.push('--page', String(options.page));
-    }
+  if (hasQuery && options.rank !== false && options.page) {
+    args.push('--page', String(options.page));
   }
+  args.push('--scope', scope);
 
-  const output = execFileSync(process.execPath, [binaryPath(), ...args], {
-    encoding: 'utf-8',
-  });
-
+  const output = runGoosedump(args);
   const messages = parseMessages(output);
+  const pageInfo = parsePageInfo(output, options.page ?? 1);
+
   return {
     messages,
     totalCount: messages.length,
-    page: options.page ?? 1,
-    totalPages: 1,
+    page: pageInfo.page,
+    totalPages: pageInfo.totalPages,
   };
 }
 
 function goosedumpExpand(
   contextId: string,
-  entryIds: number[],
+  entryIds: string[],
   scope: string = 'lineage',
 ): GoosedumpMessage[] {
-  const ids = entryIds.join(',');
-  const args = ['pi', contextId, '--ids', ids];
-  if (scope !== 'lineage') {
-    args.push('--scope', scope);
-  }
+  if (entryIds.length === 0) return [];
+
+  const output = runGoosedump([
+    'show',
+    'pi',
+    contextId,
+    '--ids',
+    entryIds.join(','),
+    '--scope',
+    scope,
+  ]);
+  return parseMessages(output);
+}
 
-  const output = execFileSync(process.execPath, [binaryPath(), ...args], {
-    encoding: 'utf-8',
-  });
+function goosedumpCompact(
+  contextId: string,
+  options: {
+    scope?: string;
+    from?: string;
+    until?: string;
+    ids?: string[];
+  },
+): string {
+  const scope = options.scope ?? 'lineage';
+  const args = ['compact', 'pi', contextId, '--scope', scope];
+
+  if (options.ids && options.ids.length > 0) {
+    args.push('--ids', options.ids.join(','));
+  } else {
+    if (options.from) args.push('--from', options.from);
+    if (options.until) args.push('--until', options.until);
+  }
 
-  return parseMessages(output);
+  return runGoosedump(args).trim();
 }
 
 export interface GoosedumpIntegrationOptions {
@@ -236,18 +277,23 @@ export interface GoosedumpIntegrationOptions {
   overrideDefaultCompaction?: boolean;
 }
 
-interface MessageLike {
-  role?: string;
-  content?: string | { type: string; text?: string; source?: unknown }[];
+interface GoosedumpCompactRange {
+  scope: string;
+  from?: string;
+  until: string;
+  ids?: string[];
 }
 
-interface ExtractedContext {
-  goal: string;
-  outstanding: string[];
-  references: string[];
-  decisions: string[];
-  constraints: string[];
-  status: string;
+interface GoosedumpCompactionDetails {
+  source: 'goosedump';
+  goosedumpVersion: string | null;
+  contextId: string;
+  scope: string;
+  from?: string;
+  until?: string;
+  ids?: string[];
+  previousSummaryIncluded: boolean;
+  fileOps: unknown;
 }
 
 export interface GoosedumpIntegration {
@@ -258,143 +304,138 @@ export default function (pi: ExtensionAPI) {
   createGoosedumpIntegration().register(pi);
 }
 
-function getMessageText(m: MessageLike): string {
-  if (typeof m.content === 'string') return m.content;
-  if (Array.isArray(m.content)) {
-    return m.content
-      .filter((c) => c.type === 'text' && typeof c.text === 'string')
-      .map((c) => c.text!)
-      .join(' ');
-  }
-  return '';
-}
-
-function extractContextFromMessages(messages: MessageLike[]): ExtractedContext {
-  const goalPatterns = [
-    /(?:goal|objective|task|aim|purpose)[\s:]*([^.\n]+)/gi,
-    /(?:working on|implementing|building|creating|fixing|adding)\s+([^.\n]+)/gi,
-    /#\s*(?:Goal|Task|Objective)[\s:]*([^\n]+)/gi,
-  ];
-
-  const referencePatterns = [
-    /(?:https?:\/\/[^\s]+)/gi,
-    /(?:[\w./-]+\/[@\w.-]+(?:#\S+)?)/g,
-    /(?:`[^`]+\.[a-z]{1,6}`)/g,
-    /(?:v?\d+\.\d+(?:\.\d+)?(?:-[\w.]+)?)/g,
-    /(?:#[1-9]\d*)/g,
-  ];
-
-  const decisionPatterns = [
-    /(?:decided|decision|chosen?|opted|settled|agreed)\s+(?:to\s+)?([^.\n]+)/gi,
-    /(?:will|should|must|going to)\s+(?:use|switch|change|keep|stay|go with)\s+([^.\n]+)/gi,
-    /(?:let's|lets|we'll)\s+([^.\n]+)/gi,
-  ];
-
-  const constraintPatterns = [
-    /(?:cannot|can't|must not|should not|don't|do not|never)\s+([^.\n]+)/gi,
-    /(?:constraint|restriction|limitation|requirement)[\s:]*([^.\n]+)/gi,
-    /(?:need to|have to|required to)\s+(?:keep|maintain|preserve|ensure|avoid)\s+([^.\n]+)/gi,
-  ];
-
-  const statusPatterns = [
-    /(?:status|state|progress)[\s:]*([^.\n]+)/gi,
-    /(?:done|completed|finished|resolved|fixed)\s+([^.\n]+)/gi,
-    /(?:todo|pending|remaining|left|in progress|wip)\s*:?\s*([^.\n]+)/gi,
-  ];
-
-  const allText = messages.map((m) => getMessageText(m)).join('\n');
-
-  const recentText = messages
-    .slice(-30)
-    .map((m) => getMessageText(m))
-    .join('\n');
-
-  const extractMatches = (text: string, patterns: RegExp[]): Set<string> => {
-    const matches = new Set<string>();
-    for (const pattern of patterns) {
-      pattern.lastIndex = 0;
-      let match: RegExpExecArray | null;
-      while ((match = pattern.exec(text)) !== null) {
-        const extracted = (match[1] ?? '').trim().slice(0, 200);
-        if (extracted.length > 3) matches.add(extracted);
-      }
-    }
-    return matches;
-  };
+function sessionFileContextId(sessionFile: string | null | undefined): string | null {
+  if (!sessionFile) return null;
 
-  const goalMatches = extractMatches(allText, goalPatterns);
-  const goal = goalMatches.size > 0 ? [...goalMatches][0] : 'Ongoing development work';
+  const name = basename(sessionFile);
+  const nameMatch = name.match(
+    /(?:^|_)([0-9a-f]{8}-[0-9a-f]{4}-[0-9a-f]{4}-[0-9a-f]{4}-[0-9a-f]{12})\.jsonl$/i,
+  );
+  if (nameMatch) return nameMatch[1];
 
-  const outstandingItems = messages
-    .filter((m: MessageLike) => {
-      const text = getMessageText(m);
-      return /todo|pending|remaining|left|wip|bug|issue|fixme/gi.test(text);
-    })
-    .slice(-10)
-    .map((m: MessageLike) => {
-      const content = getMessageText(m);
-      const lines = content.split('\n').filter((l: string) => l.trim().length > 10);
-      return lines.length > 0 ? lines[0].trim().slice(0, 120) : null;
-    })
-    .filter((l: string | null): l is string => l !== null)
-    .slice(0, 8);
+  try {
+    const firstLine = readFileSync(sessionFile, 'utf-8').split(/\r?\n/, 1)[0];
+    const header = JSON.parse(firstLine) as { id?: unknown };
+    return typeof header.id === 'string' && header.id.length > 0 ? header.id : null;
+  } catch {
+    return null;
+  }
+}
 
-  const referenceMatches = extractMatches(allText, referencePatterns);
-  const references = [...referenceMatches].slice(0, 15);
+function currentSessionContextId(ctx: ExtensionContext): string | null {
+  return sessionFileContextId(ctx.sessionManager.getSessionFile());
+}
 
-  const decisionMatches = extractMatches(recentText, decisionPatterns);
-  const decisions = [...decisionMatches].slice(0, 6);
+function isCompactionEntry(entry: SessionEntry): entry is CompactionEntry {
+  return entry.type === 'compaction';
+}
 
-  const constraintMatches = extractMatches(allText, constraintPatterns);
-  const constraints = [...constraintMatches].slice(0, 6);
+function latestCompactionBefore(
+  branchEntries: SessionEntry[],
+  untilIndex: number,
+): CompactionEntry | undefined {
+  for (let i = untilIndex - 1; i >= 0; i -= 1) {
+    const entry = branchEntries[i];
+    if (isCompactionEntry(entry)) return entry;
+  }
+  return undefined;
+}
 
-  const statusMatches = extractMatches(recentText, statusPatterns);
-  const status = statusMatches.size > 0 ? [...statusMatches][0] : 'In progress';
+function compactionStartId(
+  branchEntries: SessionEntry[],
+  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 {
-    goal,
-    outstanding:
-      outstandingItems.length > 0 ? outstandingItems : ['No outstanding items identified'],
-    references,
-    decisions,
-    constraints: constraints.length > 0 ? constraints : ['No specific constraints identified'],
-    status,
-  };
+  return undefined;
 }
 
-function formatCompactionSummary(ctx: ExtractedContext): string {
-  const sections: string[] = [];
+function buildCompactRange(
+  branchEntries: SessionEntry[],
+  firstKeptEntryId: string,
+): GoosedumpCompactRange | undefined {
+  const untilIndex = branchEntries.findIndex((entry) => entry.id === firstKeptEntryId);
+  if (untilIndex < 0) return undefined;
+
+  const previousCompaction = latestCompactionBefore(branchEntries, untilIndex);
+  const from = previousCompaction
+    ? compactionStartId(branchEntries, previousCompaction, untilIndex)
+    : undefined;
+
+  return from && from !== firstKeptEntryId
+    ? { scope: 'lineage', from, until: firstKeptEntryId }
+    : { scope: 'lineage', until: firstKeptEntryId };
+}
 
-  sections.push(`## Session Goal\n${ctx.goal}`);
+function mergeWithPreviousSummary(
+  summary: string,
+  previousSummary: string | undefined,
+): { summary: string; previousSummaryIncluded: boolean } {
+  const nextSummary = summary.trim();
+  const priorSummary = previousSummary?.trim();
 
-  if (ctx.status) {
-    sections.push(`## Status\n${ctx.status}`);
+  if (!priorSummary) {
+    return { summary: nextSummary, previousSummaryIncluded: false };
   }
-
-  if (ctx.outstanding.length > 0) {
-    sections.push(`## Outstanding Context\n${ctx.outstanding.map((o) => `- ${o}`).join('\n')}`);
-  }
-
-  if (ctx.decisions.length > 0) {
-    sections.push(`## Key Decisions\n${ctx.decisions.map((d) => `- ${d}`).join('\n')}`);
+  if (!nextSummary) {
+    return { summary: priorSummary, previousSummaryIncluded: true };
   }
 
-  if (ctx.constraints.length > 0) {
-    sections.push(`## Constraints\n${ctx.constraints.map((c) => `- ${c}`).join('\n')}`);
-  }
+  return {
+    summary: `${priorSummary}\n\n## Recent Compaction Update\n${nextSummary}`,
+    previousSummaryIncluded: true,
+  };
+}
 
-  if (ctx.references.length > 0) {
-    sections.push(`## References\n${ctx.references.map((r) => `- ${r}`).join('\n')}`);
-  }
+function buildGoosedumpCompaction(
+  contextId: string,
+  preparation: {
+    firstKeptEntryId: string;
+    tokensBefore: number;
+    previousSummary?: string;
+    fileOps: unknown;
+  },
+  branchEntries: SessionEntry[],
+): CompactionResult<GoosedumpCompactionDetails> | undefined {
+  const range = buildCompactRange(branchEntries, preparation.firstKeptEntryId);
+  if (!range) return undefined;
+
+  const summary = goosedumpCompact(contextId, range);
+  const merged = mergeWithPreviousSummary(summary, preparation.previousSummary);
+  if (!merged.summary) return undefined;
 
-  return sections.join('\n\n');
+  return {
+    summary: merged.summary,
+    firstKeptEntryId: preparation.firstKeptEntryId,
+    tokensBefore: preparation.tokensBefore,
+    details: {
+      source: 'goosedump',
+      goosedumpVersion: goosedumpVersion(),
+      contextId,
+      scope: range.scope,
+      from: range.from,
+      until: range.until,
+      ids: range.ids,
+      previousSummaryIncluded: merged.previousSummaryIncluded,
+      fileOps: preparation.fileOps,
+    },
+  };
 }
 
 export function createGoosedumpIntegration(
   options: GoosedumpIntegrationOptions = {},
 ): GoosedumpIntegration {
   const shouldRegisterTool = options.registerTool ?? true;
-  const _overrideDefaultCompaction = options.overrideDefaultCompaction ?? false;
+  const shouldOverrideDefaultCompaction = options.overrideDefaultCompaction ?? true;
 
   let goosedumpReady = false;
   let goosedumpEnabled = false;
@@ -431,12 +472,13 @@ export function createGoosedumpIntegration(
           name: 'goosedump',
           label: 'goosedump',
           description:
-            'Browse coding agent session history. List all sessions, or view/search within a session. Supports regex search, compact overview, and result expansion. Default scope is active lineage.',
-          promptSnippet: 'goosedump({ query, scope?, page? }) - search session history',
+            'Browse coding agent session history. List all sessions, or view/search within a session. Supports ranked search, compact overview, and result expansion. Default scope is active lineage.',
+          promptSnippet:
+            'goosedump({ action: "search", contextId, query, scope?, page? }) - search session history',
           promptGuidelines: [
             'When researching past conversation history, use goosedump to find relevant context.',
-            'Start with compact search (compact: true) for quick overview, then expand interesting entries.',
-            'Default scope is "lineage" (current branch); use scope: "all" to search all sessions.',
+            'Start with compact ranked search (compact: true) for quick overview, then expand interesting entries.',
+            'Default scope is "lineage" (current branch); use scope: "all" to include all entries in the session.',
           ],
           parameters: Type.Object({
             action: Type.Union(
@@ -457,12 +499,12 @@ export function createGoosedumpIntegration(
               }),
             ),
             query: Type.Optional(
-              Type.String({ description: 'Regex pattern to search for in messages' }),
+              Type.String({ description: 'Search query to rank messages by relevance' }),
             ),
             scope: Type.Optional(
               Type.Union([Type.Literal('lineage'), Type.Literal('all')], {
                 default: 'lineage',
-                description: 'Scope: lineage (current branch) or all (all sessions)',
+                description: 'Scope: lineage (current branch) or all entries in the session',
               }),
             ),
             compact: Type.Optional(
@@ -472,7 +514,7 @@ export function createGoosedumpIntegration(
               }),
             ),
             ids: Type.Optional(
-              Type.Array(Type.Integer(), {
+              Type.Array(Type.String(), {
                 description: 'Entry IDs to expand (show full content)',
               }),
             ),
@@ -510,9 +552,7 @@ export function createGoosedumpIntegration(
 
                   const lines = ['Available sessions:', ''];
                   for (const listing of listings) {
-                    lines.push(
-                      `  ${listing.id} — ${listing.entryCount} entries (modified ${listing.modified})`,
-                    );
+                    lines.push(`  ${listing.id}`);
                   }
 
                   return {
@@ -551,7 +591,8 @@ export function createGoosedumpIntegration(
                     };
                   }
 
-                  const text = params.compact
+                  const useCompact = params.compact ?? true;
+                  const text = useCompact
                     ? formatMessagesCompact(result.messages)
                     : formatMessagesFull(result.messages);
 
@@ -656,34 +697,41 @@ export function createGoosedumpIntegration(
       }
     });
 
-    pi.on('session_before_compact', async (event, _ctx) => {
-      if (!goosedumpEnabled || !goosedumpReady) return;
+    pi.on('session_before_compact', async (event, ctx) => {
+      if (!shouldOverrideDefaultCompaction || !goosedumpEnabled || !goosedumpReady) return;
+      if (event.customInstructions?.trim()) return;
+      if (event.signal.aborted) return;
 
-      const { messagesToSummarize, firstKeptEntryId, tokensBefore } = event.preparation;
+      const { messagesToSummarize, turnPrefixMessages } = event.preparation;
+      if (messagesToSummarize.length === 0 && turnPrefixMessages.length === 0) return;
 
-      if (messagesToSummarize.length === 0) return;
+      const contextId = currentSessionContextId(ctx);
+      if (!contextId) return;
 
-      const extracted = extractContextFromMessages(messagesToSummarize as MessageLike[]);
-      const summary = formatCompactionSummary(extracted);
-
-      return {
-        compaction: {
-          summary,
-          firstKeptEntryId,
-          tokensBefore,
-          details: {
-            source: 'goosedump',
-            extracted,
-          },
-        },
-      };
+      try {
+        const compaction = buildGoosedumpCompaction(
+          contextId,
+          event.preparation,
+          event.branchEntries,
+        );
+        return compaction ? { compaction } : undefined;
+      } catch (err) {
+        if (ctx.hasUI) {
+          const message = err instanceof Error ? err.message : String(err);
+          ctx.ui.notify(
+            `goosedump compact failed; falling back to Pi compaction: ${message}`,
+            'error',
+          );
+        }
+        return undefined;
+      }
     });
 
-    pi.on('session_compact', async (event, _ctx) => {
-      if (!goosedumpEnabled || !goosedumpReady) return;
+    pi.on('session_compact', async (event, ctx) => {
+      if (!goosedumpEnabled || !goosedumpReady || !event.fromExtension) return;
 
       const compactionEntry = event.compactionEntry;
-      if (!compactionEntry || compactionEntry.fromHook) return;
+      if (!compactionEntry) return;
 
       const tokensBefore = compactionEntry.tokensBefore;
       const summaryLen = compactionEntry.summary.length;
@@ -691,7 +739,7 @@ export function createGoosedumpIntegration(
       const tokensSaved =
         tokensBefore > 0 ? Math.round((1 - tokenEstimate / tokensBefore) * 100) : 0;
 
-      _ctx.ui.notify(
+      ctx.ui.notify(
         `Goosedump compacted session: ~${tokensSaved}% token reduction (${tokensBefore} → ~${tokenEstimate} tokens)`,
         'info',
       );
@@ -755,9 +803,8 @@ export function createGoosedumpIntegration(
                     const listing = listings[i];
                     const isSelected = i === selectedIndex;
                     const cursor = isSelected ? accent('▶') : ' ';
-                    const entryInfo = dim(`${listing.entryCount} entries`);
-                    const idText = isSelected ? accent(`[${listing.id}]`) : text(`[${listing.id}]`);
-                    const line = `  ${cursor} ${idText} ${entryInfo}`;
+                    const idText = isSelected ? accent(listing.id) : text(listing.id);
+                    const line = `  ${cursor} ${idText}`;
                     lines.push(makeRow(truncateToWidth(line, innerW), innerW, border));
                   }
 

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "pi-goosedump",
-  "version": "0.1.3",
+  "version": "0.2.1",
   "description": "Coding agent context data browser plugin for pi",
   "keywords": [
     "goosedump",
@@ -29,7 +29,7 @@
   },
   "dependencies": {
     "@earendil-works/pi-tui": "^0.78.0",
-    "@jarkkojs/goosedump": "^0.1.2",
+    "@jarkkojs/goosedump": "^0.2.1",
     "@sinclair/typebox": "^0.34.49"
   },
   "devDependencies": {