pi-goosedump 0.8.0 → 0.9.0

package/index.ts

@@ -13,15 +13,27 @@ import type {
 import { defineTool, getSettingsListTheme } from '@earendil-works/pi-coding-agent';
 
 import { execFileSync } from 'node:child_process';
-import { existsSync, mkdirSync, readFileSync, writeFileSync } from 'node:fs';
+import {
+  closeSync,
+  existsSync,
+  mkdirSync,
+  openSync,
+  readFileSync,
+  readSync,
+  writeFileSync,
+} from 'node:fs';
 import { createRequire } from 'node:module';
 import { homedir } from 'node:os';
-import { basename, dirname, extname, isAbsolute, join, relative } from 'node:path';
+import { dirname, join } from 'node:path';
 
 import {
+  type Component,
+  Input,
   Key,
   SettingsList,
   type SettingItem,
+  decodeKittyPrintable,
+  getKeybindings,
   matchesKey,
   truncateToWidth,
   visibleWidth,
@@ -31,95 +43,33 @@ import { Type } from '@sinclair/typebox';
 
 const require = createRequire(import.meta.url);
 
-const GOOSEDUMP_VERSION = [0, 8, 1] as const;
-
-// One element of goosedump 0.8's `list` JSON output.
-interface ListEntryJson {
-  id: string;
-  parent: string | null;
-  provider: string;
-  cwd: string;
-  count: number;
-  label: string | null;
-  from: string | null;
-  until: string | null;
-  native_id?: string;
-}
-
-interface GoosedumpListing {
-  id: string;
-  provider: string;
-  cwd: string;
-  parent: string | null;
-  label: string | null;
-  path: string | null;
-}
-
+// One rendered message after normalizing a context into pi's native JSONL.
 interface GoosedumpMessage {
   id: string;
   role: string;
   content: string;
-  score?: number;
 }
 
-interface GoosedumpSearchResult {
-  messages: GoosedumpMessage[];
-  page: number;
-  totalPages: number;
-}
-interface ShowPartJson {
-  type: 'text' | 'reasoning' | 'toolCall' | 'toolResult' | 'image' | 'bash' | 'passthrough';
+// A `content` part of a pi-native message line.
+interface PiPartJson {
+  type: string;
   text?: string;
+  thinking?: string;
   name?: string;
   arguments?: unknown;
-  toolName?: string;
-  content?: string;
-  isError?: boolean;
   mimeType?: string;
-  ocrText?: string;
-  command?: string;
-  output?: string;
-  kind?: string;
-  raw?: unknown;
-}
-
-interface ShowMessageJson {
-  entryId: string;
-  role: string;
-  parts: ShowPartJson[];
+  data?: string;
 }
 
-interface ShowJson {
-  messages: ShowMessageJson[];
-}
-
-interface HitJson {
-  entryId: string;
-  role: string;
-  score: number;
-  text: string;
-  files: string[];
-  terms: string[];
-}
-
-interface SearchJson {
-  page: number;
-  totalPages: number;
-  total: number;
-  hits: HitJson[];
-}
-
-interface CompactJson {
-  goals: string[];
-  files: { modified: string[]; created: string[]; read: string[] };
-  commits: string[];
-  outstanding: string[];
-  preferences: string[];
-  brief: string;
+// One JSONL line from `show`/`grep`/`search`/`compact` rendered as pi native.
+interface PiEntryJson {
+  type?: string;
+  id?: string;
+  message?: { role?: string; content?: PiPartJson[] | string };
+  summary?: string;
 }
 
 interface GoosedumpSettings {
-  stepsBeforeCompact: number;
   turnsBeforeCompact: number;
 }
 
@@ -127,12 +77,9 @@ type SettingsScope = 'global' | 'project';
 type GoosedumpSettingKey = keyof GoosedumpSettings;
 
 const DEFAULT_GOOSEDUMP_SETTINGS: GoosedumpSettings = {
-  stepsBeforeCompact: 0,
   turnsBeforeCompact: 0,
 };
 
-const COMPACT_SETTING_VALUES = ['0', '5', '10', '20', '50', '100'];
-
 function piAgentDir(): string {
   return process.env.PI_CODING_AGENT_DIR ?? join(homedir(), '.pi', 'agent');
 }
@@ -165,11 +112,9 @@ function readGoosedumpSettingsFrom(path: string): Partial<GoosedumpSettings> {
   if (!isRecord(raw)) return {};
 
   const settings: Partial<GoosedumpSettings> = {};
-  for (const key of ['stepsBeforeCompact', 'turnsBeforeCompact'] as const) {
-    const value = raw[key];
-    if (typeof value === 'number' && Number.isSafeInteger(value) && value >= 0) {
-      settings[key] = value;
-    }
+  const value = raw.turnsBeforeCompact;
+  if (typeof value === 'number' && Number.isSafeInteger(value) && value >= 0 && value <= 255) {
+    settings.turnsBeforeCompact = value;
   }
   return settings;
 }
@@ -206,48 +151,7 @@ function formatCompactSetting(value: number): string {
 }
 
 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 goosedumpVersion(): string | null {
-  try {
-    const pkg = require('@jarkkojs/goosedump/package.json') as { version: string };
-    return pkg.version;
-  } 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;
+  return require.resolve('@jarkkojs/goosedump/bin/goosedump.js');
 }
 
 function clip(value: string, max: number): string {
@@ -271,47 +175,50 @@ function summarizeToolArgs(args: unknown): string {
   return clip(JSON.stringify(args), 160);
 }
 
-function showPartContent(part: ShowPartJson): string {
+function flattenPiPart(part: PiPartJson): string {
   switch (part.type) {
     case 'text':
-    case 'reasoning':
       return part.text ?? '';
+    case 'thinking':
+      return part.thinking ?? '';
     case 'toolCall': {
       const summary = summarizeToolArgs(part.arguments);
       return summary ? `${part.name ?? 'tool'}(${summary})` : (part.name ?? 'tool');
     }
-    case 'toolResult': {
-      const name = part.toolName ?? 'tool';
-      const header = `${name}${part.isError ? ' ⚠' : ''}`;
-      return part.content ? `${header}\n${part.content}` : header;
-    }
-    case 'image': {
-      const header = `[image ${part.mimeType ?? 'unknown'}]`;
-      return part.ocrText ? `${header}\n${part.ocrText}` : header;
-    }
-    case 'bash': {
-      const cmd = part.command ? `$ ${part.command}` : '';
-      if (cmd && part.output) return `${cmd}\n${part.output}`;
-      return cmd || (part.output ?? '');
-    }
-    case 'passthrough': {
-      const kind = part.kind ? `passthrough:${part.kind}` : 'passthrough';
-      const raw = part.raw === undefined ? '' : JSON.stringify(part.raw);
-      return raw ? `[${kind}] ${raw}` : `[${kind}]`;
-    }
+    case 'image':
+      return part.mimeType ? `[image ${part.mimeType}]` : '[image]';
+    default:
+      return clip(JSON.stringify(part), 160);
   }
 }
 
-function showMessageContent(m: ShowMessageJson): string {
-  return m.parts.map(showPartContent).filter(Boolean).join('\n');
-}
-
-function showMessage(m: ShowMessageJson): GoosedumpMessage {
-  return { id: m.entryId, role: m.role, content: showMessageContent(m) };
-}
-
-function hitMessage(h: HitJson): GoosedumpMessage {
-  return { id: h.entryId, role: h.role, content: h.text, score: h.score };
+// goosedump's pi render emits a tool result as a message whose `content` is a
+// plain string rather than a part array, so accept both shapes.
+function flattenPiContent(content: PiPartJson[] | string | undefined): string {
+  if (typeof content === 'string') return content;
+  if (!Array.isArray(content)) return '';
+  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[] {
+  const messages: GoosedumpMessage[] = [];
+  for (const line of output.split('\n')) {
+    if (!line) continue;
+    let entry: PiEntryJson;
+    try {
+      entry = JSON.parse(line) as PiEntryJson;
+    } 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 });
+  }
+  return messages;
 }
 
 const ANSI_SGR = new RegExp(String.fromCharCode(27) + '\\[[0-9;]*m', 'g');
@@ -334,64 +241,58 @@ function textResult(text: string): AgentToolResult<void> {
   return { content: [{ type: 'text', text }], details: undefined };
 }
 
-function missingContextId(action: string, provider = 'pi'): AgentToolResult<void> {
+function missingSessionId(tool: string, provider = 'pi'): AgentToolResult<void> {
   if (provider !== 'pi') {
-    return textResult(`contextId is required for ${action} when provider is "${provider}"`);
+    return textResult(`session is required for ${tool} when provider is "${provider}"`);
   }
-  return textResult(`contextId is required for ${action} when no current session is available`);
+  return textResult(`session is required for ${tool} when no current session is available`);
 }
 
 function runGoosedump(args: string[]): string {
-  return execFileSync('node', [resolveGoosedumpBinary(), ...args], {
-    encoding: 'utf-8',
-  });
-}
-
-function goosedumpList(provider = 'pi'): GoosedumpListing[] {
-  const entries = JSON.parse(runGoosedump(['list'])) as ListEntryJson[];
-  return entries
-    .filter((entry) => entry.provider === provider)
-    .map((entry) => {
-      const nativeId = entry.native_id ?? entry.id;
-      return {
-        id: entry.id,
-        provider: entry.provider,
-        cwd: entry.cwd,
-        parent: entry.parent,
-        label: entry.label ?? null,
-        // Only pi sessions map back to a local file we can resume.
-        path: provider === 'pi' ? piSessionFilePath(nativeId) : null,
-      };
+  try {
+    return execFileSync('node', [resolveGoosedumpBinary(), ...args], {
+      encoding: 'utf-8',
+      maxBuffer: 16 * 1024 * 1024,
     });
+  } catch (err) {
+    // Surface goosedump's own stderr instead of Node's truncated generic message.
+    const stderr = (err as { stderr?: string }).stderr?.trim();
+    const message = stderr ?? (err instanceof Error ? err.message : String(err));
+    throw new Error(message);
+  }
 }
 
-function piSessionsDir(): string {
-  const explicit = process.env.PI_CODING_AGENT_SESSION_DIR;
-  if (explicit) return explicit;
-  const agentDir = process.env.PI_CODING_AGENT_DIR ?? join(homedir(), '.pi', 'agent');
-  return join(agentDir, 'sessions');
+// Read only the first line of a file without loading the whole transcript.
+function readFirstLine(path: string): string | null {
+  const fd = openSync(path, 'r');
+  try {
+    const buf = Buffer.alloc(8192);
+    const bytesRead = readSync(fd, buf, 0, buf.length, 0);
+    if (bytesRead < 0) return null;
+    const slice = buf.subarray(0, bytesRead);
+    const newline = slice.indexOf(0x0a);
+    return (newline < 0 ? slice : slice.subarray(0, newline)).toString('utf8');
+  } catch {
+    return null;
+  } finally {
+    closeSync(fd);
+  }
 }
 
-// goosedump derives a pi native id from the session file path relative to the
-// sessions base (without extension), so reconstruct the file path the same way.
-function piSessionFilePath(nativeId: string): string | null {
-  const path = join(piSessionsDir(), `${nativeId}.jsonl`);
-  return existsSync(path) ? path : null;
+// goosedump 0.9 addresses every context as an unambiguous `provider:id` target.
+function formatTarget(provider: string, id: string): string {
+  return `${provider}:${id}`;
 }
 
 function goosedumpSearch(
   target: string,
   query: string,
   options: { scope?: string; page?: number } = {},
-): GoosedumpSearchResult {
+): GoosedumpMessage[] {
   const scope = options.scope ?? 'lineage';
-  const args = ['search', target, query];
-  if (options.page) args.push('--page', String(options.page));
-  args.push('--scope', scope);
-
-  const json = JSON.parse(runGoosedump(args)) as SearchJson;
-  const messages = (json.hits ?? []).map(hitMessage);
-  return { messages, page: json.page ?? options.page ?? 1, totalPages: json.totalPages ?? 1 };
+  const args = ['search', target, query, '--as-provider', 'pi', '--scope', scope];
+  if (options.page) args.push('-p', String(options.page));
+  return parsePiMessages(runGoosedump(args));
 }
 
 function goosedumpGrep(
@@ -400,10 +301,9 @@ function goosedumpGrep(
   options: { scope?: string } = {},
 ): GoosedumpMessage[] {
   const scope = options.scope ?? 'lineage';
-  const json = JSON.parse(runGoosedump(['grep', target, pattern, '--scope', scope])) as {
-    hits?: HitJson[];
-  };
-  return (json.hits ?? []).map(hitMessage);
+  return parsePiMessages(
+    runGoosedump(['grep', target, pattern, '--as-provider', 'pi', '--scope', scope]),
+  );
 }
 
 function goosedumpShow(
@@ -411,100 +311,44 @@ function goosedumpShow(
   options: { scope?: string; ids?: string[] } = {},
 ): GoosedumpMessage[] {
   const scope = options.scope ?? 'lineage';
-  const args = ['show', target];
+  const args = ['show', target, '--as-provider', 'pi', '--scope', scope];
   for (const id of options.ids ?? []) args.push('-m', id);
-  args.push('--scope', scope);
-
-  const json = JSON.parse(runGoosedump(args)) as ShowJson;
-  return (json.messages ?? []).map(showMessage);
+  return parsePiMessages(runGoosedump(args));
 }
 
-// goosedump accepts --output-format on show/grep/search to emit a context in a
-// provider's native, round-trippable format. That output is raw native text (not
-// the ShowJson/HitJson shapes), so this bypasses the JSON-parsing wrappers and
-// returns it verbatim. Only used when the caller explicitly sets outputFormat.
-function goosedumpConvert(
-  subcommand: 'show' | 'grep' | 'search',
-  target: string,
-  outputFormat: string,
-  options: { positionals?: string[]; scope?: string; ids?: string[]; page?: number } = {},
-): string {
-  const args = [subcommand, target, ...(options.positionals ?? [])];
-  for (const id of options.ids ?? []) args.push('-m', id);
-  if (options.page) args.push('--page', String(options.page));
-  args.push('--scope', options.scope ?? 'lineage', '--output-format', outputFormat);
-  return runGoosedump(args);
-}
-
-// Resolve a goosedump target id. In 0.7 every context is addressed by its 8-hex
-// index id, so an explicit contextId is already the target. It falls back to the
-// current session only for pi; other providers have no current session, so they
-// require an explicit contextId.
+// 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.
 function resolveTarget(
   ctx: ExtensionContext,
   provider: string,
   contextId: string | undefined,
 ): string | null {
-  if (contextId) return contextId;
-  return provider === 'pi' ? currentSessionContextId(ctx) : null;
-}
-
-function capList(items: string[], limit: number): string {
-  const shown = items.slice(0, limit).join(', ');
-  return items.length > limit ? `${shown} (+${items.length - limit} more)` : shown;
-}
-
-function bulletSection(title: string, items: string[]): string | null {
-  if (items.length === 0) return null;
-  return `[${title}]\n${items.map((item) => `- ${item}`).join('\n')}`;
-}
-
-function renderCompactSummary(c: CompactJson): string {
-  const fileLines: string[] = [];
-  if (c.files.modified.length > 0) fileLines.push(`Modified: ${capList(c.files.modified, 10)}`);
-  if (c.files.created.length > 0) fileLines.push(`Created: ${capList(c.files.created, 10)}`);
-  if (c.files.read.length > 0) fileLines.push(`Read: ${capList(c.files.read, 10)}`);
-
-  const parts = [
-    bulletSection('Session Goal', c.goals),
-    bulletSection('Files And Changes', fileLines),
-    bulletSection('Commits', c.commits),
-    bulletSection('Outstanding Context', c.outstanding),
-    bulletSection('User Preferences', c.preferences),
-    c.brief.trim() ? c.brief : null,
-  ].filter((part): part is string => part !== null);
-
-  return parts.join('\n\n---\n\n');
+  if (contextId) return formatTarget(provider, contextId);
+  if (provider === 'pi') return currentSessionTarget(ctx);
+  return null;
 }
 
 function goosedumpCompact(
   target: string,
-  options: {
-    scope?: string;
-    from?: string;
-    until?: string;
-    ids?: string[];
-  },
+  options: { scope?: string; from?: string; until: string },
 ): string {
   const scope = options.scope ?? 'lineage';
   const args = ['compact', target, '--scope', scope];
-
-  if (options.ids && options.ids.length > 0) {
-    for (const id of options.ids) args.push('-m', id);
-  } else {
-    if (options.from) args.push('--from', options.from);
-    if (options.until) args.push('--until', options.until);
+  if (options.from) args.push('--from', options.from);
+  args.push('--until', options.until);
+
+  const output = runGoosedump(args);
+  for (const line of output.split('\n')) {
+    if (!line) continue;
+    try {
+      const entry = JSON.parse(line) as PiEntryJson;
+      if (entry.type === 'compaction' && typeof entry.summary === 'string') return entry.summary;
+    } catch {
+      continue;
+    }
   }
-
-  const json = JSON.parse(runGoosedump(args)) as CompactJson;
-  return renderCompactSummary(json);
-}
-
-function goosedumpDelete(id: string, options: { dryRun?: boolean } = {}): string {
-  const args = ['delete'];
-  if (options.dryRun) args.push('--dry-run');
-  args.push(id);
-  return runGoosedump(args);
+  return output.trim();
 }
 
 export interface GoosedumpIntegrationOptions {
@@ -516,18 +360,14 @@ interface GoosedumpCompactRange {
   scope: string;
   from?: string;
   until: string;
-  ids?: string[];
 }
 
 interface GoosedumpCompactionDetails {
   source: 'goosedump';
-  goosedumpVersion: string | null;
-  contextId: string;
+  target: string;
   scope: string;
   from?: string;
-  until?: string;
-  ids?: string[];
-  previousSummaryIncluded: boolean;
+  until: string;
   fileOps: unknown;
 }
 
@@ -539,34 +379,56 @@ export default function (pi: ExtensionAPI) {
   createGoosedumpIntegration().register(pi);
 }
 
-// Compute the pi native id goosedump assigns to a session file: its path relative
-// to the sessions base without the .jsonl extension, or the bare stem when the
-// file lives outside that base (mirroring goosedump's own fallback).
-function sessionFileNativeId(sessionFile: string): string {
-  const rel = relative(piSessionsDir(), sessionFile);
-  if (rel === '' || rel.startsWith('..') || isAbsolute(rel)) {
-    const name = basename(sessionFile);
-    const ext = extname(name);
-    return ext ? name.slice(0, -ext.length) : name;
-  }
-  const ext = extname(rel);
-  return ext ? rel.slice(0, -ext.length) : rel;
-}
-
-// Resolve the current pi session to its goosedump 8-hex context id by matching the
-// session file's native id against goosedump's index (via `list`).
-function currentSessionContextId(ctx: ExtensionContext): string | null {
+// Resolve the current pi session to its goosedump `pi:<id>` target. goosedump
+// 0.9 uses the session header's own `id` field as the context id, so read it
+// from the session file's first line and provider-qualify it; every target
+// passed to the binary is `provider:id`, never bare.
+function currentSessionTarget(ctx: ExtensionContext): string | null {
   const sessionFile = ctx.sessionManager.getSessionFile();
   if (!sessionFile) return null;
-  const nativeId = sessionFileNativeId(sessionFile);
-  const listing = goosedumpList('pi').find((entry) => entry.id === nativeId);
-  return listing ? listing.id : null;
+  const line = readFirstLine(sessionFile);
+  if (!line) return null;
+  try {
+    const entry = JSON.parse(line) as PiEntryJson;
+    if (entry.type === 'session' && typeof entry.id === 'string') {
+      return formatTarget('pi', entry.id);
+    }
+  } catch {
+    return null;
+  }
+  return null;
 }
 
 function isCompactionEntry(entry: SessionEntry): entry is CompactionEntry {
   return entry.type === 'compaction';
 }
 
+function isMessageEntry(entry: SessionEntry): entry is SessionEntry & {
+  type: 'message';
+  message: { role?: string };
+} {
+  return entry.type === 'message';
+}
+
+// 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 keepBoundaryId(branchEntries: SessionEntry[], keep: number): string | undefined {
+  let seen = 0;
+  for (let i = branchEntries.length - 1; i >= 0; i -= 1) {
+    const entry = branchEntries[i];
+    if (isMessageEntry(entry) && entry.message.role === 'user') {
+      seen += 1;
+      if (seen === keep) {
+        return i === 0 ? undefined : entry.id;
+      }
+    }
+  }
+  return undefined;
+}
+
 function latestCompactionBefore(
   branchEntries: SessionEntry[],
   untilIndex: number,
@@ -613,107 +475,8 @@ function buildCompactRange(
     : { scope: 'lineage', until: firstKeptEntryId };
 }
 
-const LEGACY_GOOSEDUMP_NOTE =
-  'Use `goosedump` to search prior active-lineage work, decisions, and context from before this summary. Do not redo work already completed.';
-const GOOSEDUMP_SEPARATOR = '\n\n---\n\n';
-const GOOSEDUMP_HEADERS = [
-  'Session Goal',
-  'Files And Changes',
-  'Commits',
-  'Outstanding Context',
-  'User Preferences',
-] as const;
-
-function isGoosedumpSection(value: string): boolean {
-  return GOOSEDUMP_HEADERS.some((header) => value.startsWith(`[${header}]`));
-}
-
-function stripGoosedumpRecallNote(summary: string): string {
-  const idx = summary.lastIndexOf(LEGACY_GOOSEDUMP_NOTE);
-  if (idx < 0) return summary.trim();
-  return summary
-    .slice(0, idx)
-    .replace(/\s*(?:\n\n---\n\n)?\s*$/, '')
-    .trim();
-}
-
-function sectionOf(summary: string, header: string): string {
-  const tag = `[${header}]`;
-  const start = summary.indexOf(tag);
-  if (start < 0) return '';
-
-  const rest = summary.slice(start);
-  const nextHeader = GOOSEDUMP_HEADERS.filter((h) => h !== header)
-    .map((h) => rest.indexOf(`[${h}]`))
-    .filter((idx) => idx > 0);
-  const nextSeparator = rest.indexOf(GOOSEDUMP_SEPARATOR);
-  const candidates = [...nextHeader, ...(nextSeparator > 0 ? [nextSeparator] : [])].sort(
-    (a, b) => a - b,
-  );
-  const end = candidates[0];
-  return (end ? rest.slice(0, end) : rest).trim();
-}
-
-function briefOf(summary: string): string {
-  return stripGoosedumpRecallNote(summary)
-    .split(GOOSEDUMP_SEPARATOR)
-    .map((part) => part.trim())
-    .filter((part) => part && !isGoosedumpSection(part))
-    .join(GOOSEDUMP_SEPARATOR);
-}
-
-function mergeSection(header: string, previous: string, next: string): string {
-  if (header === 'Outstanding Context') return next;
-  if (!previous) return next;
-  if (!next) return previous;
-
-  const lines = [
-    ...new Set(
-      [...previous.split('\n'), ...next.split('\n')].filter((line) => line.startsWith('- ')),
-    ),
-  ];
-  const cap = header === 'Session Goal' ? 8 : header === 'User Preferences' ? 15 : 10;
-  const capped = lines.length > cap ? lines.slice(-cap) : lines;
-  return capped.length > 0 ? `[${header}]\n${capped.join('\n')}` : '';
-}
-
-function capBriefTranscript(brief: string): string {
-  const lines = brief.split('\n');
-  if (lines.length <= 120) return brief;
-  const kept = lines.slice(-120);
-  const firstHeader = kept.findIndex((line) => /^\[(user|assistant)\]$/.test(line));
-  const clean = firstHeader > 0 ? kept.slice(firstHeader) : kept;
-  return `...(${lines.length - clean.length} earlier lines omitted)\n\n${clean.join('\n')}`;
-}
-
-function mergeWithPreviousSummary(
-  summary: string,
-  previousSummary: string | undefined,
-): { summary: string; previousSummaryIncluded: boolean } {
-  const nextSummary = stripGoosedumpRecallNote(summary);
-  const priorSummary = previousSummary ? stripGoosedumpRecallNote(previousSummary) : '';
-
-  if (!priorSummary) {
-    return { summary: summary.trim(), previousSummaryIncluded: false };
-  }
-  if (!nextSummary) {
-    return { summary: previousSummary?.trim() ?? '', previousSummaryIncluded: true };
-  }
-
-  const sections = GOOSEDUMP_HEADERS.map((header) =>
-    mergeSection(header, sectionOf(priorSummary, header), sectionOf(nextSummary, header)),
-  ).filter(Boolean);
-  const brief = capBriefTranscript(
-    [briefOf(priorSummary), briefOf(nextSummary)].filter(Boolean).join('\n\n'),
-  );
-  const parts = [...sections, ...(brief ? [brief] : [])];
-  const merged = parts.join(GOOSEDUMP_SEPARATOR);
-
-  return { summary: merged.trim(), previousSummaryIncluded: true };
-}
-
 function buildGoosedumpCompaction(
-  contextId: string,
+  target: string,
   preparation: {
     firstKeptEntryId: string;
     tokensBefore: number;
@@ -721,103 +484,138 @@ function buildGoosedumpCompaction(
     fileOps: unknown;
   },
   branchEntries: SessionEntry[],
-): CompactionResult<GoosedumpCompactionDetails> | undefined {
-  const range = buildCompactRange(branchEntries, preparation.firstKeptEntryId);
+  keep?: number,
+): CompactionResult<GoosedumpCompactionDetails> | { cancel: true; reason: string } | undefined {
+  // A `keep:N` override replaces Pi's token-based cut with a turn-based one:
+  // summarize everything before the Nth-from-last user entry and keep the tail.
+  let firstKeptEntryId = preparation.firstKeptEntryId;
+  if (keep !== undefined && keep > 0) {
+    const id = keepBoundaryId(branchEntries, keep);
+    if (!id) {
+      return { cancel: true, reason: `fewer than ${keep} user turns; nothing to compact` };
+    }
+    firstKeptEntryId = id;
+  }
+
+  const range = buildCompactRange(branchEntries, firstKeptEntryId);
   if (!range) return undefined;
 
-  const summary = goosedumpCompact(contextId, range);
-  const merged = mergeWithPreviousSummary(summary, preparation.previousSummary);
-  if (!merged.summary) return undefined;
+  const summary = goosedumpCompact(target, range);
+  if (!summary) return undefined;
 
   return {
-    summary: merged.summary,
-    firstKeptEntryId: preparation.firstKeptEntryId,
+    summary,
+    firstKeptEntryId,
     tokensBefore: preparation.tokensBefore,
     details: {
       source: 'goosedump',
-      goosedumpVersion: goosedumpVersion(),
-      contextId,
+      target,
       scope: range.scope,
       from: range.from,
       until: range.until,
-      ids: range.ids,
-      previousSummaryIncluded: merged.previousSummaryIncluded,
       fileOps: preparation.fileOps,
     },
   };
 }
 
-async function runSessionBrowser(
-  ctx: ExtensionContext,
-  listings: GoosedumpListing[],
-): Promise<string | null | undefined> {
-  let resumePath: string | null | undefined;
-
-  const OVERLAY_WIDTH = 84;
-  const LIST_VIEWPORT = 18;
-  const COMPACT_VIEWPORT = 18;
-  const location = ctx.cwd;
-  const settingValues = COMPACT_SETTING_VALUES;
-
-  function locationListings(): GoosedumpListing[] {
-    return listings.filter((listing) => listing.cwd === location);
+function isControlChar(char: string): boolean {
+  const code = char.charCodeAt(0);
+  return code < 32 || code === 0x7f || (code >= 0x80 && code <= 0x9f);
+}
+
+class NumberInputSubmenu implements Component {
+  private readonly input = new Input();
+  private readonly hint: (text: string) => string;
+  private readonly onSubmitValue: (value: string) => void;
+  private readonly onCancelEdit: () => void;
+  private readonly title: string;
+
+  constructor(
+    title: string,
+    initialValue: string,
+    onSubmit: (value: string) => void,
+    onCancel: () => void,
+  ) {
+    this.title = title;
+    this.onSubmitValue = onSubmit;
+    this.onCancelEdit = onCancel;
+    this.input.setValue(initialValue);
+    this.hint = getSettingsListTheme().hint;
   }
 
-  function refreshListings(): void {
-    listings.splice(0, listings.length, ...goosedumpList());
+  handleInput(data: string): void {
+    const kb = getKeybindings();
+    if (kb.matches(data, 'tui.select.confirm') || data === '\n') {
+      const digits = this.input.getValue().replace(/\D/g, '');
+      const parsed = Number(digits);
+      this.onSubmitValue(digits !== '' && Number.isSafeInteger(parsed) ? String(parsed) : '0');
+      return;
+    }
+    if (kb.matches(data, 'tui.select.cancel')) {
+      this.onCancelEdit();
+      return;
+    }
+    const kittyChar = decodeKittyPrintable(data);
+    const printable = kittyChar ?? (data.length === 1 && !isControlChar(data) ? data : undefined);
+    if (printable !== undefined && !/^[0-9]$/.test(printable)) return;
+    this.input.handleInput(data);
   }
 
-  function shortPath(path: string, maxLen: number): string {
-    if (path.length <= maxLen) return path;
-    const head = Math.floor(maxLen / 2) + 2;
-    const tail = maxLen - head - 3;
-    if (tail < 4) return `${path.slice(0, maxLen - 3)}...`;
-    return `${path.slice(0, head)}...${path.slice(path.length - tail)}`;
+  invalidate(): void {
+    this.input.invalidate();
   }
 
-  function settingLabel(scope: SettingsScope, key: GoosedumpSettingKey): string {
-    const scopeLabel = scope === 'global' ? 'Global' : 'Project';
-    const keyLabel = key === 'stepsBeforeCompact' ? 'stepsBeforeCompact' : 'turnsBeforeCompact';
-    return `${scopeLabel} ${keyLabel}`;
+  render(width: number): string[] {
+    return [
+      this.hint(`  ${this.title}`),
+      '',
+      ...this.input.render(width),
+      '',
+      this.hint('  enter submit  ·  esc cancel'),
+    ];
   }
+}
 
-  function buildSettingItems(): SettingItem[] {
-    const global = readScopedGoosedumpSettings(location, 'global');
-    const project = readScopedGoosedumpSettings(location, 'project');
-    const settingsByScope = { global, project } satisfies Record<SettingsScope, GoosedumpSettings>;
-
-    return (['global', 'project'] as const).flatMap((scope) =>
-      (['stepsBeforeCompact', 'turnsBeforeCompact'] as const).map((key) => ({
-        id: `${scope}:${key}`,
-        label: settingLabel(scope, key),
-        description:
-          key === 'stepsBeforeCompact'
-            ? 'Tool steps before goosedump starts compaction; 0 disables this trigger.'
-            : 'LLM turns before goosedump starts compaction; 0 disables this trigger.',
-        currentValue: String(settingsByScope[scope][key]),
-        values: settingValues,
-      })),
-    );
-  }
+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}`;
+}
+
+async function runSettingsEditor(ctx: ExtensionContext): Promise<void> {
+  const OVERLAY_WIDTH = 84;
+  const location = ctx.cwd;
 
   await ctx.ui.custom<void>(
     (tui, theme, _kb, done) => {
-      let tab: 'sessions' | 'settings' = 'sessions';
-      let selectedIndex = 0;
-      let listScroll = 0;
-      let mode: 'list' | 'compact' = 'list';
-      let compactLines: string[] = [];
-      let compactScroll = 0;
-      let compactTitle = '';
-      let pendingDeletionId: string | null = null;
       let settingsList: SettingsList;
 
-      const wrapWidth = OVERLAY_WIDTH - 4;
+      function settingLabel(scope: SettingsScope, key: GoosedumpSettingKey): string {
+        const scopeLabel = scope === 'global' ? 'Global' : 'Project';
+        return `${scopeLabel} ${key}`;
+      }
 
-      function resetSelection(): void {
-        const count = locationListings().length;
-        selectedIndex = Math.min(selectedIndex, Math.max(0, count - 1));
-        listScroll = Math.min(listScroll, Math.max(0, count - LIST_VIEWPORT));
+      function buildSettingItems(): SettingItem[] {
+        const global = readScopedGoosedumpSettings(location, 'global');
+        const project = readScopedGoosedumpSettings(location, 'project');
+        const settingsByScope = { global, project } satisfies Record<
+          SettingsScope,
+          GoosedumpSettings
+        >;
+
+        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),
+          submenu: (currentValue, subDone) =>
+            new NumberInputSubmenu(
+              settingLabel(scope, 'turnsBeforeCompact'),
+              currentValue,
+              (value) => subDone(value),
+              () => subDone(),
+            ),
+        }));
       }
 
       function rebuildSettingsList(): void {
@@ -828,305 +626,266 @@ async function runSessionBrowser(
           (id, newValue) => {
             const [scope, key] = id.split(':') as [SettingsScope, GoosedumpSettingKey];
             const parsed = Number(newValue);
-            if (!Number.isSafeInteger(parsed) || parsed < 0) return;
+            if (!Number.isSafeInteger(parsed) || parsed < 0 || parsed > 255) return;
             writeScopedGoosedumpSetting(location, scope, key, parsed);
             settingsList.updateValue(id, newValue);
             ctx.ui.notify(`${settingLabel(scope, key)} = ${formatCompactSetting(parsed)}`, 'info');
             tui.requestRender();
           },
           () => {
-            tab = 'sessions';
-            tui.requestRender();
+            done(undefined);
           },
         );
       }
 
       rebuildSettingsList();
 
-      function executeDeletion(): void {
+      return {
+        render(width: number): string[] {
+          const innerW = width - 4;
+          const border = theme.fg('border', '│');
+          const borderFg = (s: string) => theme.fg('border', s);
+          const accent = (s: string) => theme.fg('accent', s);
+          const dim = (s: string) => theme.fg('dim', s);
+          const lines: string[] = [];
+          const title = accent(' Goosedump Settings ');
+          const topFill = borderFg('─'.repeat(Math.max(0, width - 4 - visibleWidth(title))));
+          lines.push(`${borderFg('╭─')}${title}${topFill}${borderFg('─╮')}`);
+          for (const line of settingsList.render(innerW)) lines.push(makeRow(line, innerW, border));
+          lines.push(makeRow('', innerW, border));
+          const effective = resolveGoosedumpSettings(location);
+          lines.push(
+            makeRow(
+              dim(`Effective: turns=${formatCompactSetting(effective.turnsBeforeCompact)}`),
+              innerW,
+              border,
+            ),
+          );
+          lines.push(makeRow(dim('↑↓ select  enter/space edit  esc close'), innerW, 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;
+          }
+          settingsList.handleInput(data);
+          tui.requestRender();
+        },
+        invalidate(): void {},
+      };
+    },
+    {
+      overlay: true,
+      overlayOptions: {
+        anchor: 'center',
+        width: OVERLAY_WIDTH,
+        margin: 2,
+      },
+    },
+  );
+}
+
+async function runSearchPanel(ctx: ExtensionContext, query: string): Promise<void> {
+  const OVERLAY_WIDTH = 84;
+  const VIEWPORT = 18;
+  const PAGE_SIZE = 5;
+  const wrapWidth = OVERLAY_WIDTH - 4;
+
+  await ctx.ui.custom<void>(
+    (tui, theme, _kb, done) => {
+      const target = currentSessionTarget(ctx);
+      const borderFg = (s: string) => theme.fg('border', s);
+      const border = theme.fg('border', '│');
+      const accent = (s: string) => theme.fg('accent', s);
+      const text = (s: string) => theme.fg('text', s);
+      const dim = (s: string) => theme.fg('dim', s);
+      const muted = (s: string) => theme.fg('muted', s);
+
+      let entries: GoosedumpMessage[] = [];
+      let error: string | null = null;
+      let mode: 'results' | 'detail' = 'results';
+      let selected = 0;
+      let scroll = 0;
+      let detailLines: string[] = [];
+      let detailScroll = 0;
+
+      function runSearch(): void {
         try {
-          const id = pendingDeletionId!;
-          goosedumpDelete(id);
-          refreshListings();
-          resetSelection();
-          pendingDeletionId = null;
+          const first = goosedumpSearch(target!, query, { scope: 'lineage', page: 1 });
+          if (first.length === 0) {
+            entries = [];
+            error = `No results for "${query}"`;
+            selected = 0;
+            scroll = 0;
+            return;
+          }
+
+          const all: GoosedumpMessage[] = [...first];
+          for (let page = 2; page <= 10; page += 1) {
+            const result = goosedumpSearch(target!, query, { scope: 'lineage', page });
+            if (result.length === 0) break;
+            all.push(...result);
+            if (result.length < PAGE_SIZE) break;
+          }
+
+          entries = all;
+          error = null;
+          selected = 0;
+          scroll = 0;
         } catch (err) {
-          const msg = err instanceof Error ? err.message : String(err);
-          ctx.ui.notify(`Failed to delete session: ${msg}`, 'error');
-          pendingDeletionId = null;
+          entries = [];
+          error = err instanceof Error ? err.message : String(err);
         }
-        tui.requestRender();
-      }
-
-      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}`;
       }
 
-      function renderTabs(innerW: number, border: string): string {
-        const sessions = tab === 'sessions' ? theme.fg('accent', '[Sessions]') : '[Sessions]';
-        const settings = tab === 'settings' ? theme.fg('accent', '[Settings]') : '[Settings]';
-        return makeRow(`${sessions} ${settings}`, innerW, border);
+      if (!target) {
+        error = 'No current Pi session available.';
+      } else {
+        runSearch();
       }
 
-      function renderSettings(width: number, innerW: number, border: string): string[] {
-        const borderFg = (s: string) => theme.fg('border', s);
-        const accent = (s: string) => theme.fg('accent', s);
-        const dim = (s: string) => theme.fg('dim', s);
-        const lines: string[] = [];
-        const title = accent(' Goosedump Dashboard ');
-        const topFill = borderFg('─'.repeat(Math.max(0, width - 4 - visibleWidth(title))));
-        lines.push(`${borderFg('╭─')}${title}${topFill}${borderFg('─╮')}`);
-        lines.push(renderTabs(innerW, border));
-        lines.push(
-          makeRow(
-            dim('Settings are written to ~/.pi/agent/settings.json and .pi/settings.json.'),
-            innerW,
-            border,
-          ),
-        );
-        lines.push(makeRow('', innerW, border));
-        for (const line of settingsList.render(innerW)) lines.push(makeRow(line, innerW, border));
-        lines.push(makeRow('', innerW, border));
-        const effective = resolveGoosedumpSettings(location);
-        lines.push(
-          makeRow(
-            dim(
-              `Effective: steps=${formatCompactSetting(effective.stepsBeforeCompact)} turns=${formatCompactSetting(effective.turnsBeforeCompact)}`,
-            ),
-            innerW,
-            border,
-          ),
-        );
-        lines.push(
-          makeRow(dim('tab switch  ↑↓ select  enter/space cycle  esc close'), innerW, border),
-        );
-        lines.push(`${borderFg('╰')}${borderFg('─'.repeat(width - 2))}${borderFg('╯')}`);
-        return lines;
+      function loadDetail(id: string): void {
+        try {
+          const messages = goosedumpShow(target!, { ids: [id] });
+          const content = messages.length > 0 ? messages[0].content : 'No content for this entry.';
+          detailLines = wrapTextWithAnsi(content, wrapWidth);
+          detailScroll = 0;
+          mode = 'detail';
+        } catch (err) {
+          const message = err instanceof Error ? err.message : String(err);
+          ctx.ui.notify(`goosedump error: ${message}`, 'error');
+        }
       }
 
       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[] = [];
+          const title = accent(` Goosedump search: ${truncateToWidth(query, 44)} `);
+          const topFill = borderFg('─'.repeat(Math.max(0, width - 4 - visibleWidth(title))));
+          lines.push(`${borderFg('╭─')}${title}${topFill}${borderFg('─╮')}`);
 
-          if (mode === 'compact') {
-            const lines: string[] = [];
-            const title = accent(` Compact: ${truncateToWidth(compactTitle, 48)} `);
-            const topFill = borderFg('─'.repeat(Math.max(0, width - 4 - visibleWidth(title))));
-            lines.push(`${borderFg('╭─')}${title}${topFill}${borderFg('─╮')}`);
+          if (error) {
+            lines.push(makeRow(muted(error), innerW, border));
+            lines.push(makeRow(dim('esc close'), innerW, border));
+            lines.push(`${borderFg('╰')}${borderFg('─'.repeat(width - 2))}${borderFg('╯')}`);
+            return lines;
+          }
 
-            const total = compactLines.length;
-            const window = compactLines.slice(compactScroll, compactScroll + COMPACT_VIEWPORT);
+          if (mode === 'detail') {
+            const total = detailLines.length;
+            const window = detailLines.slice(detailScroll, detailScroll + VIEWPORT);
             for (const row of window) lines.push(makeRow(text(row), innerW, border));
-            for (let i = window.length; i < COMPACT_VIEWPORT; i++)
-              lines.push(makeRow('', innerW, border));
-
+            for (let i = window.length; i < VIEWPORT; i++) lines.push(makeRow('', innerW, border));
             const position =
-              total > COMPACT_VIEWPORT
-                ? `${compactScroll + 1}-${Math.min(compactScroll + COMPACT_VIEWPORT, total)} of ${total}`
+              total > VIEWPORT
+                ? `${detailScroll + 1}-${Math.min(detailScroll + VIEWPORT, total)} of ${total}`
                 : `${total} line${total === 1 ? '' : 's'}`;
             lines.push(makeRow('', innerW, border));
-            lines.push(makeRow(dim(`↑↓ scroll  esc back  (${position})`), innerW, border));
+            lines.push(makeRow(dim(`esc back  ↑↓ scroll  (${position})`), innerW, border));
             lines.push(`${borderFg('╰')}${borderFg('─'.repeat(width - 2))}${borderFg('╯')}`);
             return lines;
           }
 
-          if (tab === 'settings') return renderSettings(width, innerW, border);
-
-          const currentListings = locationListings();
-          const lines: string[] = [];
-          const title = accent(' Goosedump Dashboard ');
-          const topFill = borderFg('─'.repeat(Math.max(0, width - 4 - visibleWidth(title))));
-          lines.push(`${borderFg('╭─')}${title}${topFill}${borderFg('─╮')}`);
-          lines.push(renderTabs(innerW, border));
-          lines.push(
-            makeRow(muted(`Location: ${shortPath(location, innerW - 10)}`), innerW, border),
-          );
-          lines.push(
-            makeRow(
-              muted(
-                `${currentListings.length} session${currentListings.length === 1 ? '' : 's'} here`,
-              ),
-              innerW,
-              border,
-            ),
-          );
-          lines.push(makeRow('', innerW, border));
-
-          const window = currentListings.slice(listScroll, listScroll + LIST_VIEWPORT);
+          const maxScroll = Math.max(0, entries.length - VIEWPORT);
+          const clampScroll = Math.min(scroll, maxScroll);
+          const window = entries.slice(clampScroll, clampScroll + VIEWPORT);
           for (let i = 0; i < window.length; i++) {
-            const absolute = listScroll + i;
-            const listing = window[i];
-            const isSelected = absolute === selectedIndex;
-            const deletePending = pendingDeletionId !== null && listing.id === pendingDeletionId;
-            const cursor = deletePending ? dim('␡') : isSelected ? accent('▶') : ' ';
-            const idText = deletePending
-              ? dim(listing.id)
-              : isSelected
-                ? accent(listing.id)
-                : text(listing.id);
-            const label = listing.label ? ` ${listing.label}` : '';
-            const count = muted(
-              ` (${listing.provider}, ${listing.path ? 'resumable' : 'no file'})`,
-            );
-            lines.push(makeRow(` ${cursor} ${idText}${muted(label)}${count}`, innerW, border));
-          }
-
-          for (let i = window.length; i < LIST_VIEWPORT; i++)
-            lines.push(makeRow('', innerW, border));
-
-          if (currentListings.length > LIST_VIEWPORT) {
-            const position = `${listScroll + 1}-${Math.min(listScroll + LIST_VIEWPORT, currentListings.length)} of ${currentListings.length}`;
-            lines.push(makeRow(dim(`(${position})`), innerW, border));
-          }
-
-          if (pendingDeletionId) {
-            lines.push(makeRow('', innerW, border));
+            const absolute = clampScroll + i;
+            const entry = window[i];
+            const isSelected = absolute === selected;
+            const cursor = isSelected ? accent('▶') : ' ';
+            const idText = isSelected ? accent(entry.id) : text(entry.id);
+            const snippet = compactLine(entry.content);
             lines.push(
-              makeRow(
-                dim(`Delete session ${pendingDeletionId}?  enter=confirm  esc=cancel`),
-                innerW,
-                border,
-              ),
+              makeRow(` ${cursor} ${idText} ${muted(entry.role)} ${dim(snippet)}`, innerW, border),
             );
           }
-
+          for (let i = window.length; i < VIEWPORT; i++) lines.push(makeRow('', innerW, border));
+          const count = entries.length;
+          const position =
+            count > VIEWPORT
+              ? `${clampScroll + 1}-${Math.min(clampScroll + VIEWPORT, count)} of ${count}`
+              : `${count} entr${count === 1 ? 'y' : 'ies'}`;
           lines.push(makeRow('', innerW, border));
           lines.push(
-            makeRow(
-              dim(
-                'tab settings  ↑↓ navigate  enter compact  shift+enter resume  ctrl+d delete  esc close',
-              ),
-              innerW,
-              border,
-            ),
+            makeRow(dim(`↑↓ navigate  enter expand  esc close  (${position})`), innerW, border),
           );
           lines.push(`${borderFg('╰')}${borderFg('─'.repeat(width - 2))}${borderFg('╯')}`);
           return lines;
         },
-
         handleInput(data: string): void {
-          if (mode === 'compact') {
-            const maxScroll = Math.max(0, compactLines.length - COMPACT_VIEWPORT);
-            if (matchesKey(data, Key.escape) || matchesKey(data, Key.ctrl('c'))) {
-              mode = 'list';
+          if (matchesKey(data, Key.escape) || matchesKey(data, Key.ctrl('c'))) {
+            if (mode === 'detail') {
+              mode = 'results';
               tui.requestRender();
               return;
             }
+            done(undefined);
+            return;
+          }
+          if (error) return;
+
+          if (mode === 'detail') {
+            const maxScroll = Math.max(0, detailLines.length - VIEWPORT);
             if (matchesKey(data, Key.up)) {
-              compactScroll = Math.max(0, compactScroll - 1);
+              detailScroll = Math.max(0, detailScroll - 1);
               tui.requestRender();
               return;
             }
             if (matchesKey(data, Key.down)) {
-              compactScroll = Math.min(maxScroll, compactScroll + 1);
+              detailScroll = Math.min(maxScroll, detailScroll + 1);
               tui.requestRender();
               return;
             }
             if (matchesKey(data, Key.pageUp)) {
-              compactScroll = Math.max(0, compactScroll - COMPACT_VIEWPORT);
+              detailScroll = Math.max(0, detailScroll - VIEWPORT);
               tui.requestRender();
               return;
             }
             if (matchesKey(data, Key.pageDown)) {
-              compactScroll = Math.min(maxScroll, compactScroll + COMPACT_VIEWPORT);
+              detailScroll = Math.min(maxScroll, detailScroll + VIEWPORT);
               tui.requestRender();
               return;
             }
             return;
           }
 
-          if (matchesKey(data, Key.tab) || matchesKey(data, Key.shift(Key.tab))) {
-            tab = tab === 'sessions' ? 'settings' : 'sessions';
-            if (tab === 'settings') rebuildSettingsList();
-            tui.requestRender();
-            return;
-          }
-
-          if (tab === 'settings') {
-            if (matchesKey(data, Key.escape) || matchesKey(data, Key.ctrl('c'))) {
-              done(undefined);
-              return;
-            }
-            settingsList.handleInput(data);
-            tui.requestRender();
-            return;
-          }
-
-          if (matchesKey(data, Key.escape) || matchesKey(data, Key.ctrl('c'))) {
-            done(undefined);
-            return;
-          }
-
-          const currentListings = locationListings();
+          const maxScroll = Math.max(0, entries.length - VIEWPORT);
           if (matchesKey(data, Key.up)) {
-            selectedIndex = Math.max(0, selectedIndex - 1);
-            if (selectedIndex < listScroll) listScroll = selectedIndex;
+            selected = Math.max(0, selected - 1);
+            if (selected < scroll) scroll = selected;
             tui.requestRender();
             return;
           }
-
           if (matchesKey(data, Key.down)) {
-            selectedIndex = Math.min(Math.max(0, currentListings.length - 1), selectedIndex + 1);
-            if (selectedIndex >= listScroll + LIST_VIEWPORT) {
-              listScroll = selectedIndex - LIST_VIEWPORT + 1;
-            }
+            selected = Math.min(Math.max(0, entries.length - 1), selected + 1);
+            if (selected >= scroll + VIEWPORT) scroll = selected - VIEWPORT + 1;
             tui.requestRender();
             return;
           }
-
-          if (pendingDeletionId) {
-            if (matchesKey(data, Key.escape) || matchesKey(data, Key.ctrl('c'))) {
-              pendingDeletionId = null;
-              tui.requestRender();
-              return;
-            }
-            if (matchesKey(data, Key.enter) || matchesKey(data, Key.return)) {
-              executeDeletion();
-              return;
-            }
-            return;
-          }
-
-          if (matchesKey(data, Key.ctrl('d'))) {
-            const listing = currentListings[selectedIndex];
-            if (listing) pendingDeletionId = listing.id;
+          if (matchesKey(data, Key.pageUp)) {
+            selected = Math.max(0, selected - VIEWPORT);
+            scroll = Math.max(0, Math.min(scroll, selected));
             tui.requestRender();
             return;
           }
-
-          if (matchesKey(data, Key.shift(Key.enter))) {
-            resumePath = currentListings[selectedIndex]?.path;
-            done(undefined);
+          if (matchesKey(data, Key.pageDown)) {
+            selected = Math.min(entries.length - 1, selected + VIEWPORT);
+            scroll = Math.min(maxScroll, Math.max(scroll, selected - VIEWPORT + 1));
+            tui.requestRender();
             return;
           }
-
           if (matchesKey(data, Key.enter) || matchesKey(data, Key.return)) {
-            const listing = currentListings[selectedIndex];
-            if (!listing) return;
-            compactTitle = listing.id;
-            compactScroll = 0;
-            try {
-              const summary = goosedumpCompact(listing.id, { scope: 'lineage' }).trim();
-              compactLines = summary
-                ? wrapTextWithAnsi(summary, wrapWidth)
-                : ['No compact summary available for this session.'];
-            } catch (err) {
-              const msg = err instanceof Error ? err.message : String(err);
-              compactLines = wrapTextWithAnsi(`Failed to compact session: ${msg}`, wrapWidth);
-            }
-            mode = 'compact';
+            const entry = entries[selected];
+            if (!entry) return;
+            loadDetail(entry.id);
             tui.requestRender();
+            return;
           }
         },
-
         invalidate(): void {},
       };
     },
@@ -1139,8 +898,6 @@ async function runSessionBrowser(
       },
     },
   );
-
-  return resumePath;
 }
 
 export function createGoosedumpIntegration(
@@ -1152,21 +909,21 @@ export function createGoosedumpIntegration(
   let goosedumpAvailable = false;
   let compactSettings = DEFAULT_GOOSEDUMP_SETTINGS;
   let settingsSignature = '';
-  let stepsRemaining = 0;
   let turnsRemaining = 0;
   let counterTriggered = false;
   let compactionQueued = false;
+  let pendingKeep: number | null = null;
 
   function compactSettingsSignature(settings: GoosedumpSettings): string {
-    return `${settings.stepsBeforeCompact}:${settings.turnsBeforeCompact}`;
+    return String(settings.turnsBeforeCompact);
   }
 
   function resetCompactCounters(cwd: string): void {
     compactSettings = resolveGoosedumpSettings(cwd);
     settingsSignature = compactSettingsSignature(compactSettings);
-    stepsRemaining = compactSettings.stepsBeforeCompact;
     turnsRemaining = compactSettings.turnsBeforeCompact;
     counterTriggered = false;
+    pendingKeep = null;
   }
 
   function reloadCompactSettings(cwd: string): void {
@@ -1175,13 +932,13 @@ export function createGoosedumpIntegration(
     if (nextSignature !== settingsSignature) resetCompactCounters(cwd);
   }
 
-  function noteCompletedStep(ctx: ExtensionContext): void {
-    if (!goosedumpAvailable || !shouldOverrideDefaultCompaction) return;
-    reloadCompactSettings(ctx.cwd);
-    if (compactSettings.stepsBeforeCompact === 0) return;
-
-    stepsRemaining -= 1;
-    if (stepsRemaining <= 0) counterTriggered = true;
+  function updateStatus(ctx: ExtensionContext): void {
+    if (!goosedumpAvailable) return;
+    const showCount = shouldOverrideDefaultCompaction && compactSettings.turnsBeforeCompact > 0;
+    const suffix = showCount
+      ? `: ${Math.max(0, turnsRemaining).toString(16).toUpperCase().padStart(2, '0')}`
+      : '';
+    ctx.ui.setStatus('goosedump', ctx.ui.theme.fg('text', `GD${suffix}`));
   }
 
   function noteCompletedTurn(ctx: ExtensionContext): void {
@@ -1191,18 +948,26 @@ export function createGoosedumpIntegration(
       turnsRemaining -= 1;
       if (turnsRemaining <= 0) counterTriggered = true;
     }
+    updateStatus(ctx);
 
     if (!counterTriggered || compactionQueued) return;
+    // ctx.compact() uses manual compaction semantics and aborts the current run.
+    // Wait until no queued work remains before triggering plugin-driven compaction.
+    if (ctx.hasPendingMessages()) return;
 
     resetCompactCounters(ctx.cwd);
+    updateStatus(ctx);
     compactionQueued = true;
     ctx.compact({
       onComplete: () => {
         compactionQueued = false;
         resetCompactCounters(ctx.cwd);
+        updateStatus(ctx);
       },
       onError: (error) => {
         compactionQueued = false;
+        resetCompactCounters(ctx.cwd);
+        updateStatus(ctx);
         const message = error instanceof Error ? error.message : String(error);
         if (ctx.hasUI) ctx.ui.notify(`goosedump compact failed: ${message}`, 'error');
       },
@@ -1210,8 +975,10 @@ export function createGoosedumpIntegration(
   }
 
   function checkGoosedump(ctx?: ExtensionContext): boolean {
-    const version = goosedumpVersion();
-    if (!version) {
+    try {
+      resolveGoosedumpBinary();
+      return true;
+    } catch {
       if (ctx) {
         ctx.ui.notify(
           'goosedump was not found. Install with: npm install @jarkkojs/goosedump',
@@ -1220,84 +987,74 @@ export function createGoosedumpIntegration(
       }
       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;
+  // Shared trigger for on-demand goosedump compaction (from the /goose-compact
+  // command and the goose_compact tool). Stashes a turn-based keep override and
+  // fires Pi's compaction flow; the session_before_compact hook reads pendingKeep
+  // and resets it on use, completion, or error.
+  function requestCompaction(ctx: ExtensionContext, keep: number | null): void {
+    pendingKeep = keep;
+    ctx.compact({
+      onComplete: () => {
+        pendingKeep = null;
+      },
+      onError: (error) => {
+        pendingKeep = null;
+        const message = error instanceof Error ? error.message : String(error);
+        if (ctx.hasUI) ctx.ui.notify(`goosedump compact failed: ${message}`, 'error');
+      },
+    });
   }
 
   function register(pi: ExtensionAPI): void {
     if (shouldRegisterTool) {
       pi.registerTool(
         defineTool({
-          name: 'goosedump',
-          label: 'goosedump',
+          name: 'goose_search',
+          label: 'goose_search',
           description:
-            "Browse coding agent session history across providers. List sessions, or view/search/grep the current Pi session or a named session. Set provider to browse another tool's sessions (claude, codex, gemini, ...); set outputFormat for raw native output. Supports ranked search, glob filtering, compact overview, and result expansion. Default scope is active lineage.",
+            'Search coding agent session history by ranked relevance. Returns compact entry overviews with entry IDs; use goose_get to expand specific IDs to full content. Defaults to the current Pi session.',
           promptSnippet:
-            'goosedump({ action: "search", query, contextId?, provider?, scope?, page? }) - search session history; omit contextId for current Pi session',
+            'goose_search({ query, provider?, session?, scope?, page? }) - rank messages by query relevance; defaults to current Pi session',
           promptGuidelines: [
-            'When researching past conversation history, use goosedump to find relevant context.',
-            'Start with compact ranked search (compact: true) for quick overview, then expand interesting entries.',
+            "Use goose_search to find relevant context in this or another coding agent's session history.",
+            'Start with compact ranked results, then use goose_get to expand interesting entry IDs to full content.',
             'Default scope is "lineage" (current branch); use scope: "all" to include all entries in the session.',
-            'Omit contextId to search, expand, or view the current Pi session; use list first for other sessions.',
-            'Set provider (e.g. "claude", "gemini") with a contextId to browse another tool\'s sessions; results render the same way as Pi sessions.',
-            'Set outputFormat (e.g. "claude", "json") only when you explicitly need the raw native session instead of the rendered view.',
+            'Omit session to search the current Pi session; set provider (e.g. "claude", "gemini") with a session id to browse another tool\'s sessions.',
           ],
           parameters: Type.Object({
-            action: Type.Optional(
+            query: Type.String({ description: 'Search query to rank messages by relevance' }),
+            provider: Type.Optional(
               Type.Union(
                 [
-                  Type.Literal('list'),
-                  Type.Literal('search'),
-                  Type.Literal('grep'),
-                  Type.Literal('expand'),
-                  Type.Literal('view'),
+                  Type.Literal('pi'),
+                  Type.Literal('claude'),
+                  Type.Literal('codex'),
+                  Type.Literal('crush'),
+                  Type.Literal('gemini'),
+                  Type.Literal('goose'),
+                  Type.Literal('opencode'),
                 ],
                 {
-                  default: 'list',
+                  default: 'pi',
                   description:
-                    'Operation: list sessions, search within a session, grep by glob pattern, expand entries, or view full session. Defaults to list.',
+                    'Source provider whose sessions to search. Defaults to pi. Non-pi providers have no current session, so they require an explicit session id.',
                 },
               ),
             ),
-            contextId: Type.Optional(
+            session: Type.Optional(
               Type.String({
                 description:
-                  'Context/session ID. Defaults to the current Pi session for search, grep, expand, view; required when provider is not pi.',
+                  'Context/session ID. Defaults to the current Pi session for pi; required when provider is not pi.',
               }),
             ),
-            query: Type.Optional(
-              Type.String({ description: 'Search query to rank messages by relevance' }),
-            ),
-            pattern: Type.Optional(
-              Type.String({ description: 'Glob pattern to filter messages (e.g. *rand*)' }),
-            ),
             scope: Type.Optional(
               Type.Union([Type.Literal('lineage'), Type.Literal('all')], {
                 default: 'lineage',
                 description: 'Scope: lineage (current branch) or all entries in the session',
               }),
             ),
-            compact: Type.Optional(
-              Type.Boolean({
-                default: true,
-                description: 'Display results in compact entry-overview format',
-              }),
-            ),
-            ids: Type.Optional(
-              Type.Array(Type.String(), {
-                description: 'Entry IDs to expand (show full content)',
-              }),
-            ),
             page: Type.Optional(
               Type.Integer({
                 minimum: 1,
@@ -1305,6 +1062,57 @@ export function createGoosedumpIntegration(
                 description: 'Page number for ranked results',
               }),
             ),
+          }),
+          async execute(_id, params, _signal, _onUpdate, ctx): Promise<AgentToolResult<void>> {
+            if (!goosedumpAvailable) {
+              return textResult(
+                'goosedump is not available. Install with: npm install @jarkkojs/goosedump',
+              );
+            }
+
+            try {
+              const provider = params.provider ?? 'pi';
+              const target = resolveTarget(ctx, provider, params.session);
+              if (!target) return missingSessionId('goose_search', provider);
+
+              const page = params.page ?? 1;
+              const messages = goosedumpSearch(target, params.query, {
+                scope: params.scope ?? 'lineage',
+                page,
+              });
+
+              if (messages.length === 0) {
+                return textResult(`No results for "${params.query}"`);
+              }
+
+              const text = formatMessagesCompact(messages);
+              const header = `Results for "${params.query}" (page ${page}):\n\n`;
+              return textResult(header + text);
+            } catch (err) {
+              const message = err instanceof Error ? err.message : String(err);
+              return textResult(`goosedump error: ${message}`);
+            }
+          },
+        }),
+      );
+
+      pi.registerTool(
+        defineTool({
+          name: 'goose_get',
+          label: 'goose_get',
+          description:
+            'Expand specific entry IDs (from goose_search or goose_grep) to their full content. Defaults to the current Pi session.',
+          promptSnippet:
+            'goose_get({ ids, provider?, session? }) - expand entry IDs to full content; defaults to current Pi session',
+          promptGuidelines: [
+            'Use goose_get to expand entry IDs returned by goose_search or goose_grep into their full content.',
+            'Pass only the specific IDs you need; full transcripts are expensive.',
+          ],
+          parameters: Type.Object({
+            ids: Type.Array(Type.String(), {
+              minItems: 1,
+              description: 'Entry IDs to expand (show full content)',
+            }),
             provider: Type.Optional(
               Type.Union(
                 [
@@ -1319,28 +1127,97 @@ export function createGoosedumpIntegration(
                 {
                   default: 'pi',
                   description:
-                    'Source provider whose sessions to browse (list, view, search, grep, expand). Defaults to pi. Non-pi providers have no current session, so they require an explicit contextId. Results render through the normal structured view regardless of provider.',
+                    'Source provider whose sessions to read. Defaults to pi. Non-pi providers have no current session, so they require an explicit session id.',
                 },
               ),
             ),
-            outputFormat: Type.Optional(
+            session: Type.Optional(
+              Type.String({
+                description:
+                  'Context/session ID. Defaults to the current Pi session for pi; required when provider is not pi.',
+              }),
+            ),
+            scope: Type.Optional(
+              Type.Union([Type.Literal('lineage'), Type.Literal('all')], {
+                default: 'lineage',
+                description: 'Scope: lineage (current branch) or all entries in the session',
+              }),
+            ),
+          }),
+          async execute(_id, params, _signal, _onUpdate, ctx): Promise<AgentToolResult<void>> {
+            if (!goosedumpAvailable) {
+              return textResult(
+                'goosedump is not available. Install with: npm install @jarkkojs/goosedump',
+              );
+            }
+
+            try {
+              const provider = params.provider ?? 'pi';
+              const target = resolveTarget(ctx, provider, params.session);
+              if (!target) return missingSessionId('goose_get', provider);
+              const messages = goosedumpShow(target, {
+                scope: params.scope ?? 'lineage',
+                ids: params.ids,
+              });
+
+              if (messages.length === 0) {
+                return textResult('No entries found for the given IDs.');
+              }
+
+              return textResult(formatMessagesFull(messages));
+            } catch (err) {
+              const message = err instanceof Error ? err.message : String(err);
+              return textResult(`goosedump error: ${message}`);
+            }
+          },
+        }),
+      );
+
+      pi.registerTool(
+        defineTool({
+          name: 'goose_grep',
+          label: 'goose_grep',
+          description:
+            'Filter session messages by glob pattern (e.g. *rand*). Returns compact entry overviews with entry IDs; use goose_get to expand. Defaults to the current Pi session.',
+          promptSnippet:
+            'goose_grep({ pattern, provider?, session?, scope? }) - filter messages by glob; defaults to current Pi session',
+          promptGuidelines: [
+            'Use goose_grep to filter session messages by glob pattern when you need exact substring/glob matching instead of ranked relevance.',
+            'Expand interesting entry IDs with goose_get.',
+            'Default scope is "lineage" (current branch); use scope: "all" to include all entries in the session.',
+          ],
+          parameters: Type.Object({
+            pattern: Type.String({ description: 'Glob pattern to filter messages (e.g. *rand*)' }),
+            provider: Type.Optional(
               Type.Union(
                 [
-                  Type.Literal('json'),
+                  Type.Literal('pi'),
                   Type.Literal('claude'),
                   Type.Literal('codex'),
                   Type.Literal('crush'),
                   Type.Literal('gemini'),
                   Type.Literal('goose'),
                   Type.Literal('opencode'),
-                  Type.Literal('pi'),
                 ],
                 {
+                  default: 'pi',
                   description:
-                    "Explicitly emit raw native output instead of the normal rendered view (view, expand, grep, search). JSONL providers (claude, codex, pi, gemini) emit raw session JSONL; SQLite providers (crush, goose, opencode) emit a JSON table projection; json emits goosedump's structured JSON. Omit to render normally.",
+                    'Source provider whose sessions to grep. Defaults to pi. Non-pi providers have no current session, so they require an explicit session id.',
                 },
               ),
             ),
+            session: Type.Optional(
+              Type.String({
+                description:
+                  'Context/session ID. Defaults to the current Pi session for pi; required when provider is not pi.',
+              }),
+            ),
+            scope: Type.Optional(
+              Type.Union([Type.Literal('lineage'), Type.Literal('all')], {
+                default: 'lineage',
+                description: 'Scope: lineage (current branch) or all entries in the session',
+              }),
+            ),
           }),
           async execute(_id, params, _signal, _onUpdate, ctx): Promise<AgentToolResult<void>> {
             if (!goosedumpAvailable) {
@@ -1350,144 +1227,19 @@ export function createGoosedumpIntegration(
             }
 
             try {
-              switch (params.action ?? 'list') {
-                case 'list': {
-                  const listings = goosedumpList(params.provider ?? 'pi');
-                  if (listings.length === 0) {
-                    return textResult('No sessions found.');
-                  }
-
-                  const lines = ['Available sessions:', ''];
-                  for (const listing of listings) {
-                    const suffix = listing.label ? `${listing.cwd}  ${listing.label}` : listing.cwd;
-                    lines.push(`  ${listing.id}  ${suffix}`);
-                  }
-
-                  return textResult(lines.join('\n'));
-                }
-
-                case 'search': {
-                  const provider = params.provider ?? 'pi';
-                  const target = resolveTarget(ctx, provider, params.contextId);
-                  if (!target) return missingContextId('search', provider);
-
-                  if (!params.query) return textResult('query is required for search');
-
-                  if (params.outputFormat) {
-                    return textResult(
-                      goosedumpConvert('search', target, params.outputFormat, {
-                        positionals: [params.query],
-                        scope: params.scope,
-                        page: params.page ?? 1,
-                      }),
-                    );
-                  }
-
-                  const result = goosedumpSearch(target, params.query, {
-                    scope: params.scope ?? 'lineage',
-                    page: params.page ?? 1,
-                  });
-
-                  if (result.messages.length === 0) {
-                    return textResult(`No results for "${params.query}"`);
-                  }
-
-                  const useCompact = params.compact ?? true;
-                  const text = useCompact
-                    ? formatMessagesCompact(result.messages)
-                    : formatMessagesFull(result.messages);
-
-                  const header = `Results for "${params.query}" (page ${result.page} of ${result.totalPages}):\n\n`;
-                  return textResult(header + text);
-                }
-
-                case 'grep': {
-                  const provider = params.provider ?? 'pi';
-                  const target = resolveTarget(ctx, provider, params.contextId);
-                  if (!target) return missingContextId('grep', provider);
-
-                  if (!params.pattern) return textResult('pattern is required for grep');
-
-                  if (params.outputFormat) {
-                    return textResult(
-                      goosedumpConvert('grep', target, params.outputFormat, {
-                        positionals: [params.pattern],
-                        scope: params.scope,
-                      }),
-                    );
-                  }
-
-                  const messages = goosedumpGrep(target, params.pattern, {
-                    scope: params.scope ?? 'lineage',
-                  });
-
-                  if (messages.length === 0) {
-                    return textResult(`No matches for "${params.pattern}"`);
-                  }
-
-                  const useCompact = params.compact ?? true;
-                  const text = useCompact
-                    ? formatMessagesCompact(messages)
-                    : formatMessagesFull(messages);
-
-                  return textResult(text);
-                }
-
-                case 'expand': {
-                  const provider = params.provider ?? 'pi';
-                  const target = resolveTarget(ctx, provider, params.contextId);
-                  if (!target) return missingContextId('expand', provider);
-
-                  if (!params.ids || params.ids.length === 0) {
-                    return textResult('ids is required for expand (array of entry IDs)');
-                  }
-
-                  if (params.outputFormat) {
-                    return textResult(
-                      goosedumpConvert('show', target, params.outputFormat, {
-                        ids: params.ids,
-                        scope: params.scope,
-                      }),
-                    );
-                  }
-
-                  const messages = goosedumpShow(target, {
-                    scope: params.scope ?? 'lineage',
-                    ids: params.ids,
-                  });
-
-                  if (messages.length === 0) {
-                    return textResult('No entries found for the given IDs.');
-                  }
-
-                  return textResult(formatMessagesFull(messages));
-                }
-
-                case 'view': {
-                  const provider = params.provider ?? 'pi';
-                  const target = resolveTarget(ctx, provider, params.contextId);
-                  if (!target) return missingContextId('view', provider);
-
-                  if (params.outputFormat) {
-                    return textResult(
-                      goosedumpConvert('show', target, params.outputFormat, {
-                        scope: params.scope,
-                      }),
-                    );
-                  }
-
-                  const messages = goosedumpShow(target, { scope: params.scope ?? 'lineage' });
-
-                  if (messages.length === 0) {
-                    return textResult(`Session "${target}" has no messages.`);
-                  }
-
-                  return textResult(formatMessagesFull(messages));
-                }
-
-                default:
-                  return textResult(`Unknown action: ${params.action ?? 'list'}`);
+              const provider = params.provider ?? 'pi';
+              const target = resolveTarget(ctx, provider, params.session);
+              if (!target) return missingSessionId('goose_grep', provider);
+
+              const messages = goosedumpGrep(target, params.pattern, {
+                scope: params.scope ?? 'lineage',
+              });
+
+              if (messages.length === 0) {
+                return textResult(`No matches for "${params.pattern}"`);
               }
+
+              return textResult(formatMessagesCompact(messages));
             } catch (err) {
               const message = err instanceof Error ? err.message : String(err);
               return textResult(`goosedump error: ${message}`);
@@ -1495,22 +1247,52 @@ export function createGoosedumpIntegration(
           },
         }),
       );
+
+      pi.registerTool(
+        defineTool({
+          name: 'goose_compact',
+          label: 'goose_compact',
+          description:
+            "Trigger a goosedump compaction of the current session now, optionally keeping the last N user turns verbatim while summarizing everything before. Compaction runs asynchronously via Pi's compaction flow.",
+          promptSnippet:
+            "goose_compact({ keep? }) - compact now; keep last N user turns (turn-based), omit to compact up to Pi's cut",
+          promptGuidelines: [
+            'Use goose_compact to compact the session proactively with goosedump when context is large or nearing limits.',
+            "Pass keep:N (N >= 1) to keep the last N user turns verbatim and summarize everything before them; omit to compact up to Pi's token-based cut.",
+            'Compaction is asynchronous; the session is notified when it completes.',
+          ],
+          parameters: Type.Object({
+            keep: Type.Optional(
+              Type.Integer({
+                minimum: 1,
+                description:
+                  "User turns to keep verbatim; summarize everything before them. Omit to compact up to Pi's token-based cut.",
+              }),
+            ),
+          }),
+          async execute(_id, params, _signal, _onUpdate, ctx): Promise<AgentToolResult<void>> {
+            if (!goosedumpAvailable) {
+              return textResult(
+                'goosedump is not available. Install with: npm install @jarkkojs/goosedump',
+              );
+            }
+
+            const keep = params.keep ?? null;
+            requestCompaction(ctx, keep);
+            return textResult(
+              keep !== null
+                ? `Compacting with goosedump; keeping the last ${keep} user turn${keep === 1 ? '' : 's'}.`
+                : "Compacting with goosedump up to Pi's cut.",
+            );
+          },
+        }),
+      );
     }
 
     pi.on('session_start', async (_event, ctx) => {
       goosedumpAvailable = checkGoosedump(ctx);
       resetCompactCounters(ctx.cwd);
-
-      if (goosedumpAvailable) {
-        const theme = ctx.ui.theme;
-        const dot = theme.fg('success', '●');
-        const label = theme.fg('text', 'Goosedump');
-        ctx.ui.setStatus('goosedump', `${dot} ${label}`);
-      }
-    });
-
-    pi.on('tool_execution_end', async (_event, ctx) => {
-      noteCompletedStep(ctx);
+      updateStatus(ctx);
     });
 
     pi.on('turn_end', async (_event, ctx) => {
@@ -1525,15 +1307,23 @@ export function createGoosedumpIntegration(
       const { messagesToSummarize, turnPrefixMessages } = event.preparation;
       if (messagesToSummarize.length === 0 && turnPrefixMessages.length === 0) return;
 
-      const contextId = currentSessionContextId(ctx);
-      if (!contextId) return;
+      const target = currentSessionTarget(ctx);
+      if (!target) return;
 
       try {
+        const keep = pendingKeep ?? undefined;
         const compaction = buildGoosedumpCompaction(
-          contextId,
+          target,
           event.preparation,
           event.branchEntries,
+          keep,
         );
+        if (compaction && 'cancel' in compaction) {
+          pendingKeep = null;
+          if (ctx.hasUI) ctx.ui.notify(compaction.reason, 'info');
+          return { cancel: true };
+        }
+        pendingKeep = null;
         return compaction ? { compaction } : undefined;
       } catch (err) {
         if (ctx.hasUI) {
@@ -1569,8 +1359,8 @@ export function createGoosedumpIntegration(
       registerCommand?: ExtensionAPI['registerCommand'];
     };
 
-    maybePi.registerCommand?.('goosedump', {
-      description: 'Browse coding agent session history',
+    maybePi.registerCommand?.('goose-settings', {
+      description: 'Edit goosedump compaction settings',
       handler: async (_args, ctx) => {
         if (!goosedumpAvailable) {
           ctx.ui.notify(
@@ -1581,20 +1371,63 @@ export function createGoosedumpIntegration(
         }
 
         try {
-          const listings = goosedumpList();
+          await runSettingsEditor(ctx);
+          updateStatus(ctx);
+        } catch (err) {
+          const message = err instanceof Error ? err.message : String(err);
+          ctx.ui.notify(`goosedump error: ${message}`, 'error');
+        }
+      },
+    });
+
+    maybePi.registerCommand?.('goose-compact', {
+      description: 'Compact now with goosedump; optionally keep the last N user turns',
+      handler: async (args, ctx) => {
+        if (!goosedumpAvailable) {
+          ctx.ui.notify(
+            'goosedump is not available. Install with: npm install @jarkkojs/goosedump',
+            'error',
+          );
+          return;
+        }
 
-          if (listings.length === 0) {
-            ctx.ui.notify('No sessions found.', 'info');
+        // `/goose-compact [keep:N]` — an optional leading `keep:N` (N >= 1) keeps
+        // 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') {
+          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');
             return;
           }
+        }
 
-          const resumePath = await runSessionBrowser(ctx, listings);
+        requestCompaction(ctx, keep);
+      },
+    });
 
-          if (resumePath) {
-            await ctx.switchSession(resumePath);
-          } else if (resumePath === null) {
-            ctx.ui.notify('Cannot resume: session file path is unavailable.', 'error');
-          }
+    maybePi.registerCommand?.('goose-search', {
+      description: 'Search the current session history',
+      handler: async (args, ctx) => {
+        if (!goosedumpAvailable) {
+          ctx.ui.notify(
+            'goosedump is not available. Install with: npm install @jarkkojs/goosedump',
+            'error',
+          );
+          return;
+        }
+
+        let query = typeof args === 'string' ? args.trim() : '';
+        if (query.length === 0) {
+          const input = await ctx.ui.input('Search query:', '');
+          query = (input ?? '').trim();
+        }
+
+        if (query.length === 0) return;
+        try {
+          await runSearchPanel(ctx, query);
         } catch (err) {
           const message = err instanceof Error ? err.message : String(err);
           ctx.ui.notify(`goosedump error: ${message}`, 'error');