pi-goosedump 0.13.1 → 0.13.2

package/README.md

@@ -1,7 +1,7 @@
 # pi-goosedump
 
 Pi extension for session search, durable memory, session management, and
-compaction. Tools use the `goose_` prefix.
+compaction. Canonical tools use the `gooseDump_` prefix (with legacy `goose_` aliases supported).
 
 ## Install
 
@@ -15,14 +15,14 @@ packaged binary.
 
 ## Tools
 
-- `goose_search` and `goose_grep` find session entries.
-- `goose_get` expands entry IDs to full content.
-- `goose_remember`, `goose_recall`, and `goose_forget` manage durable memory.
-- `goose_memory_status` reports memory storage health.
-- `goose_compact` compacts the current Pi session.
-- `goose_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 `goose_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

package/dist/index.ts

@@ -1714,17 +1714,35 @@ function hideMemoryActivity(ctx) {
 }
 
 // src/policy.ts
-var GOOSE_TOOL_NAMES = [
-  "goose_remember",
-  "goose_recall",
-  "goose_forget",
-  "goose_memory_status",
-  "goose_search",
-  "goose_get",
-  "goose_grep",
-  "goose_compact",
-  "goose_sessions"
+var GOOSEDUMP_TOOL_NAMES = [
+  "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"
+};
+function resolveCanonicalToolName(name) {
+  if (GOOSEDUMP_TOOL_NAMES.includes(name)) {
+    return name;
+  }
+  return LEGACY_TO_CANONICAL_TOOL_NAMES[name];
+}
 var PARAM_DESCRIPTIONS = {
   provider: "Source provider. Defaults to pi. Non-Pi providers have no current session and require an explicit session ID.",
   session: "Session ID. Defaults to the current Pi session; required when provider is not pi.",
@@ -1744,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 goose_search or goose_grep for candidate entry IDs, then goose_get before quoting or acting on prior session content.";
-var PREFER_REMEMBER = "Prefer goose_remember after milestones instead of restating durable facts in prompts.";
-var PREFER_RECALL = "Prefer goose_recall over re-asking the user or re-deriving settled project context.";
-var PREFER_HISTORY = "Prefer goose_search or goose_grep, then goose_get, over replaying full history or guessing prior work.";
-var PREFER_COMPACT = "Prefer goose_compact when context is large, repetitive, or nearing limits; optional keep:N keeps the last N user turns.";
-var PREFER_SESSIONS = "Prefer goose_sessions for cwd session discovery/delete; use goose_forget / goose_memory_status to maintain durable memory.";
-var GOOSE_TOOL_POLICIES = {
-  goose_remember: {
+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: {
     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,
@@ -1761,7 +1779,7 @@ var GOOSE_TOOL_POLICIES = {
       "Defaults to the current Pi session; pass provider/session to learn from another agent session."
     ]
   },
-  goose_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,
@@ -1774,59 +1792,59 @@ var GOOSE_TOOL_POLICIES = {
       "Filter with type when you already know the memory kind (decision, fact, preference, procedure, lesson)."
     ]
   },
-  goose_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 goose_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 goose_memory_status to inspect remaining store health."
+      "Forgotten content leaves a tombstone; use gooseDump_memory_status to inspect remaining store health."
     ]
   },
-  goose_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 goose_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."
     ]
   },
-  goose_search: {
-    description: "Preferred for ranked session-history search. Returns compact entry IDs; expand hits with goose_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 goose_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
     ]
   },
-  goose_get: {
-    description: "Preferred for expanding goose_search/goose_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 goose_get after goose_search or goose_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
     ]
   },
-  goose_grep: {
-    description: "Preferred for glob/substring filtering of session history when ranked search is too fuzzy. Expand hits with goose_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 goose_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
     ]
   },
-  goose_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,
@@ -1837,7 +1855,7 @@ var GOOSE_TOOL_POLICIES = {
       "Successful compaction may queue background memory learning."
     ]
   },
-  goose_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,
@@ -1848,6 +1866,28 @@ var GOOSE_TOOL_POLICIES = {
     ]
   }
 };
+var GOOSE_TOOL_POLICIES = new Proxy(CANONICAL_GOOSE_TOOL_POLICIES, {
+  get(target, prop, receiver) {
+    if (typeof prop === "string" && prop in LEGACY_TO_CANONICAL_TOOL_NAMES) {
+      const canonical = LEGACY_TO_CANONICAL_TOOL_NAMES[prop];
+      return Reflect.get(target, canonical, receiver);
+    }
+    return Reflect.get(target, prop, receiver);
+  },
+  has(target, prop) {
+    return prop in target || typeof prop === "string" && prop in LEGACY_TO_CANONICAL_TOOL_NAMES;
+  },
+  ownKeys(target) {
+    return Reflect.ownKeys(target);
+  },
+  getOwnPropertyDescriptor(target, prop) {
+    return Reflect.getOwnPropertyDescriptor(target, prop);
+  }
+});
+function getGooseToolPolicy(name) {
+  const canonical = resolveCanonicalToolName(name);
+  return canonical ? CANONICAL_GOOSE_TOOL_POLICIES[canonical] : undefined;
+}
 function renderToolRoutingPolicy(options = {}) {
   const title = options.title ?? "Goose tool policy:";
   const seen = new Set;
@@ -1934,22 +1974,108 @@ function upsertTextComponent(lastComponent, text) {
 }
 
 // src/tool-renderers.ts
-function renderGooseRememberCall(args, theme, ...rest) {
+function formatExpandedRecall(content, theme) {
+  const boldFn = typeof theme?.bold === "function" ? theme.bold.bind(theme) : (t) => t;
+  const fg = typeof theme?.fg === "function" ? theme.fg.bind(theme) : (_s, t) => t;
+  return content.split(`
+`).map((line) => {
+    const headMatch = line.match(/^(\s*)(\[mem_[^\]]+\])(\s+.*)$/);
+    if (headMatch) {
+      const [, indent, memId, rest] = headMatch;
+      return `${indent}  ${fg("accent", boldFn(memId))}${rest}`;
+    }
+    if (/^\s*(Match|Evidence|Relationships):/.test(line)) {
+      return fg("muted", boldFn(line.trim()));
+    }
+    return line;
+  }).join(`
+`);
+}
+function formatExpandedTranscriptLines(content, theme) {
+  const boldFn = typeof theme?.bold === "function" ? theme.bold.bind(theme) : (t) => t;
+  const fg = typeof theme?.fg === "function" ? theme.fg.bind(theme) : (_s, t) => t;
+  return content.split(`
+`).map((line) => {
+    const match = line.match(/^(\s*)(\[#[^\]]+\])(\s+([a-zA-Z_-]+):)?(\s*.*)$/);
+    if (match) {
+      const [, indent, id, , role, restText] = match;
+      const styledId = fg("accent", boldFn(id));
+      const styledRole = role ? ` ${fg("muted", `${role}:`)}` : "";
+      const styledRest = restText ? ` ${restText.trimStart()}` : "";
+      return `${indent}  ${styledId}${styledRole}${styledRest}`;
+    }
+    return line;
+  }).join(`
+`);
+}
+function formatExpandedGet(content, theme) {
+  const boldFn = typeof theme?.bold === "function" ? theme.bold.bind(theme) : (t) => t;
+  const fg = typeof theme?.fg === "function" ? theme.fg.bind(theme) : (_s, t) => t;
+  return content.split(`
+`).map((line) => {
+    const headerMatch = line.match(/^(\[#[^\]]+\])\s*([a-zA-Z_-]+)?:?$/);
+    if (headerMatch) {
+      const styledId = fg("accent", boldFn(headerMatch[1]));
+      const styledRole = headerMatch[2] ? ` ${fg("muted", `${headerMatch[2]}:`)}` : "";
+      return `  ${styledId}${styledRole}`;
+    }
+    if (line.trim() === "---") {
+      return fg("dim", "───");
+    }
+    return line ? `  ${line}` : "";
+  }).join(`
+`);
+}
+function formatExpandedSessions(content, theme) {
+  const boldFn = typeof theme?.bold === "function" ? theme.bold.bind(theme) : (t) => t;
+  const fg = typeof theme?.fg === "function" ? theme.fg.bind(theme) : (_s, t) => t;
+  return content.split(`
+`).map((line) => {
+    const match = line.match(/^(\s*)-\s+(\S+)(\s+\(active\))?(\s+\[.*?\])?(.*)$/);
+    if (match) {
+      const [, indent, sessionId, activePart, metaPart, extra] = match;
+      const bullet = fg("dim", "•");
+      const styledId = fg("accent", boldFn(sessionId));
+      const styledActive = activePart ? ` ${fg("accent", boldFn("● active"))}` : "";
+      const styledMeta = metaPart ? ` ${fg("dim", metaPart.trim())}` : "";
+      return `${indent}  ${bullet} ${styledId}${styledActive}${styledMeta}${extra ?? ""}`;
+    }
+    if (line.startsWith("Sessions for ")) {
+      return fg("dim", line);
+    }
+    return line;
+  }).join(`
+`);
+}
+function formatExpandedMemoryStatus(content, theme) {
+  try {
+    const parsed = JSON.parse(content);
+    if (parsed && typeof parsed === "object" && !Array.isArray(parsed)) {
+      const boldFn = typeof theme?.bold === "function" ? theme.bold.bind(theme) : (t) => t;
+      const fg = typeof theme?.fg === "function" ? theme.fg.bind(theme) : (_s, t) => t;
+      return Object.entries(parsed).map(([k, v]) => `  ${fg("muted", k)}: ${fg("accent", boldFn(String(v)))}`).join(`
+`);
+    }
+  } catch {}
+  return content;
+}
+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, "goose_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);
 }
-function renderGooseRememberResult(result, options, theme, ...rest) {
+var renderGooseRememberCall = renderGooseDumpRememberCall;
+function renderGooseDumpRememberResult(result, options, theme, ...rest) {
   const { isPartial, isError, expanded, width } = resolveRenderResultContext(options, rest);
   if (isPartial)
-    return renderPendingResult("pending goose_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: "goose_remember failed",
+      fallback: "gooseDump_remember failed",
       theme
     });
   }
@@ -1961,7 +2087,8 @@ function renderGooseRememberResult(result, options, theme, ...rest) {
   });
   return upsertTextComponent(rest[0]?.lastComponent, clampLineToWidth(summary, width));
 }
-function renderGooseRecallCall(args, theme, ...rest) {
+var renderGooseRememberResult = renderGooseDumpRememberResult;
+function renderGooseDumpRecallCall(args, theme, ...rest) {
   const context = rest[0] ?? {};
   const query = typeof args?.query === "string" ? `"${args.query}"` : '""';
   const flags = [
@@ -1971,16 +2098,22 @@ function renderGooseRecallCall(args, theme, ...rest) {
     args?.history && "history"
   ].filter(Boolean);
   const flagsBadge = flags.length > 0 ? theme.fg("dim", ` [${flags.join(", ")}]`) : "";
-  const text = clampLineToWidth(`${renderToolLabel(theme, "goose_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);
 }
-function renderGooseRecallResult(result, options, theme, ...rest) {
+var renderGooseRecallCall = renderGooseDumpRecallCall;
+function renderGooseDumpRecallResult(result, options, theme, ...rest) {
   const { isPartial, isError, expanded, width } = resolveRenderResultContext(options, rest);
   if (isPartial)
-    return renderPendingResult("pending goose_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: "goose_recall failed", theme });
+    return renderErrorResult(content, {
+      expanded,
+      width,
+      fallback: "gooseDump_recall failed",
+      theme
+    });
   }
   if (content.startsWith("No durable memory") || content.startsWith("Durable memory is disabled") || content.startsWith("Memory recall dropped")) {
     return upsertTextComponent(rest[0]?.lastComponent, clampLineToWidth(summaryLine(content, { theme, style: "dim" }), width));
@@ -1994,46 +2127,56 @@ function renderGooseRecallResult(result, options, theme, ...rest) {
     theme,
     style: "success"
   });
+  const formattedContent = expanded ? formatExpandedRecall(content, theme) : content;
   const body = expanded ? `${summary}
 
-${content}` : summary;
+${formattedContent}` : summary;
   return upsertTextComponent(rest[0]?.lastComponent, clampLinesToWidth(body.split(`
 `), width).join(`
 `));
 }
-function renderGooseForgetCall(args, theme, ...rest) {
+var renderGooseRecallResult = renderGooseDumpRecallResult;
+function renderGooseDumpForgetCall(args, theme, ...rest) {
   const context = rest[0] ?? {};
   const target = args?.target ? String(args.target) : '""';
-  const text = clampLineToWidth(`${renderToolLabel(theme, "goose_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);
 }
-function renderGooseForgetResult(result, options, theme, ...rest) {
+var renderGooseForgetCall = renderGooseDumpForgetCall;
+function renderGooseDumpForgetResult(result, options, theme, ...rest) {
   const { isPartial, isError, expanded, width } = resolveRenderResultContext(options, rest);
   if (isPartial)
-    return renderPendingResult("pending goose_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: "goose_forget failed", theme });
+    return renderErrorResult(content, {
+      expanded,
+      width,
+      fallback: "gooseDump_forget failed",
+      theme
+    });
   }
   const isFailure = content.toLowerCase().includes("error");
   const summary = summaryLine(content, { theme, style: isFailure ? "error" : "success" });
   return upsertTextComponent(rest[0]?.lastComponent, clampLineToWidth(summary, width));
 }
-function renderGooseMemoryStatusCall(_args, theme, ...rest) {
+var renderGooseForgetResult = renderGooseDumpForgetResult;
+function renderGooseDumpMemoryStatusCall(_args, theme, ...rest) {
   const context = rest[0] ?? {};
-  const text = clampLineToWidth(renderToolLabel(theme, "goose_memory_status"), context.width);
+  const text = clampLineToWidth(renderToolLabel(theme, "gooseDump_memory_status"), context.width);
   return upsertTextComponent(context.lastComponent, text);
 }
-function renderGooseMemoryStatusResult(result, options, theme, ...rest) {
+var renderGooseMemoryStatusCall = renderGooseDumpMemoryStatusCall;
+function renderGooseDumpMemoryStatusResult(result, options, theme, ...rest) {
   const { isPartial, isError, expanded, width } = resolveRenderResultContext(options, rest);
   if (isPartial)
-    return renderPendingResult("pending goose_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: "goose_memory_status failed",
+      fallback: "gooseDump_memory_status failed",
       theme
     });
   }
@@ -2053,14 +2196,16 @@ function renderGooseMemoryStatusResult(result, options, theme, ...rest) {
       summaryText = firstLine;
   }
   const summary = summaryLine(summaryText, { hidden: !expanded, theme, style: "success" });
+  const formattedContent = expanded ? formatExpandedMemoryStatus(content, theme) : content;
   const body = expanded ? `${summary}
 
-${content}` : summary;
+${formattedContent}` : summary;
   return upsertTextComponent(rest[0]?.lastComponent, clampLinesToWidth(body.split(`
 `), width).join(`
 `));
 }
-function renderGooseSearchCall(args, theme, ...rest) {
+var renderGooseMemoryStatusResult = renderGooseDumpMemoryStatusResult;
+function renderGooseDumpSearchCall(args, theme, ...rest) {
   const context = rest[0] ?? {};
   const query = typeof args?.query === "string" ? `"${args.query}"` : '""';
   const target = args?.session ? theme.fg("dim", ` in ${args.provider ?? "pi"}:${args.session}`) : "";
@@ -2069,16 +2214,22 @@ function renderGooseSearchCall(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, "goose_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);
 }
-function renderGooseSearchResult(result, options, theme, ...rest) {
+var renderGooseSearchCall = renderGooseDumpSearchCall;
+function renderGooseDumpSearchResult(result, options, theme, ...rest) {
   const { isPartial, isError, expanded, width } = resolveRenderResultContext(options, rest);
   if (isPartial)
-    return renderPendingResult("pending goose_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: "goose_search failed", theme });
+    return renderErrorResult(content, {
+      expanded,
+      width,
+      fallback: "gooseDump_search failed",
+      theme
+    });
   }
   if (content.startsWith("No results")) {
     return upsertTextComponent(rest[0]?.lastComponent, clampLineToWidth(summaryLine(content, { theme, style: "dim" }), width));
@@ -2094,28 +2245,31 @@ function renderGooseSearchResult(result, options, theme, ...rest) {
     theme,
     style: "success"
   });
+  const formattedContent = expanded ? formatExpandedTranscriptLines(content, theme) : content;
   const body = expanded ? `${summary}
 
-${content}` : summary;
+${formattedContent}` : summary;
   return upsertTextComponent(rest[0]?.lastComponent, clampLinesToWidth(body.split(`
 `), width).join(`
 `));
 }
-function renderGooseGetCall(args, theme, ...rest) {
+var renderGooseSearchResult = renderGooseDumpSearchResult;
+function renderGooseDumpGetCall(args, theme, ...rest) {
   const context = rest[0] ?? {};
   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, "goose_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);
 }
-function renderGooseGetResult(result, options, theme, ...rest) {
+var renderGooseGetCall = renderGooseDumpGetCall;
+function renderGooseDumpGetResult(result, options, theme, ...rest) {
   const { isPartial, isError, expanded, width } = resolveRenderResultContext(options, rest);
   if (isPartial)
-    return renderPendingResult("pending goose_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: "goose_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));
@@ -2128,29 +2282,37 @@ function renderGooseGetResult(result, options, theme, ...rest) {
     theme,
     style: "success"
   });
+  const formattedContent = expanded ? formatExpandedGet(content, theme) : content;
   const body = expanded ? `${summary}
 
-${content}` : summary;
+${formattedContent}` : summary;
   return upsertTextComponent(rest[0]?.lastComponent, clampLinesToWidth(body.split(`
 `), width).join(`
 `));
 }
-function renderGooseGrepCall(args, theme, ...rest) {
+var renderGooseGetResult = renderGooseDumpGetResult;
+function renderGooseDumpGrepCall(args, theme, ...rest) {
   const context = rest[0] ?? {};
   const pattern = typeof args?.pattern === "string" ? `/${args.pattern}/` : "//";
   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, "goose_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);
 }
-function renderGooseGrepResult(result, options, theme, ...rest) {
+var renderGooseGrepCall = renderGooseDumpGrepCall;
+function renderGooseDumpGrepResult(result, options, theme, ...rest) {
   const { isPartial, isError, expanded, width } = resolveRenderResultContext(options, rest);
   if (isPartial)
-    return renderPendingResult("pending goose_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: "goose_grep failed", theme });
+    return renderErrorResult(content, {
+      expanded,
+      width,
+      fallback: "gooseDump_grep failed",
+      theme
+    });
   }
   if (content.startsWith("No matches")) {
     return upsertTextComponent(rest[0]?.lastComponent, clampLineToWidth(summaryLine(content, { theme, style: "dim" }), width));
@@ -2160,50 +2322,60 @@ function renderGooseGrepResult(result, options, theme, ...rest) {
 `).filter((l) => l.trim().length > 0).length;
   const unit = count === 1 ? "match" : "matches";
   const summary = summaryLine(`${count} ${unit}`, { hidden: !expanded, theme, style: "success" });
+  const formattedContent = expanded ? formatExpandedTranscriptLines(content, theme) : content;
   const body = expanded ? `${summary}
 
-${content}` : summary;
+${formattedContent}` : summary;
   return upsertTextComponent(rest[0]?.lastComponent, clampLinesToWidth(body.split(`
 `), width).join(`
 `));
 }
-function renderGooseCompactCall(args, theme, ...rest) {
+var renderGooseGrepResult = renderGooseDumpGrepResult;
+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, "goose_compact")}${flagsBadge}`, context.width);
+  const text = clampLineToWidth(`${renderToolLabel(theme, "gooseDump_compact")}${flagsBadge}`, context.width);
   return upsertTextComponent(context.lastComponent, text);
 }
-function renderGooseCompactResult(result, options, theme, ...rest) {
+var renderGooseCompactCall = renderGooseDumpCompactCall;
+function renderGooseDumpCompactResult(result, options, theme, ...rest) {
   const { isPartial, isError, expanded, width } = resolveRenderResultContext(options, rest);
   if (isPartial)
-    return renderPendingResult("pending goose_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: "goose_compact failed", theme });
+    return renderErrorResult(content, {
+      expanded,
+      width,
+      fallback: "gooseDump_compact failed",
+      theme
+    });
   }
   const style = content.includes("already in progress") ? "warning" : content.includes("Nothing to compact") ? "dim" : "success";
   const summary = summaryLine(content.split(`
 `)[0] || "compaction completed", { theme, style });
   return upsertTextComponent(rest[0]?.lastComponent, clampLineToWidth(summary, width));
 }
-function renderGooseSessionsCall(args, theme, ...rest) {
+var renderGooseCompactResult = renderGooseDumpCompactResult;
+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, "goose_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);
 }
-function renderGooseSessionsResult(result, options, theme, ...rest) {
+var renderGooseSessionsCall = renderGooseDumpSessionsCall;
+function renderGooseDumpSessionsResult(result, options, theme, ...rest) {
   const { isPartial, isError, expanded, width } = resolveRenderResultContext(options, rest);
   if (isPartial)
-    return renderPendingResult("pending goose_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: "goose_sessions failed",
+      fallback: "gooseDump_sessions failed",
       theme
     });
   }
@@ -2223,13 +2395,15 @@ function renderGooseSessionsResult(result, options, theme, ...rest) {
     theme,
     style: "success"
   });
+  const formattedContent = expanded ? formatExpandedSessions(content, theme) : content;
   const body = expanded ? `${summary}
 
-${content}` : summary;
+${formattedContent}` : summary;
   return upsertTextComponent(rest[0]?.lastComponent, clampLinesToWidth(body.split(`
 `), width).join(`
 `));
 }
+var renderGooseSessionsResult = renderGooseDumpSessionsResult;
 
 // src/tools.ts
 function memoryDisabledResult() {
@@ -2282,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 goose_get with fewer IDs or a narrower goose_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";
@@ -2297,7 +2471,10 @@ function resolveHistoryTarget(ctx, tool, params) {
   };
 }
 function gooseToolMeta(name) {
-  const policy = GOOSE_TOOL_POLICIES[name];
+  const policy = getGooseToolPolicy(name);
+  if (!policy) {
+    throw new Error(`Unknown goose tool policy: ${name}`);
+  }
   return {
     name,
     label: name,
@@ -2312,7 +2489,7 @@ function defineGooseTool(name, parameters, handler, renderers) {
     parameters,
     async execute(_id, params, signal, _onUpdate, ctx) {
       try {
-        return await handler(params, signal, ctx);
+        return await handler(params, signal, ctx, name);
       } catch (err) {
         return goosedumpErrorResult(err);
       }
@@ -2323,11 +2500,15 @@ function defineGooseTool(name, parameters, handler, renderers) {
 }
 function registerGooseTools(pi, deps) {
   const { nativeExecutablePath, enqueueRemember, requestCompaction, runNonCompactInference } = deps;
-  pi.registerTool(defineGooseTool("goose_remember", Type3.Object({ ...historyTargetParams() }), async (params, _signal, ctx) => {
+  function registerPair(canonicalName, legacyName, parameters, handler, renderers) {
+    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) => {
     const disabled = requireMemoryEnabled(ctx);
     if (disabled)
       return disabled;
-    const resolved = resolveHistoryTarget(ctx, "goose_remember", params);
+    const resolved = resolveHistoryTarget(ctx, toolName, params);
     if (!resolved.ok)
       return resolved.result;
     const accepted = enqueueRemember(resolved.target, ctx, (message) => {
@@ -2336,8 +2517,8 @@ 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 }));
-  pi.registerTool(defineGooseTool("goose_recall", Type3.Object({
+  }, { renderCall: renderGooseRememberCall, renderResult: renderGooseRememberResult });
+  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({
@@ -2373,28 +2554,28 @@ function registerGooseTools(pi, deps) {
     if (hits.length === 0)
       return textResult(`No durable memory for "${params.query}"`);
     return textResult(formatMemoryHits(hits));
-  }, { renderCall: renderGooseRecallCall, renderResult: renderGooseRecallResult }));
-  pi.registerTool(defineGooseTool("goose_forget", Type3.Object({
+  }, { renderCall: renderGooseRecallCall, renderResult: renderGooseRecallResult });
+  registerPair("gooseDump_forget", "goose_forget", Type3.Object({
     target: Type3.String({
       description: PARAM_DESCRIPTIONS.forgetTarget
     })
-  }), async (params, signal, ctx) => {
+  }), async (params, signal, ctx, toolName) => {
     const disabled = requireMemoryEnabled(ctx);
     if (disabled)
       return disabled;
     if (params.target.trim().length === 0) {
-      return textResult("goose_forget error: target is required");
+      return textResult(`${toolName} error: target is required`);
     }
     const res = await goosedumpMemoryForget(params.target.trim(), signal, nativeExecutablePath);
     return textResult(res);
-  }, { renderCall: renderGooseForgetCall, renderResult: renderGooseForgetResult }));
-  pi.registerTool(defineGooseTool("goose_memory_status", Type3.Object({}), async (_params, signal, ctx) => {
+  }, { renderCall: renderGooseForgetCall, renderResult: renderGooseForgetResult });
+  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 }));
-  pi.registerTool(defineGooseTool("goose_search", Type3.Object({
+  }, { renderCall: renderGooseMemoryStatusCall, renderResult: renderGooseMemoryStatusResult });
+  registerPair("gooseDump_search", "goose_search", Type3.Object({
     query: Type3.String({ description: PARAM_DESCRIPTIONS.searchQuery }),
     ...historyBranchParams(),
     page: Type3.Optional(Type3.Integer({
@@ -2402,8 +2583,8 @@ function registerGooseTools(pi, deps) {
       default: 1,
       description: PARAM_DESCRIPTIONS.page
     }))
-  }), async (params, signal, ctx) => {
-    const resolved = resolveHistoryTarget(ctx, "goose_search", params);
+  }), async (params, signal, ctx, toolName) => {
+    const resolved = resolveHistoryTarget(ctx, toolName, params);
     if (!resolved.ok)
       return resolved.result;
     const page = params.page ?? 1;
@@ -2415,15 +2596,15 @@ function registerGooseTools(pi, deps) {
     return textResult(`Results for "${params.query}" (page ${page}):
 
 ${text}`);
-  }, { renderCall: renderGooseSearchCall, renderResult: renderGooseSearchResult }));
-  pi.registerTool(defineGooseTool("goose_get", Type3.Object({
+  }, { renderCall: renderGooseSearchCall, renderResult: renderGooseSearchResult });
+  registerPair("gooseDump_get", "goose_get", Type3.Object({
     ids: Type3.Array(Type3.String(), {
       minItems: 1,
       description: PARAM_DESCRIPTIONS.entryIds
     }),
     ...historyBranchParams()
-  }), async (params, signal, ctx) => {
-    const resolved = resolveHistoryTarget(ctx, "goose_get", params);
+  }), async (params, signal, ctx, toolName) => {
+    const resolved = resolveHistoryTarget(ctx, toolName, params);
     if (!resolved.ok)
       return resolved.result;
     const messages = await goosedumpShow(resolved.target, { scope: resolved.scope, ids: params.ids }, signal, nativeExecutablePath);
@@ -2431,12 +2612,12 @@ ${text}`);
       return textResult("No entries found for the given IDs.");
     }
     return boundedHistoryResult(formatMessagesFull(messages));
-  }, { renderCall: renderGooseGetCall, renderResult: renderGooseGetResult }));
-  pi.registerTool(defineGooseTool("goose_grep", Type3.Object({
+  }, { renderCall: renderGooseGetCall, renderResult: renderGooseGetResult });
+  registerPair("gooseDump_grep", "goose_grep", Type3.Object({
     pattern: Type3.String({ description: PARAM_DESCRIPTIONS.pattern }),
     ...historyBranchParams()
-  }), async (params, signal, ctx) => {
-    const resolved = resolveHistoryTarget(ctx, "goose_grep", params);
+  }), async (params, signal, ctx, toolName) => {
+    const resolved = resolveHistoryTarget(ctx, toolName, params);
     if (!resolved.ok)
       return resolved.result;
     const messages = await goosedumpGrep(resolved.target, params.pattern, { scope: resolved.scope }, signal, nativeExecutablePath);
@@ -2444,8 +2625,8 @@ ${text}`);
       return textResult(`No matches for "${params.pattern}"`);
     }
     return boundedHistoryResult(formatMessagesCompact(messages));
-  }, { renderCall: renderGooseGrepCall, renderResult: renderGooseGrepResult }));
-  pi.registerTool(defineGooseTool("goose_compact", Type3.Object({
+  }, { renderCall: renderGooseGrepCall, renderResult: renderGooseGrepResult });
+  registerPair("gooseDump_compact", "goose_compact", Type3.Object({
     keep: Type3.Optional(Type3.Integer({
       minimum: 1,
       description: PARAM_DESCRIPTIONS.keep
@@ -2459,8 +2640,8 @@ ${text}`);
       return textResult("Nothing to compact (session too small).");
     }
     return textResult(compactStartedMessage(keep, result === "queued"));
-  }, { renderCall: renderGooseCompactCall, renderResult: renderGooseCompactResult }));
-  pi.registerTool(defineGooseTool("goose_sessions", Type3.Object({
+  }, { renderCall: renderGooseCompactCall, renderResult: renderGooseCompactResult });
+  registerPair("gooseDump_sessions", "goose_sessions", Type3.Object({
     action: Type3.Optional(Type3.Union([Type3.Literal("list"), Type3.Literal("delete")], {
       default: "list",
       description: PARAM_DESCRIPTIONS.sessionsAction
@@ -2469,7 +2650,7 @@ ${text}`);
     session: Type3.Optional(Type3.String({
       description: PARAM_DESCRIPTIONS.sessionsDeleteId
     }))
-  }), async (params, signal, ctx) => {
+  }), async (params, signal, ctx, toolName) => {
     const action = params.action ?? "list";
     const provider = params.provider ?? "pi";
     const currentTarget = currentSessionTarget(ctx);
@@ -2477,7 +2658,7 @@ ${text}`);
     const cwdSessions = sessions.filter((s) => s.cwd === ctx.cwd && s.provider === provider);
     if (action === "delete") {
       if (!params.session) {
-        return textResult("goose_sessions error: session ID is required for action: delete");
+        return textResult(`${toolName} error: session ID is required for action: delete`);
       }
       const target = formatTarget(provider, params.session);
       if (!cwdSessions.some((session) => session.id === params.session)) {
@@ -2504,7 +2685,7 @@ ${text}`);
 
 ${lines.join(`
 `)}`);
-  }, { renderCall: renderGooseSessionsCall, renderResult: renderGooseSessionsResult }));
+  }, { renderCall: renderGooseSessionsCall, renderResult: renderGooseSessionsResult });
 }
 
 // src/tui.ts
@@ -2588,7 +2769,7 @@ class NumberInputSubmenu {
   }
   render(width) {
     return [
-      this.hint(`  ${this.title} · current ${this.currentValue ?? "inherit"} · ${this.min}-${this.max}`),
+      `  \x1B[1m${this.title}\x1B[22m ${this.hint(`· current ${this.currentValue ?? "inherit"} · ${this.min}-${this.max}`)}`,
       "",
       ...this.input.render(width),
       "",
@@ -2609,14 +2790,15 @@ function overlayColors(theme) {
     text: (s) => theme.fg("text", s),
     dim: (s) => theme.fg("dim", s),
     muted: (s) => theme.fg("muted", s),
-    bold: (s) => theme.bold?.(s) ?? s
+    bold: (s) => theme.bold?.(s) ?? s,
+    error: (s) => theme.fg("error", s)
   };
 }
 function overlayInnerWidth(width) {
   return Math.max(1, width - 4);
 }
 function overlayHeader(colors, width, title) {
-  const styled = colors.accent(` ${title} `);
+  const styled = colors.accent(colors.bold(` ${title} `));
   const fill = colors.borderFg("─".repeat(Math.max(0, width - 4 - visibleWidth2(styled))));
   return `${colors.borderFg("╭─")}${styled}${fill}${colors.borderFg("─╮")}`;
 }
@@ -2625,8 +2807,9 @@ function overlayFooter(colors, width) {
 }
 function overlayError(colors, width, message) {
   const innerW = overlayInnerWidth(width);
+  const errorFn = colors.error ?? colors.muted;
   return [
-    makeRow(colors.muted(message), innerW, colors.border),
+    makeRow(errorFn(colors.bold(message)), innerW, colors.border),
     makeRow(colors.dim("esc close"), innerW, colors.border)
   ];
 }
@@ -2760,7 +2943,7 @@ async function runSettingsEditor(ctx) {
         } else if (tab === "help") {
           const shortcutWidth = Math.max(visibleWidth2("Shortcut"), ...helpRows.map(([shortcut]) => visibleWidth2(shortcut)));
           const descriptionWidth = Math.max(1, innerW - shortcutWidth - 4);
-          content.push(dim(`  ${pad("Shortcut", shortcutWidth)}  Description`), ...helpRows.map(([shortcut, description]) => `  ${accent(pad(shortcut, shortcutWidth))}  ${text(truncateToWidth2(description, descriptionWidth))}`));
+          content.push(`  ${bold(text(pad("Shortcut", shortcutWidth)))}  ${bold(text("Description"))}`, dim(`  ${"─".repeat(shortcutWidth)}  ${"─".repeat(Math.min(descriptionWidth, 40))}`), ...helpRows.map(([shortcut, description]) => `  ${accent(bold(pad(shortcut, shortcutWidth)))}  ${text(truncateToWidth2(description, descriptionWidth))}`));
         } else {
           const labelWidth = Math.max(...specs.map(({ key }) => visibleWidth2(settingLabel(key))));
           for (const [index, entry] of specs.entries()) {
@@ -2768,11 +2951,16 @@ async function runSettingsEditor(ctx) {
             const inherited = projectSettings[entry.key] === undefined;
             const value = projectSettings[entry.key] ?? globalSettings[entry.key];
             const valueText = `[ ${formatSettingDisplayValue(entry.key, value)} ]`;
-            const renderedValue = inherited ? dim(valueText) : selected ? accent(valueText) : text(valueText);
-            const cursor = selected ? accent("›") : " ";
-            content.push(`${cursor} ${text(pad(settingLabel(entry.key), labelWidth))}  ${renderedValue}`);
+            const renderedValue = inherited ? dim(valueText) : selected ? accent(bold(valueText)) : text(valueText);
+            const cursor = selected ? accent(bold("›")) : " ";
+            const label = pad(settingLabel(entry.key), labelWidth);
+            const renderedLabel = selected ? text(bold(label)) : text(label);
+            content.push(`${cursor} ${renderedLabel}  ${renderedValue}`);
           }
         }
+        if (!editor) {
+          content.push("", dim("  tab switch tab  ·  ↑↓ navigate  ·  enter edit  ·  esc close"));
+        }
         return [
           overlayHeader(colors, width, "Goosedump Settings"),
           ...content.map((line) => makeRow(line, innerW, colors.border)),
@@ -2849,6 +3037,7 @@ async function runSearchPanel(ctx, query, executablePath) {
     let scroll = 0;
     let detailLines = [];
     let detailScroll = 0;
+    let detailEntry = null;
     async function runSearch() {
       try {
         const first = await goosedumpSearch(target, query, { scope: "lineage", page: 1 }, undefined, executablePath);
@@ -2887,8 +3076,12 @@ async function runSearchPanel(ctx, query, executablePath) {
     async function loadDetail(id) {
       try {
         const messages = await goosedumpShow(target, { ids: [id] }, undefined, executablePath);
-        const content = messages.length > 0 ? messages[0].content : "No content for this entry.";
-        detailLines = wrapTextWithAnsi(content, wrapWidth);
+        const msg = messages.length > 0 ? messages[0] : null;
+        detailEntry = msg;
+        const entryHeader = msg ? `${colors.accent(colors.bold(`[${msg.id}]`))} ${colors.muted(`${msg.role}:`)}` : "";
+        const content = msg ? msg.content : "No content for this entry.";
+        const wrapped = wrapTextWithAnsi(content, wrapWidth);
+        detailLines = entryHeader ? [entryHeader, "", ...wrapped] : wrapped;
         detailScroll = 0;
         mode = "detail";
       } catch (err) {
@@ -2900,7 +3093,7 @@ async function runSearchPanel(ctx, query, executablePath) {
     }
     return {
       render(width) {
-        const header = overlayHeader(colors, width, `Goosedump search: ${truncateToWidth2(query, 44)}`);
+        const header = mode === "detail" && detailEntry ? overlayHeader(colors, width, `Goosedump Entry: [${detailEntry.id}] (${detailEntry.role})`) : overlayHeader(colors, width, `Goosedump search: ${truncateToWidth2(query, 44)}`);
         if (error) {
           return [header, ...overlayError(colors, width, error), overlayFooter(colors, width)];
         }
@@ -2915,8 +3108,8 @@ async function runSearchPanel(ctx, query, executablePath) {
           header,
           ...overlayViewport(colors, width, entries, scroll, VIEWPORT, "↑↓ navigate  enter expand  esc close", (count) => `entr${count === 1 ? "y" : "ies"}`, (entry, absolute) => {
             const isSelected = absolute === selected;
-            const cursor = isSelected ? colors.accent("▶") : " ";
-            const idText = isSelected ? colors.accent(entry.id) : colors.text(entry.id);
+            const cursor = isSelected ? colors.accent(colors.bold("▶")) : " ";
+            const idText = isSelected ? colors.accent(colors.bold(entry.id)) : colors.text(entry.id);
             const snippet = compactLine(entry.content);
             return ` ${cursor} ${idText} ${colors.muted(entry.role)} ${colors.dim(snippet)}`;
           }),
@@ -3164,11 +3357,11 @@ async function runSessionsPanel(ctx, executablePath) {
             const isSelected = absolute === selected;
             const isActive = currentTarget === formatTarget(s.provider, s.id);
             const key = `${s.provider}:${s.id}`;
-            const cursor = isSelected ? colors.accent("▶") : " ";
+            const cursor = isSelected ? colors.accent(colors.bold("▶")) : " ";
             const indent = " ".repeat(row.depth * 2);
             const toggle = row.hasChildren ? expandedNodes.has(key) ? colors.muted("−") : colors.muted("+") : " ";
-            const activeMark = isActive ? colors.accent("(active)") : "";
-            const idText = isSelected ? colors.accent(s.id) : colors.text(s.id);
+            const activeMark = isActive ? colors.accent(colors.bold("● active")) : "";
+            const idText = isSelected ? colors.accent(colors.bold(s.id)) : colors.text(s.id);
             const providerTag = colors.muted(`[${s.provider}]`);
             const countTag = colors.dim(`${s.count} entries`);
             const dateTag = s.from ? colors.dim(new Date(s.from).toLocaleDateString()) : "";

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "pi-goosedump",
-  "version": "0.13.1",
+  "version": "0.13.2",
   "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.1"
+    "@jarkkojs/goosedump": "^0.13.2"
   },
   "devDependencies": {
     "@earendil-works/pi-coding-agent": "^0.84.2",