pi-goosedump 0.10.10 → 0.10.12

package/README.md

@@ -22,8 +22,11 @@ report that they are unavailable.
 - **`goose_get`** expands entry IDs returned by `goose_search` or `goose_grep`.
 - **`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 and returns remembered
-  excerpts with provenance within a 4,096-byte/token-safe output budget.
+  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.
 - **`goose_compact`** starts asynchronous compaction of the current Pi session.
   Set `keep` to preserve the last N user turns verbatim.
 
@@ -40,6 +43,7 @@ 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_compact({ keep: 2 })
 ```
 

package/index.ts

@@ -76,6 +76,13 @@ interface GoosedumpMemoryHit {
   entry_id: string;
   path: string;
   source_path: string;
+  memory_type: 'decision' | 'fact' | 'preference' | 'procedure' | 'episode';
+  trust: number;
+  confidence: number;
+  valid_from: number | null;
+  valid_until: number | null;
+  scope: 'context' | 'project';
+  derivation: 'observed' | 'mutation';
 }
 
 const RECALL_TOKEN_BUDGET = 4096;
@@ -398,13 +405,24 @@ function parseMemoryHits(output: string): GoosedumpMemoryHit[] {
       typeof item.context_id === 'string' &&
       typeof item.entry_id === 'string' &&
       typeof item.path === 'string' &&
-      typeof item.source_path === 'string',
+      typeof item.source_path === 'string' &&
+      ['decision', 'fact', 'preference', 'procedure', 'episode'].includes(
+        item.memory_type as string,
+      ) &&
+      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 as string) &&
+      ['observed', 'mutation'].includes(item.derivation as string),
   );
 }
 
 function formatMemoryHit(hit: GoosedumpMemoryHit, maxBytes: number): string {
   const provenance =
-    `[${hit.hash}] ${hit.kind} (${hit.provider}:${hit.context_id}/${hit.entry_id})\n` +
+    `[${hit.hash}] ${hit.memory_type} (${hit.kind}; ${hit.scope}/${hit.derivation}; ` +
+    `trust ${hit.trust.toFixed(2)}, confidence ${hit.confidence.toFixed(2)}; ` +
+    `${hit.provider}:${hit.context_id}/${hit.entry_id})\n` +
     `Working directory: ${hit.path}\nSource: ${hit.source_path}\n`;
   const full = `${provenance}${hit.text}`;
   if (Buffer.byteLength(full) <= maxBytes) return full;
@@ -582,13 +600,19 @@ function goosedumpShow(
 
 async function goosedumpRecall(
   query: string,
-  options: { provider?: string; path?: string; limit?: number } = {},
+  options: {
+    provider?: string;
+    path?: string;
+    type?: GoosedumpMemoryHit['memory_type'];
+    limit?: number;
+  } = {},
   signal?: AbortSignal,
   executablePath?: string,
 ): Promise<{ hits: GoosedumpMemoryHit[]; warning: string }> {
   const args = ['recall', query, '--limit', String(options.limit ?? 5)];
   if (options.provider) args.push('--provider', options.provider);
   if (options.path) args.push('--path', options.path);
+  if (options.type) args.push('--type', options.type);
   const output = await runGoosedumpAsync(args, signal, executablePath);
   return { hits: parseMemoryHits(output.stdout), warning: output.stderr.trim() };
 }
@@ -1574,6 +1598,14 @@ export function createGoosedumpIntegration(
                 },
               ),
             ),
+            type: Type.Optional(
+              Type.Union(
+                ['decision', 'fact', 'preference', 'procedure', 'episode'].map((type) =>
+                  Type.Literal(type),
+                ),
+                { description: 'Optional memory-type filter' },
+              ),
+            ),
             allProjects: Type.Optional(
               Type.Boolean({
                 default: false,
@@ -1597,6 +1629,7 @@ export function createGoosedumpIntegration(
                 {
                   provider: params.provider,
                   path: params.allProjects ? undefined : ctx.cwd,
+                  type: params.type,
                   limit: params.limit,
                 },
                 signal,

package/package.json

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