pi-goosedump 0.11.2 → 0.12.0

package/dist/index.ts

@@ -0,0 +1,1535 @@
+// SPDX-License-Identifier: Apache-2.0
+// Copyright (C) Jarkko Sakkinen 2026
+
+// index.ts
+import {
+  DEFAULT_COMPACTION_SETTINGS,
+  defineTool,
+  findCutPoint,
+  getSettingsListTheme
+} from "@earendil-works/pi-coding-agent";
+import { execFile, execFileSync } from "node:child_process";
+import { randomUUID } from "node:crypto";
+import {
+  closeSync,
+  existsSync,
+  mkdirSync,
+  openSync,
+  readFileSync,
+  readSync,
+  renameSync,
+  unlinkSync,
+  writeFileSync
+} from "node:fs";
+import { createRequire } from "node:module";
+import { homedir } from "node:os";
+import { dirname, join } from "node:path";
+import {
+  Input,
+  Key,
+  SettingsList,
+  decodeKittyPrintable,
+  getKeybindings,
+  matchesKey,
+  truncateToWidth,
+  visibleWidth,
+  wrapTextWithAnsi
+} from "@earendil-works/pi-tui";
+import { Type } from "@sinclair/typebox";
+var require2 = createRequire(import.meta.url);
+var BRANCH_SUMMARY_PREFIX = `The following is a summary of a branch that this conversation came back from:
+
+<summary>
+`;
+var BRANCH_SUMMARY_SUFFIX = "</summary>";
+var RECALL_TOKEN_BUDGET = 4096;
+var RECALL_MAX_BYTES = RECALL_TOKEN_BUDGET;
+var MEMORY_HIT_SEPARATOR = `
+
+---
+
+`;
+var MEMORY_TEXT_TRUNCATED = `
+[Entry text truncated]`;
+var DEFAULT_GOOSEDUMP_SETTINGS = {
+  turnsBeforeCompact: 0
+};
+var TURNS_BEFORE_COMPACT_MIN = 0;
+var TURNS_BEFORE_COMPACT_MAX = 255;
+function isTurnsBeforeCompact(value) {
+  return typeof value === "number" && Number.isSafeInteger(value) && value >= TURNS_BEFORE_COMPACT_MIN && value <= TURNS_BEFORE_COMPACT_MAX;
+}
+function piAgentDir() {
+  return process.env.PI_CODING_AGENT_DIR ?? join(homedir(), ".pi", "agent");
+}
+function globalSettingsPath() {
+  return join(piAgentDir(), "settings.json");
+}
+function projectSettingsPath(cwd) {
+  return join(cwd, ".pi", "settings.json");
+}
+function isRecord(value) {
+  return typeof value === "object" && value !== null && !Array.isArray(value);
+}
+function readJsonObject(path) {
+  if (!existsSync(path))
+    return {};
+  try {
+    const parsed = JSON.parse(readFileSync(path, "utf8"));
+    return isRecord(parsed) ? parsed : {};
+  } catch {
+    return {};
+  }
+}
+function readJsonObjectStrict(path) {
+  if (!existsSync(path))
+    return {};
+  let parsed;
+  try {
+    parsed = JSON.parse(readFileSync(path, "utf8"));
+  } catch (error) {
+    const message = error instanceof Error ? error.message : String(error);
+    throw new Error(`${path}: ${message}`);
+  }
+  if (!isRecord(parsed))
+    throw new Error(`${path} must contain a JSON object`);
+  return parsed;
+}
+function writeJsonObjectAtomically(path, value) {
+  mkdirSync(dirname(path), { recursive: true });
+  const temporaryPath = `${path}.${randomUUID()}.tmp`;
+  try {
+    writeFileSync(temporaryPath, `${JSON.stringify(value, null, 2)}
+`, { flag: "wx" });
+    renameSync(temporaryPath, path);
+  } catch (error) {
+    try {
+      unlinkSync(temporaryPath);
+    } catch {}
+    throw error;
+  }
+}
+function readGoosedumpSettingsFrom(path) {
+  const raw = readJsonObject(path).goosedump;
+  if (!isRecord(raw))
+    return {};
+  const settings = {};
+  const value = raw.turnsBeforeCompact;
+  if (isTurnsBeforeCompact(value))
+    settings.turnsBeforeCompact = value;
+  return settings;
+}
+function validateGoosedumpSettings(path) {
+  const root = readJsonObjectStrict(path);
+  if (root.goosedump === undefined)
+    return;
+  if (!isRecord(root.goosedump)) {
+    throw new Error(`${path}: goosedump must be a JSON object`);
+  }
+  const value = root.goosedump.turnsBeforeCompact;
+  if (value !== undefined && !isTurnsBeforeCompact(value)) {
+    throw new Error(`${path}: goosedump.turnsBeforeCompact must be an integer from ` + `${TURNS_BEFORE_COMPACT_MIN} to ${TURNS_BEFORE_COMPACT_MAX}`);
+  }
+}
+function resolveGoosedumpSettings(cwd) {
+  return {
+    ...DEFAULT_GOOSEDUMP_SETTINGS,
+    ...readGoosedumpSettingsFrom(globalSettingsPath()),
+    ...readGoosedumpSettingsFrom(projectSettingsPath(cwd))
+  };
+}
+function notifyInvalidSettings(ctx) {
+  for (const path of [globalSettingsPath(), projectSettingsPath(ctx.cwd)]) {
+    try {
+      validateGoosedumpSettings(path);
+    } catch (error) {
+      const message = error instanceof Error ? error.message : String(error);
+      if (ctx.hasUI)
+        ctx.ui.notify(`goosedump settings error: ${message}`, "error");
+    }
+  }
+}
+function readScopedGoosedumpSettings(cwd, scope) {
+  const path = scope === "global" ? globalSettingsPath() : projectSettingsPath(cwd);
+  const raw = readJsonObjectStrict(path).goosedump;
+  if (!isRecord(raw))
+    return { ...DEFAULT_GOOSEDUMP_SETTINGS };
+  const settings = {};
+  const value = raw.turnsBeforeCompact;
+  if (isTurnsBeforeCompact(value))
+    settings.turnsBeforeCompact = value;
+  return { ...DEFAULT_GOOSEDUMP_SETTINGS, ...settings };
+}
+function writeScopedGoosedumpSetting(cwd, scope, key, value) {
+  const path = scope === "global" ? globalSettingsPath() : projectSettingsPath(cwd);
+  const root = readJsonObjectStrict(path);
+  const goosedump = isRecord(root.goosedump) ? root.goosedump : {};
+  root.goosedump = { ...goosedump, [key]: value };
+  writeJsonObjectAtomically(path, root);
+}
+function clearScopedGoosedumpSetting(cwd, scope, key) {
+  const path = scope === "global" ? globalSettingsPath() : projectSettingsPath(cwd);
+  const root = readJsonObjectStrict(path);
+  if (!isRecord(root.goosedump))
+    return;
+  const goosedump = { ...root.goosedump };
+  delete goosedump[key];
+  if (Object.keys(goosedump).length === 0)
+    delete root.goosedump;
+  else
+    root.goosedump = goosedump;
+  writeJsonObjectAtomically(path, root);
+}
+function formatCompactSetting(value) {
+  return value === 0 ? "disabled" : String(value);
+}
+function resolveGoosedumpBinary() {
+  return require2.resolve("@jarkkojs/goosedump/bin/goosedump.js");
+}
+function resolveNativeGoosedumpBinary() {
+  const target = `${process.platform}-${process.arch}`;
+  let packageName;
+  let binaryName = "goosedump";
+  switch (target) {
+    case "linux-x64":
+      packageName = "@jarkkojs/goosedump-linux-x64";
+      break;
+    case "darwin-arm64":
+      packageName = "@jarkkojs/goosedump-darwin-arm64";
+      break;
+    case "win32-x64":
+      packageName = "@jarkkojs/goosedump-win32-x64";
+      binaryName = "goosedump.exe";
+      break;
+    default:
+      throw new Error(`unsupported platform architecture: ${target}`);
+  }
+  const wrapperRequire = createRequire(resolveGoosedumpBinary());
+  const packageDir = dirname(wrapperRequire.resolve(`${packageName}/package.json`));
+  const binaryPath = join(packageDir, "bin", binaryName);
+  if (!existsSync(binaryPath))
+    throw new Error(`binary not found: ${binaryPath}`);
+  return binaryPath;
+}
+function clip(value, max) {
+  return value.length > max ? `${value.slice(0, max)}...` : value;
+}
+function summarizeToolArgs(args) {
+  if (args && typeof args === "object" && !Array.isArray(args)) {
+    const obj = args;
+    for (const key of ["path", "file_path", "filePath", "file"]) {
+      if (typeof obj[key] === "string")
+        return `path=${obj[key]}`;
+    }
+    for (const key of ["command", "query", "pattern", "description"]) {
+      if (typeof obj[key] === "string")
+        return `${key}=${clip(obj[key], 160)}`;
+    }
+    const keys = Object.keys(obj);
+    return keys.length === 0 ? "" : keys.sort().join(", ");
+  }
+  if (typeof args === "string")
+    return clip(args, 160);
+  if (args == null)
+    return "";
+  return clip(JSON.stringify(args), 160);
+}
+function flattenPiPart(part) {
+  switch (part.type) {
+    case "text":
+      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 "image":
+      return part.mimeType ? `[image ${part.mimeType}]` : "[image]";
+    default:
+      return clip(JSON.stringify(part), 160);
+  }
+}
+function flattenPiContent(content) {
+  if (typeof content === "string")
+    return content;
+  if (!Array.isArray(content))
+    return "";
+  return content.map(flattenPiPart).filter(Boolean).join(`
+`);
+}
+function parsePiMessages(output) {
+  const messages = [];
+  for (const line of output.split(`
+`)) {
+    if (!line)
+      continue;
+    let entry;
+    try {
+      entry = JSON.parse(line);
+    } catch {
+      continue;
+    }
+    if (entry.type === "message" && entry.message) {
+      const content = flattenPiContent(entry.message.content);
+      messages.push({ id: entry.id ?? "", role: entry.message.role ?? "unknown", content });
+    } else if (entry.type === "custom_message") {
+      messages.push({
+        id: entry.id ?? "",
+        role: "user",
+        content: flattenPiContent(entry.content)
+      });
+    } else if (entry.type === "branch_summary") {
+      messages.push({
+        id: entry.id ?? "",
+        role: "user",
+        content: `${BRANCH_SUMMARY_PREFIX}${entry.summary ?? ""}${BRANCH_SUMMARY_SUFFIX}`
+      });
+    }
+  }
+  return messages;
+}
+function parseMemoryHits(output) {
+  const value = JSON.parse(output);
+  if (!Array.isArray(value))
+    throw new Error("goosedump memory search returned invalid JSON");
+  return value.filter((item) => isRecord(item) && typeof item.hash === "string" && typeof item.kind === "string" && typeof item.text === "string" && typeof item.score === "number" && typeof item.provider === "string" && typeof item.context_id === "string" && typeof item.entry_id === "string" && typeof item.path === "string" && typeof item.source_path === "string" && ["decision", "fact", "preference", "procedure", "episode"].includes(item.memory_type) && typeof item.trust === "number" && typeof item.confidence === "number" && (item.valid_from === null || typeof item.valid_from === "number") && (item.valid_until === null || typeof item.valid_until === "number") && ["context", "project"].includes(item.scope) && ["observed", "mutation"].includes(item.derivation));
+}
+function formatMemoryHit(hit, maxBytes) {
+  const provenance = `[${hit.hash}] ${hit.memory_type} (${hit.kind}; ${hit.scope}/${hit.derivation}; ` + `trust ${hit.trust.toFixed(2)}, confidence ${hit.confidence.toFixed(2)}; ` + `${hit.provider}:${hit.context_id}/${hit.entry_id})
+` + `Working directory: ${hit.path}
+Source: ${hit.source_path}
+`;
+  const full = `${provenance}${hit.text}`;
+  if (Buffer.byteLength(full) <= maxBytes)
+    return full;
+  const provenanceBytes = Buffer.byteLength(provenance);
+  const markerBytes = Buffer.byteLength(MEMORY_TEXT_TRUNCATED);
+  if (provenanceBytes + markerBytes >= maxBytes)
+    return utf8Prefix(provenance, maxBytes);
+  const textBytes = maxBytes - provenanceBytes - markerBytes;
+  return `${provenance}${utf8Prefix(hit.text, textBytes)}${MEMORY_TEXT_TRUNCATED}`;
+}
+function formatMemoryHits(hits, maxBytes = RECALL_MAX_BYTES) {
+  const formatted = [];
+  let remainingBytes = maxBytes;
+  const separatorBytes = Buffer.byteLength(MEMORY_HIT_SEPARATOR);
+  for (let index = 0;index < hits.length; index += 1) {
+    if (index > 0) {
+      if (remainingBytes < separatorBytes)
+        break;
+      formatted.push(MEMORY_HIT_SEPARATOR);
+      remainingBytes -= separatorBytes;
+    }
+    const remainingHits = hits.length - index;
+    const futureSeparators = separatorBytes * (remainingHits - 1);
+    const hitBytes = Math.floor((remainingBytes - futureSeparators) / remainingHits);
+    if (hitBytes <= 0)
+      break;
+    const hit = formatMemoryHit(hits[index], hitBytes);
+    formatted.push(hit);
+    remainingBytes -= Buffer.byteLength(hit);
+  }
+  return formatted.join("");
+}
+var ANSI_SGR = new RegExp(String.fromCharCode(27) + "\\[[0-9;]*m", "g");
+function compactLine(content) {
+  const plain = content.replace(ANSI_SGR, "");
+  const collapsed = plain.replace(/\s+/g, " ").trim();
+  return collapsed.length > 80 ? `${collapsed.slice(0, 80)}...` : collapsed;
+}
+function formatMessagesCompact(messages) {
+  return messages.map((m) => `[${m.id}] ${m.role}: ${compactLine(m.content)}`).join(`
+`);
+}
+function formatMessagesFull(messages) {
+  return messages.map((m) => `[${m.id}] ${m.role}:
+${m.content}`).join(`
+
+---
+
+`);
+}
+function textResult(text) {
+  return { content: [{ type: "text", text }], details: undefined };
+}
+function missingSessionId(tool, provider = "pi") {
+  if (provider !== "pi") {
+    return textResult(`session is required for ${tool} when provider is "${provider}"`);
+  }
+  return textResult(`session is required for ${tool} when no current session is available`);
+}
+var GOOSEDUMP_UNAVAILABLE_MESSAGE = "goosedump is not available. Install with: npm install @jarkkojs/goosedump";
+function goosedumpUnavailableResult() {
+  return textResult(GOOSEDUMP_UNAVAILABLE_MESSAGE);
+}
+function compactStartedMessage(keep) {
+  return keep !== null ? `Compacting with goosedump; keeping the last ${keep} user turn${keep === 1 ? "" : "s"}.` : "Compacting with goosedump up to Pi's token-based cut.";
+}
+function runGoosedump(args) {
+  try {
+    return execFileSync(process.execPath, [resolveGoosedumpBinary(), ...args], {
+      encoding: "utf-8",
+      maxBuffer: 16 * 1024 * 1024
+    });
+  } catch (err) {
+    const stderr = err.stderr?.trim();
+    const message = stderr ?? (err instanceof Error ? err.message : String(err));
+    throw new Error(message);
+  }
+}
+function runGoosedumpAsync(args, signal, executablePath = resolveNativeGoosedumpBinary()) {
+  return new Promise((resolve, reject) => {
+    execFile(executablePath, args, {
+      encoding: "utf-8",
+      maxBuffer: 16 * 1024 * 1024,
+      signal
+    }, (err, stdout, stderr) => {
+      if (err) {
+        const message = stderr.trim() || err.message;
+        reject(new Error(message));
+      } else {
+        resolve({ stdout, stderr });
+      }
+    });
+  });
+}
+function readFirstLine(path) {
+  let fd;
+  try {
+    fd = openSync(path, "r");
+    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(10);
+    return (newline < 0 ? slice : slice.subarray(0, newline)).toString("utf8");
+  } catch {
+    return null;
+  } finally {
+    if (fd !== undefined)
+      closeSync(fd);
+  }
+}
+function formatTarget(provider, id) {
+  return `${provider}:${id}`;
+}
+function appendScope(args, scope) {
+  if (scope === "all")
+    args.push("--all");
+}
+function goosedumpSearch(target, query, options = {}) {
+  const args = ["session", "search", target, query, "--as", "pi"];
+  appendScope(args, options.scope);
+  if (options.page)
+    args.push("--page", String(options.page));
+  return parsePiMessages(runGoosedump(args));
+}
+function goosedumpGrep(target, pattern, options = {}) {
+  const args = ["session", "find", target, pattern, "--as", "pi"];
+  appendScope(args, options.scope);
+  return parsePiMessages(runGoosedump(args));
+}
+function goosedumpShow(target, options = {}) {
+  const args = ["session", "show", target, "--as", "pi"];
+  appendScope(args, options.scope);
+  for (const id of options.ids ?? [])
+    args.push("--entry", id);
+  return parsePiMessages(runGoosedump(args));
+}
+async function goosedumpRecall(query, options = {}, signal, executablePath) {
+  const args = ["memory", "search", query, "--limit", String(options.limit ?? 5)];
+  if (options.provider)
+    args.push("--provider", options.provider);
+  if (options.path)
+    args.push("--path", options.path);
+  if (options.type)
+    args.push("--type", options.type);
+  const output = await runGoosedumpAsync(args, signal, executablePath);
+  return { hits: parseMemoryHits(output.stdout), warning: output.stderr.trim() };
+}
+function resolveTarget(ctx, provider, contextId) {
+  if (contextId)
+    return formatTarget(provider, contextId);
+  if (provider === "pi")
+    return currentSessionTarget(ctx);
+  return null;
+}
+var GOOSE_PROVIDERS = ["pi", "claude", "codex", "crush", "gemini", "goose", "opencode"];
+var HISTORY_TARGET_GUIDELINE = "Use the current Pi session by default; non-Pi providers require an explicit session ID.";
+function historyProviderParam(operation) {
+  return Type.Optional(Type.Union(GOOSE_PROVIDERS.map((provider) => Type.Literal(provider)), {
+    default: "pi",
+    description: `Source provider whose sessions to ${operation}. Defaults to pi. Non-pi providers have no current session, so they require an explicit session id.`
+  }));
+}
+function historySessionParam() {
+  return Type.Optional(Type.String({
+    description: "Context/session ID. Defaults to the current Pi session for pi; required when provider is not pi."
+  }));
+}
+function historyScopeParam() {
+  return Type.Optional(Type.Union([Type.Literal("lineage"), Type.Literal("all")], {
+    default: "lineage",
+    description: "Scope: lineage (current branch) or all entries in the session"
+  }));
+}
+async function goosedumpCompact(target, options, signal, executablePath) {
+  const args = ["session", "compact", target, "--remember"];
+  appendScope(args, options.scope);
+  if (options.from)
+    args.push("--from", options.from);
+  if (options.previousSummary)
+    args.push("--previous-summary", options.previousSummary);
+  args.push("--before", options.until);
+  const output = await runGoosedumpAsync(args, signal, executablePath);
+  for (const line of output.stdout.split(`
+`)) {
+    if (!line)
+      continue;
+    try {
+      const entry = JSON.parse(line);
+      if (entry.type === "compaction" && typeof entry.summary === "string") {
+        return { summary: entry.summary, warning: output.stderr.trim() };
+      }
+    } catch {
+      continue;
+    }
+  }
+  return { summary: output.stdout.trim(), warning: output.stderr.trim() };
+}
+function pi_goosedump_default(pi) {
+  createGoosedumpIntegration().register(pi);
+}
+function currentSessionTarget(ctx) {
+  const sessionFile = ctx.sessionManager.getSessionFile();
+  if (!sessionFile)
+    return null;
+  const line = readFirstLine(sessionFile);
+  if (!line)
+    return null;
+  try {
+    const entry = JSON.parse(line);
+    if (entry.type === "session" && typeof entry.id === "string") {
+      return formatTarget("pi", entry.id);
+    }
+  } catch {
+    return null;
+  }
+  return null;
+}
+function isCompactionEntry(entry) {
+  return entry.type === "compaction";
+}
+function isMessageEntry(entry) {
+  return entry.type === "message";
+}
+function isCompletedAssistant(message) {
+  return message.role === "assistant" && message.stopReason !== "error" && message.stopReason !== "aborted";
+}
+var SUMMARIZABLE_ENTRY_TYPES = new Set(["message", "custom_message", "branch_summary"]);
+function piKeepRecentTokens(cwd) {
+  for (const path of [projectSettingsPath(cwd), globalSettingsPath()]) {
+    const compaction = readJsonObject(path).compaction;
+    if (isRecord(compaction) && typeof compaction.keepRecentTokens === "number") {
+      return compaction.keepRecentTokens;
+    }
+  }
+  return DEFAULT_COMPACTION_SETTINGS.keepRecentTokens;
+}
+function piCompactionEnabled(cwd) {
+  for (const path of [projectSettingsPath(cwd), globalSettingsPath()]) {
+    const compaction = readJsonObject(path).compaction;
+    if (isRecord(compaction) && typeof compaction.enabled === "boolean") {
+      return compaction.enabled;
+    }
+  }
+  return DEFAULT_COMPACTION_SETTINGS.enabled;
+}
+function piReserveTokens(cwd) {
+  for (const path of [projectSettingsPath(cwd), globalSettingsPath()]) {
+    const compaction = readJsonObject(path).compaction;
+    if (isRecord(compaction) && typeof compaction.reserveTokens === "number") {
+      return compaction.reserveTokens;
+    }
+  }
+  return DEFAULT_COMPACTION_SETTINGS.reserveTokens;
+}
+function piAutoCompactionPending(ctx) {
+  const usage = ctx.getContextUsage();
+  if (!usage || usage.tokens === null)
+    return false;
+  return piCompactionEnabled(ctx.cwd) && usage.tokens > usage.contextWindow - piReserveTokens(ctx.cwd);
+}
+function hasCompactableHistory(ctx) {
+  const branch = ctx.sessionManager.getBranch();
+  if (branch.length === 0)
+    return false;
+  if (branch[branch.length - 1].type === "compaction")
+    return false;
+  const boundaryStart = activeHistoryStartIndex(branch);
+  const cut = findCutPoint(branch, boundaryStart, branch.length, piKeepRecentTokens(ctx.cwd));
+  if (!branch[cut.firstKeptEntryIndex]?.id)
+    return false;
+  const historyEnd = cut.isSplitTurn ? cut.turnStartIndex : cut.firstKeptEntryIndex;
+  for (let i = boundaryStart;i < historyEnd; i += 1) {
+    if (SUMMARIZABLE_ENTRY_TYPES.has(branch[i].type))
+      return true;
+  }
+  if (cut.isSplitTurn) {
+    for (let i = cut.turnStartIndex;i < cut.firstKeptEntryIndex; i += 1) {
+      if (SUMMARIZABLE_ENTRY_TYPES.has(branch[i].type))
+        return true;
+    }
+  }
+  return false;
+}
+function latestCompaction(branchEntries) {
+  for (let i = branchEntries.length - 1;i >= 0; i -= 1) {
+    const entry = branchEntries[i];
+    if (isCompactionEntry(entry))
+      return entry;
+  }
+  return;
+}
+function compactionBoundaryStartIndex(branchEntries, compaction) {
+  const keptIndex = branchEntries.findIndex((entry) => entry.id === compaction.firstKeptEntryId);
+  if (keptIndex >= 0)
+    return keptIndex;
+  const compactionIndex = branchEntries.findIndex((entry) => entry.id === compaction.id);
+  return compactionIndex >= 0 ? compactionIndex + 1 : 0;
+}
+function activeHistoryStartIndex(branchEntries) {
+  const compaction = latestCompaction(branchEntries);
+  return compaction ? compactionBoundaryStartIndex(branchEntries, compaction) : 0;
+}
+function completedTurnsSinceCompaction(branchEntries) {
+  let start = 0;
+  for (let i = branchEntries.length - 1;i >= 0; i -= 1) {
+    if (isCompactionEntry(branchEntries[i])) {
+      start = i + 1;
+      break;
+    }
+  }
+  let completed = 0;
+  for (let i = start;i < branchEntries.length; i += 1) {
+    const entry = branchEntries[i];
+    if (isMessageEntry(entry) && isCompletedAssistant(entry.message))
+      completed += 1;
+  }
+  return completed;
+}
+function keepBoundaryId(branchEntries, keep) {
+  const historyStart = activeHistoryStartIndex(branchEntries);
+  let seen = 0;
+  for (let i = branchEntries.length - 1;i >= historyStart; i -= 1) {
+    const entry = branchEntries[i];
+    if (isMessageEntry(entry) && entry.message.role === "user") {
+      seen += 1;
+      if (seen === keep)
+        return i === historyStart ? undefined : entry.id;
+    }
+  }
+  return;
+}
+function latestCompactionForRange(branchEntries, untilIndex) {
+  for (let i = branchEntries.length - 1;i >= 0; i -= 1) {
+    const entry = branchEntries[i];
+    if (!isCompactionEntry(entry))
+      continue;
+    if (compactionBoundaryStartIndex(branchEntries, entry) < untilIndex)
+      return entry;
+  }
+  return;
+}
+function compactionStartId(branchEntries, previousCompaction, untilIndex) {
+  const boundaryStart = compactionBoundaryStartIndex(branchEntries, previousCompaction);
+  return boundaryStart < untilIndex ? branchEntries[boundaryStart]?.id : undefined;
+}
+function buildCompactRange(branchEntries, firstKeptEntryId) {
+  const untilIndex = branchEntries.findIndex((entry) => entry.id === firstKeptEntryId);
+  if (untilIndex < 0)
+    return;
+  const previousCompaction = latestCompactionForRange(branchEntries, untilIndex);
+  const from = previousCompaction ? compactionStartId(branchEntries, previousCompaction, untilIndex) : undefined;
+  return from && from !== firstKeptEntryId ? { scope: "lineage", from, until: firstKeptEntryId } : { scope: "lineage", until: firstKeptEntryId };
+}
+function utf8Prefix(text, maxBytes) {
+  const prefix = [];
+  let bytes = 0;
+  for (const char of text) {
+    const charBytes = Buffer.byteLength(char);
+    if (bytes + charBytes > maxBytes)
+      break;
+    prefix.push(char);
+    bytes += charBytes;
+  }
+  return prefix.join("");
+}
+async function buildGoosedumpCompaction(target, preparation, branchEntries, keep, signal, executablePath) {
+  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;
+  const generated = await goosedumpCompact(target, { ...range, previousSummary: preparation.previousSummary }, signal, executablePath);
+  if (!generated.summary)
+    return;
+  const summary = generated.summary;
+  return {
+    summary,
+    firstKeptEntryId,
+    tokensBefore: preparation.tokensBefore,
+    details: {
+      source: "goosedump",
+      target,
+      scope: range.scope,
+      from: range.from,
+      until: range.until,
+      fileOps: preparation.fileOps,
+      warning: generated.warning || undefined
+    }
+  };
+}
+function isControlChar(char) {
+  const code = char.charCodeAt(0);
+  return code < 32 || code === 127 || code >= 128 && code <= 159;
+}
+
+class NumberInputSubmenu {
+  input = new Input;
+  hint;
+  onSubmitValue;
+  onCancelEdit;
+  onClearValue;
+  onInvalidValue;
+  title;
+  currentValue;
+  min;
+  max;
+  constructor(title, currentValue, onSubmit, onCancel, options) {
+    this.title = title;
+    this.currentValue = currentValue;
+    this.onSubmitValue = onSubmit;
+    this.onCancelEdit = onCancel;
+    this.onClearValue = options?.onClear;
+    this.onInvalidValue = options?.onInvalid ?? (() => {});
+    this.min = options?.min ?? 0;
+    this.max = options?.max ?? 255;
+    this.hint = getSettingsListTheme().hint;
+  }
+  handleInput(data) {
+    const kb = getKeybindings();
+    if (kb.matches(data, "tui.select.confirm") || data === `
+`) {
+      const value = this.input.getValue();
+      if (value === "") {
+        if (this.onClearValue)
+          this.onClearValue();
+        else
+          this.onCancelEdit();
+        return;
+      }
+      if (!/^\d+$/.test(value)) {
+        this.onInvalidValue(`Enter a whole number between ${this.min} and ${this.max}`);
+        return;
+      }
+      const parsed = Number(value);
+      if (!Number.isSafeInteger(parsed) || parsed < this.min || parsed > this.max) {
+        this.onInvalidValue(`Enter a whole number between ${this.min} and ${this.max}`);
+        return;
+      }
+      this.onSubmitValue(parsed);
+      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);
+  }
+  invalidate() {
+    this.input.invalidate();
+  }
+  render(width) {
+    return [
+      this.hint(`  ${this.title} · current ${this.currentValue ?? "inherit"} · ${this.min}-${this.max}`),
+      "",
+      ...this.input.render(width),
+      "",
+      this.hint(this.onClearValue ? "  empty inherit  ·  enter submit  ·  esc cancel" : "  enter submit  ·  esc cancel")
+    ];
+  }
+}
+function makeRow(content, innerW, border) {
+  const line = truncateToWidth(content, innerW);
+  const pad = Math.max(0, innerW - visibleWidth(line));
+  return `${border} ${line}${" ".repeat(pad)} ${border}`;
+}
+async function runSettingsEditor(ctx) {
+  const OVERLAY_WIDTH = 84;
+  const location = ctx.cwd;
+  await ctx.ui.custom((tui, theme, _kb, done) => {
+    let settingsList;
+    function settingLabel(scope, key) {
+      const scopeLabel = scope === "global" ? "Global" : "Project";
+      return `${scopeLabel} ${key}`;
+    }
+    function buildSettingItems() {
+      const global = readScopedGoosedumpSettings(location, "global");
+      const projectPath = projectSettingsPath(location);
+      const projectRaw = readJsonObjectStrict(projectPath).goosedump;
+      const projectValue = isRecord(projectRaw) && isTurnsBeforeCompact(projectRaw.turnsBeforeCompact) ? projectRaw.turnsBeforeCompact : undefined;
+      return ["global", "project"].map((scope) => ({
+        id: `${scope}:turnsBeforeCompact`,
+        label: settingLabel(scope, "turnsBeforeCompact"),
+        description: scope === "project" ? "LLM turns before compaction; empty inherits Global." : "LLM turns before compaction; 0 disables.",
+        currentValue: String(scope === "project" ? projectValue ?? "" : global.turnsBeforeCompact),
+        submenu: (currentValue, subDone) => new NumberInputSubmenu(settingLabel(scope, "turnsBeforeCompact"), currentValue === "" ? null : Number(currentValue), (value) => subDone(String(value)), () => subDone(), {
+          min: TURNS_BEFORE_COMPACT_MIN,
+          max: TURNS_BEFORE_COMPACT_MAX,
+          onClear: scope === "project" ? () => subDone("") : undefined,
+          onInvalid: (message) => ctx.ui.notify(message, "error")
+        })
+      }));
+    }
+    function rebuildSettingsList() {
+      settingsList = new SettingsList(buildSettingItems(), 10, getSettingsListTheme(), (id, newValue) => {
+        const [scope, key] = id.split(":");
+        if (scope === "project" && newValue === "") {
+          try {
+            clearScopedGoosedumpSetting(location, scope, key);
+            settingsList.updateValue(id, "");
+            ctx.ui.notify(`${settingLabel(scope, key)} inherits Global`, "info");
+            tui.requestRender();
+          } catch (error) {
+            const message = error instanceof Error ? error.message : String(error);
+            ctx.ui.notify(`goosedump settings error: ${message}`, "error");
+          }
+          return;
+        }
+        const parsed = Number(newValue);
+        if (!isTurnsBeforeCompact(parsed))
+          return;
+        try {
+          writeScopedGoosedumpSetting(location, scope, key, parsed);
+          settingsList.updateValue(id, newValue);
+          ctx.ui.notify(`${settingLabel(scope, key)} = ${formatCompactSetting(parsed)}`, "info");
+          tui.requestRender();
+        } catch (error) {
+          const message = error instanceof Error ? error.message : String(error);
+          ctx.ui.notify(`goosedump settings error: ${message}`, "error");
+        }
+        tui.requestRender();
+      }, () => {
+        done(undefined);
+      });
+    }
+    rebuildSettingsList();
+    return {
+      render(width) {
+        const innerW = width - 4;
+        const border = theme.fg("border", "│");
+        const borderFg = (s) => theme.fg("border", s);
+        const accent = (s) => theme.fg("accent", s);
+        const dim = (s) => theme.fg("dim", s);
+        const lines = [];
+        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) {
+        if (matchesKey(data, Key.escape) || matchesKey(data, Key.ctrl("c"))) {
+          done(undefined);
+          return;
+        }
+        settingsList.handleInput(data);
+        tui.requestRender();
+      },
+      invalidate() {}
+    };
+  }, {
+    overlay: true,
+    overlayOptions: {
+      anchor: "center",
+      width: OVERLAY_WIDTH,
+      margin: 2
+    }
+  });
+}
+async function runSearchPanel(ctx, query) {
+  const OVERLAY_WIDTH = 84;
+  const VIEWPORT = 18;
+  const PAGE_SIZE = 5;
+  const wrapWidth = OVERLAY_WIDTH - 4;
+  await ctx.ui.custom((tui, theme, _kb, done) => {
+    const target = currentSessionTarget(ctx);
+    const borderFg = (s) => theme.fg("border", s);
+    const border = theme.fg("border", "│");
+    const accent = (s) => theme.fg("accent", s);
+    const text = (s) => theme.fg("text", s);
+    const dim = (s) => theme.fg("dim", s);
+    const muted = (s) => theme.fg("muted", s);
+    let entries = [];
+    let error = null;
+    let mode = "results";
+    let selected = 0;
+    let scroll = 0;
+    let detailLines = [];
+    let detailScroll = 0;
+    function runSearch() {
+      try {
+        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 = [...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) {
+        entries = [];
+        error = err instanceof Error ? err.message : String(err);
+      }
+    }
+    if (!target) {
+      error = "No current Pi session available.";
+    } else {
+      runSearch();
+    }
+    function loadDetail(id) {
+      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) {
+        const innerW = width - 4;
+        const lines = [];
+        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 (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;
+        }
+        if (mode === "detail") {
+          const total = detailLines.length;
+          const window2 = detailLines.slice(detailScroll, detailScroll + VIEWPORT);
+          for (const row of window2)
+            lines.push(makeRow(text(row), innerW, border));
+          for (let i = window2.length;i < VIEWPORT; i++)
+            lines.push(makeRow("", innerW, border));
+          const position2 = 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(`esc back  ↑↓ scroll  (${position2})`), innerW, border));
+          lines.push(`${borderFg("╰")}${borderFg("─".repeat(width - 2))}${borderFg("╯")}`);
+          return lines;
+        }
+        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 = 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(` ${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(`↑↓ navigate  enter expand  esc close  (${position})`), innerW, border));
+        lines.push(`${borderFg("╰")}${borderFg("─".repeat(width - 2))}${borderFg("╯")}`);
+        return lines;
+      },
+      handleInput(data) {
+        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 maxScroll2 = Math.max(0, detailLines.length - VIEWPORT);
+          if (matchesKey(data, Key.up)) {
+            detailScroll = Math.max(0, detailScroll - 1);
+            tui.requestRender();
+            return;
+          }
+          if (matchesKey(data, Key.down)) {
+            detailScroll = Math.min(maxScroll2, detailScroll + 1);
+            tui.requestRender();
+            return;
+          }
+          if (matchesKey(data, Key.pageUp)) {
+            detailScroll = Math.max(0, detailScroll - VIEWPORT);
+            tui.requestRender();
+            return;
+          }
+          if (matchesKey(data, Key.pageDown)) {
+            detailScroll = Math.min(maxScroll2, detailScroll + VIEWPORT);
+            tui.requestRender();
+            return;
+          }
+          return;
+        }
+        const maxScroll = Math.max(0, entries.length - VIEWPORT);
+        if (matchesKey(data, Key.up)) {
+          selected = Math.max(0, selected - 1);
+          if (selected < scroll)
+            scroll = selected;
+          tui.requestRender();
+          return;
+        }
+        if (matchesKey(data, Key.down)) {
+          selected = Math.min(Math.max(0, entries.length - 1), selected + 1);
+          if (selected >= scroll + VIEWPORT)
+            scroll = selected - VIEWPORT + 1;
+          tui.requestRender();
+          return;
+        }
+        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.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 entry = entries[selected];
+          if (!entry)
+            return;
+          loadDetail(entry.id);
+          tui.requestRender();
+          return;
+        }
+      },
+      invalidate() {}
+    };
+  }, {
+    overlay: true,
+    overlayOptions: {
+      anchor: "center",
+      width: OVERLAY_WIDTH,
+      margin: 2
+    }
+  });
+}
+function createGoosedumpIntegration(options = {}) {
+  const shouldRegisterTool = options.registerTool ?? true;
+  const shouldOverrideDefaultCompaction = options.overrideDefaultCompaction ?? true;
+  const nativeExecutablePath = options.nativeExecutablePath;
+  let goosedumpAvailable = false;
+  let compactSettings = DEFAULT_GOOSEDUMP_SETTINGS;
+  let turnsRemaining = 0;
+  let counterTriggered = false;
+  let compactionQueued = false;
+  let compactionHookActive = false;
+  let pendingKeep = null;
+  function syncCompactCounters(ctx, clearPending = false) {
+    compactSettings = resolveGoosedumpSettings(ctx.cwd);
+    const completedTurns = completedTurnsSinceCompaction(ctx.sessionManager.getBranch());
+    turnsRemaining = Math.max(0, compactSettings.turnsBeforeCompact - completedTurns);
+    counterTriggered = compactSettings.turnsBeforeCompact > 0 && completedTurns >= compactSettings.turnsBeforeCompact;
+    if (clearPending)
+      pendingKeep = null;
+  }
+  function updateStatus(ctx) {
+    if (!goosedumpAvailable)
+      return;
+    const active = shouldOverrideDefaultCompaction && compactSettings.turnsBeforeCompact > 0;
+    const counter = active ? Math.max(0, turnsRemaining).toString(16).toUpperCase().padStart(2, "0") : "--";
+    ctx.ui.setStatus("goosedump", ctx.ui.theme.fg("text", `GD: ${counter}`));
+  }
+  function noteCompletedTurn(ctx) {
+    if (!goosedumpAvailable || !shouldOverrideDefaultCompaction)
+      return;
+    syncCompactCounters(ctx);
+    updateStatus(ctx);
+  }
+  function checkGoosedump(ctx) {
+    try {
+      execFileSync(process.execPath, [resolveGoosedumpBinary(), "--version"], { stdio: "ignore" });
+      return true;
+    } catch {
+      if (ctx) {
+        ctx.ui.notify("goosedump was not found. Install with: npm install @jarkkojs/goosedump", "error");
+      }
+      return false;
+    }
+  }
+  function requestCompaction(ctx, keep) {
+    if (compactionQueued || compactionHookActive)
+      return "busy";
+    if (keep === null && !hasCompactableHistory(ctx))
+      return "nothing-to-compact";
+    compactionQueued = true;
+    pendingKeep = keep;
+    ctx.compact({
+      onComplete: () => {
+        compactionQueued = false;
+        pendingKeep = null;
+      },
+      onError: (error) => {
+        compactionQueued = false;
+        pendingKeep = null;
+        const message = error instanceof Error ? error.message : String(error);
+        if (ctx.hasUI)
+          ctx.ui.notify(`goosedump compaction failed: ${message}`, "error");
+      }
+    });
+    return "started";
+  }
+  function register(pi) {
+    if (shouldRegisterTool) {
+      pi.registerTool(defineTool({
+        name: "goose_recall",
+        label: "goose_recall",
+        description: "Recall durable context harvested from earlier compactions. Searches the current project by default and returns bounded remembered excerpts with provenance.",
+        promptSnippet: "Recall durable context from earlier sessions",
+        promptGuidelines: [
+          "Use goose_recall for decisions, evidence, and context that may have disappeared from the current session.",
+          "Results include their original provider, session, entry, and working-directory provenance.",
+          "The current project is searched by default; set allProjects only when cross-project context is appropriate."
+        ],
+        parameters: Type.Object({
+          query: Type.String({ description: "Persistent-memory search query" }),
+          provider: Type.Optional(Type.Union(GOOSE_PROVIDERS.map((provider) => Type.Literal(provider)), {
+            description: "Optional source-provider filter"
+          })),
+          type: Type.Optional(Type.Union(["decision", "fact", "preference", "procedure", "episode"].map((type) => Type.Literal(type)), { description: "Optional memory-type filter" })),
+          allProjects: Type.Optional(Type.Boolean({
+            default: false,
+            description: "Search memory from every working directory"
+          })),
+          limit: Type.Optional(Type.Integer({
+            minimum: 1,
+            maximum: 20,
+            default: 5,
+            description: "Maximum remembered entries to return"
+          }))
+        }),
+        async execute(_id, params, signal, _onUpdate, ctx) {
+          if (!goosedumpAvailable)
+            return goosedumpUnavailableResult();
+          try {
+            const { hits, warning } = await goosedumpRecall(params.query, {
+              provider: params.provider,
+              path: params.allProjects ? undefined : ctx.cwd,
+              type: params.type,
+              limit: params.limit
+            }, signal, nativeExecutablePath);
+            if (warning && ctx.hasUI)
+              ctx.ui.notify(warning, "warning");
+            if (hits.length === 0)
+              return textResult(`No durable memory for "${params.query}"`);
+            return textResult(formatMemoryHits(hits));
+          } catch (err) {
+            const message = err instanceof Error ? err.message : String(err);
+            return textResult(`goosedump error: ${message}`);
+          }
+        }
+      }));
+      pi.registerTool(defineTool({
+        name: "goose_search",
+        label: "goose_search",
+        description: "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: "Search session history by ranked relevance",
+        promptGuidelines: [
+          "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.',
+          HISTORY_TARGET_GUIDELINE
+        ],
+        parameters: Type.Object({
+          query: Type.String({ description: "Search query to rank messages by relevance" }),
+          provider: historyProviderParam("search"),
+          session: historySessionParam(),
+          scope: historyScopeParam(),
+          page: Type.Optional(Type.Integer({
+            minimum: 1,
+            default: 1,
+            description: "Page number for ranked results"
+          }))
+        }),
+        async execute(_id, params, _signal, _onUpdate, ctx) {
+          if (!goosedumpAvailable)
+            return goosedumpUnavailableResult();
+          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}):
+
+`;
+            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: "Expand session entries by ID to full content",
+        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.",
+          'Default scope is "lineage" (current branch); use scope: "all" to retrieve entries from all session branches.',
+          HISTORY_TARGET_GUIDELINE
+        ],
+        parameters: Type.Object({
+          ids: Type.Array(Type.String(), {
+            minItems: 1,
+            description: "Entry IDs to expand (show full content)"
+          }),
+          provider: historyProviderParam("read"),
+          session: historySessionParam(),
+          scope: historyScopeParam()
+        }),
+        async execute(_id, params, _signal, _onUpdate, ctx) {
+          if (!goosedumpAvailable)
+            return goosedumpUnavailableResult();
+          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: "Filter session history by glob pattern",
+        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.',
+          HISTORY_TARGET_GUIDELINE
+        ],
+        parameters: Type.Object({
+          pattern: Type.String({ description: "Glob pattern to filter messages (e.g. *rand*)" }),
+          provider: historyProviderParam("grep"),
+          session: historySessionParam(),
+          scope: historyScopeParam()
+        }),
+        async execute(_id, params, _signal, _onUpdate, ctx) {
+          if (!goosedumpAvailable)
+            return goosedumpUnavailableResult();
+          try {
+            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}`);
+          }
+        }
+      }));
+      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: "Compact session history; optionally keep recent user turns",
+        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) {
+          if (!goosedumpAvailable)
+            return goosedumpUnavailableResult();
+          const keep = params.keep ?? null;
+          const result = requestCompaction(ctx, keep);
+          if (result === "busy")
+            return textResult("Compaction already in progress.");
+          if (result === "nothing-to-compact") {
+            return textResult("Nothing to compact (session too small).");
+          }
+          return textResult(compactStartedMessage(keep));
+        }
+      }));
+    }
+    function maybeAutoCompact(ctx, resumeAfter) {
+      if (!goosedumpAvailable || !shouldOverrideDefaultCompaction)
+        return;
+      if (!counterTriggered || compactionQueued)
+        return;
+      if (ctx.hasPendingMessages())
+        return;
+      if (!hasCompactableHistory(ctx))
+        return;
+      if (!resumeAfter && piAutoCompactionPending(ctx))
+        return;
+      syncCompactCounters(ctx, true);
+      updateStatus(ctx);
+      compactionQueued = true;
+      ctx.compact({
+        onComplete: () => {
+          compactionQueued = false;
+          syncCompactCounters(ctx, true);
+          updateStatus(ctx);
+          if (resumeAfter && !ctx.hasPendingMessages()) {
+            pi.sendMessage({
+              customType: "goosedump-autocompact-resume",
+              content: "The session was compacted to reduce context size. Continue the task you were working on from where you left off.",
+              display: false
+            }, { triggerTurn: true });
+          }
+        },
+        onError: (error) => {
+          compactionQueued = false;
+          syncCompactCounters(ctx, true);
+          updateStatus(ctx);
+          const message = error instanceof Error ? error.message : String(error);
+          if (ctx.hasUI)
+            ctx.ui.notify(`goosedump compaction failed: ${message}`, "error");
+        }
+      });
+    }
+    pi.on("session_start", async (_event, ctx) => {
+      goosedumpAvailable = checkGoosedump(ctx);
+      notifyInvalidSettings(ctx);
+      syncCompactCounters(ctx, true);
+      updateStatus(ctx);
+    });
+    pi.on("turn_end", async (event, ctx) => {
+      if (isCompletedAssistant(event.message))
+        noteCompletedTurn(ctx);
+      if (event.toolResults.length > 0)
+        maybeAutoCompact(ctx, true);
+    });
+    pi.on("agent_end", async (_event, ctx) => {
+      maybeAutoCompact(ctx, false);
+    });
+    pi.on("session_before_compact", async (event, ctx) => {
+      if (!shouldOverrideDefaultCompaction || !goosedumpAvailable)
+        return;
+      if (event.customInstructions?.trim())
+        return;
+      if (event.signal.aborted)
+        return;
+      const { messagesToSummarize, turnPrefixMessages } = event.preparation;
+      if (pendingKeep === null && messagesToSummarize.length === 0 && turnPrefixMessages.length === 0) {
+        return;
+      }
+      const target = currentSessionTarget(ctx);
+      if (!target)
+        return;
+      if (compactionHookActive)
+        return { cancel: true };
+      compactionHookActive = true;
+      try {
+        const keep = pendingKeep ?? undefined;
+        const compaction = await buildGoosedumpCompaction(target, event.preparation, event.branchEntries, keep, event.signal, nativeExecutablePath);
+        if (compaction && "cancel" in compaction) {
+          if (ctx.hasUI)
+            ctx.ui.notify(compaction.reason, "info");
+          return { cancel: true };
+        }
+        const warning = compaction?.details?.warning;
+        if (warning && ctx.hasUI) {
+          ctx.ui.notify(warning, "warning");
+        }
+        return compaction ? { compaction } : undefined;
+      } catch (err) {
+        if (event.signal.aborted)
+          return { cancel: true };
+        if (ctx.hasUI) {
+          const message = err instanceof Error ? err.message : String(err);
+          ctx.ui.notify(`goosedump compaction failed; falling back to Pi compaction: ${message}`, "error");
+        }
+        return;
+      } finally {
+        compactionHookActive = false;
+        pendingKeep = null;
+      }
+    });
+    pi.on("session_compact", async (event, ctx) => {
+      if (!goosedumpAvailable || !shouldOverrideDefaultCompaction)
+        return;
+      syncCompactCounters(ctx, true);
+      updateStatus(ctx);
+      const compactionEntry = event.compactionEntry;
+      if (!event.fromExtension || !compactionEntry || !isRecord(compactionEntry.details) || compactionEntry.details.source !== "goosedump") {
+        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;
+    maybePi.registerCommand?.("goose-settings", {
+      description: "Edit goosedump compaction settings",
+      handler: async (_args, ctx) => {
+        if (!goosedumpAvailable) {
+          ctx.ui.notify(GOOSEDUMP_UNAVAILABLE_MESSAGE, "error");
+          return;
+        }
+        try {
+          await runSettingsEditor(ctx);
+          syncCompactCounters(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_UNAVAILABLE_MESSAGE, "error");
+          return;
+        }
+        let keep = null;
+        if (typeof args === "string" && args.trim()) {
+          const match = args.trim().match(/^keep:(\d+)$/);
+          if (!match) {
+            ctx.ui.notify("Usage: /goose-compact [keep:N], where N >= 1", "error");
+            return;
+          }
+          keep = Number(match[1]);
+          if (!Number.isSafeInteger(keep) || keep < 1) {
+            ctx.ui.notify("keep:N requires a safe integer N >= 1", "error");
+            return;
+          }
+        }
+        const result = requestCompaction(ctx, keep);
+        if (result === "busy") {
+          ctx.ui.notify("Compaction already in progress", "info");
+        } else if (result === "nothing-to-compact") {
+          ctx.ui.notify("Nothing to compact (session too small)", "info");
+        } else {
+          ctx.ui.notify(compactStartedMessage(keep), "info");
+        }
+      }
+    });
+    maybePi.registerCommand?.("goose-search", {
+      description: "Search the current session history",
+      handler: async (args, ctx) => {
+        if (!goosedumpAvailable) {
+          ctx.ui.notify(GOOSEDUMP_UNAVAILABLE_MESSAGE, "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");
+        }
+      }
+    });
+  }
+  return { register };
+}
+export {
+  parsePiMessages,
+  pi_goosedump_default as default,
+  createGoosedumpIntegration
+};