pi-goosedump 0.12.52 → 0.12.54

package/dist/index.ts

@@ -2,17 +2,101 @@
 // Copyright (C) Jarkko Sakkinen 2026
 
 // src/cli.ts
+import { Type as Type2 } from "@sinclair/typebox";
+import { Value as Value2 } from "@sinclair/typebox/value";
 import { execFile } from "node:child_process";
-import { existsSync } from "node:fs";
+import { existsSync, readFileSync } from "node:fs";
 import { createRequire } from "node:module";
 import { dirname, join } from "node:path";
+import { fileURLToPath } from "node:url";
+
+// src/format.ts
+import { Value } from "@sinclair/typebox/value";
 
 // src/types.ts
+import { Type } from "@sinclair/typebox";
 var BRANCH_SUMMARY_PREFIX = `The following is a summary of a branch that this conversation came back from:
 
 <summary>
 `;
 var BRANCH_SUMMARY_SUFFIX = "</summary>";
+var GOOSE_MEMORY_TYPES = [
+  "decision",
+  "fact",
+  "preference",
+  "procedure",
+  "lesson"
+];
+var GOOSEDUMP_MEMORY_TYPE_SCHEMA = Type.Union([
+  Type.Literal("decision"),
+  Type.Literal("fact"),
+  Type.Literal("preference"),
+  Type.Literal("procedure"),
+  Type.Literal("lesson")
+]);
+var GOOSEDUMP_MEMORY_STATUS_SCHEMA = Type.Union([
+  Type.Literal("active"),
+  Type.Literal("superseded")
+]);
+var GOOSEDUMP_MEMORY_SOURCE_SCHEMA = Type.Object({
+  citation_id: Type.String(),
+  provider: Type.String(),
+  session_id: Type.String(),
+  entry_id: Type.String(),
+  role: Type.String(),
+  observed_at: Type.Number(),
+  project: Type.String(),
+  source_path: Type.String(),
+  content_hash: Type.Optional(Type.String()),
+  snippet: Type.String()
+});
+var GOOSEDUMP_MEMORY_ENTITY_SCHEMA = Type.Object({
+  kind: Type.String(),
+  value: Type.String(),
+  origins: Type.Optional(Type.Array(Type.String()))
+});
+var GOOSEDUMP_MEMORY_MATCH_REASON_SCHEMA = Type.Object({
+  kind: Type.Union([
+    Type.Literal("lexical"),
+    Type.Literal("entity"),
+    Type.Literal("relation"),
+    Type.Literal("vector"),
+    Type.Literal("history")
+  ]),
+  detail: Type.String()
+});
+var GOOSEDUMP_MEMORY_RELATIONSHIP_SCHEMA = Type.Object({
+  direction: Type.Union([Type.Literal("outgoing"), Type.Literal("incoming")]),
+  kind: Type.Union([
+    Type.Literal("duplicates"),
+    Type.Literal("supports"),
+    Type.Literal("revises"),
+    Type.Literal("contradicts")
+  ]),
+  claim_id: Type.String(),
+  display_id: Type.String(),
+  memory_type: GOOSEDUMP_MEMORY_TYPE_SCHEMA,
+  text: Type.String(),
+  status: GOOSEDUMP_MEMORY_STATUS_SCHEMA,
+  rationale: Type.String()
+});
+var GOOSEDUMP_MEMORY_HIT_SCHEMA = Type.Object({
+  id: Type.String(),
+  display_id: Type.String(),
+  memory_type: GOOSEDUMP_MEMORY_TYPE_SCHEMA,
+  text: Type.String(),
+  keywords: Type.Array(Type.String()),
+  status: Type.Optional(GOOSEDUMP_MEMORY_STATUS_SCHEMA),
+  score: Type.Number(),
+  project: Type.String(),
+  valid_from: Type.Union([Type.Number(), Type.Null()]),
+  valid_until: Type.Union([Type.Number(), Type.Null()]),
+  superseded_by: Type.Optional(Type.Union([Type.String(), Type.Null()])),
+  related_by: Type.Optional(Type.Array(GOOSEDUMP_MEMORY_ENTITY_SCHEMA)),
+  relationships: Type.Array(GOOSEDUMP_MEMORY_RELATIONSHIP_SCHEMA),
+  match_reasons: Type.Array(GOOSEDUMP_MEMORY_MATCH_REASON_SCHEMA),
+  evidence: Type.Array(GOOSEDUMP_MEMORY_SOURCE_SCHEMA)
+});
 var RECALL_TOKEN_BUDGET = 4096;
 var RECALL_MAX_BYTES = RECALL_TOKEN_BUDGET;
 var RECALL_DEFAULT_LIMIT = 5;
@@ -23,15 +107,47 @@ var MEMORY_HIT_SEPARATOR = `
 `;
 var MEMORY_TEXT_TRUNCATED = `
 [Entry text truncated]`;
+var TURNS_BEFORE_COMPACT_MIN = 0;
+var TURNS_BEFORE_COMPACT_MAX = 255;
+var SUMMARY_MAX_TOKENS_MIN = 512;
+var SUMMARY_MAX_TOKENS_MAX = 65536;
+var TURNS_BEFORE_COMPACT_SCHEMA = Type.Integer({
+  minimum: TURNS_BEFORE_COMPACT_MIN,
+  maximum: TURNS_BEFORE_COMPACT_MAX
+});
+var SUMMARY_MAX_TOKENS_SCHEMA = Type.Integer({
+  minimum: SUMMARY_MAX_TOKENS_MIN,
+  maximum: SUMMARY_MAX_TOKENS_MAX
+});
+var ENABLE_MEMORY_SCHEMA = Type.Boolean();
+var GOOSEDUMP_SETTINGS_SCHEMA = Type.Object({
+  turnsBeforeCompact: TURNS_BEFORE_COMPACT_SCHEMA,
+  summaryMaxTokens: SUMMARY_MAX_TOKENS_SCHEMA,
+  enableMemory: ENABLE_MEMORY_SCHEMA
+});
+var GOOSEDUMP_SETTING_SCHEMAS = {
+  turnsBeforeCompact: TURNS_BEFORE_COMPACT_SCHEMA,
+  summaryMaxTokens: SUMMARY_MAX_TOKENS_SCHEMA,
+  enableMemory: ENABLE_MEMORY_SCHEMA
+};
+var GOOSEDUMP_SETTING_KEYS = Object.keys(GOOSEDUMP_SETTINGS_SCHEMA.properties);
 var DEFAULT_GOOSEDUMP_SETTINGS = {
   turnsBeforeCompact: 0,
   summaryMaxTokens: 4096,
   enableMemory: false
 };
-var TURNS_BEFORE_COMPACT_MIN = 0;
-var TURNS_BEFORE_COMPACT_MAX = 255;
-var SUMMARY_MAX_TOKENS_MIN = 512;
-var SUMMARY_MAX_TOKENS_MAX = 65536;
+var GOOSEDUMP_SESSION_SCHEMA = Type.Object({
+  id: Type.String(),
+  parent: Type.Union([Type.String(), Type.Null()]),
+  provider: Type.String(),
+  cwd: Type.String(),
+  path: Type.String(),
+  count: Type.Integer({ minimum: 0 }),
+  label: Type.Union([Type.String(), Type.Null()]),
+  from: Type.Union([Type.String(), Type.Null()]),
+  until: Type.Union([Type.String(), Type.Null()])
+});
+var GOOSEDUMP_SESSION_LIST_SCHEMA = Type.Array(GOOSEDUMP_SESSION_SCHEMA);
 var GOOSE_PROVIDERS = [
   "pi",
   "claude",
@@ -105,9 +221,6 @@ function isControlChar(char) {
   const code = char.charCodeAt(0);
   return code < 32 || code === 127 || code >= 128 && code <= 159;
 }
-function isStringArray(value) {
-  return Array.isArray(value) && value.every((item) => typeof item === "string");
-}
 
 // src/format.ts
 function summarizeToolArgs(args) {
@@ -191,20 +304,11 @@ function parsePiMessages(output) {
   }
   return messages;
 }
-function isMemorySource(value) {
-  return isRecord(value) && typeof value.citation_id === "string" && typeof value.provider === "string" && typeof value.session_id === "string" && typeof value.entry_id === "string" && typeof value.role === "string" && typeof value.observed_at === "number" && typeof value.project === "string" && typeof value.source_path === "string" && typeof value.snippet === "string" && (value.content_hash === undefined || typeof value.content_hash === "string");
-}
-function isMemoryMatchReason(value) {
-  return isRecord(value) && typeof value.detail === "string" && ["lexical", "entity", "relation", "vector", "history"].includes(value.kind);
-}
-function isMemoryRelationship(value) {
-  return isRecord(value) && ["outgoing", "incoming"].includes(value.direction) && ["duplicates", "supports", "revises", "contradicts"].includes(value.kind) && typeof value.claim_id === "string" && typeof value.display_id === "string" && ["fact", "decision", "preference", "procedure", "lesson"].includes(value.memory_type) && typeof value.text === "string" && ["active", "superseded"].includes(value.status) && typeof value.rationale === "string";
-}
 function parseMemoryHits(output) {
   const value = JSON.parse(output);
   if (!Array.isArray(value))
     throw new Error("goosedump memory recall returned invalid JSON");
-  return value.filter((item) => isRecord(item) && typeof item.id === "string" && typeof item.display_id === "string" && typeof item.text === "string" && isStringArray(item.keywords) && typeof item.score === "number" && typeof item.project === "string" && (item.valid_from === null || typeof item.valid_from === "number") && (item.valid_until === null || typeof item.valid_until === "number") && (item.status === undefined || item.status === "active" || item.status === "superseded") && (item.superseded_by === undefined || item.superseded_by === null || typeof item.superseded_by === "string") && (item.related_by === undefined || Array.isArray(item.related_by) && item.related_by.every((entity) => isRecord(entity) && typeof entity.kind === "string" && typeof entity.value === "string")) && Array.isArray(item.relationships) && item.relationships.every(isMemoryRelationship) && Array.isArray(item.match_reasons) && item.match_reasons.every(isMemoryMatchReason) && ["fact", "decision", "preference", "procedure", "lesson"].includes(item.memory_type) && Array.isArray(item.evidence) && item.evidence.every(isMemorySource));
+  return value.filter((item) => Value.Check(GOOSEDUMP_MEMORY_HIT_SCHEMA, item));
 }
 function formatMemorySource(source) {
   const observed = new Date(source.observed_at).toISOString();
@@ -283,19 +387,53 @@ ${m.content}`).join(`
 
 // src/cli.ts
 var require2 = createRequire(import.meta.url);
+var NATIVE_PACKAGE_TABLE = "native-packages.json";
+var NATIVE_GOOSEDUMP_PACKAGE_SCHEMA = Type2.Object({
+  packageName: Type2.String({ minLength: 1 }),
+  binaryName: Type2.String({ minLength: 1 })
+});
+var NATIVE_GOOSEDUMP_PACKAGES_SCHEMA = Type2.Object({
+  "darwin-arm64": NATIVE_GOOSEDUMP_PACKAGE_SCHEMA,
+  "linux-arm64": NATIVE_GOOSEDUMP_PACKAGE_SCHEMA,
+  "linux-x64": NATIVE_GOOSEDUMP_PACKAGE_SCHEMA,
+  "win32-x64": NATIVE_GOOSEDUMP_PACKAGE_SCHEMA
+});
+var cachedNativePackages;
+function resolveNativePackageTable() {
+  try {
+    const wrapperRequire = createRequire(resolveGoosedumpBinary());
+    return wrapperRequire.resolve(`./${NATIVE_PACKAGE_TABLE}`);
+  } catch {}
+  let dir = dirname(fileURLToPath(import.meta.url));
+  for (let i = 0;i < 8; i++) {
+    const candidate = join(dir, "bin", NATIVE_PACKAGE_TABLE);
+    if (existsSync(candidate))
+      return candidate;
+    const parent = dirname(dir);
+    if (parent === dir)
+      break;
+    dir = parent;
+  }
+  throw new Error("broken pi-goosedump installation: cannot resolve the native package table from @jarkkojs/goosedump");
+}
+function loadNativeGoosedumpPackages() {
+  const table = JSON.parse(readFileSync(resolveNativePackageTable(), "utf8"));
+  if (!Value2.Check(NATIVE_GOOSEDUMP_PACKAGES_SCHEMA, table)) {
+    throw new Error("broken pi-goosedump installation: native package table is invalid");
+  }
+  return table;
+}
+function nativeGoosedumpPackages() {
+  cachedNativePackages ??= loadNativeGoosedumpPackages();
+  return cachedNativePackages;
+}
 function nativeGoosedumpPackage(target) {
-  switch (target) {
-    case "linux-x64":
-      return { packageName: "@jarkkojs/goosedump-linux-x64", binaryName: "goosedump" };
-    case "linux-arm64":
-      return { packageName: "@jarkkojs/goosedump-linux-arm64", binaryName: "goosedump" };
-    case "darwin-arm64":
-      return { packageName: "@jarkkojs/goosedump-darwin-arm64", binaryName: "goosedump" };
-    case "win32-x64":
-      return { packageName: "@jarkkojs/goosedump-win32-x64", binaryName: "goosedump.exe" };
-    default:
-      throw new Error(`unsupported platform architecture: ${target}`);
+  const packages = nativeGoosedumpPackages();
+  const entry = packages[target];
+  if (!entry) {
+    throw new Error(`unsupported platform architecture: ${target}; supported platforms: ${Object.keys(packages).join(", ")}`);
   }
+  return entry;
 }
 function resolveGoosedumpBinary() {
   try {
@@ -400,6 +538,9 @@ async function goosedumpListSessions(signal, executablePath) {
   if (!Array.isArray(parsed)) {
     throw new Error("invalid goosedump session list JSON: expected an array");
   }
+  if (!Value2.Check(GOOSEDUMP_SESSION_LIST_SCHEMA, parsed)) {
+    throw new Error("invalid goosedump session list JSON");
+  }
   return parsed;
 }
 async function goosedumpRemoveSession(target, signal, executablePath) {
@@ -464,42 +605,37 @@ 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 { randomUUID } from "node:crypto";
 import {
   existsSync as existsSync2,
   mkdirSync,
-  readFileSync,
+  readFileSync as readFileSync2,
   renameSync,
   unlinkSync,
   writeFileSync
 } from "node:fs";
 import { homedir } from "node:os";
 import { dirname as dirname2, join as join2 } from "node:path";
-var GOOSEDUMP_SETTING_SPECS = {
-  turnsBeforeCompact: {
-    kind: "number",
-    min: TURNS_BEFORE_COMPACT_MIN,
-    max: TURNS_BEFORE_COMPACT_MAX
-  },
-  summaryMaxTokens: {
-    kind: "number",
-    min: SUMMARY_MAX_TOKENS_MIN,
-    max: SUMMARY_MAX_TOKENS_MAX
-  },
-  enableMemory: { kind: "boolean" }
-};
+function settingSpecFromSchema(schema) {
+  if (schema.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");
+  }
+  return { kind: "number", min: minimum, max: maximum };
+}
+var GOOSEDUMP_SETTING_SPECS = Object.fromEntries(GOOSEDUMP_SETTING_KEYS.map((key) => [key, settingSpecFromSchema(GOOSEDUMP_SETTING_SCHEMAS[key])]));
 var MEMORY_DISABLED_MESSAGE = "Durable memory is disabled. Set goosedump.enableMemory to true in settings (or /goose-settings).";
 function isValidGoosedumpSettingValue(key, value) {
-  const spec = GOOSEDUMP_SETTING_SPECS[key];
-  if (spec.kind === "boolean")
-    return typeof value === "boolean";
-  return typeof value === "number" && Number.isSafeInteger(value) && value >= spec.min && value <= spec.max;
+  return Value3.Check(GOOSEDUMP_SETTING_SCHEMAS[key], value);
 }
 function pickValidGoosedumpSettings(raw) {
   if (!isRecord(raw))
     return {};
   const settings = {};
-  for (const key of Object.keys(GOOSEDUMP_SETTING_SPECS)) {
+  for (const key of GOOSEDUMP_SETTING_KEYS) {
     const value = raw[key];
     if (!isValidGoosedumpSettingValue(key, value))
       continue;
@@ -527,7 +663,7 @@ function readJsonObject(path) {
   if (!existsSync2(path))
     return {};
   try {
-    const parsed = JSON.parse(readFileSync(path, "utf8"));
+    const parsed = JSON.parse(readFileSync2(path, "utf8"));
     return isRecord(parsed) ? parsed : {};
   } catch {
     return {};
@@ -538,7 +674,7 @@ function readJsonObjectStrict(path) {
     return {};
   let parsed;
   try {
-    parsed = JSON.parse(readFileSync(path, "utf8"));
+    parsed = JSON.parse(readFileSync2(path, "utf8"));
   } catch (error) {
     const message = error instanceof Error ? error.message : String(error);
     throw new Error(`${path}: ${message}`);
@@ -596,7 +732,7 @@ function validateGoosedumpSettings(path) {
   if (!isRecord(root.goosedump)) {
     throw new Error(`${path}: goosedump must be a JSON object`);
   }
-  for (const key of Object.keys(GOOSEDUMP_SETTING_SPECS)) {
+  for (const key of GOOSEDUMP_SETTING_KEYS) {
     const value = root.goosedump[key];
     if (value !== undefined && !isValidGoosedumpSettingValue(key, value)) {
       throw new Error(`${path}: goosedump.${key} must be ${goosedumpSettingValidationMessage(key)}`);
@@ -1499,7 +1635,7 @@ import {
   defineTool,
   truncateHead
 } from "@earendil-works/pi-coding-agent";
-import { Type } from "@sinclair/typebox";
+import { Type as Type3 } from "@sinclair/typebox";
 function memoryDisabledResult() {
   return textResult(MEMORY_DISABLED_MESSAGE);
 }
@@ -1509,18 +1645,18 @@ function requireMemoryEnabled(ctx) {
   return memoryDisabledResult();
 }
 function historyProviderParam() {
-  return Type.Optional(Type.Union(GOOSE_PROVIDERS.map((provider) => Type.Literal(provider)), {
+  return Type3.Optional(Type3.Union(GOOSE_PROVIDERS.map((provider) => Type3.Literal(provider)), {
     default: "pi",
     description: PARAM_DESCRIPTIONS.provider
   }));
 }
 function historySessionParam() {
-  return Type.Optional(Type.String({
+  return Type3.Optional(Type3.String({
     description: PARAM_DESCRIPTIONS.session
   }));
 }
 function historyScopeParam() {
-  return Type.Optional(Type.Union([Type.Literal("lineage"), Type.Literal("all")], {
+  return Type3.Optional(Type3.Union([Type3.Literal("lineage"), Type3.Literal("all")], {
     default: "lineage",
     description: PARAM_DESCRIPTIONS.scope
   }));
@@ -1574,7 +1710,6 @@ function gooseToolMeta(name) {
     promptGuidelines: [...policy.guidelines]
   };
 }
-var GOOSE_MEMORY_TYPES = ["decision", "fact", "preference", "procedure", "lesson"];
 function defineGooseTool(name, parameters, handler) {
   return defineTool({
     ...gooseToolMeta(name),
@@ -1590,7 +1725,7 @@ function defineGooseTool(name, parameters, handler) {
 }
 function registerGooseTools(pi, deps) {
   const { nativeExecutablePath, enqueueRemember, requestCompaction } = deps;
-  pi.registerTool(defineGooseTool("goose_remember", Type.Object({ ...historyTargetParams() }), async (params, _signal, ctx) => {
+  pi.registerTool(defineGooseTool("goose_remember", Type3.Object({ ...historyTargetParams() }), async (params, _signal, ctx) => {
     const disabled = requireMemoryEnabled(ctx);
     if (disabled)
       return disabled;
@@ -1604,18 +1739,18 @@ function registerGooseTools(pi, deps) {
     });
     return textResult(`Memory learning queued for ${resolved.target}.`);
   }));
-  pi.registerTool(defineGooseTool("goose_recall", Type.Object({
-    query: Type.String({ description: PARAM_DESCRIPTIONS.memoryQuery }),
-    type: Type.Optional(Type.Union(GOOSE_MEMORY_TYPES.map((type) => Type.Literal(type)), { description: PARAM_DESCRIPTIONS.memoryType })),
-    allProjects: Type.Optional(Type.Boolean({
+  pi.registerTool(defineGooseTool("goose_recall", Type3.Object({
+    query: Type3.String({ description: PARAM_DESCRIPTIONS.memoryQuery }),
+    type: Type3.Optional(Type3.Union(GOOSE_MEMORY_TYPES.map((type) => Type3.Literal(type)), { description: PARAM_DESCRIPTIONS.memoryType })),
+    allProjects: Type3.Optional(Type3.Boolean({
       default: false,
       description: PARAM_DESCRIPTIONS.allProjects
     })),
-    history: Type.Optional(Type.Boolean({
+    history: Type3.Optional(Type3.Boolean({
       default: false,
       description: PARAM_DESCRIPTIONS.history
     })),
-    limit: Type.Optional(Type.Integer({
+    limit: Type3.Optional(Type3.Integer({
       minimum: 1,
       maximum: 20,
       default: 5,
@@ -1637,8 +1772,8 @@ function registerGooseTools(pi, deps) {
       return textResult(`No durable memory for "${params.query}"`);
     return textResult(formatMemoryHits(hits));
   }));
-  pi.registerTool(defineGooseTool("goose_forget", Type.Object({
-    target: Type.String({
+  pi.registerTool(defineGooseTool("goose_forget", Type3.Object({
+    target: Type3.String({
       description: PARAM_DESCRIPTIONS.forgetTarget
     })
   }), async (params, signal, ctx) => {
@@ -1651,16 +1786,16 @@ function registerGooseTools(pi, deps) {
     const res = await goosedumpMemoryForget(params.target.trim(), signal, nativeExecutablePath);
     return textResult(res);
   }));
-  pi.registerTool(defineGooseTool("goose_memory_status", Type.Object({}), async (_params, signal, ctx) => {
+  pi.registerTool(defineGooseTool("goose_memory_status", Type3.Object({}), async (_params, signal, ctx) => {
     const disabled = requireMemoryEnabled(ctx);
     if (disabled)
       return disabled;
     return textResult(await goosedumpMemoryStatus(signal, nativeExecutablePath));
   }));
-  pi.registerTool(defineGooseTool("goose_search", Type.Object({
-    query: Type.String({ description: PARAM_DESCRIPTIONS.searchQuery }),
+  pi.registerTool(defineGooseTool("goose_search", Type3.Object({
+    query: Type3.String({ description: PARAM_DESCRIPTIONS.searchQuery }),
     ...historyBranchParams(),
-    page: Type.Optional(Type.Integer({
+    page: Type3.Optional(Type3.Integer({
       minimum: 1,
       default: 1,
       description: PARAM_DESCRIPTIONS.page
@@ -1679,8 +1814,8 @@ function registerGooseTools(pi, deps) {
 
 ${text}`);
   }));
-  pi.registerTool(defineGooseTool("goose_get", Type.Object({
-    ids: Type.Array(Type.String(), {
+  pi.registerTool(defineGooseTool("goose_get", Type3.Object({
+    ids: Type3.Array(Type3.String(), {
       minItems: 1,
       description: PARAM_DESCRIPTIONS.entryIds
     }),
@@ -1695,8 +1830,8 @@ ${text}`);
     }
     return boundedHistoryResult(formatMessagesFull(messages));
   }));
-  pi.registerTool(defineGooseTool("goose_grep", Type.Object({
-    pattern: Type.String({ description: PARAM_DESCRIPTIONS.pattern }),
+  pi.registerTool(defineGooseTool("goose_grep", Type3.Object({
+    pattern: Type3.String({ description: PARAM_DESCRIPTIONS.pattern }),
     ...historyBranchParams()
   }), async (params, signal, ctx) => {
     const resolved = resolveHistoryTarget(ctx, "goose_grep", params);
@@ -1708,8 +1843,8 @@ ${text}`);
     }
     return boundedHistoryResult(formatMessagesCompact(messages));
   }));
-  pi.registerTool(defineGooseTool("goose_compact", Type.Object({
-    keep: Type.Optional(Type.Integer({
+  pi.registerTool(defineGooseTool("goose_compact", Type3.Object({
+    keep: Type3.Optional(Type3.Integer({
       minimum: 1,
       description: PARAM_DESCRIPTIONS.keep
     }))
@@ -1723,13 +1858,13 @@ ${text}`);
     }
     return textResult(compactStartedMessage(keep, result === "queued"));
   }));
-  pi.registerTool(defineGooseTool("goose_sessions", Type.Object({
-    action: Type.Optional(Type.Union([Type.Literal("list"), Type.Literal("delete")], {
+  pi.registerTool(defineGooseTool("goose_sessions", Type3.Object({
+    action: Type3.Optional(Type3.Union([Type3.Literal("list"), Type3.Literal("delete")], {
       default: "list",
       description: PARAM_DESCRIPTIONS.sessionsAction
     })),
     provider: historyProviderParam(),
-    session: Type.Optional(Type.String({
+    session: Type3.Optional(Type3.String({
       description: PARAM_DESCRIPTIONS.sessionsDeleteId
     }))
   }), async (params, signal, ctx) => {

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "pi-goosedump",
-  "version": "0.12.52",
+  "version": "0.12.54",
   "description": "Pi extension for goosedump session search, durable memory, session management, and compaction",
   "keywords": [
     "compaction",
@@ -38,7 +38,7 @@
   },
   "dependencies": {
     "@earendil-works/pi-tui": "^0.82.1",
-    "@jarkkojs/goosedump": "^0.12.52",
+    "@jarkkojs/goosedump": "^0.12.54",
     "@sinclair/typebox": "^0.34.49"
   },
   "devDependencies": {