agenr 3.1.0 → 3.3.0

package/dist/{chunk-NNO2V4GH.js → chunk-Z5X7T4QZ.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"];
@@ -153,9 +152,12 @@ var DEFAULT_AGENR_FEATURE_FLAGS = {
   sessionTreeCompaction: false,
   goalContinuation: false
 };
+function createAllEnabledFeatureFlagConfig() {
+  return Object.fromEntries(AGENR_FEATURE_FLAG_KEYS.map((key) => [key, true]));
+}
 
 // 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 +165,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 +466,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 +511,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 +534,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 +542,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 +579,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 +587,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 +631,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 +639,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 +690,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 +746,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 +820,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 +886,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 +927,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 +953,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 +985,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 +1185,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 +1364,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 +1458,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 +1786,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 +3231,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 +3256,7 @@ function normalizeProcedureSource(record, label, filePath) {
   }
   return {
     kind,
-    ...path4 ? { path: path4 } : {},
+    ...path5 ? { path: path5 } : {},
     ...locator ? { locator } : {},
     ...sourceLabel ? { label: sourceLabel } : {}
   };
@@ -5371,9 +5410,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 +5429,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) {
@@ -5400,8 +5439,6 @@ async function rollbackTransaction(transaction) {
 }
 
 // src/adapters/shared/memory-tool-format.ts
-var DEFAULT_RECALL_LIMIT = 10;
-var RESULT_SUBJECT_LOG_LIMIT = 5;
 var ENTRY_PREVIEW_MAX_CHARS = 220;
 var ENTRY_FETCH_MAX_CONTENT_CHARS = 32768;
 function buildEntryRecallPreview(content) {
@@ -5433,68 +5470,6 @@ function truncate(value, maxChars) {
   }
   return `${value.slice(0, maxChars - 3).trimEnd()}...`;
 }
-function sanitizeStoreToolParams(params) {
-  return {
-    type: params.type,
-    subject: params.subject,
-    ...params.importance !== void 0 ? { importance: params.importance } : {},
-    ...params.expiry !== void 0 ? { expiry: params.expiry } : {},
-    ...params.tags.length > 0 ? { tags: params.tags } : {},
-    contentLength: params.content.length,
-    ...params.sourceContext !== void 0 ? { sourceContextLength: params.sourceContext.length } : {},
-    ...params.supersedes !== void 0 ? { hasSupersedes: true } : {},
-    ...params.claimKey !== void 0 ? { hasClaimKey: true } : {},
-    ...params.validFrom !== void 0 ? { hasValidFrom: true } : {},
-    ...params.validTo !== void 0 ? { hasValidTo: true } : {}
-  };
-}
-function formatRecallToolSummary(params) {
-  const parts = [`query=${JSON.stringify(truncate(params.query, 80))}`];
-  if (params.mode) {
-    parts.push(`mode=${params.mode}`);
-  }
-  if (params.limit !== void 0 && params.limit !== DEFAULT_RECALL_LIMIT) {
-    parts.push(`limit=${params.limit}`);
-  }
-  if (params.types.length > 0) {
-    parts.push(`types=${JSON.stringify(params.types)}`);
-  }
-  if (params.tags.length > 0) {
-    parts.push(`tags=${JSON.stringify(params.tags)}`);
-  }
-  if (params.asOf) {
-    parts.push(`as_of=${JSON.stringify(params.asOf)}`);
-  }
-  if (params.budget !== void 0) {
-    parts.push(`budget=${params.budget}`);
-  }
-  return parts.join(" ");
-}
-function sanitizeRecallToolParams(params) {
-  return {
-    query: params.query,
-    ...params.mode ? { mode: params.mode } : {},
-    ...params.limit !== void 0 ? { limit: params.limit } : {},
-    ...params.threshold !== void 0 ? { threshold: params.threshold } : {},
-    ...params.types.length > 0 ? { types: params.types } : {},
-    ...params.tags.length > 0 ? { tags: params.tags } : {},
-    ...params.asOf ? { asOf: params.asOf } : {},
-    ...params.budget !== void 0 ? { budget: params.budget } : {}
-  };
-}
-function formatUnifiedRecallLogSummary(result) {
-  const procedureCount = result.procedureCandidates.length;
-  const procedureSummary = result.procedure ? ` [procedure: ${JSON.stringify(truncate(result.procedure.title, 80))}]` : "";
-  const entrySubjects = result.entries.map((entry) => entry.entry.subject.trim()).filter((subject) => subject.length > 0);
-  const displayed = entrySubjects.slice(0, RESULT_SUBJECT_LOG_LIMIT).map((subject) => JSON.stringify(truncate(subject, 80)));
-  const remaining = entrySubjects.length - RESULT_SUBJECT_LOG_LIMIT;
-  const suffix = displayed.length === 0 ? "" : ` [entry subjects: ${displayed.join(", ")}${remaining > 0 ? `, ... and ${remaining} more` : ""}]`;
-  const entryEpisodeSummary = `${result.episodes.length} episode${result.episodes.length === 1 ? "" : "s"}, ${result.entries.length} entr${result.entries.length === 1 ? "y" : "ies"}`;
-  if (procedureCount === 0 && !result.procedure) {
-    return `${entryEpisodeSummary}${suffix}`;
-  }
-  return `${procedureCount} procedure candidate${procedureCount === 1 ? "" : "s"}, ${entryEpisodeSummary}${procedureSummary}${suffix}`;
-}
 function buildRecallToolDetails(result, extraDetails = {}) {
   return {
     status: "ok",
@@ -7909,6 +7884,7 @@ function dedupePreservingOrder2(values) {
 }
 
 export {
+  resolveLocalFilesystemPath,
   ENTRY_TYPES,
   EXPIRY_LEVELS,
   CLAIM_KEY_STATUSES,
@@ -7968,6 +7944,7 @@ export {
   parseOptionalTimestampString,
   AGENR_FEATURE_FLAG_KEYS,
   DEFAULT_AGENR_FEATURE_FLAGS,
+  createAllEnabledFeatureFlagConfig,
   DEFAULT_SURGEON_COST_CAP,
   DEFAULT_SURGEON_DAILY_COST_CAP,
   DEFAULT_SURGEON_CONTEXT_LIMIT,
@@ -8000,10 +7977,6 @@ export {
   recallResultHasTruncatedEntryPreviews,
   assertEntryFetchableContentLength,
   truncate,
-  sanitizeStoreToolParams,
-  formatRecallToolSummary,
-  sanitizeRecallToolParams,
-  formatUnifiedRecallLogSummary,
   buildRecallToolDetails,
   formatFetchedEntryText,
   buildFetchToolDetails,