pi-goosedump 0.13.5 → 0.13.7

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;
@@ -740,7 +740,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);
 }
@@ -1715,27 +1715,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 +1762,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 +1779,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 +1792,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 +1855,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 +2062,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 +2098,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 +2139,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 +2163,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 +2214,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 +2259,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 +2297,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 +2335,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 +2362,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
     });
   }
@@ -2456,7 +2456,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 +2504,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 +2518,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 +2555,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 +2569,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,7 +2597,7 @@ 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,
       description: PARAM_DESCRIPTIONS.entryIds
@@ -2613,7 +2613,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 +2626,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 +2641,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
@@ -3561,13 +3561,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 +3585,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 +3605,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.5",
+  "version": "0.13.7",
   "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.5"
+    "@jarkkojs/goosedump": "^0.13.7"
   },
   "devDependencies": {
     "@earendil-works/pi-coding-agent": "^0.84.2",