pi-goosedump 0.12.55 → 0.12.57

package/README.md

@@ -1,7 +1,7 @@
 # pi-goosedump
 
-Pi extension for goosedump-backed session search, durable memory, session
-management, and compaction. Tools use the `goose_` prefix.
+Pi extension for session search, durable memory, session management, and
+compaction. Tools use the `goose_` prefix.
 
 ## Install
 
@@ -9,66 +9,30 @@ management, and compaction. Tools use the `goose_` prefix.
 pi install npm:pi-goosedump
 ```
 
-Bundled native binaries: Linux x64 and arm64, macOS arm64, and Windows x64.
-
-Unsupported platforms are rejected when the extension loads. The extension uses
-that packaged binary by default and does not fall back to a `goosedump`
-executable on `PATH`. Set the shared `GOOSEDUMP_BINARY` environment variable to
-an absolute executable path to override it. An invalid override or missing
-packaged binary is treated as a broken installation. Local models download on
-first use.
+The extension includes binaries for Linux x64/arm64, macOS arm64, and Windows
+x64. Set `GOOSEDUMP_BINARY` to an absolute executable path to override the
+packaged binary.
 
 ## Tools
 
-Prefer these tools whenever prior sessions or durable memory can answer a
-question. Expand ranked or grepped hits with `goose_get` before guessing.
-
-| Tool                  | When to use                                                |
-| --------------------- | ---------------------------------------------------------- |
-| `goose_search`        | Ranked session-history search; returns entry IDs           |
-| `goose_grep`          | Exact glob/substring filter over session messages          |
-| `goose_get`           | Expand entry IDs from search/grep to full content          |
-| `goose_remember`      | Queue background learning from a session after a milestone |
-| `goose_recall`        | Recall project-scoped durable memory with provenance       |
-| `goose_forget`        | Remove a stale memory or a session's retained sources      |
-| `goose_memory_status` | Inspect storage health, type counts, and tombstones        |
-| `goose_compact`       | Compact the current Pi session asynchronously              |
-| `goose_sessions`      | List or delete sessions in the current working directory   |
-
-Defaults:
-
-| Setting          | Default                        |
-| ---------------- | ------------------------------ |
-| Session target   | Current Pi session             |
-| History scope    | `lineage` (active branch)      |
-| Recall limit     | 5                              |
-| Non-Pi providers | Require an explicit session ID |
-
-Use each tool's schema for full options. Typical flow:
-
-1. `goose_search` or `goose_grep` for candidate entry IDs
-2. `goose_get` on the interesting IDs
-3. `goose_recall` for durable facts, decisions, preferences, procedures, lessons
-4. `goose_remember` after milestones worth retaining
+- `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.
 
-## Commands
+Search and grep return entry IDs; call `goose_get` before relying on their
+content. Non-Pi providers require an explicit session ID.
 
-| Command                           | Purpose                                          |
-| --------------------------------- | ------------------------------------------------ |
-| `/goose-search [query]`           | Search the current session                       |
-| `/goose-compact [keep:N]`         | Compact now; keep the last N user turns verbatim |
-| `/goose-sessions`                 | List, resume, or delete project sessions         |
-| `/goose-forget [id\|provider:id]` | Forget stored memory                             |
-| `/goose-memory-status`            | Show memory storage and indexing status          |
-| `/goose-settings`                 | Edit goosedump settings                          |
-| `/goosedump-settings`             | Edit goosedump settings (alias)                  |
+## Commands
 
-Resume is available only for Pi sessions.
+`/goose-search`, `/goose-compact`, `/goose-sessions`, `/goose-forget`,
+`/goose-memory-status`, and `/goose-settings`.
 
 ## Settings
 
-- Global: `~/.pi/agent/settings.json`
-- Project: `.pi/settings.json`
+Add `goosedump` to `~/.pi/agent/settings.json` or `.pi/settings.json`:
 
 ```json
 {
@@ -80,49 +44,17 @@ Resume is available only for Pi sessions.
 }
 ```
 
-| Key                  | Range          | Default | Notes                                                          |
-| -------------------- | -------------- | ------: | -------------------------------------------------------------- |
-| `turnsBeforeCompact` | `0`–`255`      |       0 | `0` disables; each completed model response counts as one turn |
-| `summaryMaxTokens`   | `512`–`65536`  |    4096 | Capped to 80% of `compaction.reserveTokens` when lower         |
-| `enableMemory`       | `true`/`false` |   false | Controls whether durable memory tools/commands/learning are on |
-
-The footer shows the remaining turn count in hexadecimal.
-
-### Compaction behavior
-
-- Pi's `compaction.enabled` controls automatic compaction.
-- The first enabled context or turn limit starts one compaction.
-- Successful compaction resets the turn counter.
-- Manual and automatic compaction preserve the previous summary and summarize
-  only new entries.
-- `keep:N` leaves the last N user turns verbatim.
-- Manual requests wait until Pi is idle.
-- Memory learning runs in the background after a successful compaction.
-- If the turn limit expires during a tool loop, Pi saves the current batch,
-  compacts at that turn boundary, and resumes automatically.
-- Goosedump failures fall back to Pi's compactor.
+`turnsBeforeCompact: 0` disables turn-based compaction. Memory learning runs in
+the background after successful compaction when memory is enabled.
 
 ## Development
 
-Install dependencies and run the test suite:
-
 ```sh
 npm install
 npm test
 npm run check
 ```
 
-To exercise the extension against the binary built in this repository:
-
-```sh
-cargo build
-GOOSEDUMP_BINARY="$(cd ../.. && pwd)/target/debug/goosedump" \
-  pi --no-extensions -e ./index.ts
-```
-
-The explicit override takes precedence over the packaged platform binary. It must
-be an absolute path to an executable regular file.
-
-## License
+## Licensing
 
-Apache-2.0. See [LICENSE](LICENSE).
+[Apache 2.0](LICENSE).

package/dist/index.ts

@@ -1,9 +1,12 @@
 // SPDX-License-Identifier: Apache-2.0
 // Copyright (C) Jarkko Sakkinen 2026
 
+// src/integration.ts
+import { randomUUID as randomUUID2 } from "node:crypto";
+
 // src/cli.ts
-import { Type as Type2 } from "@sinclair/typebox";
-import { Value as Value2 } from "@sinclair/typebox/value";
+import { Type as Type2 } from "typebox";
+import { Value as Value2 } from "typebox/value";
 import { execFile } from "node:child_process";
 import { accessSync, constants as fsConstants, existsSync, readFileSync as readFileSync2, statSync } from "node:fs";
 import { createRequire } from "node:module";
@@ -11,10 +14,10 @@ import { dirname, isAbsolute, join } from "node:path";
 import { fileURLToPath } from "node:url";
 
 // src/format.ts
-import { Value } from "@sinclair/typebox/value";
+import { Value } from "typebox/value";
 
 // src/types.ts
-import { Type } from "@sinclair/typebox";
+import { Type } from "typebox";
 var BRANCH_SUMMARY_PREFIX = `The following is a summary of a branch that this conversation came back from:
 
 <summary>
@@ -136,6 +139,11 @@ var DEFAULT_GOOSEDUMP_SETTINGS = {
   summaryMaxTokens: 4096,
   enableMemory: false
 };
+var GOOSEDUMP_SETTING_LABELS = {
+  turnsBeforeCompact: "Turns before compact",
+  summaryMaxTokens: "Summary max tokens",
+  enableMemory: "Enable memory"
+};
 var GOOSEDUMP_SESSION_SCHEMA = Type.Object({
   id: Type.String(),
   parent: Type.Union([Type.String(), Type.Null()]),
@@ -529,8 +537,11 @@ 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 goosedumpMemoryRemember(target, signal, executablePath) {
-  const output = await runGoosedumpAsync(["memory", "learn", target, "--json"], signal, executablePath);
+async function goosedumpMemoryRemember(target, signal, executablePath, leaseOwner) {
+  const args = ["memory", "learn", target, "--json"];
+  if (leaseOwner)
+    args.push("--lease-owner", leaseOwner);
+  const output = await runGoosedumpAsync(args, signal, executablePath);
   return output.stdout.trim();
 }
 async function goosedumpMemoryForget(target, signal, executablePath) {
@@ -620,7 +631,7 @@ import { findCutPoint } from "@earendil-works/pi-coding-agent";
 
 // src/settings.ts
 import { DEFAULT_COMPACTION_SETTINGS } from "@earendil-works/pi-coding-agent";
-import { Value as Value3 } from "@sinclair/typebox/value";
+import { Value as Value3 } from "typebox/value";
 import { randomUUID } from "node:crypto";
 import {
   existsSync as existsSync2,
@@ -633,9 +644,9 @@ import {
 import { homedir } from "node:os";
 import { dirname as dirname2, join as join2 } from "node:path";
 function settingSpecFromSchema(schema) {
-  if (schema.type === "boolean")
+  const { type, minimum, maximum } = schema;
+  if (type === "boolean")
     return { kind: "boolean" };
-  const { minimum, maximum } = schema;
   if (typeof minimum !== "number" || typeof maximum !== "number") {
     throw new Error("goosedump setting schema is missing integer bounds");
   }
@@ -996,6 +1007,7 @@ class CompactionRuntime {
   overrideDefaultCompaction;
   nativeExecutablePath;
   enqueueRemember;
+  runCompactInference;
   compactSettings = DEFAULT_GOOSEDUMP_SETTINGS;
   piAutoCompactionEnabled = DEFAULT_COMPACTION_SETTINGS2.enabled;
   piCompactionReserveTokens = DEFAULT_COMPACTION_SETTINGS2.reserveTokens;
@@ -1014,6 +1026,7 @@ class CompactionRuntime {
     this.overrideDefaultCompaction = deps.overrideDefaultCompaction;
     this.nativeExecutablePath = deps.nativeExecutablePath;
     this.enqueueRemember = deps.enqueueRemember;
+    this.runCompactInference = deps.runCompactInference;
   }
   setActivePi(pi) {
     this.activePi = pi;
@@ -1224,7 +1237,7 @@ class CompactionRuntime {
           });
         }
       }
-      const compaction = await buildGoosedumpCompaction(target, event.preparation, event.branchEntries, effectiveSummaryMaxTokens(ctx.cwd, projectSettingsTrusted(ctx)), keep, signal, this.nativeExecutablePath);
+      const compaction = await this.runCompactInference(() => buildGoosedumpCompaction(target, event.preparation, event.branchEntries, effectiveSummaryMaxTokens(ctx.cwd, projectSettingsTrusted(ctx)), keep, signal, this.nativeExecutablePath));
       if (!this.runningOperationIsCurrent(operation, generation, sessionFile)) {
         return { cancel: true };
       }
@@ -1461,36 +1474,124 @@ class CompactionRuntime {
   }
 }
 
+// src/inference-coordinator.ts
+class InferenceBusyError extends Error {
+  constructor(message = "another inference task is already active") {
+    super(message);
+    this.name = "InferenceBusyError";
+  }
+}
+
+class InferenceCoordinator {
+  activeAttempt = null;
+  compactActive = false;
+  idleWaiters = [];
+  tryRunNonCompact(operation, externalSignal) {
+    if (this.compactActive || this.activeAttempt)
+      return null;
+    let resolvePromise = () => {};
+    let rejectPromise = () => {};
+    const promise = new Promise((resolve, reject) => {
+      resolvePromise = resolve;
+      rejectPromise = reject;
+    });
+    const job = {
+      operation,
+      externalSignal,
+      settled: false,
+      resolve: (value) => {
+        if (job.settled)
+          return;
+        job.settled = true;
+        resolvePromise(value);
+      },
+      reject: (error) => {
+        if (job.settled)
+          return;
+        job.settled = true;
+        rejectPromise(error);
+      }
+    };
+    this.startNonCompact(job);
+    return promise;
+  }
+  async runCompact(operation) {
+    if (this.compactActive)
+      throw new InferenceBusyError("compaction inference is already active");
+    this.compactActive = true;
+    const interrupted = this.activeAttempt;
+    if (interrupted) {
+      interrupted.preempted = true;
+      interrupted.controller.abort(new Error("inference paused for compaction"));
+      await interrupted.completion;
+    }
+    try {
+      return await operation();
+    } finally {
+      this.compactActive = false;
+      if (interrupted && !interrupted.job.settled) {
+        this.startNonCompact(interrupted.job);
+      } else {
+        this.resolveIdleWaiters();
+      }
+    }
+  }
+  async waitForIdle() {
+    while (this.compactActive || this.activeAttempt) {
+      await new Promise((resolve) => this.idleWaiters.push(resolve));
+    }
+  }
+  startNonCompact(job) {
+    const externalSignal = job.externalSignal;
+    if (externalSignal?.aborted) {
+      job.reject(externalSignal.reason ?? new Error("inference cancelled"));
+      this.resolveIdleWaiters();
+      return;
+    }
+    const controller = new AbortController;
+    const forwardExternalAbort = () => controller.abort(externalSignal?.reason);
+    externalSignal?.addEventListener("abort", forwardExternalAbort, { once: true });
+    const attempt = {
+      job,
+      controller,
+      preempted: false,
+      completion: Promise.resolve()
+    };
+    this.activeAttempt = attempt;
+    attempt.completion = Promise.resolve().then(() => job.operation(controller.signal)).then((value) => {
+      job.resolve(value);
+    }, (error) => {
+      if (!attempt.preempted)
+        job.reject(error);
+    }).finally(() => {
+      externalSignal?.removeEventListener("abort", forwardExternalAbort);
+      if (this.activeAttempt === attempt)
+        this.activeAttempt = null;
+      this.resolveIdleWaiters();
+    });
+  }
+  resolveIdleWaiters() {
+    if (this.compactActive || this.activeAttempt)
+      return;
+    const waiters = this.idleWaiters;
+    this.idleWaiters = [];
+    for (const resolve of waiters)
+      resolve();
+  }
+}
+
 // src/memory-activity.ts
-import { truncateToWidth } from "@earendil-works/pi-tui";
-var MEMORY_ACTIVITY_WIDGET_KEY = "goosedump-memory-activity";
-var ACTIVITY_FRAMES = ["▰▱▱▱", "▱▰▱▱", "▱▱▰▱", "▱▱▱▰", "▱▱▰▱", "▱▰▱▱"];
+var MEMORY_ACTIVITY_STATUS_KEY = "goosedump-memory-activity";
 function showMemoryActivity(ctx) {
   if (!ctx.hasUI)
     return;
-  ctx.ui.setWidget(MEMORY_ACTIVITY_WIDGET_KEY, (tui, theme) => {
-    let frame = 0;
-    const timer = setInterval(() => {
-      frame = (frame + 1) % ACTIVITY_FRAMES.length;
-      tui.requestRender();
-    }, 140);
-    timer.unref();
-    return {
-      render(width) {
-        const bar = theme.fg("accent", ACTIVITY_FRAMES[frame] ?? ACTIVITY_FRAMES[0]);
-        const label = theme.fg("muted", "Remembering...");
-        return [truncateToWidth(`${bar} ${label}`, width, "")];
-      },
-      invalidate() {},
-      dispose() {
-        clearInterval(timer);
-      }
-    };
-  });
+  const dot = ctx.ui.theme.fg("accent", "●");
+  const label = ctx.ui.theme.fg("muted", "remembering");
+  ctx.ui.setStatus(MEMORY_ACTIVITY_STATUS_KEY, `${dot} ${label}`);
 }
 function hideMemoryActivity(ctx) {
   if (ctx.hasUI)
-    ctx.ui.setWidget(MEMORY_ACTIVITY_WIDGET_KEY, undefined);
+    ctx.ui.setStatus(MEMORY_ACTIVITY_STATUS_KEY, undefined);
 }
 
 // src/policy.ts
@@ -1650,7 +1751,7 @@ import {
   defineTool,
   truncateHead
 } from "@earendil-works/pi-coding-agent";
-import { Type as Type3 } from "@sinclair/typebox";
+import { Type as Type3 } from "typebox";
 function memoryDisabledResult() {
   return textResult(MEMORY_DISABLED_MESSAGE);
 }
@@ -1739,7 +1840,7 @@ function defineGooseTool(name, parameters, handler) {
   });
 }
 function registerGooseTools(pi, deps) {
-  const { nativeExecutablePath, enqueueRemember, requestCompaction } = deps;
+  const { nativeExecutablePath, enqueueRemember, requestCompaction, runNonCompactInference } = deps;
   pi.registerTool(defineGooseTool("goose_remember", Type3.Object({ ...historyTargetParams() }), async (params, _signal, ctx) => {
     const disabled = requireMemoryEnabled(ctx);
     if (disabled)
@@ -1747,12 +1848,12 @@ function registerGooseTools(pi, deps) {
     const resolved = resolveHistoryTarget(ctx, "goose_remember", params);
     if (!resolved.ok)
       return resolved.result;
-    enqueueRemember(resolved.target, ctx, (message) => {
+    const accepted = enqueueRemember(resolved.target, ctx, (message) => {
       if (ctx.hasUI) {
         ctx.ui.notify(`goosedump memory learning failed: ${message}`, "warning");
       }
     });
-    return textResult(`Memory learning queued for ${resolved.target}.`);
+    return textResult(accepted ? `Memory learning started for ${resolved.target}.` : `Memory learning dropped for ${resolved.target}: another inference task is active.`);
   }));
   pi.registerTool(defineGooseTool("goose_recall", Type3.Object({
     query: Type3.String({ description: PARAM_DESCRIPTIONS.memoryQuery }),
@@ -1775,12 +1876,16 @@ function registerGooseTools(pi, deps) {
     const disabled = requireMemoryEnabled(ctx);
     if (disabled)
       return disabled;
-    const { hits, warning } = await goosedumpRecall(params.query, {
+    const inference = runNonCompactInference((inferenceSignal) => goosedumpRecall(params.query, {
       path: params.allProjects ? undefined : ctx.cwd,
       type: params.type,
       limit: params.limit,
       history: params.history
-    }, signal, nativeExecutablePath);
+    }, inferenceSignal, nativeExecutablePath), signal);
+    if (!inference) {
+      return textResult("Memory recall dropped: another inference task is active.");
+    }
+    const { hits, warning } = await inference;
     if (warning && ctx.hasUI)
       ctx.ui.notify(warning, "warning");
     if (hits.length === 0)
@@ -1927,7 +2032,7 @@ import {
   Key,
   decodeKittyPrintable,
   matchesKey,
-  truncateToWidth as truncateToWidth2,
+  truncateToWidth,
   visibleWidth,
   wrapTextWithAnsi
 } from "@earendil-works/pi-tui";
@@ -2010,7 +2115,7 @@ class NumberInputSubmenu {
   }
 }
 function makeRow(content, innerW, border) {
-  const line = truncateToWidth2(content, innerW);
+  const line = truncateToWidth(content, innerW);
   const pad = Math.max(0, innerW - visibleWidth(line));
   return `${border} ${line}${" ".repeat(pad)} ${border}`;
 }
@@ -2078,7 +2183,7 @@ async function runSettingsEditor(ctx) {
     let globalSettings = { ...DEFAULT_GOOSEDUMP_SETTINGS };
     let projectSettings = {};
     function settingLabel(key) {
-      return `Project ${key}`;
+      return GOOSEDUMP_SETTING_LABELS[key];
     }
     function reloadSettings() {
       globalSettings = readScopedGoosedumpSettings(location, "global");
@@ -2162,7 +2267,7 @@ async function runSettingsEditor(ctx) {
         const { accent, bold, dim, muted, text } = colors;
         const innerW = overlayInnerWidth(width);
         const pad = (value, cellWidth) => {
-          const clipped = truncateToWidth2(value, cellWidth);
+          const clipped = truncateToWidth(value, cellWidth);
           return `${clipped}${" ".repeat(Math.max(0, cellWidth - visibleWidth(clipped)))}`;
         };
         const tabLabel = (label, active) => active ? accent(bold(`[${label}]`)) : muted(label);
@@ -2173,8 +2278,9 @@ async function runSettingsEditor(ctx) {
         } else if (tab === "help") {
           const shortcutWidth = Math.max(visibleWidth("Shortcut"), ...helpRows.map(([shortcut]) => visibleWidth(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(dim(`  ${pad("Shortcut", shortcutWidth)}  Description`), ...helpRows.map(([shortcut, description]) => `  ${accent(pad(shortcut, shortcutWidth))}  ${text(truncateToWidth(description, descriptionWidth))}`));
         } else {
+          const labelWidth = Math.max(...specs.map(({ key }) => visibleWidth(settingLabel(key))));
           for (const [index, entry] of specs.entries()) {
             const selected = index === selectedSetting;
             const inherited = projectSettings[entry.key] === undefined;
@@ -2182,10 +2288,8 @@ async function runSettingsEditor(ctx) {
             const valueText = `[ ${formatSettingDisplayValue(entry.key, value)} ]`;
             const renderedValue = inherited ? dim(valueText) : selected ? accent(valueText) : text(valueText);
             const cursor = selected ? accent("›") : " ";
-            content.push(`${cursor} ${renderedValue} ${text(entry.key)}`);
+            content.push(`${cursor} ${text(pad(settingLabel(entry.key), labelWidth))}  ${renderedValue}`);
           }
-          const effective = resolveGoosedumpSettings(location, projectTrusted);
-          content.push("", dim(`Effective: turns=${formatCompactSetting(effective.turnsBeforeCompact)} · summary=${effectiveSummaryMaxTokens(location, projectTrusted)} tokens · memory=${effective.enableMemory ? "on" : "off"}`));
         }
         return [
           overlayHeader(colors, width, "Goosedump Settings"),
@@ -2314,7 +2418,7 @@ async function runSearchPanel(ctx, query, executablePath) {
     }
     return {
       render(width) {
-        const header = overlayHeader(colors, width, `Goosedump search: ${truncateToWidth2(query, 44)}`);
+        const header = overlayHeader(colors, width, `Goosedump search: ${truncateToWidth(query, 44)}`);
         if (error) {
           return [header, ...overlayError(colors, width, error), overlayFooter(colors, width)];
         }
@@ -2672,50 +2776,35 @@ function createGoosedumpIntegration(options = {}) {
   const shouldRegisterTool = options.registerTool ?? true;
   const shouldOverrideDefaultCompaction = options.overrideDefaultCompaction ?? true;
   const nativeExecutablePath = options.nativeExecutablePath ?? resolveNativeGoosedumpBinary();
-  const rememberQueue = [];
-  let rememberRunning = null;
+  const inference = new InferenceCoordinator;
   function enqueueRemember(target, ctx, reportError) {
     if (!isMemoryEnabled(ctx.cwd, projectSettingsTrusted(ctx)))
-      return;
-    for (let i = rememberQueue.length - 1;i >= 0; i -= 1) {
-      if (rememberQueue[i]?.target === target)
-        rememberQueue.splice(i, 1);
-    }
-    rememberQueue.push({ target, ctx, reportError });
-    ensureRememberWorker();
-  }
-  function ensureRememberWorker() {
-    if (rememberRunning)
-      return;
-    rememberRunning = (async () => {
-      while (rememberQueue.length > 0) {
-        const job = rememberQueue.shift();
-        if (!job)
-          continue;
-        showMemoryActivity(job.ctx);
-        try {
-          await goosedumpMemoryRemember(job.target, undefined, nativeExecutablePath);
-        } catch (err) {
-          const message = err instanceof Error ? err.message : String(err);
-          job.reportError(message);
-        } finally {
-          hideMemoryActivity(job.ctx);
-        }
+      return false;
+    const leaseOwner = randomUUID2();
+    const running = inference.tryRunNonCompact(async (signal) => {
+      showMemoryActivity(ctx);
+      try {
+        await goosedumpMemoryRemember(target, signal, nativeExecutablePath, leaseOwner);
+      } finally {
+        hideMemoryActivity(ctx);
       }
-    })().finally(() => {
-      rememberRunning = null;
-      if (rememberQueue.length > 0)
-        ensureRememberWorker();
     });
+    if (!running)
+      return false;
+    running.catch((err) => {
+      const message = err instanceof Error ? err.message : String(err);
+      reportError(message);
+    });
+    return true;
   }
   async function flushRememberQueue() {
-    while (rememberRunning)
-      await rememberRunning;
+    await inference.waitForIdle();
   }
   const compaction = new CompactionRuntime({
     overrideDefaultCompaction: shouldOverrideDefaultCompaction,
     nativeExecutablePath,
-    enqueueRemember
+    enqueueRemember,
+    runCompactInference: (operation) => inference.runCompact(operation)
   });
   function register(pi) {
     compaction.setActivePi(pi);
@@ -2723,6 +2812,7 @@ function createGoosedumpIntegration(options = {}) {
       registerGooseTools(pi, {
         nativeExecutablePath,
         enqueueRemember,
+        runNonCompactInference: (operation, signal) => inference.tryRunNonCompact(operation, signal),
         requestCompaction: (ctx, keep) => compaction.requestCompaction(ctx, keep)
       });
     }

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "pi-goosedump",
-  "version": "0.12.55",
+  "version": "0.12.57",
   "description": "Pi extension for goosedump session search, durable memory, session management, and compaction",
   "keywords": [
     "compaction",
@@ -37,24 +37,32 @@
     "ci:test": "npm test"
   },
   "dependencies": {
-    "@earendil-works/pi-tui": "^0.82.1",
-    "@jarkkojs/goosedump": "^0.12.55",
-    "@sinclair/typebox": "^0.34.49"
+    "@jarkkojs/goosedump": "^0.12.57"
   },
   "devDependencies": {
-    "@earendil-works/pi-coding-agent": "^0.82.1",
+    "@earendil-works/pi-coding-agent": "^0.84.2",
+    "@earendil-works/pi-tui": "^0.84.2",
     "@types/node": "^26.1.2",
     "oxfmt": "^0.60.0",
     "oxlint": "^1.68.0",
+    "typebox": "1.3.7",
     "typescript": "^7.0.2",
     "vitest": "^4.1.10"
   },
   "peerDependencies": {
-    "@earendil-works/pi-coding-agent": "^0.82.1"
+    "@earendil-works/pi-coding-agent": "^0.84.2",
+    "@earendil-works/pi-tui": "^0.84.2",
+    "typebox": "^1.3.7"
   },
   "peerDependenciesMeta": {
     "@earendil-works/pi-coding-agent": {
       "optional": true
+    },
+    "@earendil-works/pi-tui": {
+      "optional": true
+    },
+    "typebox": {
+      "optional": true
     }
   },
   "pi": {