pi-goosedump 0.12.0 → 0.12.1

package/README.md

@@ -27,11 +27,13 @@ report that they are unavailable.
   provenance within a 4,096-byte/token-safe output budget.
 - **`goose_compact`** starts asynchronous compaction of the current Pi session.
   Set `keep` to preserve the last N user turns verbatim.
-
-The session-history tools accept an optional `provider` (`pi` by default),
-`session`, and `scope` (`lineage` by default or `all`). The current Pi session
-is used when both provider and session are omitted. Non-Pi providers require an
-explicit session ID. Targets sent to goosedump are always provider-qualified.
+- **`goose_sessions`** lists or deletes saved sessions scoped to the current working directory. Deleting the active session is safety-blocked.
+- **`goose_forget`** deletes stored durable memory by content hash or provider:id. Writes durable tombstones to prevent re-learning.
+- **`goose_memory_status`** inspects durable-memory counts and indexing health.
+  The session-history tools accept an optional `provider` (`pi` by default),
+  `session`, and `scope` (`lineage` by default or `all`). The current Pi session
+  is used when both provider and session are omitted. Non-Pi providers require an
+  explicit session ID. Targets sent to goosedump are always provider-qualified.
 
 Examples:
 
@@ -43,6 +45,9 @@ goose_grep({ pattern: "*timeout*" })
 goose_recall({ query: "prior architecture decision" })
 goose_recall({ query: "database", type: "decision" })
 goose_compact({ keep: 2 })
+goose_sessions({ action: "list" })
+goose_forget({ hash: "a1b2c3d4..." })
+goose_memory_status({})
 ```
 
 ## Commands
@@ -51,6 +56,9 @@ goose_compact({ keep: 2 })
   an inline prompt; selecting a result expands it.
 - **`/goose-compact [keep:N]`** compacts now. With `keep:N`, the last N user
   turns remain verbatim; without it, Pi chooses the cut point.
+- **`/goose-sessions`** lists or deletes saved sessions scoped to the current working directory.
+- **`/goose-forget [hash|provider:id]`** deletes stored durable memory by hash or session.
+- **`/goose-memory-status`** displays durable-memory storage health and indexing counts.
 - **`/goose-settings`** edits global and project compaction settings.
 
 ## Settings
@@ -70,8 +78,9 @@ Optional settings live under `goosedump` in:
 
 `turnsBeforeCompact` is an integer from 0 to 255. `0` disables scheduled
 compaction. The countdown is restored when a session resumes and appears in the
-footer as hexadecimal: `GD: 0A` means ten turns remain, `GD: 00` is ready to
-compact, and `GD: --` is disabled. Clearing the project value restores the
+footer with a status dot (green when >25% turns remain, yellow when ≤25%, red when ≤12.5%)
+followed by hexadecimal turn countdown: `● GD: 0A` means ten turns remain, `● GD: 00` is ready
+to compact, and `● GD: --` is disabled. Clearing the project value restores the
 global setting.
 
 ## Compaction behavior

package/dist/index.ts

@@ -366,18 +366,6 @@ function goosedumpUnavailableResult() {
 function compactStartedMessage(keep) {
   return keep !== null ? `Compacting with goosedump; keeping the last ${keep} user turn${keep === 1 ? "" : "s"}.` : "Compacting with goosedump up to Pi's token-based cut.";
 }
-function runGoosedump(args) {
-  try {
-    return execFileSync(process.execPath, [resolveGoosedumpBinary(), ...args], {
-      encoding: "utf-8",
-      maxBuffer: 16 * 1024 * 1024
-    });
-  } catch (err) {
-    const stderr = err.stderr?.trim();
-    const message = stderr ?? (err instanceof Error ? err.message : String(err));
-    throw new Error(message);
-  }
-}
 function runGoosedumpAsync(args, signal, executablePath = resolveNativeGoosedumpBinary()) {
   return new Promise((resolve, reject) => {
     execFile(executablePath, args, {
@@ -419,24 +407,27 @@ function appendScope(args, scope) {
   if (scope === "all")
     args.push("--all");
 }
-function goosedumpSearch(target, query, options = {}) {
+async function goosedumpSearch(target, query, options = {}, signal, executablePath) {
   const args = ["session", "search", target, query, "--as", "pi"];
   appendScope(args, options.scope);
   if (options.page)
     args.push("--page", String(options.page));
-  return parsePiMessages(runGoosedump(args));
+  const output = await runGoosedumpAsync(args, signal, executablePath);
+  return parsePiMessages(output.stdout);
 }
-function goosedumpGrep(target, pattern, options = {}) {
+async function goosedumpGrep(target, pattern, options = {}, signal, executablePath) {
   const args = ["session", "find", target, pattern, "--as", "pi"];
   appendScope(args, options.scope);
-  return parsePiMessages(runGoosedump(args));
+  const output = await runGoosedumpAsync(args, signal, executablePath);
+  return parsePiMessages(output.stdout);
 }
-function goosedumpShow(target, options = {}) {
+async function goosedumpShow(target, options = {}, signal, executablePath) {
   const args = ["session", "show", target, "--as", "pi"];
   appendScope(args, options.scope);
   for (const id of options.ids ?? [])
     args.push("--entry", id);
-  return parsePiMessages(runGoosedump(args));
+  const output = await runGoosedumpAsync(args, signal, executablePath);
+  return parsePiMessages(output.stdout);
 }
 async function goosedumpRecall(query, options = {}, signal, executablePath) {
   const args = ["memory", "search", query, "--limit", String(options.limit ?? 5)];
@@ -449,6 +440,28 @@ async function goosedumpRecall(query, options = {}, signal, executablePath) {
   const output = await runGoosedumpAsync(args, signal, executablePath);
   return { hits: parseMemoryHits(output.stdout), warning: output.stderr.trim() };
 }
+async function goosedumpMemoryForget(target, signal, executablePath) {
+  const output = await runGoosedumpAsync(["memory", "forget", target], signal, executablePath);
+  return output.stdout.trim() || `Removed memory target: ${target}`;
+}
+async function goosedumpMemoryStatus(signal, executablePath) {
+  const output = await runGoosedumpAsync(["memory", "status"], signal, executablePath);
+  return output.stdout.trim();
+}
+async function goosedumpListSessions(signal, executablePath) {
+  const args = ["session", "list", "--json"];
+  const output = await runGoosedumpAsync(args, signal, executablePath);
+  try {
+    const parsed = JSON.parse(output.stdout);
+    return Array.isArray(parsed) ? parsed : [];
+  } catch {
+    return [];
+  }
+}
+async function goosedumpRemoveSession(target, signal, executablePath) {
+  const args = ["session", "remove", target, "--yes"];
+  await runGoosedumpAsync(args, signal, executablePath);
+}
 function resolveTarget(ctx, provider, contextId) {
   if (contextId)
     return formatTarget(provider, contextId);
@@ -896,9 +909,9 @@ async function runSearchPanel(ctx, query) {
     let scroll = 0;
     let detailLines = [];
     let detailScroll = 0;
-    function runSearch() {
+    async function runSearch() {
       try {
-        const first = goosedumpSearch(target, query, { scope: "lineage", page: 1 });
+        const first = await goosedumpSearch(target, query, { scope: "lineage", page: 1 });
         if (first.length === 0) {
           entries = [];
           error = `No results for "${query}"`;
@@ -908,7 +921,7 @@ async function runSearchPanel(ctx, query) {
         }
         const all = [...first];
         for (let page = 2;page <= 10; page += 1) {
-          const result = goosedumpSearch(target, query, { scope: "lineage", page });
+          const result = await goosedumpSearch(target, query, { scope: "lineage", page });
           if (result.length === 0)
             break;
           all.push(...result);
@@ -929,9 +942,9 @@ async function runSearchPanel(ctx, query) {
     } else {
       runSearch();
     }
-    function loadDetail(id) {
+    async function loadDetail(id) {
       try {
-        const messages = goosedumpShow(target, { ids: [id] });
+        const messages = await goosedumpShow(target, { ids: [id] });
         const content = messages.length > 0 ? messages[0].content : "No content for this entry.";
         detailLines = wrapTextWithAnsi(content, wrapWidth);
         detailScroll = 0;
@@ -1071,6 +1084,176 @@ async function runSearchPanel(ctx, query) {
     }
   });
 }
+async function runSessionsPanel(ctx, executablePath) {
+  const OVERLAY_WIDTH = 84;
+  const VIEWPORT = 18;
+  await ctx.ui.custom((tui, theme, _kb, done) => {
+    const currentTarget = currentSessionTarget(ctx);
+    const borderFg = (s) => theme.fg("border", s);
+    const border = theme.fg("border", "│");
+    const accent = (s) => theme.fg("accent", s);
+    const text = (s) => theme.fg("text", s);
+    const dim = (s) => theme.fg("dim", s);
+    const muted = (s) => theme.fg("muted", s);
+    let sessions = [];
+    let error = null;
+    let selected = 0;
+    let scroll = 0;
+    async function loadSessions() {
+      try {
+        const all = await goosedumpListSessions(undefined, executablePath);
+        const cwdSessions = all.filter((s) => s.cwd === ctx.cwd);
+        cwdSessions.sort((a, b) => {
+          const timeA = a.from ? new Date(a.from).getTime() : 0;
+          const timeB = b.from ? new Date(b.from).getTime() : 0;
+          return timeB - timeA;
+        });
+        sessions = cwdSessions;
+        if (sessions.length === 0) {
+          error = "No sessions found for current directory.";
+        } else {
+          error = null;
+        }
+        selected = Math.min(selected, Math.max(0, sessions.length - 1));
+        scroll = Math.min(scroll, Math.max(0, sessions.length - VIEWPORT));
+        tui.requestRender();
+      } catch (err) {
+        sessions = [];
+        error = err instanceof Error ? err.message : String(err);
+        tui.requestRender();
+      }
+    }
+    loadSessions();
+    async function deleteSelected() {
+      const s = sessions[selected];
+      if (!s)
+        return;
+      const target = formatTarget(s.provider, s.id);
+      if (currentTarget === target) {
+        ctx.ui.notify("Cannot delete the active session.", "error");
+        return;
+      }
+      try {
+        await goosedumpRemoveSession(target, undefined, executablePath);
+        ctx.ui.notify(`Deleted session ${s.id}`, "info");
+        await loadSessions();
+      } catch (err) {
+        const message = err instanceof Error ? err.message : String(err);
+        ctx.ui.notify(`Failed to delete session: ${message}`, "error");
+      }
+    }
+    return {
+      render(width) {
+        const innerW = width - 4;
+        const lines = [];
+        const title = accent(" Goosedump Sessions ");
+        const topFill = borderFg("─".repeat(Math.max(0, width - 4 - visibleWidth(title))));
+        lines.push(`${borderFg("╭─")}${title}${topFill}${borderFg("─╮")}`);
+        if (error) {
+          lines.push(makeRow(muted(error), innerW, border));
+          lines.push(makeRow(dim("esc close"), innerW, border));
+          lines.push(`${borderFg("╰")}${borderFg("─".repeat(width - 2))}${borderFg("╯")}`);
+          return lines;
+        }
+        const maxScroll = Math.max(0, sessions.length - VIEWPORT);
+        const clampScroll = Math.min(scroll, maxScroll);
+        const window = sessions.slice(clampScroll, clampScroll + VIEWPORT);
+        for (let i = 0;i < window.length; i++) {
+          const absolute = clampScroll + i;
+          const s = window[i];
+          const isSelected = absolute === selected;
+          const isActive = currentTarget === formatTarget(s.provider, s.id);
+          const cursor = isSelected ? accent("▶") : " ";
+          const activeMark = isActive ? accent("(active)") : "";
+          const idText = isSelected ? accent(s.id) : text(s.id);
+          const providerTag = muted(`[${s.provider}]`);
+          const countTag = dim(`${s.count} entries`);
+          const dateTag = s.from ? dim(new Date(s.from).toLocaleDateString()) : "";
+          const rowContent = ` ${cursor} ${idText} ${providerTag} ${countTag} ${dateTag} ${activeMark}`.trimEnd();
+          lines.push(makeRow(rowContent, innerW, border));
+        }
+        for (let i = window.length;i < VIEWPORT; i++)
+          lines.push(makeRow("", innerW, border));
+        const count = sessions.length;
+        const position = count > VIEWPORT ? `${clampScroll + 1}-${Math.min(clampScroll + VIEWPORT, count)} of ${count}` : `${count} session${count === 1 ? "" : "s"}`;
+        lines.push(makeRow("", innerW, border));
+        lines.push(makeRow(dim(`↑↓ navigate  enter resume  d delete  esc close  (${position})`), innerW, border));
+        lines.push(`${borderFg("╰")}${borderFg("─".repeat(width - 2))}${borderFg("╯")}`);
+        return lines;
+      },
+      handleInput(data) {
+        if (matchesKey(data, Key.escape) || matchesKey(data, Key.ctrl("c"))) {
+          done(undefined);
+          return;
+        }
+        if (error && sessions.length === 0)
+          return;
+        const maxScroll = Math.max(0, sessions.length - VIEWPORT);
+        if (matchesKey(data, Key.up)) {
+          selected = Math.max(0, selected - 1);
+          if (selected < scroll)
+            scroll = selected;
+          tui.requestRender();
+          return;
+        }
+        if (matchesKey(data, Key.down)) {
+          selected = Math.min(Math.max(0, sessions.length - 1), selected + 1);
+          if (selected >= scroll + VIEWPORT)
+            scroll = selected - VIEWPORT + 1;
+          tui.requestRender();
+          return;
+        }
+        if (matchesKey(data, Key.pageUp)) {
+          selected = Math.max(0, selected - VIEWPORT);
+          scroll = Math.max(0, Math.min(scroll, selected));
+          tui.requestRender();
+          return;
+        }
+        if (matchesKey(data, Key.pageDown)) {
+          selected = Math.min(sessions.length - 1, selected + VIEWPORT);
+          scroll = Math.min(maxScroll, Math.max(scroll, selected - VIEWPORT + 1));
+          tui.requestRender();
+          return;
+        }
+        if (data === "d" || data === "D" || matchesKey(data, Key.delete)) {
+          deleteSelected();
+          return;
+        }
+        if (matchesKey(data, Key.enter) || matchesKey(data, Key.return)) {
+          const s = sessions[selected];
+          if (!s)
+            return;
+          if (s.provider !== "pi") {
+            ctx.ui.notify(`Only Pi sessions can be resumed (session ${s.id} is ${s.provider})`, "warning");
+            return;
+          }
+          const sessionDir = ctx.sessionManager.getSessionDir();
+          const sessionPath = join(sessionDir, s.id.endsWith(".jsonl") ? s.id : `${s.id}.jsonl`);
+          if (!existsSync(sessionPath)) {
+            ctx.ui.notify(`Session transcript file not found: ${sessionPath}`, "error");
+            return;
+          }
+          done(undefined);
+          const cmdCtx = ctx;
+          if (typeof cmdCtx.switchSession === "function") {
+            cmdCtx.switchSession(sessionPath);
+          } else {
+            ctx.ui.notify(`Session switched to ${sessionPath}`, "info");
+          }
+          return;
+        }
+      },
+      invalidate() {}
+    };
+  }, {
+    overlay: true,
+    overlayOptions: {
+      anchor: "center",
+      width: OVERLAY_WIDTH,
+      margin: 2
+    }
+  });
+}
 function createGoosedumpIntegration(options = {}) {
   const shouldRegisterTool = options.registerTool ?? true;
   const shouldOverrideDefaultCompaction = options.overrideDefaultCompaction ?? true;
@@ -1094,8 +1277,19 @@ function createGoosedumpIntegration(options = {}) {
     if (!goosedumpAvailable)
       return;
     const active = shouldOverrideDefaultCompaction && compactSettings.turnsBeforeCompact > 0;
+    let dotColor = "success";
+    if (active) {
+      const remainingRatio = turnsRemaining / compactSettings.turnsBeforeCompact;
+      if (remainingRatio <= 0.125) {
+        dotColor = "error";
+      } else if (remainingRatio <= 0.25) {
+        dotColor = "warning";
+      }
+    }
+    const dot = ctx.ui.theme.fg(dotColor, "●");
     const counter = active ? Math.max(0, turnsRemaining).toString(16).toUpperCase().padStart(2, "0") : "--";
-    ctx.ui.setStatus("goosedump", ctx.ui.theme.fg("text", `GD: ${counter}`));
+    const label = ctx.ui.theme.fg("text", `GD: ${counter}`);
+    ctx.ui.setStatus("goosedump", `${dot} ${label}`);
   }
   function noteCompletedTurn(ctx) {
     if (!goosedumpAvailable || !shouldOverrideDefaultCompaction)
@@ -1186,6 +1380,56 @@ function createGoosedumpIntegration(options = {}) {
           }
         }
       }));
+      pi.registerTool(defineTool({
+        name: "goose_forget",
+        label: "goose_forget",
+        description: "Forget/remove durable context entries from goosedump memory.",
+        promptSnippet: "Remove obsolete entries from durable memory store",
+        promptGuidelines: [
+          "Use goose_forget to delete stale, inaccurate, or obsolete entries from durable memory.",
+          "Requires a target memory ID or key."
+        ],
+        parameters: Type.Object({
+          target: Type.String({
+            description: "Memory target/ID to forget (e.g. entry ID or key pattern)"
+          })
+        }),
+        async execute(_id, params, signal, _onUpdate, _ctx) {
+          if (!goosedumpAvailable)
+            return goosedumpUnavailableResult();
+          if (!params.target || params.target.trim().length === 0) {
+            return textResult("goose_forget error: target is required");
+          }
+          try {
+            const res = await goosedumpMemoryForget(params.target.trim(), signal, nativeExecutablePath);
+            return textResult(res);
+          } catch (err) {
+            const message = err instanceof Error ? err.message : String(err);
+            return textResult(`goosedump error: ${message}`);
+          }
+        }
+      }));
+      pi.registerTool(defineTool({
+        name: "goose_memory_status",
+        label: "goose_memory_status",
+        description: "Show durable memory status, indexing stats, and governance breakdown.",
+        promptSnippet: "Inspect durable memory health and statistics",
+        promptGuidelines: [
+          "Use goose_memory_status to check memory index volume, health, and ingestion queue status."
+        ],
+        parameters: Type.Object({}),
+        async execute(_id, _params, signal, _onUpdate, _ctx) {
+          if (!goosedumpAvailable)
+            return goosedumpUnavailableResult();
+          try {
+            const res = await goosedumpMemoryStatus(signal, nativeExecutablePath);
+            return textResult(res);
+          } catch (err) {
+            const message = err instanceof Error ? err.message : String(err);
+            return textResult(`goosedump error: ${message}`);
+          }
+        }
+      }));
       pi.registerTool(defineTool({
         name: "goose_search",
         label: "goose_search",
@@ -1208,7 +1452,7 @@ function createGoosedumpIntegration(options = {}) {
             description: "Page number for ranked results"
           }))
         }),
-        async execute(_id, params, _signal, _onUpdate, ctx) {
+        async execute(_id, params, signal, _onUpdate, ctx) {
           if (!goosedumpAvailable)
             return goosedumpUnavailableResult();
           try {
@@ -1217,10 +1461,7 @@ function createGoosedumpIntegration(options = {}) {
             if (!target)
               return missingSessionId("goose_search", provider);
             const page = params.page ?? 1;
-            const messages = goosedumpSearch(target, params.query, {
-              scope: params.scope ?? "lineage",
-              page
-            });
+            const messages = await goosedumpSearch(target, params.query, { scope: params.scope ?? "lineage", page }, signal, nativeExecutablePath);
             if (messages.length === 0) {
               return textResult(`No results for "${params.query}"`);
             }
@@ -1255,7 +1496,7 @@ function createGoosedumpIntegration(options = {}) {
           session: historySessionParam(),
           scope: historyScopeParam()
         }),
-        async execute(_id, params, _signal, _onUpdate, ctx) {
+        async execute(_id, params, signal, _onUpdate, ctx) {
           if (!goosedumpAvailable)
             return goosedumpUnavailableResult();
           try {
@@ -1263,10 +1504,7 @@ function createGoosedumpIntegration(options = {}) {
             const target = resolveTarget(ctx, provider, params.session);
             if (!target)
               return missingSessionId("goose_get", provider);
-            const messages = goosedumpShow(target, {
-              scope: params.scope ?? "lineage",
-              ids: params.ids
-            });
+            const messages = await goosedumpShow(target, { scope: params.scope ?? "lineage", ids: params.ids }, signal, nativeExecutablePath);
             if (messages.length === 0) {
               return textResult("No entries found for the given IDs.");
             }
@@ -1294,7 +1532,7 @@ function createGoosedumpIntegration(options = {}) {
           session: historySessionParam(),
           scope: historyScopeParam()
         }),
-        async execute(_id, params, _signal, _onUpdate, ctx) {
+        async execute(_id, params, signal, _onUpdate, ctx) {
           if (!goosedumpAvailable)
             return goosedumpUnavailableResult();
           try {
@@ -1302,9 +1540,7 @@ function createGoosedumpIntegration(options = {}) {
             const target = resolveTarget(ctx, provider, params.session);
             if (!target)
               return missingSessionId("goose_grep", provider);
-            const messages = goosedumpGrep(target, params.pattern, {
-              scope: params.scope ?? "lineage"
-            });
+            const messages = await goosedumpGrep(target, params.pattern, { scope: params.scope ?? "lineage" }, signal, nativeExecutablePath);
             if (messages.length === 0) {
               return textResult(`No matches for "${params.pattern}"`);
             }
@@ -1344,6 +1580,72 @@ function createGoosedumpIntegration(options = {}) {
           return textResult(compactStartedMessage(keep));
         }
       }));
+      pi.registerTool(defineTool({
+        name: "goose_sessions",
+        label: "goose_sessions",
+        description: "List or delete session IDs for the current working directory.",
+        promptSnippet: "List or delete coding agent sessions for current directory",
+        promptGuidelines: [
+          "Use goose_sessions to discover sessions in the current directory or delete a non-active session.",
+          "Strictly scoped to the current working directory.",
+          "Deleting the currently active session is not allowed."
+        ],
+        parameters: Type.Object({
+          action: Type.Optional(Type.Union([Type.Literal("list"), Type.Literal("delete")], {
+            default: "list",
+            description: "Action: list (default) or delete"
+          })),
+          provider: historyProviderParam("list"),
+          session: Type.Optional(Type.String({
+            description: "Session ID to delete (required for action: delete)"
+          }))
+        }),
+        async execute(_id, params, signal, _onUpdate, ctx) {
+          if (!goosedumpAvailable)
+            return goosedumpUnavailableResult();
+          const action = params.action ?? "list";
+          const provider = params.provider ?? "pi";
+          const currentTarget = currentSessionTarget(ctx);
+          if (action === "delete") {
+            if (!params.session) {
+              return textResult("goose_sessions error: session ID is required for action: delete");
+            }
+            const target = formatTarget(provider, params.session);
+            if (currentTarget && target === currentTarget) {
+              return textResult("Cannot delete the active session.");
+            }
+            try {
+              await goosedumpRemoveSession(target, signal, nativeExecutablePath);
+              return textResult(`Deleted session ${target}`);
+            } catch (err) {
+              const message = err instanceof Error ? err.message : String(err);
+              return textResult(`goosedump error: ${message}`);
+            }
+          }
+          try {
+            const sessions = await goosedumpListSessions(signal, nativeExecutablePath);
+            const cwdSessions = sessions.filter((s) => s.cwd === ctx.cwd && s.provider === provider);
+            if (cwdSessions.length === 0) {
+              return textResult(`No ${provider} sessions found for ${ctx.cwd}`);
+            }
+            const lines = cwdSessions.map((s) => {
+              const target = formatTarget(s.provider, s.id);
+              const isActive = currentTarget === target;
+              const activeMarker = isActive ? " (active)" : "";
+              const dateStr = s.from ? new Date(s.from).toISOString() : "unknown date";
+              const countStr = `${s.count} entries`;
+              return `- ${s.id}${activeMarker} [${countStr}; ${dateStr}]`;
+            });
+            return textResult(`Sessions for ${ctx.cwd} (${provider}):
+
+${lines.join(`
+`)}`);
+          } catch (err) {
+            const message = err instanceof Error ? err.message : String(err);
+            return textResult(`goosedump error: ${message}`);
+          }
+        }
+      }));
     }
     function maybeAutoCompact(ctx, resumeAfter) {
       if (!goosedumpAvailable || !shouldOverrideDefaultCompaction)
@@ -1525,6 +1827,60 @@ function createGoosedumpIntegration(options = {}) {
         }
       }
     });
+    maybePi.registerCommand?.("goose-sessions", {
+      description: "Manage and switch between sessions for the current working directory",
+      handler: async (_args, ctx) => {
+        if (!goosedumpAvailable) {
+          ctx.ui.notify(GOOSEDUMP_UNAVAILABLE_MESSAGE, "error");
+          return;
+        }
+        try {
+          await runSessionsPanel(ctx, nativeExecutablePath);
+        } catch (err) {
+          const message = err instanceof Error ? err.message : String(err);
+          ctx.ui.notify(`goosedump error: ${message}`, "error");
+        }
+      }
+    });
+    maybePi.registerCommand?.("goose-forget", {
+      description: "Forget/remove an entry from goosedump durable memory",
+      handler: async (args, ctx) => {
+        if (!goosedumpAvailable) {
+          ctx.ui.notify(GOOSEDUMP_UNAVAILABLE_MESSAGE, "error");
+          return;
+        }
+        let target = typeof args === "string" ? args.trim() : "";
+        if (target.length === 0) {
+          const input = await ctx.ui.input("Memory target/ID to forget:", "");
+          target = (input ?? "").trim();
+        }
+        if (target.length === 0)
+          return;
+        try {
+          const res = await goosedumpMemoryForget(target, undefined, nativeExecutablePath);
+          ctx.ui.notify(res, "info");
+        } catch (err) {
+          const message = err instanceof Error ? err.message : String(err);
+          ctx.ui.notify(`goosedump error: ${message}`, "error");
+        }
+      }
+    });
+    maybePi.registerCommand?.("goose-memory-status", {
+      description: "Show durable memory status and health stats",
+      handler: async (_args, ctx) => {
+        if (!goosedumpAvailable) {
+          ctx.ui.notify(GOOSEDUMP_UNAVAILABLE_MESSAGE, "error");
+          return;
+        }
+        try {
+          const res = await goosedumpMemoryStatus(undefined, nativeExecutablePath);
+          ctx.ui.notify(res, "info");
+        } catch (err) {
+          const message = err instanceof Error ? err.message : String(err);
+          ctx.ui.notify(`goosedump error: ${message}`, "error");
+        }
+      }
+    });
   }
   return { register };
 }

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "pi-goosedump",
-  "version": "0.12.0",
+  "version": "0.12.1",
   "description": "Pi extension for goosedump-backed session-history search, entry expansion, and compaction",
   "keywords": [
     "compaction",
@@ -38,7 +38,7 @@
   },
   "dependencies": {
     "@earendil-works/pi-tui": "^0.78.0",
-    "@jarkkojs/goosedump": "^0.12.0",
+    "@jarkkojs/goosedump": "^0.12.1",
     "@sinclair/typebox": "^0.34.49"
   },
   "devDependencies": {