pi-goosedump 0.12.25 → 0.12.27

package/README.md

@@ -1,8 +1,7 @@
 # pi-goosedump
 
-`pi-goosedump` adds goosedump-backed session-history search, durable-memory
-recall, entry expansion, and compaction to Pi. Its tools use the `goose_`
-prefix.
+`pi-goosedump` adds goosedump-backed session search, durable memory, session
+management, and compaction to Pi. Its tools use the `goose_` prefix.
 
 ## Install
 
@@ -10,78 +9,41 @@ prefix.
 pi install npm:pi-goosedump
 ```
 
-The package installs `@jarkkojs/goosedump`, including native binaries for Linux
-x64, macOS arm64, and Windows x64. If no compatible binary is available, the
-extension keeps Pi's normal compaction behavior and its goosedump features
-report that they are unavailable.
-
-## Memory in a nutshell
-
-1. **Remember:** [`gpt-oss-20b`](https://github.com/jarkkojs/goosedump/blob/main/docs/models/gpt-oss-20b.md)
-   extracts typed, atomic statements with source provenance. [`bge-small-en-v1.5`](https://github.com/jarkkojs/goosedump/blob/main/docs/models/bge-small-en-v1.5.md)
-   embeds each statement. SQLite stores the statements, vectors, and provenance.
-2. **Recall:** lexical and entity matches come first. Cosine-similar BGE vectors
-   fill the remaining slots. There is no separate vector database.
-
-Explicit `goose_remember` requests and learning after successful compactions are
-queued in the background, so model extraction and embedding do not block Pi.
+The package includes native binaries for Linux x64, macOS arm64, and Windows
+x64. On unsupported platforms, Pi keeps its normal compaction behavior and the
+goosedump tools report that they are unavailable. Local models download on
+first use.
 
 ## Tools
 
-- **`goose_search`** ranks session messages and returns compact overviews with
-  entry IDs.
-- **`goose_get`** expands entry IDs returned by `goose_search` or `goose_grep`.
-- **`goose_grep`** filters session messages with a glob pattern.
-- **`goose_remember`** queues durable memory learning from a session. It defaults
-  to the current Pi session and returns before extraction and embedding finish.
-- **`goose_recall`** recalls typed memories with source provenance. It searches
-  active memories in the current project by default; `history` includes
-  superseded statements and `allProjects` searches every project.
-- **`goose_compact`** starts asynchronous compaction of the current Pi session.
-  `keep` preserves the last N user turns verbatim.
-- **`goose_sessions`** lists or deletes sessions from the current working
-  directory. The active session cannot be deleted.
-- **`goose_forget`** deletes one memory or all retained sources from a session.
-- **`goose_memory_status`** reports storage, embedding coverage, tombstones, and
-  type counts.
-
-Session-history tools default to the current Pi session and active lineage.
-Non-Pi providers require an explicit session ID.
-
-Examples:
-
-```text
-goose_search({ query: "bug fix" })
-goose_search({ query: "auth", scope: "all", page: 2 })
-goose_get({ ids: ["entry-a", "entry-b"] })
-goose_grep({ pattern: "*timeout*" })
-goose_recall({ query: "prior architecture decision" })
-goose_recall({ query: "database", type: "decision" })
-goose_recall({ query: "database", history: true })
-goose_remember({})
-goose_compact({ keep: 2 })
-goose_sessions({ action: "list" })
-goose_forget({ target: "mem_a1b2c3d4" })
-goose_memory_status({})
-```
+- `goose_search` ranks session messages and returns entry IDs.
+- `goose_get` expands entries returned by search or grep.
+- `goose_grep` filters messages with a glob.
+- `goose_remember` queues memory learning from a session.
+- `goose_recall` recalls project-scoped memory with provenance.
+- `goose_compact` compacts the current Pi session asynchronously.
+- `goose_sessions` lists or deletes sessions in the current working directory.
+- `goose_forget` deletes a memory or a session's retained sources.
+- `goose_memory_status` reports storage and indexing health.
+
+Session tools default to the current Pi session and active lineage. Non-Pi
+providers require a session ID. Recall returns up to five memories by default.
+Use each tool's schema for its full options.
 
 ## Commands
 
-- **`/goose-search [query]`** searches the current session. A bare command opens
-  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 [memory-id|provider:id]`** deletes stored durable memory by ID or session.
-- **`/goose-memory-status`** displays durable-memory storage health and indexing counts.
-- **`/goose-settings`** edits global and project compaction settings.
+- `/goose-search [query]` searches the current session.
+- `/goose-compact [keep:N]` compacts now and can preserve recent user turns.
+- `/goose-sessions` lists project sessions and can resume or delete them.
+  Resume is available only for Pi sessions.
+- `/goose-forget [memory-id|provider:id]` forgets stored memory.
+- `/goose-memory-status` shows memory storage and indexing status.
+- `/goose-settings` edits global and project compaction settings.
 
 ## Settings
 
-Optional settings live under `goosedump` in:
-
-- `~/.pi/agent/settings.json` for global settings.
-- `.pi/settings.json` for project overrides.
+Put global settings in `~/.pi/agent/settings.json` and project overrides in
+`.pi/settings.json`:
 
 ```json
 {
@@ -92,39 +54,23 @@ Optional settings live under `goosedump` in:
 }
 ```
 
-`turnsBeforeCompact` is an integer from 0 to 255. `0` disables the turn-based
-trigger. Pi's `compaction.enabled` setting controls all automatic compaction, including
-the turn-based trigger. Each completed model response counts as one turn, including
-responses that call tools. The countdown is restored when a session resumes and
-appears in the footer with a status dot (green when >25% turns remain, yellow when
-≤25%, red when ≤12.5%) followed by a hexadecimal countdown. `● GD:0A` means ten
-turns remain, `● GD:00` is ready to compact, and `● GD:--` means the turn trigger is
-disabled. The footer adds `queued` while compaction is waiting to start and
-`compacting` while the summary is being built. When the counter hits zero mid
-tool-loop, compaction starts immediately after the current tool batch is persisted
-and the task is resumed automatically. When the counter hits zero on a terminal
-turn, compaction starts after the agent has settled. Pi remains the scheduler for
-its context threshold. Whichever enabled limit is reached first compacts once, and
-every successful compaction resets the countdown. A failed or cancelled compaction
-leaves the counter armed at zero and retries on the next tool turn or settlement.
-
-`summaryMaxTokens` is an integer from 512 to 65536 (default 4096). The effective
-summary budget is the lower of this value and 80% of Pi's `compaction.reserveTokens`,
-leaving room for the next model response. Clearing a project value restores the
-global setting.
-
-## Compaction behavior
-
-The extension uses `goosedump session compact` for manual, scheduled, and automatic
-compaction. It preserves the previous summary, summarizes only the new range, and
-passes the effective token budget. `keep:N` leaves the last N user turns verbatim.
-Tool requests are queued until Pi is idle; if Pi reaches its context threshold
-first, the queued request is coalesced into that compaction.
-
-After success, memory learning is queued in the background. A learning failure
-keeps the summary and displays a warning. Custom instructions use Pi's normal
-compactor; other goosedump failures fall back to Pi.
+- `turnsBeforeCompact`: `0` to `255`; `0` disables the turn trigger. Each
+  completed model response counts as one turn. The footer shows the remaining
+  count in hexadecimal.
+- `summaryMaxTokens`: `512` to `65536`; defaults to `4096`. Pi limits the
+  effective budget to 80% of `compaction.reserveTokens` when that is lower.
+
+Pi's `compaction.enabled` controls automatic compaction. The first enabled
+context or turn limit reached 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, and memory learning runs in the background after success.
+If the turn limit expires during a tool loop, Pi saves the current batch, starts
+compaction at that turn boundary, and resumes automatically. Goosedump failures
+fall back to Pi's compactor.
 
 ## License
 
-`pi-goosedump` is licensed under `Apache-2.0`. See [LICENSE](LICENSE).
+Apache-2.0. See [LICENSE](LICENSE).

package/dist/index.ts

@@ -1515,23 +1515,21 @@ function createGoosedumpIntegration(options = {}) {
       display: false
     }, { triggerTurn: true });
   }
-  function tryMidRunCounterCompaction(ctx) {
-    if (!goosedumpAvailable || !turnCompactionEnabled())
-      return false;
-    if (!counterTriggered)
-      return false;
-    if (ctx.hasPendingMessages())
-      return false;
-    if (!hasCompactableHistory(ctx))
-      return false;
-    if (compactionState.phase === "idle") {
-      queueTurnCompaction(ctx, settlementGeneration);
-    } else if (compactionState.phase === "queued" && compactionState.request.origin === "turn") {
-      setCompactionState(ctx, requeueRequest(compactionState.request, Math.min(compactionState.request.eligibleSettlement, settlementGeneration)));
-    } else {
-      return false;
-    }
-    return startQueuedCompaction(ctx, { resumeAfter: true, allowActiveRun: true });
+  function deferMidRunCounterCompaction(ctx) {
+    if (!goosedumpAvailable || !turnCompactionEnabled() || !counterTriggered)
+      return;
+    if (ctx.hasPendingMessages() || !hasCompactableHistory(ctx))
+      return;
+    if (compactionState.phase !== "queued" || compactionState.request.origin !== "turn")
+      return;
+    const request = compactionState.request;
+    setImmediate(() => {
+      if (compactionState.phase !== "queued" || compactionState.request !== request || !contextIsCurrent(ctx)) {
+        return;
+      }
+      const runStillActive = settlementGeneration < request.eligibleSettlement;
+      startQueuedCompaction(ctx, runStillActive ? { allowActiveRun: true, resumeAfter: true } : undefined);
+    });
   }
   function checkGoosedump(ctx) {
     try {
@@ -1600,7 +1598,7 @@ function createGoosedumpIntegration(options = {}) {
     const operation = ++operationGeneration;
     const generation = request.sessionGeneration;
     const sessionFile = request.sessionFile;
-    const resumeAfter = options2.resumeAfter === true;
+    const resumeAfter = request.origin === "turn" && options2.resumeAfter === true;
     setCompactionState(ctx, {
       phase: "running",
       request,
@@ -2071,7 +2069,7 @@ ${lines.join(`
       if (isCompletedAssistant(event.message))
         noteCompletedTurn(ctx);
       if (event.toolResults.length > 0)
-        tryMidRunCounterCompaction(ctx);
+        deferMidRunCounterCompaction(ctx);
     });
     pi.on("agent_settled", async (_event, ctx) => {
       handleAgentSettled(ctx);
@@ -2108,7 +2106,7 @@ ${lines.join(`
       let request;
       let owner;
       if (compactionState.phase === "running") {
-        if (compactionState.hookClaimed || compactionState.owner === "pi") {
+        if (compactionState.hookClaimed || compactionState.owner === "pi" || event.reason !== "manual") {
           return { cancel: true };
         }
         operation = compactionState.operation;

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "pi-goosedump",
-  "version": "0.12.25",
+  "version": "0.12.27",
   "description": "Pi extension for goosedump session search, durable memory, and compaction",
   "keywords": [
     "compaction",
@@ -38,12 +38,12 @@
   },
   "dependencies": {
     "@earendil-works/pi-tui": "^0.82.1",
-    "@jarkkojs/goosedump": "^0.12.25",
+    "@jarkkojs/goosedump": "^0.12.27",
     "@sinclair/typebox": "^0.34.49"
   },
   "devDependencies": {
     "@earendil-works/pi-coding-agent": "^0.82.1",
-    "@types/node": "^24.0.0",
+    "@types/node": "^26.1.2",
     "oxfmt": "^0.60.0",
     "oxlint": "^1.68.0",
     "typescript": "^7.0.2",