pi-goosedump 0.13.6 → 0.13.8

package/README.md

@@ -1,7 +1,7 @@
 # pi-goosedump
 
 Pi extension for session search, durable memory, session management, and
-compaction. Canonical tools use the `gooseDump_` prefix (with legacy `goose_` aliases supported).
+compaction. Canonical tools use the `goosedump_` prefix (with legacy `goose_` aliases supported).
 
 ## Install
 
@@ -15,20 +15,20 @@ packaged binary.
 
 ## Tools
 
-- `gooseDump_search` and `gooseDump_grep` find session entries.
-- `gooseDump_get` expands entry IDs to full content.
-- `gooseDump_remember`, `gooseDump_recall`, and `gooseDump_forget` manage durable memory.
-- `gooseDump_memory_status` reports memory storage health.
-- `gooseDump_compact` compacts the current Pi session.
-- `gooseDump_sessions` lists or deletes sessions for the current project.
+- `goosedump_search` and `goosedump_grep` find session entries.
+- `goosedump_get` expands entry IDs to full content.
+- `goosedump_remember`, `goosedump_recall`, and `goosedump_forget` manage durable memory.
+- `goosedump_memory_status` reports memory storage health.
+- `goosedump_compact` compacts the current Pi session.
+- `goosedump_sessions` lists or deletes sessions for the current project.
 
-Search and grep return entry IDs; call `gooseDump_get` before relying on their
+Search and grep return entry IDs; call `goosedump_get` before relying on their
 content. Non-Pi providers require an explicit session ID.
 
 ## Commands
 
-`/goose-search`, `/goose-compact`, `/goose-sessions`, `/goose-forget`,
-`/goose-memory-status`, and `/goose-settings`.
+`/goosedump-search`, `/goosedump-compact`, `/goosedump-sessions`, `/goosedump-forget`,
+`/goosedump-memory-status`, and `/goosedump-settings`.
 
 ## Settings
 

package/dist/index.ts

@@ -685,7 +685,7 @@ async function goosedumpCompact(target, options, signal, executablePath) {
       continue;
     }
   }
-  return { summary: output.stdout.trim(), warning: output.stderr.trim() };
+  return { summary: "", warning: output.stderr.trim() };
 }
 function currentSessionTarget(ctx) {
   const sessionManager = ctx.sessionManager;
@@ -725,6 +725,7 @@ import {
   mkdirSync,
   readFileSync as readFileSync3,
   renameSync,
+  statSync as statSync2,
   unlinkSync,
   writeFileSync
 } from "node:fs";
@@ -740,7 +741,7 @@ function settingSpecFromSchema(schema) {
   return { kind: "number", min: minimum, max: maximum };
 }
 var GOOSEDUMP_SETTING_SPECS = Object.fromEntries(GOOSEDUMP_SETTING_KEYS.map((key) => [key, settingSpecFromSchema(GOOSEDUMP_SETTING_SCHEMAS[key])]));
-var MEMORY_DISABLED_MESSAGE = "Durable memory is disabled. Set goosedump.enableMemory to true in settings (or /goose-settings).";
+var MEMORY_DISABLED_MESSAGE = "Durable memory is disabled. Set goosedump.enableMemory to true in settings (or /goosedump-settings).";
 function isValidGoosedumpSettingValue(key, value) {
   return Value3.Check(GOOSEDUMP_SETTING_SCHEMAS[key], value);
 }
@@ -851,7 +852,26 @@ function validateGoosedumpSettings(path) {
 }
 var isNumberValue = (value) => typeof value === "number";
 var isBooleanValue = (value) => typeof value === "boolean";
+var settingsCache = null;
+function settingsStamp(path) {
+  try {
+    const stat = statSync2(path);
+    return `${stat.mtimeMs}:${stat.size}:${stat.ino}`;
+  } catch {
+    return "missing";
+  }
+}
 function resolveWorkspaceSettings(cwd, includeProject) {
+  const globalPath = globalSettingsPath();
+  const projectPath = includeProject ? projectSettingsPath(cwd) : undefined;
+  const key = `${globalPath}|${settingsStamp(globalPath)}|${projectPath ?? ""}|${projectPath ? settingsStamp(projectPath) : ""}`;
+  if (settingsCache?.key === key)
+    return settingsCache.value;
+  const value = computeWorkspaceSettings(cwd, includeProject);
+  settingsCache = { key, value };
+  return value;
+}
+function computeWorkspaceSettings(cwd, includeProject) {
   const globalObj = readJsonObject(globalSettingsPath());
   const projectObj = includeProject ? readJsonObject(projectSettingsPath(cwd)) : undefined;
   const goosedump = {
@@ -905,6 +925,7 @@ function updateScopedGoosedumpSetting(cwd, scope, update) {
     delete root.goosedump;
   else
     root.goosedump = next;
+  settingsCache = null;
   writeJsonObjectAtomically(path, root);
 }
 function readScopedGoosedumpSettings(cwd, scope) {
@@ -983,12 +1004,22 @@ function latestCompaction(branchEntries) {
   }
   return;
 }
+
+class BranchPositions {
+  positions = new Map;
+  constructor(branchEntries) {
+    branchEntries.forEach((entry, index) => this.positions.set(entry.id, index));
+  }
+  boundaryStartIndex(compaction) {
+    const kept = this.positions.get(compaction.firstKeptEntryId);
+    if (kept !== undefined)
+      return kept;
+    const own = this.positions.get(compaction.id);
+    return own !== undefined ? own + 1 : 0;
+  }
+}
 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;
+  return new BranchPositions(branchEntries).boundaryStartIndex(compaction);
 }
 function activeHistoryStartIndex(branchEntries) {
   const compaction = latestCompaction(branchEntries);
@@ -1022,12 +1053,13 @@ function buildCompactRange(branchEntries, firstKeptEntryId) {
   const untilIndex = branchEntries.findIndex((entry) => entry.id === firstKeptEntryId);
   if (untilIndex < 0)
     return;
+  const positions = new BranchPositions(branchEntries);
   let from;
   for (let i = Math.min(untilIndex - 1, branchEntries.length - 1);i >= 0; i -= 1) {
     const entry = branchEntries[i];
     if (!isCompactionEntry(entry))
       continue;
-    const boundaryStart = compactionBoundaryStartIndex(branchEntries, entry);
+    const boundaryStart = positions.boundaryStartIndex(entry);
     if (boundaryStart < untilIndex) {
       from = branchEntries[boundaryStart]?.id;
       break;
@@ -1715,27 +1747,27 @@ function hideMemoryActivity(ctx) {
 
 // src/policy.ts
 var GOOSEDUMP_TOOL_NAMES = [
-  "gooseDump_remember",
-  "gooseDump_recall",
-  "gooseDump_forget",
-  "gooseDump_memory_status",
-  "gooseDump_search",
-  "gooseDump_get",
-  "gooseDump_grep",
-  "gooseDump_compact",
-  "gooseDump_sessions"
+  "goosedump_remember",
+  "goosedump_recall",
+  "goosedump_forget",
+  "goosedump_memory_status",
+  "goosedump_search",
+  "goosedump_get",
+  "goosedump_grep",
+  "goosedump_compact",
+  "goosedump_sessions"
 ];
 var GOOSE_TOOL_NAMES = GOOSEDUMP_TOOL_NAMES;
 var LEGACY_TO_CANONICAL_TOOL_NAMES = {
-  goose_remember: "gooseDump_remember",
-  goose_recall: "gooseDump_recall",
-  goose_forget: "gooseDump_forget",
-  goose_memory_status: "gooseDump_memory_status",
-  goose_search: "gooseDump_search",
-  goose_get: "gooseDump_get",
-  goose_grep: "gooseDump_grep",
-  goose_compact: "gooseDump_compact",
-  goose_sessions: "gooseDump_sessions"
+  goose_remember: "goosedump_remember",
+  goose_recall: "goosedump_recall",
+  goose_forget: "goosedump_forget",
+  goose_memory_status: "goosedump_memory_status",
+  goose_search: "goosedump_search",
+  goose_get: "goosedump_get",
+  goose_grep: "goosedump_grep",
+  goose_compact: "goosedump_compact",
+  goose_sessions: "goosedump_sessions"
 };
 function resolveCanonicalToolName(name) {
   if (GOOSEDUMP_TOOL_NAMES.includes(name)) {
@@ -1762,14 +1794,14 @@ var PARAM_DESCRIPTIONS = {
   sessionsDeleteId: "Session ID to delete (required for action: delete)"
 };
 var HISTORY_TARGET_GUIDELINE = "Default to the current Pi session; non-Pi providers require an explicit session ID.";
-var HISTORY_WORKFLOW_GUIDELINE = "Prefer gooseDump_search or gooseDump_grep for candidate entry IDs, then gooseDump_get before quoting or acting on prior session content.";
-var PREFER_REMEMBER = "Prefer gooseDump_remember after milestones instead of restating durable facts in prompts.";
-var PREFER_RECALL = "Prefer gooseDump_recall over re-asking the user or re-deriving settled project context.";
-var PREFER_HISTORY = "Prefer gooseDump_search or gooseDump_grep, then gooseDump_get, over replaying full history or guessing prior work.";
-var PREFER_COMPACT = "Prefer gooseDump_compact when context is large, repetitive, or nearing limits; optional keep:N keeps the last N user turns.";
-var PREFER_SESSIONS = "Prefer gooseDump_sessions for cwd session discovery/delete; use gooseDump_forget / gooseDump_memory_status to maintain durable memory.";
+var HISTORY_WORKFLOW_GUIDELINE = "Prefer goosedump_search or goosedump_grep for candidate entry IDs, then goosedump_get before quoting or acting on prior session content.";
+var PREFER_REMEMBER = "Prefer goosedump_remember after milestones instead of restating durable facts in prompts.";
+var PREFER_RECALL = "Prefer goosedump_recall over re-asking the user or re-deriving settled project context.";
+var PREFER_HISTORY = "Prefer goosedump_search or goosedump_grep, then goosedump_get, over replaying full history or guessing prior work.";
+var PREFER_COMPACT = "Prefer goosedump_compact when context is large, repetitive, or nearing limits; optional keep:N keeps the last N user turns.";
+var PREFER_SESSIONS = "Prefer goosedump_sessions for cwd session discovery/delete; use goosedump_forget / goosedump_memory_status to maintain durable memory.";
 var CANONICAL_GOOSE_TOOL_POLICIES = {
-  gooseDump_remember: {
+  goosedump_remember: {
     description: "Preferred for background memory learning after milestones. Extracts evidence-backed claims for later recall; defaults to the current Pi session.",
     snippet: "Persist important context from the current or another session into durable memory",
     preference: PREFER_REMEMBER,
@@ -1779,7 +1811,7 @@ var CANONICAL_GOOSE_TOOL_POLICIES = {
       "Defaults to the current Pi session; pass provider/session to learn from another agent session."
     ]
   },
-  gooseDump_recall: {
+  goosedump_recall: {
     description: "Preferred for durable project memory before re-asking the user or re-deriving settled decisions. Returns provenance-backed claims, never instructions.",
     snippet: "Recall durable context from earlier sessions",
     preference: PREFER_RECALL,
@@ -1792,59 +1824,59 @@ var CANONICAL_GOOSE_TOOL_POLICIES = {
       "Filter with type when you already know the memory kind (decision, fact, preference, procedure, lesson)."
     ]
   },
-  gooseDump_forget: {
+  goosedump_forget: {
     description: "Preferred for tombstoning stale or wrong durable memory by mem_ ID or provider:session.",
     snippet: "Remove obsolete entries from durable memory store",
     guidelines: [
-      "Call gooseDump_forget when stored memory is stale, wrong, or should no longer be recalled.",
+      "Call goosedump_forget when stored memory is stale, wrong, or should no longer be recalled.",
       "Target a memory ID (mem_...) or a provider:session to drop that session's retained sources.",
-      "Forgotten content leaves a tombstone; use gooseDump_memory_status to inspect remaining store health."
+      "Forgotten content leaves a tombstone; use goosedump_memory_status to inspect remaining store health."
     ]
   },
-  gooseDump_memory_status: {
+  goosedump_memory_status: {
     description: "Preferred for diagnosing empty recall, missing embeddings, or unexpected durable-memory volume.",
     snippet: "Inspect durable memory health and statistics",
     guidelines: [
-      "Call gooseDump_memory_status when diagnosing empty recall, missing embeddings, or unexpected memory volume.",
+      "Call goosedump_memory_status when diagnosing empty recall, missing embeddings, or unexpected memory volume.",
       "Useful before or after bulk learn/forget operations."
     ]
   },
-  gooseDump_search: {
-    description: "Preferred for ranked session-history search. Returns compact entry IDs; expand hits with gooseDump_get. Defaults to the current Pi session.",
+  goosedump_search: {
+    description: "Preferred for ranked session-history search. Returns compact entry IDs; expand hits with goosedump_get. Defaults to the current Pi session.",
     snippet: "Search session history by ranked relevance",
     preference: PREFER_HISTORY,
     guidelines: [
       PREFER_HISTORY,
-      "Call gooseDump_search to recover relevant prior work from this or another coding-agent session.",
+      "Call goosedump_search to recover relevant prior work from this or another coding-agent session.",
       HISTORY_WORKFLOW_GUIDELINE,
       'Default scope is "lineage" (active branch); use scope: "all" for every branch in the session.',
       "Page results with page when the first page is incomplete.",
       HISTORY_TARGET_GUIDELINE
     ]
   },
-  gooseDump_get: {
-    description: "Preferred for expanding gooseDump_search/gooseDump_grep entry IDs to full content. Defaults to the current Pi session.",
+  goosedump_get: {
+    description: "Preferred for expanding goosedump_search/goosedump_grep entry IDs to full content. Defaults to the current Pi session.",
     snippet: "Expand session entries by ID to full content",
     guidelines: [
-      "Prefer gooseDump_get after gooseDump_search or gooseDump_grep; do not guess full prior content from overviews.",
+      "Prefer goosedump_get after goosedump_search or goosedump_grep; do not guess full prior content from overviews.",
       "Pass only the IDs you need; full transcripts are expensive.",
       'Default scope is "lineage" (active branch); use scope: "all" for every branch in the session.',
       HISTORY_TARGET_GUIDELINE
     ]
   },
-  gooseDump_grep: {
-    description: "Preferred for glob/substring filtering of session history when ranked search is too fuzzy. Expand hits with gooseDump_get. Defaults to the current Pi session.",
+  goosedump_grep: {
+    description: "Preferred for glob/substring filtering of session history when ranked search is too fuzzy. Expand hits with goosedump_get. Defaults to the current Pi session.",
     snippet: "Filter session history by glob pattern",
     preference: PREFER_HISTORY,
     guidelines: [
       PREFER_HISTORY,
-      "Call gooseDump_grep for exact substring or glob matches when ranked search is too fuzzy.",
+      "Call goosedump_grep for exact substring or glob matches when ranked search is too fuzzy.",
       HISTORY_WORKFLOW_GUIDELINE,
       'Default scope is "lineage" (active branch); use scope: "all" for every branch in the session.',
       HISTORY_TARGET_GUIDELINE
     ]
   },
-  gooseDump_compact: {
+  goosedump_compact: {
     description: "Preferred for proactive session compaction when context is large or nearing limits. Optional keep:N; runs through Pi's compaction flow.",
     snippet: "Compact session history; optionally keep recent user turns",
     preference: PREFER_COMPACT,
@@ -1855,7 +1887,7 @@ var CANONICAL_GOOSE_TOOL_POLICIES = {
       "Successful compaction may queue background memory learning."
     ]
   },
-  gooseDump_sessions: {
+  goosedump_sessions: {
     description: "Preferred for listing or deleting coding-agent sessions scoped to the current working directory.",
     snippet: "List or delete coding agent sessions for current directory",
     preference: PREFER_SESSIONS,
@@ -2062,20 +2094,20 @@ function formatExpandedMemoryStatus(content, theme) {
 function renderGooseDumpRememberCall(args, theme, ...rest) {
   const context = rest[0] ?? {};
   const target = args?.session ? `${args?.provider ?? "pi"}:${args.session}` : "current session";
-  const text = clampLineToWidth(`${renderToolLabel(theme, "gooseDump_remember")} ${theme.fg("accent", target)}`, context.width);
+  const text = clampLineToWidth(`${renderToolLabel(theme, "goosedump_remember")} ${theme.fg("accent", target)}`, context.width);
   return upsertTextComponent(context.lastComponent, text);
 }
 var renderGooseRememberCall = renderGooseDumpRememberCall;
 function renderGooseDumpRememberResult(result, options, theme, ...rest) {
   const { isPartial, isError, expanded, width } = resolveRenderResultContext(options, rest);
   if (isPartial)
-    return renderPendingResult("pending gooseDump_remember", width, theme);
+    return renderPendingResult("pending goosedump_remember", width, theme);
   const content = result.content?.[0]?.text ?? "";
   if (isError || result.isError) {
     return renderErrorResult(content, {
       expanded,
       width,
-      fallback: "gooseDump_remember failed",
+      fallback: "goosedump_remember failed",
       theme
     });
   }
@@ -2098,20 +2130,20 @@ function renderGooseDumpRecallCall(args, theme, ...rest) {
     args?.history && "history"
   ].filter(Boolean);
   const flagsBadge = flags.length > 0 ? theme.fg("dim", ` [${flags.join(", ")}]`) : "";
-  const text = clampLineToWidth(`${renderToolLabel(theme, "gooseDump_recall")} ${theme.fg("accent", query)}${flagsBadge}`, context.width);
+  const text = clampLineToWidth(`${renderToolLabel(theme, "goosedump_recall")} ${theme.fg("accent", query)}${flagsBadge}`, context.width);
   return upsertTextComponent(context.lastComponent, text);
 }
 var renderGooseRecallCall = renderGooseDumpRecallCall;
 function renderGooseDumpRecallResult(result, options, theme, ...rest) {
   const { isPartial, isError, expanded, width } = resolveRenderResultContext(options, rest);
   if (isPartial)
-    return renderPendingResult("pending gooseDump_recall", width, theme);
+    return renderPendingResult("pending goosedump_recall", width, theme);
   const content = result.content?.[0]?.text ?? "";
   if (isError || result.isError) {
     return renderErrorResult(content, {
       expanded,
       width,
-      fallback: "gooseDump_recall failed",
+      fallback: "goosedump_recall failed",
       theme
     });
   }
@@ -2139,20 +2171,20 @@ var renderGooseRecallResult = renderGooseDumpRecallResult;
 function renderGooseDumpForgetCall(args, theme, ...rest) {
   const context = rest[0] ?? {};
   const target = args?.target ? String(args.target) : '""';
-  const text = clampLineToWidth(`${renderToolLabel(theme, "gooseDump_forget")} ${theme.fg("accent", target)}`, context.width);
+  const text = clampLineToWidth(`${renderToolLabel(theme, "goosedump_forget")} ${theme.fg("accent", target)}`, context.width);
   return upsertTextComponent(context.lastComponent, text);
 }
 var renderGooseForgetCall = renderGooseDumpForgetCall;
 function renderGooseDumpForgetResult(result, options, theme, ...rest) {
   const { isPartial, isError, expanded, width } = resolveRenderResultContext(options, rest);
   if (isPartial)
-    return renderPendingResult("pending gooseDump_forget", width, theme);
+    return renderPendingResult("pending goosedump_forget", width, theme);
   const content = result.content?.[0]?.text ?? "";
   if (isError || result.isError) {
     return renderErrorResult(content, {
       expanded,
       width,
-      fallback: "gooseDump_forget failed",
+      fallback: "goosedump_forget failed",
       theme
     });
   }
@@ -2163,20 +2195,20 @@ function renderGooseDumpForgetResult(result, options, theme, ...rest) {
 var renderGooseForgetResult = renderGooseDumpForgetResult;
 function renderGooseDumpMemoryStatusCall(_args, theme, ...rest) {
   const context = rest[0] ?? {};
-  const text = clampLineToWidth(renderToolLabel(theme, "gooseDump_memory_status"), context.width);
+  const text = clampLineToWidth(renderToolLabel(theme, "goosedump_memory_status"), context.width);
   return upsertTextComponent(context.lastComponent, text);
 }
 var renderGooseMemoryStatusCall = renderGooseDumpMemoryStatusCall;
 function renderGooseDumpMemoryStatusResult(result, options, theme, ...rest) {
   const { isPartial, isError, expanded, width } = resolveRenderResultContext(options, rest);
   if (isPartial)
-    return renderPendingResult("pending gooseDump_memory_status", width, theme);
+    return renderPendingResult("pending goosedump_memory_status", width, theme);
   const content = result.content?.[0]?.text ?? "";
   if (isError || result.isError) {
     return renderErrorResult(content, {
       expanded,
       width,
-      fallback: "gooseDump_memory_status failed",
+      fallback: "goosedump_memory_status failed",
       theme
     });
   }
@@ -2214,20 +2246,20 @@ function renderGooseDumpSearchCall(args, theme, ...rest) {
     args?.page && args.page > 1 && `page=${args.page}`
   ].filter(Boolean);
   const flagsBadge = flags.length > 0 ? theme.fg("dim", ` [${flags.join(", ")}]`) : "";
-  const text = clampLineToWidth(`${renderToolLabel(theme, "gooseDump_search")} ${theme.fg("accent", query)}${target}${flagsBadge}`, context.width);
+  const text = clampLineToWidth(`${renderToolLabel(theme, "goosedump_search")} ${theme.fg("accent", query)}${target}${flagsBadge}`, context.width);
   return upsertTextComponent(context.lastComponent, text);
 }
 var renderGooseSearchCall = renderGooseDumpSearchCall;
 function renderGooseDumpSearchResult(result, options, theme, ...rest) {
   const { isPartial, isError, expanded, width } = resolveRenderResultContext(options, rest);
   if (isPartial)
-    return renderPendingResult("pending gooseDump_search", width, theme);
+    return renderPendingResult("pending goosedump_search", width, theme);
   const content = result.content?.[0]?.text ?? "";
   if (isError || result.isError) {
     return renderErrorResult(content, {
       expanded,
       width,
-      fallback: "gooseDump_search failed",
+      fallback: "goosedump_search failed",
       theme
     });
   }
@@ -2259,17 +2291,17 @@ function renderGooseDumpGetCall(args, theme, ...rest) {
   const ids = Array.isArray(args?.ids) ? args.ids : [];
   const idsDisplay = ids.length <= 3 ? ids.join(", ") : `${ids.slice(0, 3).join(", ")}… (${ids.length})`;
   const target = args?.session ? theme.fg("dim", ` in ${args.provider ?? "pi"}:${args.session}`) : "";
-  const text = clampLineToWidth(`${renderToolLabel(theme, "gooseDump_get")} ${theme.fg("accent", `[${idsDisplay}]`)}${target}`, context.width);
+  const text = clampLineToWidth(`${renderToolLabel(theme, "goosedump_get")} ${theme.fg("accent", `[${idsDisplay}]`)}${target}`, context.width);
   return upsertTextComponent(context.lastComponent, text);
 }
 var renderGooseGetCall = renderGooseDumpGetCall;
 function renderGooseDumpGetResult(result, options, theme, ...rest) {
   const { isPartial, isError, expanded, width } = resolveRenderResultContext(options, rest);
   if (isPartial)
-    return renderPendingResult("pending gooseDump_get", width, theme);
+    return renderPendingResult("pending goosedump_get", width, theme);
   const content = result.content?.[0]?.text ?? "";
   if (isError || result.isError) {
-    return renderErrorResult(content, { expanded, width, fallback: "gooseDump_get failed", theme });
+    return renderErrorResult(content, { expanded, width, fallback: "goosedump_get failed", theme });
   }
   if (content.startsWith("No entries found")) {
     return upsertTextComponent(rest[0]?.lastComponent, clampLineToWidth(summaryLine("no entries found", { theme, style: "dim" }), width));
@@ -2297,20 +2329,20 @@ function renderGooseDumpGrepCall(args, theme, ...rest) {
   const target = args?.session ? theme.fg("dim", ` in ${args.provider ?? "pi"}:${args.session}`) : "";
   const flags = [args?.scope && args.scope !== "lineage" && `scope=${args.scope}`].filter(Boolean);
   const flagsBadge = flags.length > 0 ? theme.fg("dim", ` [${flags.join(", ")}]`) : "";
-  const text = clampLineToWidth(`${renderToolLabel(theme, "gooseDump_grep")} ${theme.fg("accent", pattern)}${target}${flagsBadge}`, context.width);
+  const text = clampLineToWidth(`${renderToolLabel(theme, "goosedump_grep")} ${theme.fg("accent", pattern)}${target}${flagsBadge}`, context.width);
   return upsertTextComponent(context.lastComponent, text);
 }
 var renderGooseGrepCall = renderGooseDumpGrepCall;
 function renderGooseDumpGrepResult(result, options, theme, ...rest) {
   const { isPartial, isError, expanded, width } = resolveRenderResultContext(options, rest);
   if (isPartial)
-    return renderPendingResult("pending gooseDump_grep", width, theme);
+    return renderPendingResult("pending goosedump_grep", width, theme);
   const content = result.content?.[0]?.text ?? "";
   if (isError || result.isError) {
     return renderErrorResult(content, {
       expanded,
       width,
-      fallback: "gooseDump_grep failed",
+      fallback: "goosedump_grep failed",
       theme
     });
   }
@@ -2335,20 +2367,20 @@ function renderGooseDumpCompactCall(args, theme, ...rest) {
   const context = rest[0] ?? {};
   const flags = args?.keep ? [theme.fg("dim", `keep=${args.keep}`)] : [];
   const flagsBadge = flags.length > 0 ? ` [${flags.join(", ")}]` : "";
-  const text = clampLineToWidth(`${renderToolLabel(theme, "gooseDump_compact")}${flagsBadge}`, context.width);
+  const text = clampLineToWidth(`${renderToolLabel(theme, "goosedump_compact")}${flagsBadge}`, context.width);
   return upsertTextComponent(context.lastComponent, text);
 }
 var renderGooseCompactCall = renderGooseDumpCompactCall;
 function renderGooseDumpCompactResult(result, options, theme, ...rest) {
   const { isPartial, isError, expanded, width } = resolveRenderResultContext(options, rest);
   if (isPartial)
-    return renderPendingResult("pending gooseDump_compact", width, theme);
+    return renderPendingResult("pending goosedump_compact", width, theme);
   const content = result.content?.[0]?.text ?? "";
   if (isError || result.isError) {
     return renderErrorResult(content, {
       expanded,
       width,
-      fallback: "gooseDump_compact failed",
+      fallback: "goosedump_compact failed",
       theme
     });
   }
@@ -2362,20 +2394,20 @@ function renderGooseDumpSessionsCall(args, theme, ...rest) {
   const context = rest[0] ?? {};
   const action = args?.action ?? "list";
   const target = args?.session ? `${args?.provider ?? "pi"}:${args.session}` : `(${args?.provider ?? "pi"})`;
-  const text = clampLineToWidth(`${renderToolLabel(theme, "gooseDump_sessions")} ${theme.fg("accent", action)} ${theme.fg("dim", target)}`, context.width);
+  const text = clampLineToWidth(`${renderToolLabel(theme, "goosedump_sessions")} ${theme.fg("accent", action)} ${theme.fg("dim", target)}`, context.width);
   return upsertTextComponent(context.lastComponent, text);
 }
 var renderGooseSessionsCall = renderGooseDumpSessionsCall;
 function renderGooseDumpSessionsResult(result, options, theme, ...rest) {
   const { isPartial, isError, expanded, width } = resolveRenderResultContext(options, rest);
   if (isPartial)
-    return renderPendingResult("pending gooseDump_sessions", width, theme);
+    return renderPendingResult("pending goosedump_sessions", width, theme);
   const content = result.content?.[0]?.text ?? "";
   if (isError || result.isError) {
     return renderErrorResult(content, {
       expanded,
       width,
-      fallback: "gooseDump_sessions failed",
+      fallback: "goosedump_sessions failed",
       theme
     });
   }
@@ -2406,6 +2438,7 @@ ${formattedContent}` : summary;
 var renderGooseSessionsResult = renderGooseDumpSessionsResult;
 
 // src/tools.ts
+var MAX_ENTRY_IDS = 50;
 function memoryDisabledResult() {
   return textResult(MEMORY_DISABLED_MESSAGE);
 }
@@ -2456,7 +2489,7 @@ function boundedHistoryResult(text) {
     return textResult(text);
   return textResult(`${output.content}
 
-[Output truncated: showing ${output.outputLines} of ${output.totalLines} lines ` + `and ${output.outputBytes} of ${output.totalBytes} bytes. ` + "Use gooseDump_get with fewer IDs or a narrower gooseDump_grep pattern.]");
+[Output truncated: showing ${output.outputLines} of ${output.totalLines} lines ` + `and ${output.outputBytes} of ${output.totalBytes} bytes. ` + "Use goosedump_get with fewer IDs or a narrower goosedump_grep pattern.]");
 }
 function resolveHistoryTarget(ctx, tool, params) {
   const provider = params.provider ?? "pi";
@@ -2504,7 +2537,7 @@ function registerGooseTools(pi, deps) {
     pi.registerTool(defineGooseTool(canonicalName, parameters, handler, renderers));
     pi.registerTool(defineGooseTool(legacyName, parameters, handler, renderers));
   }
-  registerPair("gooseDump_remember", "goose_remember", Type3.Object({ ...historyTargetParams() }), async (params, _signal, ctx, toolName) => {
+  registerPair("goosedump_remember", "goose_remember", Type3.Object({ ...historyTargetParams() }), async (params, _signal, ctx, toolName) => {
     const disabled = requireMemoryEnabled(ctx);
     if (disabled)
       return disabled;
@@ -2518,7 +2551,7 @@ function registerGooseTools(pi, deps) {
     });
     return textResult(accepted ? `Memory learning started for ${resolved.target}.` : `Memory learning dropped for ${resolved.target}: another inference task is active.`);
   }, { renderCall: renderGooseRememberCall, renderResult: renderGooseRememberResult });
-  registerPair("gooseDump_recall", "goose_recall", Type3.Object({
+  registerPair("goosedump_recall", "goose_recall", Type3.Object({
     query: Type3.String({ description: PARAM_DESCRIPTIONS.memoryQuery }),
     type: Type3.Optional(Type3.Union(GOOSE_MEMORY_TYPES.map((type) => Type3.Literal(type)), { description: PARAM_DESCRIPTIONS.memoryType })),
     allProjects: Type3.Optional(Type3.Boolean({
@@ -2555,7 +2588,7 @@ function registerGooseTools(pi, deps) {
       return textResult(`No durable memory for "${params.query}"`);
     return textResult(formatMemoryHits(hits));
   }, { renderCall: renderGooseRecallCall, renderResult: renderGooseRecallResult });
-  registerPair("gooseDump_forget", "goose_forget", Type3.Object({
+  registerPair("goosedump_forget", "goose_forget", Type3.Object({
     target: Type3.String({
       description: PARAM_DESCRIPTIONS.forgetTarget
     })
@@ -2569,13 +2602,13 @@ function registerGooseTools(pi, deps) {
     const res = await goosedumpMemoryForget(params.target.trim(), signal, nativeExecutablePath);
     return textResult(res);
   }, { renderCall: renderGooseForgetCall, renderResult: renderGooseForgetResult });
-  registerPair("gooseDump_memory_status", "goose_memory_status", Type3.Object({}), async (_params, signal, ctx) => {
+  registerPair("goosedump_memory_status", "goose_memory_status", Type3.Object({}), async (_params, signal, ctx) => {
     const disabled = requireMemoryEnabled(ctx);
     if (disabled)
       return disabled;
     return textResult(await goosedumpMemoryStatus(signal, nativeExecutablePath));
   }, { renderCall: renderGooseMemoryStatusCall, renderResult: renderGooseMemoryStatusResult });
-  registerPair("gooseDump_search", "goose_search", Type3.Object({
+  registerPair("goosedump_search", "goose_search", Type3.Object({
     query: Type3.String({ description: PARAM_DESCRIPTIONS.searchQuery }),
     ...historyBranchParams(),
     page: Type3.Optional(Type3.Integer({
@@ -2597,9 +2630,10 @@ function registerGooseTools(pi, deps) {
 
 ${text}`);
   }, { renderCall: renderGooseSearchCall, renderResult: renderGooseSearchResult });
-  registerPair("gooseDump_get", "goose_get", Type3.Object({
+  registerPair("goosedump_get", "goose_get", Type3.Object({
     ids: Type3.Array(Type3.String(), {
       minItems: 1,
+      maxItems: MAX_ENTRY_IDS,
       description: PARAM_DESCRIPTIONS.entryIds
     }),
     ...historyBranchParams()
@@ -2613,7 +2647,7 @@ ${text}`);
     }
     return boundedHistoryResult(formatMessagesFull(messages));
   }, { renderCall: renderGooseGetCall, renderResult: renderGooseGetResult });
-  registerPair("gooseDump_grep", "goose_grep", Type3.Object({
+  registerPair("goosedump_grep", "goose_grep", Type3.Object({
     pattern: Type3.String({ description: PARAM_DESCRIPTIONS.pattern }),
     ...historyBranchParams()
   }), async (params, signal, ctx, toolName) => {
@@ -2626,7 +2660,7 @@ ${text}`);
     }
     return boundedHistoryResult(formatMessagesCompact(messages));
   }, { renderCall: renderGooseGrepCall, renderResult: renderGooseGrepResult });
-  registerPair("gooseDump_compact", "goose_compact", Type3.Object({
+  registerPair("goosedump_compact", "goose_compact", Type3.Object({
     keep: Type3.Optional(Type3.Integer({
       minimum: 1,
       description: PARAM_DESCRIPTIONS.keep
@@ -2641,7 +2675,7 @@ ${text}`);
     }
     return textResult(compactStartedMessage(keep, result === "queued"));
   }, { renderCall: renderGooseCompactCall, renderResult: renderGooseCompactResult });
-  registerPair("gooseDump_sessions", "goose_sessions", Type3.Object({
+  registerPair("goosedump_sessions", "goose_sessions", Type3.Object({
     action: Type3.Optional(Type3.Union([Type3.Literal("list"), Type3.Literal("delete")], {
       default: "list",
       description: PARAM_DESCRIPTIONS.sessionsAction
@@ -3025,7 +3059,7 @@ async function runSettingsEditor(ctx) {
 async function runSearchPanel(ctx, query, executablePath) {
   const OVERLAY_WIDTH = 84;
   const VIEWPORT = 18;
-  const PAGE_SIZE = 5;
+  const MAX_PAGES = 10;
   const wrapWidth = OVERLAY_WIDTH - 4;
   await ctx.ui.custom((tui, theme, _kb, done) => {
     const target = currentSessionTarget(ctx);
@@ -3038,9 +3072,11 @@ async function runSearchPanel(ctx, query, executablePath) {
     let detailLines = [];
     let detailScroll = 0;
     let detailEntry = null;
+    let truncated = false;
+    const controller = new AbortController;
     async function runSearch() {
       try {
-        const first = await goosedumpSearch(target, query, { scope: "lineage", page: 1 }, undefined, executablePath);
+        const first = await goosedumpSearch(target, query, { scope: "lineage", page: 1 }, controller.signal, executablePath);
         if (first.length === 0) {
           entries = [];
           error = `No results for "${query}"`;
@@ -3048,22 +3084,34 @@ async function runSearchPanel(ctx, query, executablePath) {
           scroll = 0;
           return;
         }
+        const search = (page) => goosedumpSearch(target, query, { scope: "lineage", page }, controller.signal, executablePath);
         const all = [...first];
-        for (let page = 2;page <= 10; page += 1) {
-          const result = await goosedumpSearch(target, query, { scope: "lineage", page }, undefined, executablePath);
-          if (result.length === 0)
-            break;
-          all.push(...result);
-          if (result.length < PAGE_SIZE)
-            break;
+        let lastPage = 1;
+        let complete = false;
+        const second = await search(2);
+        if (second.length < first.length) {
+          all.push(...second);
+          complete = true;
+        } else {
+          all.push(...second);
+          const rest = await Promise.all(Array.from({ length: MAX_PAGES - 2 }, (_unused, index) => search(index + 3)));
+          for (const [index, page] of rest.entries()) {
+            all.push(...page);
+            lastPage = index + 3;
+            if (page.length < first.length) {
+              complete = true;
+              break;
+            }
+          }
         }
+        truncated = !complete && lastPage >= MAX_PAGES;
         entries = all;
         error = null;
         selected = 0;
         scroll = 0;
       } catch (err) {
         entries = [];
-        error = err instanceof Error ? err.message : String(err);
+        error = controller.signal.aborted ? "Search cancelled." : err instanceof Error ? err.message : String(err);
       } finally {
         tui.requestRender();
       }
@@ -3075,7 +3123,7 @@ async function runSearchPanel(ctx, query, executablePath) {
     }
     async function loadDetail(id) {
       try {
-        const messages = await goosedumpShow(target, { ids: [id] }, undefined, executablePath);
+        const messages = await goosedumpShow(target, { ids: [id] }, controller.signal, executablePath);
         const msg = messages.length > 0 ? messages[0] : null;
         detailEntry = msg;
         const entryHeader = msg ? `${colors.accent(colors.bold(`[${msg.id}]`))} ${colors.muted(`${msg.role}:`)}` : "";
@@ -3106,7 +3154,7 @@ async function runSearchPanel(ctx, query, executablePath) {
         }
         return [
           header,
-          ...overlayViewport(colors, width, entries, scroll, VIEWPORT, "↑↓ navigate  enter expand  esc close", (count) => `entr${count === 1 ? "y" : "ies"}`, (entry, absolute) => {
+          ...overlayViewport(colors, width, entries, scroll, VIEWPORT, truncated ? `first ${entries.length} results  ↑↓ navigate  enter expand  esc close` : "↑↓ navigate  enter expand  esc close", (count) => `entr${count === 1 ? "y" : "ies"}`, (entry, absolute) => {
             const isSelected = absolute === selected;
             const cursor = isSelected ? colors.accent(colors.bold("▶")) : " ";
             const idText = isSelected ? colors.accent(colors.bold(entry.id)) : colors.text(entry.id);
@@ -3123,6 +3171,7 @@ async function runSearchPanel(ctx, query, executablePath) {
             tui.requestRender();
             return;
           }
+          controller.abort();
           done(undefined);
           return;
         }
@@ -3561,13 +3610,13 @@ ${renderToolRoutingPolicy()}`
       compaction.syncCompactCounters(ctx);
       compaction.updateStatus(ctx);
     };
-    registerGooseCommand("goose-settings", "Edit goosedump settings", openSettingsEditor);
-    registerGooseCommand("goose-compact", "Compact the current session now; optionally keep the last N user turns", async (args, ctx) => {
+    registerGooseCommand("goosedump-settings", "Edit goosedump settings", openSettingsEditor);
+    registerGooseCommand("goosedump-compact", "Compact the current session now; optionally keep the last N user turns", async (args, ctx) => {
       let keep = null;
       if (args.trim()) {
         const match = args.trim().match(/^keep:(\d+)$/);
         if (!match) {
-          ctx.ui.notify("Usage: /goose-compact [keep:N], where N >= 1", "error");
+          ctx.ui.notify("Usage: /goosedump-compact [keep:N], where N >= 1", "error");
           return;
         }
         keep = Number(match[1]);
@@ -3585,16 +3634,16 @@ ${renderToolRoutingPolicy()}`
         ctx.ui.notify(compactStartedMessage(keep, result === "queued"), "info");
       }
     });
-    registerGooseCommand("goose-search", "Search the current session history", async (args, ctx) => {
+    registerGooseCommand("goosedump-search", "Search the current session history", async (args, ctx) => {
       const query = args.trim() || (await ctx.ui.input("Search query:", ""))?.trim() || "";
       if (query.length === 0)
         return;
       await runSearchPanel(ctx, query, nativeExecutablePath);
     });
-    registerGooseCommand("goose-sessions", "List, resume, or delete sessions for the current working directory", async (_args, ctx) => {
+    registerGooseCommand("goosedump-sessions", "List, resume, or delete sessions for the current working directory", async (_args, ctx) => {
       await runSessionsPanel(ctx, nativeExecutablePath);
     });
-    registerGooseCommand("goose-forget", "Remove a durable memory entry or remembered session", async (args, ctx) => {
+    registerGooseCommand("goosedump-forget", "Remove a durable memory entry or remembered session", async (args, ctx) => {
       if (!isMemoryEnabled(ctx.cwd, projectSettingsTrusted(ctx))) {
         ctx.ui.notify(MEMORY_DISABLED_MESSAGE, "warning");
         return;
@@ -3605,7 +3654,7 @@ ${renderToolRoutingPolicy()}`
       const res = await goosedumpMemoryForget(target, undefined, nativeExecutablePath);
       ctx.ui.notify(res, "info");
     });
-    registerGooseCommand("goose-memory-status", "Show durable memory storage health and type counts", async (_args, ctx) => {
+    registerGooseCommand("goosedump-memory-status", "Show durable memory storage health and type counts", async (_args, ctx) => {
       if (!isMemoryEnabled(ctx.cwd, projectSettingsTrusted(ctx))) {
         ctx.ui.notify(MEMORY_DISABLED_MESSAGE, "warning");
         return;

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "pi-goosedump",
-  "version": "0.13.6",
+  "version": "0.13.8",
   "description": "Pi extension for goosedump session search, durable memory, session management, and compaction",
   "keywords": [
     "compaction",
@@ -37,7 +37,7 @@
     "ci:test": "npm test"
   },
   "dependencies": {
-    "@jarkkojs/goosedump": "^0.13.6"
+    "@jarkkojs/goosedump": "^0.13.8"
   },
   "devDependencies": {
     "@earendil-works/pi-coding-agent": "^0.84.2",