@agenr/agenr-plugin 3.1.0 → 3.2.0

package/dist/{chunk-NOIZQRQV.js → chunk-6HY5F5FE.js}

@@ -12,7 +12,7 @@ import {
 import {
   formatAgenrBeforeTurnRecall,
   runBeforeTurn
-} from "./chunk-V5CDMHRN.js";
+} from "./chunk-UEGURBBW.js";
 import {
   CLAIM_KEY_SOURCES,
   CLAIM_KEY_STATUSES,
@@ -41,7 +41,7 @@ import {
   resolveEmbeddingModel,
   resolveModel,
   runUnifiedRecall
-} from "./chunk-NNO2V4GH.js";
+} from "./chunk-FMQTRTWE.js";
 import {
   recall
 } from "./chunk-5LADPJ4C.js";

package/dist/{chunk-NNO2V4GH.js → chunk-FMQTRTWE.js}

@@ -37,8 +37,8 @@ function readOptionalTrimmedString(value) {
 function readOptionalFiniteNumber(value) {
   return typeof value === "number" && Number.isFinite(value) ? value : void 0;
 }
-function pushIssue(issues, path4, message) {
-  issues.push({ path: path4, message });
+function pushIssue(issues, path5, message) {
+  issues.push({ path: path5, message });
 }
 function pushUnexpectedFields(value, allowedKeys, basePath, issues) {
   for (const key of Object.keys(value)) {
@@ -48,68 +48,68 @@ function pushUnexpectedFields(value, allowedKeys, basePath, issues) {
     pushIssue(issues, joinPath(basePath, key), "Unexpected field.");
   }
 }
-function parseRequiredTrimmedString(value, path4, issues, message = "Expected a non-empty string.") {
+function parseRequiredTrimmedString(value, path5, issues, message = "Expected a non-empty string.") {
   if (typeof value !== "string") {
-    pushIssue(issues, path4, message);
+    pushIssue(issues, path5, message);
     return void 0;
   }
   const normalized = value.trim();
   if (normalized.length === 0) {
-    pushIssue(issues, path4, message);
+    pushIssue(issues, path5, message);
     return void 0;
   }
   return normalized;
 }
-function parseOptionalTrimmedString(value, path4, issues, typeMessage = "Expected a string.", emptyMessage = "Expected a non-empty string.") {
+function parseOptionalTrimmedString(value, path5, issues, typeMessage = "Expected a string.", emptyMessage = "Expected a non-empty string.") {
   if (value === void 0) {
     return void 0;
   }
   if (typeof value !== "string") {
-    pushIssue(issues, path4, typeMessage);
+    pushIssue(issues, path5, typeMessage);
     return void 0;
   }
   const normalized = value.trim();
   if (normalized.length === 0) {
-    pushIssue(issues, path4, emptyMessage);
+    pushIssue(issues, path5, emptyMessage);
     return void 0;
   }
   return normalized;
 }
-function parseOptionalBoolean(value, path4, issues, message = "Expected a boolean.") {
+function parseOptionalBoolean(value, path5, issues, message = "Expected a boolean.") {
   if (value === void 0) {
     return void 0;
   }
   if (typeof value !== "boolean") {
-    pushIssue(issues, path4, message);
+    pushIssue(issues, path5, message);
     return void 0;
   }
   return value;
 }
-function parseOptionalIntegerInRange(value, path4, issues, bounds) {
+function parseOptionalIntegerInRange(value, path5, issues, bounds) {
   if (value === void 0) {
     return void 0;
   }
   if (typeof value !== "number" || !Number.isFinite(value) || !Number.isInteger(value)) {
-    pushIssue(issues, path4, integerRangeMessage(bounds));
+    pushIssue(issues, path5, integerRangeMessage(bounds));
     return void 0;
   }
   if (bounds.min !== void 0 && value < bounds.min) {
-    pushIssue(issues, path4, integerRangeMessage(bounds));
+    pushIssue(issues, path5, integerRangeMessage(bounds));
     return void 0;
   }
   if (bounds.max !== void 0 && value > bounds.max) {
-    pushIssue(issues, path4, integerRangeMessage(bounds));
+    pushIssue(issues, path5, integerRangeMessage(bounds));
     return void 0;
   }
   return value;
 }
-function parseOptionalTimestampString(value, path4, issues, message = "Expected a valid timestamp string.") {
-  const timestamp = parseOptionalTrimmedString(value, path4, issues);
+function parseOptionalTimestampString(value, path5, issues, message = "Expected a valid timestamp string.") {
+  const timestamp = parseOptionalTrimmedString(value, path5, issues);
   if (timestamp === void 0) {
     return void 0;
   }
   if (Number.isNaN(Date.parse(timestamp))) {
-    pushIssue(issues, path4, message);
+    pushIssue(issues, path5, message);
     return void 0;
   }
   return timestamp;
@@ -142,8 +142,7 @@ function integerRangeMessage(bounds) {
 // src/config.ts
 import fs from "fs";
 import os from "os";
-import path from "path";
-import { fileURLToPath } from "url";
+import path2 from "path";
 
 // src/app/features/types.ts
 var AGENR_FEATURE_FLAG_KEYS = ["workingMemory", "sessionTreeLineage", "sessionTreeCompaction", "goalContinuation"];
@@ -155,7 +154,7 @@ var DEFAULT_AGENR_FEATURE_FLAGS = {
 };
 
 // src/adapters/config/parse-feature-flags.ts
-function parseFeatureFlags(value, path4, issues) {
+function parseFeatureFlags(value, path5, issues) {
   const defaults = DEFAULT_AGENR_FEATURE_FLAGS;
   if (value === void 0) {
     return {
@@ -163,17 +162,17 @@ function parseFeatureFlags(value, path4, issues) {
     };
   }
   if (!isRecord(value)) {
-    pushIssue(issues, path4, "Expected an object.");
+    pushIssue(issues, path5, "Expected an object.");
     return {
       resolved: { ...defaults }
     };
   }
   const startIndex = issues.length;
-  pushUnexpectedFields(value, new Set(AGENR_FEATURE_FLAG_KEYS), path4, issues);
-  const workingMemory = parseOptionalBoolean(value.workingMemory, `${path4}.workingMemory`, issues);
-  const sessionTreeLineage = parseOptionalBoolean(value.sessionTreeLineage, `${path4}.sessionTreeLineage`, issues);
-  const sessionTreeCompaction = parseOptionalBoolean(value.sessionTreeCompaction, `${path4}.sessionTreeCompaction`, issues);
-  const goalContinuation = parseOptionalBoolean(value.goalContinuation, `${path4}.goalContinuation`, issues);
+  pushUnexpectedFields(value, new Set(AGENR_FEATURE_FLAG_KEYS), path5, issues);
+  const workingMemory = parseOptionalBoolean(value.workingMemory, `${path5}.workingMemory`, issues);
+  const sessionTreeLineage = parseOptionalBoolean(value.sessionTreeLineage, `${path5}.sessionTreeLineage`, issues);
+  const sessionTreeCompaction = parseOptionalBoolean(value.sessionTreeCompaction, `${path5}.sessionTreeCompaction`, issues);
+  const goalContinuation = parseOptionalBoolean(value.goalContinuation, `${path5}.goalContinuation`, issues);
   if (issues.length > startIndex) {
     return {
       resolved: { ...defaults }
@@ -464,41 +463,41 @@ function pushTopLevelIssues(value, issues) {
     pushIssue(issues, "embeddingApiKey", "Removed field. Move this value to credentials.openaiApiKey, then delete embeddingApiKey.");
   }
 }
-function parseAuth(value, path4, issues) {
-  const normalized = parseOptionalTrimmedString(value, path4, issues);
+function parseAuth(value, path5, issues) {
+  const normalized = parseOptionalTrimmedString(value, path5, issues);
   if (!normalized) {
     return void 0;
   }
   if (!isAgenrAuthMethod(normalized)) {
-    pushIssue(issues, path4, "Expected a supported auth method.");
+    pushIssue(issues, path5, "Expected a supported auth method.");
     return void 0;
   }
   return normalized;
 }
-function parseProvider(value, path4, issues) {
-  const normalized = parseOptionalTrimmedString(value, path4, issues);
+function parseProvider(value, path5, issues) {
+  const normalized = parseOptionalTrimmedString(value, path5, issues);
   if (!normalized) {
     return void 0;
   }
   if (!isAgenrProvider(normalized)) {
-    pushIssue(issues, path4, "Expected a supported provider.");
+    pushIssue(issues, path5, "Expected a supported provider.");
     return void 0;
   }
   return normalized;
 }
-function parseCredentials(value, path4, issues) {
+function parseCredentials(value, path5, issues) {
   if (value === void 0) {
     return void 0;
   }
   if (!isRecord(value)) {
-    pushIssue(issues, path4, "Expected an object.");
+    pushIssue(issues, path5, "Expected an object.");
     return void 0;
   }
   const startIndex = issues.length;
-  pushUnexpectedFields(value, /* @__PURE__ */ new Set(["openaiApiKey", "anthropicApiKey", "anthropicOauthToken"]), path4, issues);
-  const openaiApiKey = parseOptionalTrimmedString(value.openaiApiKey, `${path4}.openaiApiKey`, issues);
-  const anthropicApiKey = parseOptionalTrimmedString(value.anthropicApiKey, `${path4}.anthropicApiKey`, issues);
-  const anthropicOauthToken = parseOptionalTrimmedString(value.anthropicOauthToken, `${path4}.anthropicOauthToken`, issues);
+  pushUnexpectedFields(value, /* @__PURE__ */ new Set(["openaiApiKey", "anthropicApiKey", "anthropicOauthToken"]), path5, issues);
+  const openaiApiKey = parseOptionalTrimmedString(value.openaiApiKey, `${path5}.openaiApiKey`, issues);
+  const anthropicApiKey = parseOptionalTrimmedString(value.anthropicApiKey, `${path5}.anthropicApiKey`, issues);
+  const anthropicOauthToken = parseOptionalTrimmedString(value.anthropicOauthToken, `${path5}.anthropicOauthToken`, issues);
   if (issues.length > startIndex) {
     return void 0;
   }
@@ -509,20 +508,20 @@ function parseCredentials(value, path4, issues) {
   };
   return hasStoredCredentials(credentials) ? credentials : void 0;
 }
-function parseModelConfig(value, path4, issues) {
+function parseModelConfig(value, path5, issues) {
   if (value === void 0) {
     return void 0;
   }
   if (!isRecord(value)) {
-    pushIssue(issues, path4, "Expected an object.");
+    pushIssue(issues, path5, "Expected an object.");
     return void 0;
   }
   const startIndex = issues.length;
-  pushUnexpectedFields(value, /* @__PURE__ */ new Set(["provider", "model"]), path4, issues);
-  const provider = parseProvider(value.provider, `${path4}.provider`, issues);
-  const model = parseOptionalTrimmedString(value.model, `${path4}.model`, issues);
+  pushUnexpectedFields(value, /* @__PURE__ */ new Set(["provider", "model"]), path5, issues);
+  const provider = parseProvider(value.provider, `${path5}.provider`, issues);
+  const model = parseOptionalTrimmedString(value.model, `${path5}.model`, issues);
   if (!provider && !model) {
-    pushIssue(issues, path4, "Expected at least one of provider or model.");
+    pushIssue(issues, path5, "Expected at least one of provider or model.");
   }
   if (issues.length > startIndex) {
     return void 0;
@@ -532,7 +531,7 @@ function parseModelConfig(value, path4, issues) {
     ...model ? { model } : {}
   };
 }
-function parseClaimExtractionConfig(value, path4, issues) {
+function parseClaimExtractionConfig(value, path5, issues) {
   const defaults = createDefaultClaimExtractionConfig();
   if (value === void 0) {
     return {
@@ -540,20 +539,20 @@ function parseClaimExtractionConfig(value, path4, issues) {
     };
   }
   if (!isRecord(value)) {
-    pushIssue(issues, path4, "Expected an object.");
+    pushIssue(issues, path5, "Expected an object.");
     return {
       resolved: defaults
     };
   }
   const startIndex = issues.length;
-  pushUnexpectedFields(value, /* @__PURE__ */ new Set(["enabled", "confidenceThreshold", "eligibleTypes", "concurrency", "model"]), path4, issues);
-  const enabled = parseOptionalBoolean(value.enabled, `${path4}.enabled`, issues);
-  const confidenceThreshold = parseOptionalUnitInterval(value.confidenceThreshold, `${path4}.confidenceThreshold`, issues);
-  const eligibleTypes = parseEligibleTypes(value.eligibleTypes, `${path4}.eligibleTypes`, issues);
-  const concurrency = parseOptionalIntegerInRange(value.concurrency, `${path4}.concurrency`, issues, {
+  pushUnexpectedFields(value, /* @__PURE__ */ new Set(["enabled", "confidenceThreshold", "eligibleTypes", "concurrency", "model"]), path5, issues);
+  const enabled = parseOptionalBoolean(value.enabled, `${path5}.enabled`, issues);
+  const confidenceThreshold = parseOptionalUnitInterval(value.confidenceThreshold, `${path5}.confidenceThreshold`, issues);
+  const eligibleTypes = parseEligibleTypes(value.eligibleTypes, `${path5}.eligibleTypes`, issues);
+  const concurrency = parseOptionalIntegerInRange(value.concurrency, `${path5}.concurrency`, issues, {
     min: 1
   });
-  const model = parseModelConfig(value.model, `${path4}.model`, issues);
+  const model = parseModelConfig(value.model, `${path5}.model`, issues);
   if (issues.length > startIndex) {
     return {
       resolved: defaults
@@ -577,7 +576,7 @@ function parseClaimExtractionConfig(value, path4, issues) {
     }
   };
 }
-function parseSurgeonConfig(value, path4, issues) {
+function parseSurgeonConfig(value, path5, issues) {
   const defaults = createDefaultSurgeonConfig();
   if (value === void 0) {
     return {
@@ -585,19 +584,19 @@ function parseSurgeonConfig(value, path4, issues) {
     };
   }
   if (!isRecord(value)) {
-    pushIssue(issues, path4, "Expected an object.");
+    pushIssue(issues, path5, "Expected an object.");
     return {
       resolved: defaults
     };
   }
   const startIndex = issues.length;
-  pushUnexpectedFields(value, /* @__PURE__ */ new Set(["model", "costCap", "dailyCostCap", "contextLimit", "customInstructions", "passes"]), path4, issues);
-  const model = parseModelConfig(value.model, `${path4}.model`, issues);
-  const costCap = parseOptionalPositiveNumber(value.costCap, `${path4}.costCap`, issues);
-  const dailyCostCap = parseOptionalNonNegativeNumber(value.dailyCostCap, `${path4}.dailyCostCap`, issues);
-  const contextLimit = parseOptionalIntegerInRange(value.contextLimit, `${path4}.contextLimit`, issues, { min: 0 });
-  const customInstructions = parseOptionalTrimmedString(value.customInstructions, `${path4}.customInstructions`, issues);
-  const retirement = parseRetirementPassConfig(value.passes, `${path4}.passes`, issues);
+  pushUnexpectedFields(value, /* @__PURE__ */ new Set(["model", "costCap", "dailyCostCap", "contextLimit", "customInstructions", "passes"]), path5, issues);
+  const model = parseModelConfig(value.model, `${path5}.model`, issues);
+  const costCap = parseOptionalPositiveNumber(value.costCap, `${path5}.costCap`, issues);
+  const dailyCostCap = parseOptionalNonNegativeNumber(value.dailyCostCap, `${path5}.dailyCostCap`, issues);
+  const contextLimit = parseOptionalIntegerInRange(value.contextLimit, `${path5}.contextLimit`, issues, { min: 0 });
+  const customInstructions = parseOptionalTrimmedString(value.customInstructions, `${path5}.customInstructions`, issues);
+  const retirement = parseRetirementPassConfig(value.passes, `${path5}.passes`, issues);
   if (issues.length > startIndex) {
     return {
       resolved: defaults
@@ -629,7 +628,7 @@ function parseSurgeonConfig(value, path4, issues) {
     }
   };
 }
-function parseRetirementPassConfig(value, path4, issues) {
+function parseRetirementPassConfig(value, path5, issues) {
   const defaults = createDefaultRetirementPassConfig();
   if (value === void 0) {
     return {
@@ -637,36 +636,36 @@ function parseRetirementPassConfig(value, path4, issues) {
     };
   }
   if (!isRecord(value)) {
-    pushIssue(issues, path4, "Expected an object.");
+    pushIssue(issues, path5, "Expected an object.");
     return {
       resolved: defaults
     };
   }
   const startIndex = issues.length;
-  pushUnexpectedFields(value, /* @__PURE__ */ new Set(["retirement"]), path4, issues);
+  pushUnexpectedFields(value, /* @__PURE__ */ new Set(["retirement"]), path5, issues);
   const retirement = value.retirement;
   if (retirement === void 0) {
     if (issues.length === startIndex) {
-      pushIssue(issues, path4, "Expected a retirement config when passes is provided.");
+      pushIssue(issues, path5, "Expected a retirement config when passes is provided.");
     }
     return {
       resolved: defaults
     };
   }
   if (!isRecord(retirement)) {
-    pushIssue(issues, `${path4}.retirement`, "Expected an object.");
+    pushIssue(issues, `${path5}.retirement`, "Expected an object.");
     return {
       resolved: defaults
     };
   }
-  pushUnexpectedFields(retirement, /* @__PURE__ */ new Set(["protectRecalledDays", "protectMinImportance", "skipRecentlyEvaluatedDays"]), `${path4}.retirement`, issues);
-  const protectRecalledDays = parseOptionalIntegerInRange(retirement.protectRecalledDays, `${path4}.retirement.protectRecalledDays`, issues, {
+  pushUnexpectedFields(retirement, /* @__PURE__ */ new Set(["protectRecalledDays", "protectMinImportance", "skipRecentlyEvaluatedDays"]), `${path5}.retirement`, issues);
+  const protectRecalledDays = parseOptionalIntegerInRange(retirement.protectRecalledDays, `${path5}.retirement.protectRecalledDays`, issues, {
     min: 0
   });
-  const protectMinImportance = parseOptionalIntegerInRange(retirement.protectMinImportance, `${path4}.retirement.protectMinImportance`, issues, {
+  const protectMinImportance = parseOptionalIntegerInRange(retirement.protectMinImportance, `${path5}.retirement.protectMinImportance`, issues, {
     min: 0
   });
-  const skipRecentlyEvaluatedDays = parseOptionalIntegerInRange(retirement.skipRecentlyEvaluatedDays, `${path4}.retirement.skipRecentlyEvaluatedDays`, issues, {
+  const skipRecentlyEvaluatedDays = parseOptionalIntegerInRange(retirement.skipRecentlyEvaluatedDays, `${path5}.retirement.skipRecentlyEvaluatedDays`, issues, {
     min: 0
   });
   if (issues.length > startIndex) {
@@ -688,54 +687,54 @@ function parseRetirementPassConfig(value, path4, issues) {
     }
   };
 }
-function parseOptionalUnitInterval(value, path4, issues) {
+function parseOptionalUnitInterval(value, path5, issues) {
   if (value === void 0) {
     return void 0;
   }
   if (typeof value !== "number" || !Number.isFinite(value) || value < 0 || value > 1) {
-    pushIssue(issues, path4, "Expected a number from 0 to 1.");
+    pushIssue(issues, path5, "Expected a number from 0 to 1.");
     return void 0;
   }
   return value;
 }
-function parseOptionalPositiveNumber(value, path4, issues) {
+function parseOptionalPositiveNumber(value, path5, issues) {
   if (value === void 0) {
     return void 0;
   }
   if (typeof value !== "number" || !Number.isFinite(value) || value <= 0) {
-    pushIssue(issues, path4, "Expected a positive number.");
+    pushIssue(issues, path5, "Expected a positive number.");
     return void 0;
   }
   return value;
 }
-function parseOptionalNonNegativeNumber(value, path4, issues) {
+function parseOptionalNonNegativeNumber(value, path5, issues) {
   if (value === void 0) {
     return void 0;
   }
   if (typeof value !== "number" || !Number.isFinite(value) || value < 0) {
-    pushIssue(issues, path4, "Expected a non-negative number.");
+    pushIssue(issues, path5, "Expected a non-negative number.");
     return void 0;
   }
   return value;
 }
-function parseEligibleTypes(value, path4, issues) {
+function parseEligibleTypes(value, path5, issues) {
   if (value === void 0) {
     return void 0;
   }
   if (!Array.isArray(value)) {
-    pushIssue(issues, path4, "Expected an array of entry types.");
+    pushIssue(issues, path5, "Expected an array of entry types.");
     return void 0;
   }
   const normalized = [];
   const seen = /* @__PURE__ */ new Set();
   for (const [index, item] of value.entries()) {
     if (typeof item !== "string") {
-      pushIssue(issues, `${path4}.${index}`, "Expected a supported entry type.");
+      pushIssue(issues, `${path5}.${index}`, "Expected a supported entry type.");
       continue;
     }
     const trimmed = item.trim();
     if (!isEntryType(trimmed)) {
-      pushIssue(issues, `${path4}.${index}`, "Expected a supported entry type.");
+      pushIssue(issues, `${path5}.${index}`, "Expected a supported entry type.");
       continue;
     }
     if (!seen.has(trimmed)) {
@@ -744,7 +743,7 @@ function parseEligibleTypes(value, path4, issues) {
     }
   }
   if (normalized.length === 0) {
-    pushIssue(issues, path4, "Expected at least one supported entry type.");
+    pushIssue(issues, path5, "Expected at least one supported entry type.");
     return void 0;
   }
   return normalized;
@@ -818,8 +817,53 @@ function toSurgeonInput(value) {
   return hasSurgeonInput(input) ? input : void 0;
 }
 
+// src/filesystem-path.ts
+import path from "path";
+import { fileURLToPath, pathToFileURL } from "url";
+function toAbsoluteFileUrl(filePath) {
+  return pathToFileURL(path.resolve(filePath)).href;
+}
+function resolveLocalFilesystemPath(targetPath) {
+  const trimmedPath = targetPath.trim();
+  if (trimmedPath.length === 0 || trimmedPath === ":memory:" || isInMemoryFileUrl(trimmedPath)) {
+    return null;
+  }
+  if (trimmedPath.startsWith("file:")) {
+    if (isAbsoluteFileUrl(trimmedPath)) {
+      try {
+        return fileURLToPath(trimmedPath);
+      } catch {
+        return null;
+      }
+    }
+    const relativePath = decodeRelativeFileUrlPath(trimmedPath);
+    return relativePath ? path.resolve(relativePath) : null;
+  }
+  return path.resolve(trimmedPath);
+}
+function resolveConfigFilesystemPath(targetPath) {
+  return resolveLocalFilesystemPath(targetPath) ?? targetPath;
+}
+function isAbsoluteFileUrl(targetPath) {
+  return /^file:(?:\/|[A-Za-z]:[\\/])/u.test(targetPath);
+}
+function isInMemoryFileUrl(targetPath) {
+  return targetPath === "file::memory:" || targetPath.startsWith("file::memory:?");
+}
+function decodeRelativeFileUrlPath(targetPath) {
+  const rawPath = targetPath.slice("file:".length).split(/[?#]/u, 1)[0]?.trim();
+  if (!rawPath) {
+    return null;
+  }
+  try {
+    return decodeURIComponent(rawPath);
+  } catch {
+    return rawPath;
+  }
+}
+
 // src/config.ts
-var DEFAULT_CONFIG_DIR = path.join(os.homedir(), ".agenr");
+var DEFAULT_CONFIG_DIR = path2.join(os.homedir(), ".agenr");
 var DEFAULT_DB_NAME = "knowledge.db";
 var CONFIG_DIR_MODE = 448;
 var CONFIG_FILE_MODE = 384;
@@ -839,7 +883,7 @@ function resolveConfigPath(options = {}) {
   if (adjacentConfigPath) {
     return adjacentConfigPath;
   }
-  return path.join(resolveConfigDir(), "config.json");
+  return path2.join(resolveConfigDir(), "config.json");
 }
 function resolveDbPath(config) {
   return normalizeOptionalString(process.env.AGENR_DB_PATH) ?? normalizeOptionalString(config?.dbPath) ?? resolvePersistedDefaultDbPath();
@@ -880,7 +924,7 @@ function resolveClaimExtractionConfig(config) {
   };
 }
 function readConfig(options = {}) {
-  const configPath = resolveFilesystemPath(resolveConfigPath(options));
+  const configPath = resolveConfigFilesystemPath(resolveConfigPath(options));
   const defaultDbPath = resolveReadDefaultDbPath(options);
   if (!fs.existsSync(configPath)) {
     const parsed2 = parseAgenrConfig(void 0, { defaultDbPath });
@@ -906,11 +950,11 @@ function readConfig(options = {}) {
   return parsed.value;
 }
 function configFileExists(options = {}) {
-  return fs.existsSync(resolveFilesystemPath(resolveConfigPath(options)));
+  return fs.existsSync(resolveConfigFilesystemPath(resolveConfigPath(options)));
 }
 function writeConfig(config, options = {}) {
-  const configPath = resolveFilesystemPath(resolveConfigPath(options));
-  const configDir = path.dirname(configPath);
+  const configPath = resolveConfigFilesystemPath(resolveConfigPath(options));
+  const configDir = path2.dirname(configPath);
   const canonical = canonicalizeAgenrConfigInput(config, {
     defaultDbPath: resolvePersistedDefaultDbPath()
   });
@@ -938,30 +982,17 @@ function resolveAdjacentConfigPath(dbPath) {
     return void 0;
   }
   if (normalizedDbPath.startsWith("file:")) {
-    try {
-      return path.join(path.dirname(fileURLToPath(normalizedDbPath)), "config.json");
-    } catch {
-      return void 0;
-    }
+    const filePath = resolveLocalFilesystemPath(normalizedDbPath);
+    return filePath ? path2.join(path2.dirname(filePath), "config.json") : void 0;
   }
-  return path.join(path.dirname(normalizedDbPath), "config.json");
+  return path2.join(path2.dirname(normalizedDbPath), "config.json");
 }
 function normalizeOptionalString(value) {
   const normalized = value?.trim();
   return normalized && normalized.length > 0 ? normalized : void 0;
 }
-function resolveFilesystemPath(targetPath) {
-  if (!targetPath.startsWith("file:")) {
-    return targetPath;
-  }
-  try {
-    return fileURLToPath(targetPath);
-  } catch {
-    return targetPath;
-  }
-}
 function resolvePersistedDefaultDbPath() {
-  return path.join(resolveConfigDir(), DEFAULT_DB_NAME);
+  return path2.join(resolveConfigDir(), DEFAULT_DB_NAME);
 }
 function resolveReadDefaultDbPath(options) {
   return normalizeOptionalString(process.env.AGENR_DB_PATH) ?? normalizeOptionalString(options.dbPath) ?? resolvePersistedDefaultDbPath();
@@ -1151,7 +1182,7 @@ async function sleep(durationMs) {
 import { createHash } from "crypto";
 import fs2 from "fs";
 import os2 from "os";
-import path2 from "path";
+import path3 from "path";
 import { createRequire } from "module";
 import { completeSimple, getEnvApiKey, getModel } from "@earendil-works/pi-ai";
 var DEFAULT_REASONING = "medium";
@@ -1330,33 +1361,38 @@ function safeReadJson(filePath) {
   }
 }
 function resolveHomeDir(env) {
-  const home = normalizeOptionalString2(env.HOME);
+  const home = normalizeOptionalString2(env.HOME) ?? normalizeOptionalString2(env.USERPROFILE) ?? resolveWindowsHomeFromParts(env);
   return home ? resolveUserPath(home) : os2.homedir();
 }
 function resolveCodexHome(env) {
   const configured = normalizeOptionalString2(env.CODEX_HOME) ?? "~/.codex";
-  const resolved = resolveUserPath(configured);
+  const resolved = resolveUserPath(configured, resolveHomeDir(env));
   try {
     return fs2.realpathSync.native(resolved);
   } catch {
     return resolved;
   }
 }
-function resolveUserPath(value) {
+function resolveUserPath(value, homeDir = os2.homedir()) {
   const trimmed = value.trim();
   if (trimmed === "~") {
-    return os2.homedir();
+    return homeDir;
   }
   if (trimmed.startsWith("~/")) {
-    return path2.join(os2.homedir(), trimmed.slice(2));
+    return path3.join(homeDir, trimmed.slice(2));
   }
   if (trimmed.startsWith("~\\")) {
-    return path2.join(os2.homedir(), trimmed.slice(2));
+    return path3.join(homeDir, trimmed.slice(2));
   }
-  return path2.resolve(trimmed);
+  return path3.resolve(trimmed);
+}
+function resolveWindowsHomeFromParts(env) {
+  const drive = normalizeOptionalString2(env.HOMEDRIVE);
+  const homePath = normalizeOptionalString2(env.HOMEPATH);
+  return drive && homePath ? `${drive}${homePath}` : void 0;
 }
 function parseCodexFromFile(env) {
-  const authPath = path2.join(resolveCodexHome(env), "auth.json");
+  const authPath = path3.join(resolveCodexHome(env), "auth.json");
   const parsed = safeReadJson(authPath);
   if (!parsed || typeof parsed !== "object") {
     return null;
@@ -1419,7 +1455,7 @@ function parseClaudeCredentialRecord(parsed, source) {
 }
 function parseClaudeFromFiles(env) {
   const homeDir = resolveHomeDir(env);
-  const candidates = [path2.join(homeDir, ".claude", ".credentials.json"), path2.join(homeDir, ".claude", "credentials.json")];
+  const candidates = [path3.join(homeDir, ".claude", ".credentials.json"), path3.join(homeDir, ".claude", "credentials.json")];
   for (const candidate of candidates) {
     const parsed = safeReadJson(candidate);
     const resolved = parseClaudeCredentialRecord(parsed, `file:${candidate}`);
@@ -1747,7 +1783,7 @@ async function sleep2(durationMs) {
 
 // src/adapters/db/client.ts
 import fs3 from "fs/promises";
-import path3 from "path";
+import path4 from "path";
 import { createClient } from "@libsql/client";
 
 // src/adapters/db/episode-queries.ts
@@ -3192,14 +3228,14 @@ function normalizeProcedureSources(value, label, filePath, options = {}) {
 function normalizeProcedureSource(record, label, filePath) {
   rejectUnexpectedProcedureFields(record, SOURCE_KEYS, label, filePath);
   const kind = readProcedureSourceKind(record.kind, `${label}.kind`, filePath, PROCEDURE_SOURCE_KINDS);
-  const path4 = readOptionalProcedureString(record.path, `${label}.path`, filePath);
+  const path5 = readOptionalProcedureString(record.path, `${label}.path`, filePath);
   const locator = readOptionalProcedureString(record.locator, `${label}.locator`, filePath);
   const sourceLabel = readOptionalProcedureString(record.label, `${label}.label`, filePath);
   switch (kind) {
     case "skill":
     case "doc":
     case "repo_file":
-      if (!path4) {
+      if (!path5) {
         throw new Error(`Invalid procedure ${filePath}: ${label}.${kind} sources require a path.`);
       }
       break;
@@ -3217,7 +3253,7 @@ function normalizeProcedureSource(record, label, filePath) {
   }
   return {
     kind,
-    ...path4 ? { path: path4 } : {},
+    ...path5 ? { path: path5 } : {},
     ...locator ? { locator } : {},
     ...sourceLabel ? { label: sourceLabel } : {}
   };
@@ -5371,9 +5407,9 @@ async function openClient(dbPath) {
   if (trimmedPath.length === 0) {
     throw new Error("Database path must not be empty.");
   }
-  if (trimmedPath !== ":memory:" && !trimmedPath.startsWith("file:")) {
-    const resolvedPath = path3.resolve(trimmedPath);
-    await fs3.mkdir(path3.dirname(resolvedPath), { recursive: true });
+  const localDbPath = resolveLocalFilesystemPath(trimmedPath);
+  if (localDbPath) {
+    await fs3.mkdir(path4.dirname(localDbPath), { recursive: true });
   }
   const client = createClient({ url: resolveClientUrl(trimmedPath) });
   await client.execute("PRAGMA foreign_keys = ON");
@@ -5390,7 +5426,7 @@ function resolveClientUrl(dbPath) {
   if (dbPath.startsWith("file:")) {
     return dbPath;
   }
-  return `file:${path3.resolve(dbPath)}`;
+  return toAbsoluteFileUrl(dbPath);
 }
 async function rollbackTransaction(transaction) {
   if (transaction.closed) {
@@ -7909,6 +7945,7 @@ function dedupePreservingOrder2(values) {
 }
 
 export {
+  resolveLocalFilesystemPath,
   ENTRY_TYPES,
   EXPIRY_LEVELS,
   CLAIM_KEY_STATUSES,

package/dist/{chunk-E2DHUFZK.js → chunk-KL6X2E3I.js}

@@ -15,14 +15,14 @@ import {
   parseRecallMode,
   resolveTargetEntry,
   storeEntriesDetailed
-} from "./chunk-EEEL53X4.js";
+} from "./chunk-TMDNFBBC.js";
 import {
   containsAgenrMemoryContext,
   formatInjectionEntryBodyLines,
   formatInjectionEntryHeader,
   stripAgenrMemoryContext,
   wrapAgenrMemoryContext
-} from "./chunk-V5CDMHRN.js";
+} from "./chunk-UEGURBBW.js";
 import {
   ENTRY_PREVIEW_MAX_CHARS,
   ENTRY_SELECT_COLUMNS,
@@ -57,7 +57,7 @@ import {
   runUnifiedRecall,
   truncate,
   validateTemporalValidityRange
-} from "./chunk-NNO2V4GH.js";
+} from "./chunk-FMQTRTWE.js";
 import {
   recall
 } from "./chunk-5LADPJ4C.js";

package/dist/{chunk-EEEL53X4.js → chunk-TMDNFBBC.js}

@@ -23,7 +23,7 @@ import {
   readRequiredString,
   truncate,
   validateTemporalValidityRange
-} from "./chunk-NNO2V4GH.js";
+} from "./chunk-FMQTRTWE.js";
 import {
   compactClaimKey,
   describeClaimKeyNormalizationFailure,

package/dist/{chunk-V5CDMHRN.js → chunk-UEGURBBW.js}

@@ -2,7 +2,7 @@ import {
   projectClaimCentricRecallEntry,
   runProcedureRecall,
   truncate
-} from "./chunk-NNO2V4GH.js";
+} from "./chunk-FMQTRTWE.js";
 import {
   recall
 } from "./chunk-5LADPJ4C.js";

package/dist/{chunk-JSVQILB3.js → chunk-ZAX3YSTU.js}

@@ -1,6 +1,6 @@
 import {
   formatTargetSelectorFromParams
-} from "./chunk-EEEL53X4.js";
+} from "./chunk-TMDNFBBC.js";
 
 // src/adapters/openclaw/transcript/parser.ts
 import { createHash } from "crypto";

package/dist/index.js

@@ -4,7 +4,7 @@ import {
   openClawTranscriptParser,
   parseTuiSessionKey,
   readOpenClawSessionsStore
-} from "./chunk-JSVQILB3.js";
+} from "./chunk-ZAX3YSTU.js";
 import {
   BEFORE_TURN_DEBUG_ARTIFACT_DEFAULT_TOP_K,
   BEFORE_TURN_DEBUG_ARTIFACT_MAX_TOP_K,
@@ -43,7 +43,7 @@ import {
   runStoreMemoryTool,
   runUpdateMemoryTool,
   writeBoundedSingleTranscriptEpisode
-} from "./chunk-E2DHUFZK.js";
+} from "./chunk-KL6X2E3I.js";
 import {
   asRecord,
   buildEntryMemoryResolverPorts,
@@ -54,13 +54,13 @@ import {
   resolveTargetEntry,
   sanitizeFetchToolParams,
   sanitizeUpdateToolParams
-} from "./chunk-EEEL53X4.js";
+} from "./chunk-TMDNFBBC.js";
 import {
   containsAgenrMemoryContext,
   formatAgenrBeforeTurnRecall,
   runBeforeTurn,
   stripAgenrMemoryContext
-} from "./chunk-V5CDMHRN.js";
+} from "./chunk-UEGURBBW.js";
 import {
   EMBEDDING_DIMENSIONS,
   buildRecallToolDetails,
@@ -69,7 +69,7 @@ import {
   sanitizeRecallToolParams,
   sanitizeStoreToolParams,
   truncate
-} from "./chunk-NNO2V4GH.js";
+} from "./chunk-FMQTRTWE.js";
 import {
   resolveClaimSlotPolicy
 } from "./chunk-5LADPJ4C.js";
@@ -759,7 +759,7 @@ function registerAgenrOpenClawTools(api, servicesPromise, logger) {
 var openclaw_plugin_default = {
   id: "agenr",
   name: "agenr",
-  version: "3.1.0",
+  version: "3.2.0",
   description: "agenr memory plugin for OpenClaw",
   kind: "memory",
   contracts: {

package/openclaw.plugin.json

@@ -1,7 +1,7 @@
 {
   "id": "agenr",
   "name": "agenr",
-  "version": "3.1.0",
+  "version": "3.2.0",
   "description": "agenr memory plugin for OpenClaw",
   "kind": "memory",
   "contracts": {

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@agenr/agenr-plugin",
-  "version": "3.1.0",
+  "version": "3.2.0",
   "description": "agenr memory plugin for OpenClaw",
   "type": "module",
   "exports": {
@@ -17,8 +17,10 @@
     ]
   },
   "dependencies": {
+    "@earendil-works/pi-ai": "^0.78.0",
     "@libsql/client": "^0.17.2",
-    "openclaw": "^2026.4.9"
+    "openclaw": "^2026.4.9",
+    "yaml": "^2.8.3"
   },
   "engines": {
     "node": ">=24"