pi-goosedump 0.11.3 → 0.12.1

package/README.md

@@ -23,19 +23,17 @@ report that they are unavailable.
 - **`goose_grep`** filters session messages with a glob pattern.
 - **`goose_recall`** searches memory harvested by earlier compactions. It
   searches the current working directory by default, can filter decisions,
-  facts, preferences, procedures, or episodes, and returns governed, typed excerpts
-  with trust, confidence, scope, derivation, and provenance within a
-  4,096-byte/token-safe output budget. Quarantined, expired, superseded, and
-  contradicted entries are excluded.
+  facts, preferences, procedures, or episodes, and returns typed excerpts with
+  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.
-  Trained memory is indexed through goosedump's durable, bounded-retry ingestion
-  ledger; inspect terminal failures with `goosedump ingest review --status failed`.
-
-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:
 
@@ -47,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
@@ -55,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
@@ -74,18 +78,18 @@ 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
 
 The extension replaces Pi's normal summary during manual, scheduled, and
-automatic compaction. It passes `--train` so the compacted range is harvested
-into persistent memory, preserves the previous compaction summary, and asks
-goosedump to summarize only the newly compacted range. A `keep:N` request
-instead keeps the last N active user turns; it is cancelled when no earlier
-history is available to summarize.
+automatic compaction. It invokes `goosedump session compact --remember`,
+preserves the previous compaction summary, and summarizes only the newly
+compacted range. A `keep:N` request keeps the last N active user turns;
+it is cancelled when no earlier history is available to summarize.
 
 Compactions with custom instructions continue to use Pi's normal compactor. If
 goosedump fails, the extension reports the error and falls back to Pi. Successful

package/dist/index.ts

@@ -1,3 +1,6 @@
+// SPDX-License-Identifier: Apache-2.0
+// Copyright (C) Jarkko Sakkinen 2026
+
 // index.ts
 import {
   DEFAULT_COMPACTION_SETTINGS,
@@ -289,7 +292,7 @@ function parsePiMessages(output) {
 function parseMemoryHits(output) {
   const value = JSON.parse(output);
   if (!Array.isArray(value))
-    throw new Error("goosedump recall returned invalid JSON");
+    throw new Error("goosedump memory search returned invalid JSON");
   return value.filter((item) => isRecord(item) && typeof item.hash === "string" && typeof item.kind === "string" && typeof item.text === "string" && typeof item.score === "number" && typeof item.provider === "string" && typeof item.context_id === "string" && typeof item.entry_id === "string" && typeof item.path === "string" && typeof item.source_path === "string" && ["decision", "fact", "preference", "procedure", "episode"].includes(item.memory_type) && typeof item.trust === "number" && typeof item.confidence === "number" && (item.valid_from === null || typeof item.valid_from === "number") && (item.valid_until === null || typeof item.valid_until === "number") && ["context", "project"].includes(item.scope) && ["observed", "mutation"].includes(item.derivation));
 }
 function formatMemoryHit(hit, maxBytes) {
@@ -363,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, {
@@ -412,26 +403,34 @@ function readFirstLine(path) {
 function formatTarget(provider, id) {
   return `${provider}:${id}`;
 }
-function goosedumpSearch(target, query, options = {}) {
-  const scope = options.scope ?? "lineage";
-  const args = ["search", target, query, "--as-provider", "pi", "--scope", scope];
+function appendScope(args, scope) {
+  if (scope === "all")
+    args.push("--all");
+}
+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("-p", String(options.page));
-  return parsePiMessages(runGoosedump(args));
+    args.push("--page", String(options.page));
+  const output = await runGoosedumpAsync(args, signal, executablePath);
+  return parsePiMessages(output.stdout);
 }
-function goosedumpGrep(target, pattern, options = {}) {
-  const scope = options.scope ?? "lineage";
-  return parsePiMessages(runGoosedump(["grep", target, pattern, "--as-provider", "pi", "--scope", scope]));
+async function goosedumpGrep(target, pattern, options = {}, signal, executablePath) {
+  const args = ["session", "find", target, pattern, "--as", "pi"];
+  appendScope(args, options.scope);
+  const output = await runGoosedumpAsync(args, signal, executablePath);
+  return parsePiMessages(output.stdout);
 }
-function goosedumpShow(target, options = {}) {
-  const scope = options.scope ?? "lineage";
-  const args = ["show", target, "--as-provider", "pi", "--scope", scope];
+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("-m", id);
-  return parsePiMessages(runGoosedump(args));
+    args.push("--entry", id);
+  const output = await runGoosedumpAsync(args, signal, executablePath);
+  return parsePiMessages(output.stdout);
 }
 async function goosedumpRecall(query, options = {}, signal, executablePath) {
-  const args = ["recall", query, "--limit", String(options.limit ?? 5)];
+  const args = ["memory", "search", query, "--limit", String(options.limit ?? 5)];
   if (options.provider)
     args.push("--provider", options.provider);
   if (options.path)
@@ -441,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);
@@ -468,13 +489,13 @@ function historyScopeParam() {
   }));
 }
 async function goosedumpCompact(target, options, signal, executablePath) {
-  const scope = options.scope ?? "lineage";
-  const args = ["compact", target, "--train", "--scope", scope];
+  const args = ["session", "compact", target, "--remember"];
+  appendScope(args, options.scope);
   if (options.from)
     args.push("--from", options.from);
   if (options.previousSummary)
     args.push("--previous-summary", options.previousSummary);
-  args.push("--until", options.until);
+  args.push("--before", options.until);
   const output = await runGoosedumpAsync(args, signal, executablePath);
   for (const line of output.stdout.split(`
 `)) {
@@ -888,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}"`;
@@ -900,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);
@@ -921,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;
@@ -1063,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;
@@ -1086,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)
@@ -1123,7 +1325,7 @@ function createGoosedumpIntegration(options = {}) {
         pendingKeep = null;
         const message = error instanceof Error ? error.message : String(error);
         if (ctx.hasUI)
-          ctx.ui.notify(`goosedump compact failed: ${message}`, "error");
+          ctx.ui.notify(`goosedump compaction failed: ${message}`, "error");
       }
     });
     return "started";
@@ -1178,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",
@@ -1200,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 {
@@ -1209,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}"`);
             }
@@ -1247,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 {
@@ -1255,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.");
             }
@@ -1286,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 {
@@ -1294,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}"`);
             }
@@ -1336,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)
@@ -1370,7 +1680,7 @@ function createGoosedumpIntegration(options = {}) {
           updateStatus(ctx);
           const message = error instanceof Error ? error.message : String(error);
           if (ctx.hasUI)
-            ctx.ui.notify(`goosedump compact failed: ${message}`, "error");
+            ctx.ui.notify(`goosedump compaction failed: ${message}`, "error");
         }
       });
     }
@@ -1424,7 +1734,7 @@ function createGoosedumpIntegration(options = {}) {
           return { cancel: true };
         if (ctx.hasUI) {
           const message = err instanceof Error ? err.message : String(err);
-          ctx.ui.notify(`goosedump compact failed; falling back to Pi compaction: ${message}`, "error");
+          ctx.ui.notify(`goosedump compaction failed; falling back to Pi compaction: ${message}`, "error");
         }
         return;
       } finally {
@@ -1517,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.11.3",
+  "version": "0.12.1",
   "description": "Pi extension for goosedump-backed session-history search, entry expansion, and compaction",
   "keywords": [
     "compaction",
@@ -24,7 +24,7 @@
     ".": "./dist/index.ts"
   },
   "scripts": {
-    "build": "bun build index.ts --outfile dist/index.ts --target=node --packages=external",
+    "build": "bun build index.ts --outfile dist/index.ts --target=node --packages=external --banner='// SPDX-License-Identifier: Apache-2.0\n// Copyright (C) Jarkko Sakkinen 2026\n'",
     "prepack": "npm run build",
     "fmt": "oxfmt index.ts tests package.json tsconfig.json .oxfmtrc.json README.md",
     "lint": "oxlint index.ts tests",
@@ -38,7 +38,7 @@
   },
   "dependencies": {
     "@earendil-works/pi-tui": "^0.78.0",
-    "@jarkkojs/goosedump": "^0.11.3",
+    "@jarkkojs/goosedump": "^0.12.1",
     "@sinclair/typebox": "^0.34.49"
   },
   "devDependencies": {