pi-goosedump 0.1.0

package/LICENSE

@@ -0,0 +1,21 @@
+MIT License
+
+Copyright (c) 2026 Jarkko Sakkinen
+
+Permission is hereby granted, free of charge, to any person obtaining a copy
+of this software and associated documentation files (the "Software"), to deal
+in the Software without restriction, including without limitation the rights
+to use, copy, modify, merge, publish, distribute, sublicense, and/or sell
+copies of the Software, and to permit persons to whom the Software is
+furnished to do so, subject to the following conditions:
+
+The above copyright notice and this permission notice shall be included in all
+copies or substantial portions of the Software.
+
+THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR
+IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY,
+FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL THE
+AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER
+LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM,
+OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN THE
+SOFTWARE.

package/README.md

@@ -0,0 +1,46 @@
+# pi-goosedump
+
+Coding agent context data browser plugin for [pi](https://pi.dev/) using
+[`goosedump`](https://github.com/jarkkojs/goosedump).
+
+## Install
+
+```bash
+pi install npm:pi-goosedump
+```
+
+This installs `pi-goosedump` and its `@jarkkojs/goosedump` dependency, which
+includes platform-specific native binaries for Linux, macOS, and Windows.
+
+## Usage
+
+Once installed, pi-goosedump registers a tool and a slash command:
+
+### Tool: `goosedump`
+
+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           |
+
+Examples:
+
+```
+goosedump({ action: "list" })
+goosedump({ action: "search", contextId: "abc123", query: "bug fix" })
+goosedump({ action: "expand", contextId: "abc123", ids: [0, 3, 5] })
+goosedump({ action: "view", contextId: "abc123" })
+```
+
+### Command: `/goosedump`
+
+Opens an interactive session browser.
+
+## License
+
+`pi-goosedump` is licensed under `MIT`. See [LICENSE](LICENSE) for more
+information.

package/index.ts

@@ -0,0 +1,828 @@
+// SPDX-License-Identifier: MIT
+// Copyright (C) Jarkko Sakkinen 2026
+
+import type {
+  AgentToolResult,
+  ExtensionAPI,
+  ExtensionContext,
+} 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 { homedir } from 'node:os';
+import { 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;
+
+interface GoosedumpListing {
+  id: string;
+  created: string;
+  modified: string;
+  entryCount: number;
+}
+
+interface GoosedumpMessage {
+  id: string;
+  role: string;
+  content: string;
+  timestamp: string;
+}
+
+interface GoosedumpContextResult {
+  messages: GoosedumpMessage[];
+  totalCount: number;
+  page: number;
+  totalPages: number;
+}
+
+function resolveGoosedumpBinary(): string {
+  try {
+    return require.resolve('@jarkkojs/goosedump/bin/goosedump.js');
+  } catch {
+    const dir = join(
+      process.env.PI_CODING_AGENT_DIR ?? join(homedir(), '.pi', 'agent'),
+      'package-cache',
+      'node_modules',
+      '@jarkkojs',
+      'goosedump',
+    );
+    const bin = join(dir, 'bin', 'goosedump.js');
+    if (existsSync(bin)) return bin;
+
+    throw new Error('goosedump binary not found. Install with: npm install @jarkkojs/goosedump');
+  }
+}
+
+function binaryPath(): string {
+  return resolveGoosedumpBinary();
+}
+
+function goosedumpVersion(): string | null {
+  try {
+    const result = execFileSync(process.execPath, [binaryPath(), '--version'], {
+      encoding: 'utf-8',
+    });
+    return result.trim();
+  } catch {
+    return null;
+  }
+}
+
+function parseVersion(version: string): [number, number, number] | null {
+  const match = version.match(/\b(\d+)\.(\d+)\.(\d+)\b/);
+  if (!match) return null;
+  return [Number(match[1]), Number(match[2]), Number(match[3])];
+}
+
+function hasMinimumVersion(version: string, minimum: readonly [number, number, number]): boolean {
+  const parsed = parseVersion(version);
+  if (!parsed) return false;
+
+  for (let i = 0; i < minimum.length; i++) {
+    if (parsed[i] > minimum[i]) return true;
+    if (parsed[i] < minimum[i]) return false;
+  }
+
+  return true;
+}
+
+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],
+    });
+  }
+
+  return listings;
+}
+
+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 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,
+        });
+      }
+      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,
+    });
+  }
+
+  return messages;
+}
+
+function formatMessagesCompact(messages: GoosedumpMessage[]): string {
+  return messages
+    .map(
+      (m) => `[${m.id}] ${m.role}: ${m.content.slice(0, 80)}${m.content.length > 80 ? '...' : ''}`,
+    )
+    .join('\n');
+}
+
+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'], {
+    encoding: 'utf-8',
+  });
+  return parseListings(output);
+}
+
+function goosedumpContext(
+  contextId: string,
+  options: {
+    scope?: string;
+    grep?: string;
+    compact?: boolean;
+    ids?: string;
+    rank?: boolean;
+    page?: number;
+  } = {},
+): GoosedumpContextResult {
+  const args = ['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');
+  }
+  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));
+    }
+  }
+
+  const output = execFileSync(process.execPath, [binaryPath(), ...args], {
+    encoding: 'utf-8',
+  });
+
+  const messages = parseMessages(output);
+  return {
+    messages,
+    totalCount: messages.length,
+    page: options.page ?? 1,
+    totalPages: 1,
+  };
+}
+
+function goosedumpExpand(
+  contextId: string,
+  entryIds: number[],
+  scope: string = 'lineage',
+): GoosedumpMessage[] {
+  const ids = entryIds.join(',');
+  const args = ['pi', contextId, '--ids', ids];
+  if (scope !== 'lineage') {
+    args.push('--scope', scope);
+  }
+
+  const output = execFileSync(process.execPath, [binaryPath(), ...args], {
+    encoding: 'utf-8',
+  });
+
+  return parseMessages(output);
+}
+
+export interface GoosedumpIntegrationOptions {
+  registerTool?: boolean;
+  overrideDefaultCompaction?: boolean;
+}
+
+interface MessageLike {
+  role?: string;
+  content?: string | { type: string; text?: string; source?: unknown }[];
+}
+
+interface ExtractedContext {
+  goal: string;
+  outstanding: string[];
+  references: string[];
+  decisions: string[];
+  constraints: string[];
+  status: string;
+}
+
+export interface GoosedumpIntegration {
+  register(pi: ExtensionAPI): void;
+}
+
+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;
+  };
+
+  const goalMatches = extractMatches(allText, goalPatterns);
+  const goal = goalMatches.size > 0 ? [...goalMatches][0] : 'Ongoing development work';
+
+  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);
+
+  const referenceMatches = extractMatches(allText, referencePatterns);
+  const references = [...referenceMatches].slice(0, 15);
+
+  const decisionMatches = extractMatches(recentText, decisionPatterns);
+  const decisions = [...decisionMatches].slice(0, 6);
+
+  const constraintMatches = extractMatches(allText, constraintPatterns);
+  const constraints = [...constraintMatches].slice(0, 6);
+
+  const statusMatches = extractMatches(recentText, statusPatterns);
+  const status = statusMatches.size > 0 ? [...statusMatches][0] : 'In progress';
+
+  return {
+    goal,
+    outstanding:
+      outstandingItems.length > 0 ? outstandingItems : ['No outstanding items identified'],
+    references,
+    decisions,
+    constraints: constraints.length > 0 ? constraints : ['No specific constraints identified'],
+    status,
+  };
+}
+
+function formatCompactionSummary(ctx: ExtractedContext): string {
+  const sections: string[] = [];
+
+  sections.push(`## Session Goal\n${ctx.goal}`);
+
+  if (ctx.status) {
+    sections.push(`## Status\n${ctx.status}`);
+  }
+
+  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 (ctx.constraints.length > 0) {
+    sections.push(`## Constraints\n${ctx.constraints.map((c) => `- ${c}`).join('\n')}`);
+  }
+
+  if (ctx.references.length > 0) {
+    sections.push(`## References\n${ctx.references.map((r) => `- ${r}`).join('\n')}`);
+  }
+
+  return sections.join('\n\n');
+}
+
+export function createGoosedumpIntegration(
+  options: GoosedumpIntegrationOptions = {},
+): GoosedumpIntegration {
+  const shouldRegisterTool = options.registerTool ?? true;
+  const _overrideDefaultCompaction = options.overrideDefaultCompaction ?? false;
+
+  let goosedumpReady = false;
+  let goosedumpEnabled = false;
+
+  function checkGoosedump(ctx?: ExtensionContext): boolean {
+    const version = goosedumpVersion();
+    if (!version) {
+      if (ctx) {
+        ctx.ui.notify(
+          'goosedump was not found. Install with: npm install @jarkkojs/goosedump',
+          'error',
+        );
+      }
+      return false;
+    }
+
+    if (!hasMinimumVersion(version, GOOSEDUMP_VERSION)) {
+      if (ctx) {
+        ctx.ui.notify(
+          `goosedump ${GOOSEDUMP_VERSION.join('.')} or newer is required; found: ${version}`,
+          'error',
+        );
+      }
+      return false;
+    }
+
+    return true;
+  }
+
+  function register(pi: ExtensionAPI): void {
+    if (shouldRegisterTool) {
+      pi.registerTool(
+        defineTool({
+          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',
+          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.',
+          ],
+          parameters: Type.Object({
+            action: Type.Union(
+              [
+                Type.Literal('list'),
+                Type.Literal('search'),
+                Type.Literal('expand'),
+                Type.Literal('view'),
+              ],
+              {
+                description:
+                  'Operation: list sessions, search within a session, expand entries, or view full session',
+              },
+            ),
+            contextId: Type.Optional(
+              Type.String({
+                description: 'Context/session ID (required for search, expand, view)',
+              }),
+            ),
+            query: Type.Optional(
+              Type.String({ description: 'Regex pattern to search for in messages' }),
+            ),
+            scope: Type.Optional(
+              Type.Union([Type.Literal('lineage'), Type.Literal('all')], {
+                default: 'lineage',
+                description: 'Scope: lineage (current branch) or all (all sessions)',
+              }),
+            ),
+            compact: Type.Optional(
+              Type.Boolean({
+                default: true,
+                description: 'Display results in compact entry-overview format',
+              }),
+            ),
+            ids: Type.Optional(
+              Type.Array(Type.Integer(), {
+                description: 'Entry IDs to expand (show full content)',
+              }),
+            ),
+            page: Type.Optional(
+              Type.Integer({
+                minimum: 1,
+                default: 1,
+                description: 'Page number for ranked results',
+              }),
+            ),
+          }),
+          async execute(_id, params, _signal, _onUpdate, _ctx): Promise<AgentToolResult<void>> {
+            if (!goosedumpEnabled || !goosedumpReady) {
+              return {
+                content: [
+                  {
+                    type: 'text',
+                    text: 'goosedump is not available. Install with: npm install @jarkkojs/goosedump',
+                  },
+                ],
+                details: undefined,
+              };
+            }
+
+            try {
+              switch (params.action) {
+                case 'list': {
+                  const listings = goosedumpList();
+                  if (listings.length === 0) {
+                    return {
+                      content: [{ type: 'text', text: 'No sessions found.' }],
+                      details: undefined,
+                    };
+                  }
+
+                  const lines = ['Available sessions:', ''];
+                  for (const listing of listings) {
+                    lines.push(
+                      `  ${listing.id} — ${listing.entryCount} entries (modified ${listing.modified})`,
+                    );
+                  }
+
+                  return {
+                    content: [{ type: 'text', text: lines.join('\n') }],
+                    details: undefined,
+                  };
+                }
+
+                case 'search': {
+                  if (!params.contextId) {
+                    return {
+                      content: [{ type: 'text', text: 'contextId is required for search' }],
+                      details: undefined,
+                    };
+                  }
+
+                  if (!params.query) {
+                    return {
+                      content: [{ type: 'text', text: 'query is required for search' }],
+                      details: undefined,
+                    };
+                  }
+
+                  const result = goosedumpContext(params.contextId, {
+                    scope: params.scope ?? 'lineage',
+                    grep: params.query,
+                    compact: params.compact ?? true,
+                    rank: true,
+                    page: params.page ?? 1,
+                  });
+
+                  if (result.messages.length === 0) {
+                    return {
+                      content: [{ type: 'text', text: `No results for "${params.query}"` }],
+                      details: undefined,
+                    };
+                  }
+
+                  const text = params.compact
+                    ? formatMessagesCompact(result.messages)
+                    : formatMessagesFull(result.messages);
+
+                  const header = `Results for "${params.query}" (page ${result.page} of ${result.totalPages}):\n\n`;
+                  return {
+                    content: [{ type: 'text', text: header + text }],
+                    details: undefined,
+                  };
+                }
+
+                case 'expand': {
+                  if (!params.contextId) {
+                    return {
+                      content: [{ type: 'text', text: 'contextId is required for expand' }],
+                      details: undefined,
+                    };
+                  }
+
+                  if (!params.ids || params.ids.length === 0) {
+                    return {
+                      content: [
+                        { type: 'text', text: 'ids is required for expand (array of entry IDs)' },
+                      ],
+                      details: undefined,
+                    };
+                  }
+
+                  const messages = goosedumpExpand(
+                    params.contextId,
+                    params.ids,
+                    params.scope ?? 'lineage',
+                  );
+
+                  if (messages.length === 0) {
+                    return {
+                      content: [{ type: 'text', text: 'No entries found for the given IDs.' }],
+                      details: undefined,
+                    };
+                  }
+
+                  return {
+                    content: [{ type: 'text', text: formatMessagesFull(messages) }],
+                    details: undefined,
+                  };
+                }
+
+                case 'view': {
+                  if (!params.contextId) {
+                    return {
+                      content: [{ type: 'text', text: 'contextId is required for view' }],
+                      details: undefined,
+                    };
+                  }
+
+                  const result = goosedumpContext(params.contextId, {
+                    scope: params.scope ?? 'lineage',
+                    compact: false,
+                  });
+
+                  if (result.messages.length === 0) {
+                    return {
+                      content: [
+                        { type: 'text', text: `Session "${params.contextId}" has no messages.` },
+                      ],
+                      details: undefined,
+                    };
+                  }
+
+                  return {
+                    content: [{ type: 'text', text: formatMessagesFull(result.messages) }],
+                    details: undefined,
+                  };
+                }
+
+                default:
+                  return {
+                    content: [{ type: 'text', text: `Unknown action: ${params.action}` }],
+                    details: undefined,
+                  };
+              }
+            } catch (err) {
+              const message = err instanceof Error ? err.message : String(err);
+              return {
+                content: [{ type: 'text', text: `goosedump error: ${message}` }],
+                details: undefined,
+              };
+            }
+          },
+        }),
+      );
+    }
+
+    pi.on('session_start', async (_event, ctx) => {
+      goosedumpReady = checkGoosedump(ctx);
+      goosedumpEnabled = goosedumpReady;
+
+      if (goosedumpReady) {
+        const theme = ctx.ui.theme;
+        const dot = theme.fg('success', '●');
+        const label = theme.fg('text', 'Goosedump');
+        ctx.ui.setStatus('goosedump', `${dot} ${label}`);
+      }
+    });
+
+    pi.on('session_before_compact', async (event, _ctx) => {
+      if (!goosedumpEnabled || !goosedumpReady) return;
+
+      const { messagesToSummarize, firstKeptEntryId, tokensBefore } = event.preparation;
+
+      if (messagesToSummarize.length === 0) return;
+
+      const extracted = extractContextFromMessages(messagesToSummarize as MessageLike[]);
+      const summary = formatCompactionSummary(extracted);
+
+      return {
+        compaction: {
+          summary,
+          firstKeptEntryId,
+          tokensBefore,
+          details: {
+            source: 'goosedump',
+            extracted,
+          },
+        },
+      };
+    });
+
+    pi.on('session_compact', async (event, _ctx) => {
+      if (!goosedumpEnabled || !goosedumpReady) return;
+
+      const compactionEntry = event.compactionEntry;
+      if (!compactionEntry || compactionEntry.fromHook) return;
+
+      const tokensBefore = compactionEntry.tokensBefore;
+      const summaryLen = compactionEntry.summary.length;
+      const tokenEstimate = Math.ceil(summaryLen / 4);
+      const tokensSaved =
+        tokensBefore > 0 ? Math.round((1 - tokenEstimate / tokensBefore) * 100) : 0;
+
+      _ctx.ui.notify(
+        `Goosedump compacted session: ~${tokensSaved}% token reduction (${tokensBefore} → ~${tokenEstimate} tokens)`,
+        'info',
+      );
+    });
+
+    const maybePi = pi as ExtensionAPI & {
+      registerCommand?: ExtensionAPI['registerCommand'];
+    };
+
+    maybePi.registerCommand?.('goosedump', {
+      description: 'Browse coding agent session history',
+      handler: async (_args, ctx) => {
+        if (!goosedumpEnabled || !goosedumpReady) {
+          ctx.ui.notify(
+            'goosedump is not available. Install with: npm install @jarkkojs/goosedump',
+            'error',
+          );
+          return;
+        }
+
+        try {
+          const listings = goosedumpList();
+
+          if (listings.length === 0) {
+            ctx.ui.notify('No sessions found.', 'info');
+            return;
+          }
+
+          await ctx.ui.custom<void>(
+            (tui, theme, _kb, done) => {
+              let selectedIndex = 0;
+
+              return {
+                render(width: number): string[] {
+                  const innerW = width - 4;
+                  const border = theme.fg('border', '│');
+                  const borderFg = (s: string) => theme.fg('border', s);
+                  const dim = (s: string) => theme.fg('dim', s);
+                  const accent = (s: string) => theme.fg('accent', s);
+                  const text = (s: string) => theme.fg('text', s);
+                  const muted = (s: string) => theme.fg('muted', s);
+
+                  const lines: string[] = [];
+
+                  // Top border
+                  const title = accent(' Goosedump Sessions ');
+                  const topFill = borderFg(
+                    '─'.repeat(Math.max(0, width - 4 - visibleWidth(title))),
+                  );
+                  lines.push(`${borderFg('╭─')}${title}${topFill}${borderFg('─╮')}`);
+
+                  // Session count
+                  const countInfo = `${listings.length} session${listings.length === 1 ? '' : 's'}`;
+                  lines.push(makeRow(`${muted(countInfo)}`, innerW, border));
+
+                  lines.push(makeRow('', innerW, border));
+
+                  // Session list
+                  const maxItems = Math.min(listings.length, 20);
+                  for (let i = 0; i < maxItems; i++) {
+                    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}`;
+                    lines.push(makeRow(truncateToWidth(line, innerW), innerW, border));
+                  }
+
+                  if (listings.length > 20) {
+                    lines.push(
+                      makeRow(dim(`  ... and ${listings.length - 20} more`), innerW, border),
+                    );
+                  }
+
+                  // Footer
+                  lines.push(makeRow('', innerW, border));
+                  lines.push(makeRow(dim('↑↓ navigate  esc close'), innerW, border));
+
+                  // Bottom border
+                  lines.push(`${borderFg('╰')}${borderFg('─'.repeat(width - 2))}${borderFg('╯')}`);
+
+                  return lines;
+                },
+
+                handleInput(data: string): void {
+                  if (matchesKey(data, Key.escape) || matchesKey(data, Key.ctrl('c'))) {
+                    done(undefined);
+                    return;
+                  }
+
+                  if (matchesKey(data, Key.up)) {
+                    selectedIndex = Math.max(0, selectedIndex - 1);
+                    tui.requestRender();
+                    return;
+                  }
+
+                  if (matchesKey(data, Key.down)) {
+                    selectedIndex = Math.min(listings.length - 1, selectedIndex + 1);
+                    tui.requestRender();
+                    return;
+                  }
+                },
+
+                invalidate(): void {},
+              };
+
+              function makeRow(content: string, innerW: number, border: string): string {
+                const line = truncateToWidth(content, innerW);
+                const pad = Math.max(0, innerW - visibleWidth(line));
+                return `${border} ${line}${' '.repeat(pad)} ${border}`;
+              }
+            },
+            {
+              overlay: true,
+              overlayOptions: {
+                anchor: 'center',
+                width: 72,
+                margin: 2,
+              },
+            },
+          );
+        } catch (err) {
+          const message = err instanceof Error ? err.message : String(err);
+          ctx.ui.notify(`goosedump error: ${message}`, 'error');
+        }
+      },
+    });
+  }
+
+  return { register };
+}

package/package.json

@@ -0,0 +1,57 @@
+{
+  "name": "pi-goosedump",
+  "version": "0.1.0",
+  "description": "Coding agent context data browser plugin for pi",
+  "keywords": [
+    "goosedump",
+    "pi-extension",
+    "pi-package",
+    "vcc"
+  ],
+  "license": "MIT",
+  "repository": {
+    "type": "git",
+    "url": "git+https://github.com/jarkkojs/pi-goosedump.git"
+  },
+  "files": [
+    "index.ts",
+    "README.md"
+  ],
+  "type": "module",
+  "scripts": {
+    "fmt": "oxfmt index.ts package.json tsconfig.json .oxfmtrc.json README.md",
+    "lint": "oxlint index.ts",
+    "check": "tsc --noEmit",
+    "all": "npm run fmt && npm run lint && npm run check",
+    "ci:fmt": "oxfmt --check index.ts package.json tsconfig.json .oxfmtrc.json README.md",
+    "ci:lint": "npm run lint",
+    "ci:check": "npm run check"
+  },
+  "dependencies": {
+    "@earendil-works/pi-tui": "^0.78.0",
+    "@sinclair/typebox": "^0.34.49"
+  },
+  "devDependencies": {
+    "@earendil-works/pi-coding-agent": "^0.78.0",
+    "@types/node": "^24.0.0",
+    "oxfmt": "^0.53.0",
+    "oxlint": "^1.68.0",
+    "typescript": "^5.0.0"
+  },
+  "peerDependencies": {
+    "@earendil-works/pi-coding-agent": "^0.78.0"
+  },
+  "peerDependenciesMeta": {
+    "@earendil-works/pi-coding-agent": {
+      "optional": true
+    }
+  },
+  "optionalDependencies": {
+    "@jarkkojs/goosedump": "^0.1.2"
+  },
+  "pi": {
+    "extensions": [
+      "./index.ts"
+    ]
+  }
+}