@agenr/openclaw-plugin 3.3.0 → 2026.6.2

package/dist/chunk-VTHBPXDQ.js

@@ -0,0 +1,1750 @@
+import {
+  describeClaimKeyNormalizationFailure,
+  normalizeClaimKey,
+  normalizeClaimKeySegment
+} from "./chunk-VBPYU7GO.js";
+
+// 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/core/types.ts
+var DURABLE_KINDS = ["fact", "decision", "preference", "lesson", "relationship", "milestone", "directive"];
+var DIRECTIVE_POLARITIES = ["abstain", "proactive"];
+var DIRECTIVE_BASE_TRIGGERS = ["session_start", "always"];
+var EXPIRY_LEVELS = ["core", "permanent", "temporary"];
+var CLAIM_KEY_STATUSES = ["trusted", "tentative", "unresolved"];
+var CLAIM_KEY_SOURCES = [
+  "manual",
+  "model",
+  "json_retry",
+  "deterministic_repair",
+  "dreaming_extract",
+  "dreaming_reconcile",
+  "dreaming_temporalize",
+  "dreaming_project"
+];
+var CLAIM_SUPPORT_MODES = ["explicit", "normalized", "inferred"];
+var EPISODE_ACTIVITY_LEVELS = ["substantial", "minimal", "none"];
+var PROCEDURE_STEP_KINDS = ["run_command", "read_reference", "inspect_state", "edit_file", "ask_user", "invoke_tool", "verify"];
+var PROCEDURE_CONDITION_KINDS = ["harness_is", "tool_available", "file_exists", "path_exists", "env_flag", "repo_state", "user_confirmed"];
+var PROCEDURE_SOURCE_KINDS = ["skill", "doc", "durable", "episode", "repo_file", "manual"];
+
+// src/app/features/types.ts
+var AGENR_FEATURE_FLAG_KEYS = ["workingMemory", "sessionTreeLineage", "sessionTreeCompaction", "goalContinuation"];
+var DEFAULT_AGENR_FEATURE_FLAGS = {
+  workingMemory: false,
+  sessionTreeLineage: false,
+  sessionTreeCompaction: true,
+  goalContinuation: false
+};
+function createAllEnabledFeatureFlagConfig() {
+  return Object.fromEntries(AGENR_FEATURE_FLAG_KEYS.map((key) => [key, true]));
+}
+
+// src/adapters/config/types.ts
+var DEFAULT_DREAMING_DAILY_COST_CAP = 75;
+var DEFAULT_DREAMING_PRUNE_PROTECT_RECALLED_DAYS = 14;
+var DEFAULT_DREAMING_PRUNE_PROTECT_MIN_IMPORTANCE = 9;
+var DEFAULT_DREAMING_IMPORTANCE_THRESHOLD = 25;
+var DEFAULT_DREAMING_MIN_INTERVAL_MINUTES = 30;
+var DEFAULT_DREAMING_EXTRACT_MAX_SESSIONS = 8;
+var DEFAULT_DREAMING_LIGHT_MAX_SESSIONS = 2;
+var DEFAULT_DREAMING_MAX_PROFILE_DURABLES = 8;
+var DEFAULT_DREAMING_DEEP_INTERVAL_HOURS = 168;
+var DEFAULT_CLAIM_EXTRACTION_CONCURRENCY = 10;
+var DEFAULT_CLAIM_EXTRACTION_CONFIDENCE_THRESHOLD = 0.8;
+var DEFAULT_CLAIM_EXTRACTION_ELIGIBLE_TYPES = ["fact", "preference", "decision", "lesson"];
+var DEFAULT_API_PORT = 3e3;
+var AUTH_METHOD_DEFINITIONS = [
+  {
+    id: "openai-api-key",
+    provider: "openai",
+    title: "OpenAI API key",
+    setupDescription: "Standard OpenAI API key. Pay per token.",
+    preferredModels: ["gpt-5.4-mini", "gpt-5.4", "gpt-5.4-nano"]
+  },
+  {
+    id: "openai-subscription",
+    provider: "openai-codex",
+    title: "OpenAI - Subscription (via Codex CLI)",
+    setupDescription: "Uses your Codex CLI login. No per-token cost. Requires `codex auth`.",
+    preferredModels: ["gpt-5.4-mini", "gpt-5.4"]
+  },
+  {
+    id: "anthropic-api-key",
+    provider: "anthropic",
+    title: "Anthropic API key",
+    setupDescription: "Standard Anthropic API key. Pay per token.",
+    preferredModels: ["claude-sonnet-4-6", "claude-opus-4-6", "claude-haiku-4-5"]
+  },
+  {
+    id: "anthropic-oauth",
+    provider: "anthropic",
+    title: "Anthropic - Claude subscription (OAuth)",
+    setupDescription: "Uses your Claude Code CLI login. No per-token cost.",
+    preferredModels: ["claude-sonnet-4-6", "claude-opus-4-6", "claude-haiku-4-5"]
+  },
+  {
+    id: "anthropic-token",
+    provider: "anthropic",
+    title: "Anthropic - Claude subscription (long-lived token)",
+    setupDescription: "Uses a Claude long-lived token instead of an API key.",
+    preferredModels: ["claude-sonnet-4-6", "claude-opus-4-6", "claude-haiku-4-5"]
+  }
+];
+var AUTH_METHOD_SET = new Set(AUTH_METHOD_DEFINITIONS.map((definition) => definition.id));
+var SUPPORTED_AGENR_PROVIDERS = ["openai", "openai-codex", "anthropic"];
+function isAgenrAuthMethod(value) {
+  return AUTH_METHOD_SET.has(value);
+}
+function isAgenrProvider(value) {
+  return SUPPORTED_AGENR_PROVIDERS.includes(value);
+}
+function authMethodToProvider(auth) {
+  const definition = AUTH_METHOD_DEFINITIONS.find((candidate) => candidate.id === auth);
+  if (!definition) {
+    throw new Error(`Unsupported auth method "${auth}".`);
+  }
+  return definition.provider;
+}
+function getAuthMethodDefinition(auth) {
+  const definition = AUTH_METHOD_DEFINITIONS.find((candidate) => candidate.id === auth);
+  if (!definition) {
+    throw new Error(`Unsupported auth method "${auth}".`);
+  }
+  return definition;
+}
+function sameEligibleKinds(left, right) {
+  return left.length === right.length && left.every((value, index) => value === right[index]);
+}
+function isDurableKind(value) {
+  return DURABLE_KINDS.includes(value);
+}
+
+// src/config.ts
+import fs from "fs";
+import os from "os";
+import path2 from "path";
+
+// src/adapters/shared/validation.ts
+function isRecord(value) {
+  return typeof value === "object" && value !== null && !Array.isArray(value);
+}
+function readOptionalTrimmedString(value) {
+  if (typeof value !== "string") {
+    return void 0;
+  }
+  const trimmed = value.trim();
+  return trimmed || void 0;
+}
+function readOptionalFiniteNumber(value) {
+  return typeof value === "number" && Number.isFinite(value) ? value : void 0;
+}
+function pushIssue(issues, path3, message) {
+  issues.push({ path: path3, message });
+}
+function pushUnexpectedFields(value, allowedKeys, basePath, issues) {
+  for (const key of Object.keys(value)) {
+    if (allowedKeys.has(key)) {
+      continue;
+    }
+    pushIssue(issues, joinPath(basePath, key), "Unexpected field.");
+  }
+}
+function parseRequiredTrimmedString(value, path3, issues, message = "Expected a non-empty string.") {
+  if (typeof value !== "string") {
+    pushIssue(issues, path3, message);
+    return void 0;
+  }
+  const normalized = value.trim();
+  if (normalized.length === 0) {
+    pushIssue(issues, path3, message);
+    return void 0;
+  }
+  return normalized;
+}
+function parseOptionalTrimmedString(value, path3, issues, typeMessage = "Expected a string.", emptyMessage = "Expected a non-empty string.") {
+  if (value === void 0) {
+    return void 0;
+  }
+  if (typeof value !== "string") {
+    pushIssue(issues, path3, typeMessage);
+    return void 0;
+  }
+  const normalized = value.trim();
+  if (normalized.length === 0) {
+    pushIssue(issues, path3, emptyMessage);
+    return void 0;
+  }
+  return normalized;
+}
+function parseOptionalBoolean(value, path3, issues, message = "Expected a boolean.") {
+  if (value === void 0) {
+    return void 0;
+  }
+  if (typeof value !== "boolean") {
+    pushIssue(issues, path3, message);
+    return void 0;
+  }
+  return value;
+}
+function parseOptionalIntegerInRange(value, path3, issues, bounds) {
+  if (value === void 0) {
+    return void 0;
+  }
+  if (typeof value !== "number" || !Number.isFinite(value) || !Number.isInteger(value)) {
+    pushIssue(issues, path3, integerRangeMessage(bounds));
+    return void 0;
+  }
+  if (bounds.min !== void 0 && value < bounds.min) {
+    pushIssue(issues, path3, integerRangeMessage(bounds));
+    return void 0;
+  }
+  if (bounds.max !== void 0 && value > bounds.max) {
+    pushIssue(issues, path3, integerRangeMessage(bounds));
+    return void 0;
+  }
+  return value;
+}
+function parseOptionalTimestampString(value, path3, issues, message = "Expected a valid timestamp string.") {
+  const timestamp = parseOptionalTrimmedString(value, path3, issues);
+  if (timestamp === void 0) {
+    return void 0;
+  }
+  if (Number.isNaN(Date.parse(timestamp))) {
+    pushIssue(issues, path3, message);
+    return void 0;
+  }
+  return timestamp;
+}
+function joinPath(basePath, key) {
+  return basePath.length > 0 ? `${basePath}.${key}` : key;
+}
+function integerRangeMessage(bounds) {
+  if (bounds.message) {
+    return bounds.message;
+  }
+  if (bounds.min === 0 && bounds.max === void 0) {
+    return "Expected a non-negative integer.";
+  }
+  if (bounds.min === 1 && bounds.max === void 0) {
+    return "Expected a positive integer.";
+  }
+  if (bounds.min !== void 0 && bounds.max !== void 0) {
+    return `Expected an integer from ${bounds.min} to ${bounds.max}.`;
+  }
+  if (bounds.min !== void 0) {
+    return `Expected an integer greater than or equal to ${bounds.min}.`;
+  }
+  if (bounds.max !== void 0) {
+    return `Expected an integer less than or equal to ${bounds.max}.`;
+  }
+  return "Expected an integer.";
+}
+
+// src/adapters/config/parse-feature-flags.ts
+function parseFeatureFlags(value, path3, issues) {
+  const defaults = DEFAULT_AGENR_FEATURE_FLAGS;
+  if (value === void 0) {
+    return {
+      resolved: { ...defaults }
+    };
+  }
+  if (!isRecord(value)) {
+    pushIssue(issues, path3, "Expected an object.");
+    return {
+      resolved: { ...defaults }
+    };
+  }
+  const startIndex = issues.length;
+  pushUnexpectedFields(value, new Set(AGENR_FEATURE_FLAG_KEYS), path3, issues);
+  const workingMemory = parseOptionalBoolean(value.workingMemory, `${path3}.workingMemory`, issues);
+  const sessionTreeLineage = parseOptionalBoolean(value.sessionTreeLineage, `${path3}.sessionTreeLineage`, issues);
+  const sessionTreeCompaction = parseOptionalBoolean(value.sessionTreeCompaction, `${path3}.sessionTreeCompaction`, issues);
+  const goalContinuation = parseOptionalBoolean(value.goalContinuation, `${path3}.goalContinuation`, issues);
+  if (issues.length > startIndex) {
+    return {
+      resolved: { ...defaults }
+    };
+  }
+  const input = {
+    ...workingMemory === true ? { workingMemory } : {},
+    ...sessionTreeLineage === true ? { sessionTreeLineage } : {},
+    ...sessionTreeCompaction === false ? { sessionTreeCompaction: false } : {},
+    ...goalContinuation === true ? { goalContinuation } : {}
+  };
+  return {
+    ...Object.keys(input).length > 0 ? { input } : {},
+    resolved: {
+      workingMemory: workingMemory ?? defaults.workingMemory,
+      sessionTreeLineage: sessionTreeLineage ?? defaults.sessionTreeLineage,
+      sessionTreeCompaction: sessionTreeCompaction ?? defaults.sessionTreeCompaction,
+      goalContinuation: goalContinuation ?? defaults.goalContinuation
+    }
+  };
+}
+function toFeatureFlagInput(value) {
+  if (!value) {
+    return void 0;
+  }
+  const defaults = DEFAULT_AGENR_FEATURE_FLAGS;
+  const input = {
+    ...value.workingMemory !== defaults.workingMemory ? { workingMemory: value.workingMemory } : {},
+    ...value.sessionTreeLineage !== defaults.sessionTreeLineage ? { sessionTreeLineage: value.sessionTreeLineage } : {},
+    ...value.sessionTreeCompaction !== defaults.sessionTreeCompaction ? { sessionTreeCompaction: value.sessionTreeCompaction } : {},
+    ...value.goalContinuation !== defaults.goalContinuation ? { goalContinuation: value.goalContinuation } : {}
+  };
+  return Object.keys(input).length > 0 ? input : void 0;
+}
+
+// src/adapters/config/parse-model-config.ts
+function parseProvider(value, path3, issues) {
+  const normalized = parseOptionalTrimmedString(value, path3, issues);
+  if (!normalized) {
+    return void 0;
+  }
+  if (!isAgenrProvider(normalized)) {
+    pushIssue(issues, path3, "Expected a supported provider.");
+    return void 0;
+  }
+  return normalized;
+}
+function parseModelConfig(value, path3, issues) {
+  if (value === void 0) {
+    return void 0;
+  }
+  if (!isRecord(value)) {
+    pushIssue(issues, path3, "Expected an object.");
+    return void 0;
+  }
+  const startIndex = issues.length;
+  pushUnexpectedFields(value, /* @__PURE__ */ new Set(["provider", "model"]), path3, issues);
+  const provider = parseProvider(value.provider, `${path3}.provider`, issues);
+  const model = parseOptionalTrimmedString(value.model, `${path3}.model`, issues);
+  if (!provider && !model) {
+    pushIssue(issues, path3, "Expected at least one of provider or model.");
+  }
+  if (issues.length > startIndex) {
+    return void 0;
+  }
+  return {
+    ...provider ? { provider } : {},
+    ...model ? { model } : {}
+  };
+}
+function hasModelConfig(value) {
+  return Boolean(value?.provider || value?.model);
+}
+
+// src/adapters/config/parse-dreaming-config.ts
+function parseDreamingConfig(value, path3, issues) {
+  const defaults = createDefaultDreamingConfig();
+  if (value === void 0) {
+    return { resolved: defaults };
+  }
+  if (!isRecord(value)) {
+    pushIssue(issues, path3, "Expected an object.");
+    return { resolved: defaults };
+  }
+  const startIndex = issues.length;
+  pushUnexpectedFields(value, /* @__PURE__ */ new Set(["model", "dailyCostCap", "tiers", "stages", "triggers"]), path3, issues);
+  const model = parseModelConfig(value.model, `${path3}.model`, issues);
+  const dailyCostCap = parseOptionalNonNegativeNumber(value.dailyCostCap, `${path3}.dailyCostCap`, issues);
+  const tiers = parseDreamingTiersConfig(value.tiers, `${path3}.tiers`, issues);
+  const stages = parseDreamingStagesConfig(value.stages, `${path3}.stages`, issues);
+  const triggers = parseDreamingTriggersConfig(value.triggers, `${path3}.triggers`, issues);
+  if (issues.length > startIndex) {
+    return { resolved: defaults };
+  }
+  const input = {
+    ...model ? { model } : {},
+    ...dailyCostCap !== void 0 ? { dailyCostCap } : {},
+    ...tiers.input ? { tiers: tiers.input } : {},
+    ...stages.input ? { stages: stages.input } : {},
+    ...triggers.input ? { triggers: triggers.input } : {}
+  };
+  return {
+    ...hasDreamingInput(input) ? { input } : {},
+    resolved: {
+      ...model ? { model } : {},
+      dailyCostCap: dailyCostCap ?? defaults.dailyCostCap,
+      tiers: tiers.resolved,
+      stages: stages.resolved,
+      triggers: triggers.resolved
+    }
+  };
+}
+function parseDreamingTiersConfig(value, path3, issues) {
+  const defaults = createDefaultDreamingConfig().tiers;
+  if (value === void 0) {
+    return { resolved: defaults };
+  }
+  if (!isRecord(value)) {
+    pushIssue(issues, path3, "Expected an object.");
+    return { resolved: defaults };
+  }
+  const startIndex = issues.length;
+  pushUnexpectedFields(value, /* @__PURE__ */ new Set(["light", "standard", "deep"]), path3, issues);
+  const light = parseDreamingTierEnabledConfig(value.light, `${path3}.light`, issues);
+  const standard = parseDreamingTierEnabledConfig(value.standard, `${path3}.standard`, issues);
+  const deep = parseDreamingDeepTierConfig(value.deep, `${path3}.deep`, issues);
+  if (issues.length > startIndex) {
+    return { resolved: defaults };
+  }
+  const input = {
+    ...light.input ? { light: light.input } : {},
+    ...standard.input ? { standard: standard.input } : {},
+    ...deep.input ? { deep: deep.input } : {}
+  };
+  return {
+    ...Object.keys(input).length > 0 ? { input } : {},
+    resolved: {
+      light: { enabled: light.resolved.enabled ?? defaults.light.enabled },
+      standard: { enabled: standard.resolved.enabled ?? defaults.standard.enabled },
+      deep: {
+        enabled: deep.resolved.enabled ?? defaults.deep.enabled,
+        intervalHours: deep.resolved.intervalHours ?? defaults.deep.intervalHours
+      }
+    }
+  };
+}
+function parseDreamingTierEnabledConfig(value, path3, issues) {
+  if (value === void 0) {
+    return { resolved: {} };
+  }
+  if (!isRecord(value)) {
+    pushIssue(issues, path3, "Expected an object.");
+    return { resolved: {} };
+  }
+  pushUnexpectedFields(value, /* @__PURE__ */ new Set(["enabled"]), path3, issues);
+  const enabled = parseOptionalBoolean(value.enabled, `${path3}.enabled`, issues);
+  const input = enabled !== void 0 ? { enabled } : {};
+  return {
+    ...Object.keys(input).length > 0 ? { input } : {},
+    resolved: input
+  };
+}
+function parseDreamingDeepTierConfig(value, path3, issues) {
+  if (value === void 0) {
+    return { resolved: {} };
+  }
+  if (!isRecord(value)) {
+    pushIssue(issues, path3, "Expected an object.");
+    return { resolved: {} };
+  }
+  pushUnexpectedFields(value, /* @__PURE__ */ new Set(["enabled", "intervalHours"]), path3, issues);
+  const enabled = parseOptionalBoolean(value.enabled, `${path3}.enabled`, issues);
+  const intervalHours = parseOptionalIntegerInRange(value.intervalHours, `${path3}.intervalHours`, issues, { min: 1 });
+  const input = {
+    ...enabled !== void 0 ? { enabled } : {},
+    ...intervalHours !== void 0 ? { intervalHours } : {}
+  };
+  return {
+    ...Object.keys(input).length > 0 ? { input } : {},
+    resolved: input
+  };
+}
+function parseDreamingStagesConfig(value, path3, issues) {
+  const defaults = createDefaultDreamingConfig().stages;
+  if (value === void 0) {
+    return { resolved: defaults };
+  }
+  if (!isRecord(value)) {
+    pushIssue(issues, path3, "Expected an object.");
+    return { resolved: defaults };
+  }
+  const startIndex = issues.length;
+  pushUnexpectedFields(value, /* @__PURE__ */ new Set(["extract", "project", "prune"]), path3, issues);
+  const extract = parseDreamingExtractConfig(value.extract, `${path3}.extract`, issues);
+  const project = parseDreamingProjectConfig(value.project, `${path3}.project`, issues);
+  const prune = parseDreamingPruneConfig(value.prune, `${path3}.prune`, issues);
+  if (issues.length > startIndex) {
+    return { resolved: defaults };
+  }
+  const input = {
+    ...extract.input ? { extract: extract.input } : {},
+    ...project.input ? { project: project.input } : {},
+    ...prune.input ? { prune: prune.input } : {}
+  };
+  return {
+    ...Object.keys(input).length > 0 ? { input } : {},
+    resolved: {
+      extract: extract.resolved,
+      project: project.resolved,
+      prune: prune.resolved
+    }
+  };
+}
+function parseDreamingExtractConfig(value, path3, issues) {
+  const defaults = createDefaultDreamingConfig().stages.extract;
+  if (value === void 0) {
+    return { resolved: defaults };
+  }
+  if (!isRecord(value)) {
+    pushIssue(issues, path3, "Expected an object.");
+    return { resolved: defaults };
+  }
+  const startIndex = issues.length;
+  pushUnexpectedFields(value, /* @__PURE__ */ new Set(["maxSessionsPerRun", "lightMaxSessionsPerRun", "contextLookup"]), path3, issues);
+  const maxSessionsPerRun = parseOptionalIntegerInRange(value.maxSessionsPerRun, `${path3}.maxSessionsPerRun`, issues, { min: 1 });
+  const lightMaxSessionsPerRun = parseOptionalIntegerInRange(value.lightMaxSessionsPerRun, `${path3}.lightMaxSessionsPerRun`, issues, { min: 1 });
+  const contextLookup = parseDreamingContextLookupConfig(value.contextLookup, `${path3}.contextLookup`, issues);
+  if (issues.length > startIndex) {
+    return { resolved: defaults };
+  }
+  const input = {
+    ...maxSessionsPerRun !== void 0 ? { maxSessionsPerRun } : {},
+    ...lightMaxSessionsPerRun !== void 0 ? { lightMaxSessionsPerRun } : {},
+    ...contextLookup.input ? { contextLookup: contextLookup.input } : {}
+  };
+  return {
+    ...Object.keys(input).length > 0 ? { input } : {},
+    resolved: {
+      maxSessionsPerRun: maxSessionsPerRun ?? defaults.maxSessionsPerRun,
+      lightMaxSessionsPerRun: lightMaxSessionsPerRun ?? defaults.lightMaxSessionsPerRun,
+      contextLookup: contextLookup.resolved
+    }
+  };
+}
+function parseDreamingContextLookupConfig(value, path3, issues) {
+  const defaults = createDefaultDreamingConfig().stages.extract.contextLookup;
+  if (value === void 0) {
+    return { resolved: defaults };
+  }
+  if (!isRecord(value)) {
+    pushIssue(issues, path3, "Expected an object.");
+    return { resolved: defaults };
+  }
+  pushUnexpectedFields(value, /* @__PURE__ */ new Set(["enabled"]), path3, issues);
+  const enabled = parseOptionalBoolean(value.enabled, `${path3}.enabled`, issues);
+  const input = {
+    ...enabled !== void 0 ? { enabled } : {}
+  };
+  return {
+    ...Object.keys(input).length > 0 ? { input } : {},
+    resolved: {
+      enabled: enabled ?? defaults.enabled
+    }
+  };
+}
+function parseDreamingProjectConfig(value, path3, issues) {
+  const defaults = createDefaultDreamingConfig().stages.project;
+  if (value === void 0) {
+    return { resolved: defaults };
+  }
+  if (!isRecord(value)) {
+    pushIssue(issues, path3, "Expected an object.");
+    return { resolved: defaults };
+  }
+  pushUnexpectedFields(value, /* @__PURE__ */ new Set(["maxProfileDurables"]), path3, issues);
+  const maxProfileDurables = parseOptionalIntegerInRange(value.maxProfileDurables, `${path3}.maxProfileDurables`, issues, { min: 1 });
+  const input = {
+    ...maxProfileDurables !== void 0 ? { maxProfileDurables } : {}
+  };
+  return {
+    ...Object.keys(input).length > 0 ? { input } : {},
+    resolved: {
+      maxProfileDurables: maxProfileDurables ?? defaults.maxProfileDurables
+    }
+  };
+}
+function parseDreamingPruneConfig(value, path3, issues) {
+  const defaults = createDefaultDreamingPruneConfig();
+  if (value === void 0) {
+    return { resolved: defaults };
+  }
+  if (!isRecord(value)) {
+    pushIssue(issues, path3, "Expected an object.");
+    return { resolved: defaults };
+  }
+  const startIndex = issues.length;
+  pushUnexpectedFields(value, /* @__PURE__ */ new Set(["protectRecalledDays", "protectMinImportance"]), path3, issues);
+  const protectRecalledDays = parseOptionalIntegerInRange(value.protectRecalledDays, `${path3}.protectRecalledDays`, issues, { min: 0 });
+  const protectMinImportance = parseOptionalIntegerInRange(value.protectMinImportance, `${path3}.protectMinImportance`, issues, { min: 0 });
+  if (issues.length > startIndex) {
+    return { resolved: defaults };
+  }
+  const input = {
+    ...protectRecalledDays !== void 0 ? { protectRecalledDays } : {},
+    ...protectMinImportance !== void 0 ? { protectMinImportance } : {}
+  };
+  return {
+    ...Object.keys(input).length > 0 ? { input } : {},
+    resolved: {
+      protectRecalledDays: protectRecalledDays ?? defaults.protectRecalledDays,
+      protectMinImportance: protectMinImportance ?? defaults.protectMinImportance
+    }
+  };
+}
+function parseDreamingTriggersConfig(value, path3, issues) {
+  const defaults = createDefaultDreamingConfig().triggers;
+  if (value === void 0) {
+    return { resolved: defaults };
+  }
+  if (!isRecord(value)) {
+    pushIssue(issues, path3, "Expected an object.");
+    return { resolved: defaults };
+  }
+  const startIndex = issues.length;
+  pushUnexpectedFields(value, /* @__PURE__ */ new Set(["postSessionLightDream", "importanceThreshold", "minIntervalMinutes"]), path3, issues);
+  const postSessionLightDream = parseOptionalBoolean(value.postSessionLightDream, `${path3}.postSessionLightDream`, issues);
+  const importanceThreshold = parseOptionalIntegerInRange(value.importanceThreshold, `${path3}.importanceThreshold`, issues, { min: 0 });
+  const minIntervalMinutes = parseOptionalIntegerInRange(value.minIntervalMinutes, `${path3}.minIntervalMinutes`, issues, { min: 0 });
+  if (issues.length > startIndex) {
+    return { resolved: defaults };
+  }
+  const input = {
+    ...postSessionLightDream !== void 0 ? { postSessionLightDream } : {},
+    ...importanceThreshold !== void 0 ? { importanceThreshold } : {},
+    ...minIntervalMinutes !== void 0 ? { minIntervalMinutes } : {}
+  };
+  return {
+    ...Object.keys(input).length > 0 ? { input } : {},
+    resolved: {
+      postSessionLightDream: postSessionLightDream ?? defaults.postSessionLightDream,
+      importanceThreshold: importanceThreshold ?? defaults.importanceThreshold,
+      minIntervalMinutes: minIntervalMinutes ?? defaults.minIntervalMinutes
+    }
+  };
+}
+function parseOptionalNonNegativeNumber(value, path3, issues) {
+  if (value === void 0) {
+    return void 0;
+  }
+  if (typeof value !== "number" || !Number.isFinite(value) || value < 0) {
+    pushIssue(issues, path3, "Expected a non-negative number.");
+    return void 0;
+  }
+  return value;
+}
+function createDefaultDreamingConfig() {
+  return {
+    dailyCostCap: DEFAULT_DREAMING_DAILY_COST_CAP,
+    tiers: {
+      light: { enabled: true },
+      standard: { enabled: true },
+      deep: { enabled: true, intervalHours: DEFAULT_DREAMING_DEEP_INTERVAL_HOURS }
+    },
+    stages: {
+      extract: {
+        maxSessionsPerRun: DEFAULT_DREAMING_EXTRACT_MAX_SESSIONS,
+        lightMaxSessionsPerRun: DEFAULT_DREAMING_LIGHT_MAX_SESSIONS,
+        contextLookup: {
+          enabled: true
+        }
+      },
+      project: { maxProfileDurables: DEFAULT_DREAMING_MAX_PROFILE_DURABLES },
+      prune: createDefaultDreamingPruneConfig()
+    },
+    triggers: {
+      postSessionLightDream: true,
+      importanceThreshold: DEFAULT_DREAMING_IMPORTANCE_THRESHOLD,
+      minIntervalMinutes: DEFAULT_DREAMING_MIN_INTERVAL_MINUTES
+    }
+  };
+}
+function createDefaultDreamingPruneConfig() {
+  return {
+    protectRecalledDays: DEFAULT_DREAMING_PRUNE_PROTECT_RECALLED_DAYS,
+    protectMinImportance: DEFAULT_DREAMING_PRUNE_PROTECT_MIN_IMPORTANCE
+  };
+}
+function hasDreamingInput(value) {
+  return hasModelConfig(value.model) || value.dailyCostCap !== void 0 || value.tiers !== void 0 || value.stages?.extract !== void 0 || value.stages?.project !== void 0 || value.stages?.prune !== void 0 || value.triggers !== void 0;
+}
+function toDreamingInput(value) {
+  const tiers = value.tiers;
+  const tiersInput = {
+    ...tiers.light.enabled !== true ? { light: { enabled: tiers.light.enabled } } : {},
+    ...tiers.standard.enabled !== true ? { standard: { enabled: tiers.standard.enabled } } : {},
+    ...tiers.deep.enabled !== true || tiers.deep.intervalHours !== DEFAULT_DREAMING_DEEP_INTERVAL_HOURS ? {
+      deep: {
+        ...tiers.deep.enabled !== true ? { enabled: tiers.deep.enabled } : {},
+        ...tiers.deep.intervalHours !== DEFAULT_DREAMING_DEEP_INTERVAL_HOURS ? { intervalHours: tiers.deep.intervalHours } : {}
+      }
+    } : {}
+  };
+  const extract = value.stages.extract;
+  const contextLookup = extract.contextLookup;
+  const contextLookupInput = {
+    ...contextLookup.enabled !== true ? { enabled: contextLookup.enabled } : {}
+  };
+  const extractInput = {
+    ...extract.maxSessionsPerRun !== DEFAULT_DREAMING_EXTRACT_MAX_SESSIONS ? { maxSessionsPerRun: extract.maxSessionsPerRun } : {},
+    ...extract.lightMaxSessionsPerRun !== DEFAULT_DREAMING_LIGHT_MAX_SESSIONS ? { lightMaxSessionsPerRun: extract.lightMaxSessionsPerRun } : {},
+    ...Object.keys(contextLookupInput).length > 0 ? { contextLookup: contextLookupInput } : {}
+  };
+  const project = value.stages.project;
+  const projectInput = {
+    ...project.maxProfileDurables !== DEFAULT_DREAMING_MAX_PROFILE_DURABLES ? { maxProfileDurables: project.maxProfileDurables } : {}
+  };
+  const prune = value.stages.prune;
+  const pruneInput = {
+    ...prune.protectRecalledDays !== DEFAULT_DREAMING_PRUNE_PROTECT_RECALLED_DAYS ? { protectRecalledDays: prune.protectRecalledDays } : {},
+    ...prune.protectMinImportance !== DEFAULT_DREAMING_PRUNE_PROTECT_MIN_IMPORTANCE ? { protectMinImportance: prune.protectMinImportance } : {}
+  };
+  const triggers = value.triggers;
+  const triggersInput = {
+    ...triggers.postSessionLightDream !== true ? { postSessionLightDream: triggers.postSessionLightDream } : {},
+    ...triggers.importanceThreshold !== DEFAULT_DREAMING_IMPORTANCE_THRESHOLD ? { importanceThreshold: triggers.importanceThreshold } : {},
+    ...triggers.minIntervalMinutes !== DEFAULT_DREAMING_MIN_INTERVAL_MINUTES ? { minIntervalMinutes: triggers.minIntervalMinutes } : {}
+  };
+  const stagesInput = {
+    ...Object.keys(extractInput).length > 0 ? { extract: extractInput } : {},
+    ...Object.keys(projectInput).length > 0 ? { project: projectInput } : {},
+    ...Object.keys(pruneInput).length > 0 ? { prune: pruneInput } : {}
+  };
+  const input = {
+    ...hasModelConfig(value.model) ? { model: value.model } : {},
+    ...value.dailyCostCap !== DEFAULT_DREAMING_DAILY_COST_CAP ? { dailyCostCap: value.dailyCostCap } : {},
+    ...Object.keys(tiersInput).length > 0 ? { tiers: tiersInput } : {},
+    ...Object.keys(stagesInput).length > 0 ? { stages: stagesInput } : {},
+    ...Object.keys(triggersInput).length > 0 ? { triggers: triggersInput } : {}
+  };
+  return hasDreamingInput(input) ? input : void 0;
+}
+
+// src/adapters/config/parse-agenr-config.ts
+function parseAgenrConfig(value, options) {
+  const normalized = normalizeAgenrConfig(value, options);
+  return normalized.ok ? { ok: true, value: normalized.resolved } : normalized;
+}
+function canonicalizeAgenrConfigInput(value, options) {
+  const normalized = normalizeAgenrConfig(value, options);
+  return normalized.ok ? { ok: true, value: normalized.input } : normalized;
+}
+function toAgenrConfigInput(config, options = {}) {
+  const input = {
+    ...config.auth ? { auth: config.auth } : {},
+    ...config.provider ? { provider: config.provider } : {},
+    ...config.model ? { model: config.model } : {},
+    ...hasStoredCredentials(config.credentials) ? { credentials: config.credentials } : {},
+    ...config.embeddingModel ? { embeddingModel: config.embeddingModel } : {},
+    ...config.extractionContext ? { extractionContext: config.extractionContext } : {},
+    ...hasModelConfig(config.extractionModel) ? { extractionModel: config.extractionModel } : {},
+    ...hasModelConfig(config.dedupModel) ? { dedupModel: config.dedupModel } : {},
+    ...hasModelConfig(config.episodeModel) ? { episodeModel: config.episodeModel } : {},
+    ...hasModelConfig(config.crossEncoderModel) ? { crossEncoderModel: config.crossEncoderModel } : {}
+  };
+  const features = toFeatureFlagInput(config.features);
+  if (features) {
+    input.features = features;
+  }
+  const claimExtraction = toClaimExtractionInput(config.claimExtraction);
+  if (claimExtraction) {
+    input.claimExtraction = claimExtraction;
+  }
+  const dreaming = toDreamingInput(config.dreaming);
+  if (dreaming) {
+    input.dreaming = dreaming;
+  }
+  if (config.dbPath !== options.defaultDbPath) {
+    input.dbPath = config.dbPath;
+  }
+  if (config.apiPort !== DEFAULT_API_PORT) {
+    input.apiPort = config.apiPort;
+  }
+  return input;
+}
+function normalizeAgenrConfig(value, options) {
+  const issues = [];
+  const claimDefaults = createDefaultClaimExtractionConfig();
+  const dreamingDefaults = createDefaultDreamingConfig();
+  if (value === void 0) {
+    return {
+      ok: true,
+      input: {},
+      resolved: {
+        claimExtraction: claimDefaults,
+        dreaming: dreamingDefaults,
+        features: { ...DEFAULT_AGENR_FEATURE_FLAGS },
+        dbPath: options.defaultDbPath,
+        apiPort: DEFAULT_API_PORT
+      }
+    };
+  }
+  if (!isRecord(value)) {
+    return {
+      ok: false,
+      issues: [{ path: "config", message: "Expected a JSON object." }]
+    };
+  }
+  pushTopLevelIssues(value, issues);
+  const auth = parseAuth(value.auth, "auth", issues);
+  const provider = parseProvider(value.provider, "provider", issues);
+  const model = parseOptionalTrimmedString(value.model, "model", issues);
+  const credentials = parseCredentials(value.credentials, "credentials", issues);
+  const embeddingModel = parseOptionalTrimmedString(value.embeddingModel, "embeddingModel", issues);
+  const extractionContext = parseOptionalTrimmedString(value.extractionContext, "extractionContext", issues);
+  const extractionModel = parseModelConfig(value.extractionModel, "extractionModel", issues);
+  const dedupModel = parseModelConfig(value.dedupModel, "dedupModel", issues);
+  const episodeModel = parseModelConfig(value.episodeModel, "episodeModel", issues);
+  const crossEncoderModel = parseModelConfig(value.crossEncoderModel, "crossEncoderModel", issues);
+  const claimExtraction = parseClaimExtractionConfig(value.claimExtraction, "claimExtraction", issues);
+  const dreaming = parseDreamingConfig(value.dreaming, "dreaming", issues);
+  const features = parseFeatureFlags(value.features, "features", issues);
+  const dbPath = parseOptionalTrimmedString(value.dbPath, "dbPath", issues);
+  const apiPort = parseOptionalIntegerInRange(value.apiPort, "apiPort", issues, {
+    min: 1,
+    max: 65535
+  });
+  if (auth && provider && authMethodToProvider(auth) !== provider) {
+    pushIssue(issues, "provider", `Provider "${provider}" does not match auth method "${auth}".`);
+  }
+  if (issues.length > 0) {
+    return {
+      ok: false,
+      issues
+    };
+  }
+  const input = {
+    ...auth ? { auth } : {},
+    ...provider ? { provider } : {},
+    ...model ? { model } : {},
+    ...credentials ? { credentials } : {},
+    ...embeddingModel ? { embeddingModel } : {},
+    ...extractionContext ? { extractionContext } : {},
+    ...extractionModel ? { extractionModel } : {},
+    ...dedupModel ? { dedupModel } : {},
+    ...episodeModel ? { episodeModel } : {},
+    ...crossEncoderModel ? { crossEncoderModel } : {},
+    ...claimExtraction.input ? { claimExtraction: claimExtraction.input } : {},
+    ...dreaming.input ? { dreaming: dreaming.input } : {},
+    ...features.input ? { features: features.input } : {},
+    ...dbPath ? { dbPath } : {},
+    ...apiPort !== void 0 ? { apiPort } : {}
+  };
+  return {
+    ok: true,
+    input,
+    resolved: {
+      ...auth ? { auth } : {},
+      ...provider ? { provider } : {},
+      ...model ? { model } : {},
+      ...credentials ? { credentials } : {},
+      ...embeddingModel ? { embeddingModel } : {},
+      ...extractionContext ? { extractionContext } : {},
+      ...extractionModel ? { extractionModel } : {},
+      ...dedupModel ? { dedupModel } : {},
+      ...episodeModel ? { episodeModel } : {},
+      ...crossEncoderModel ? { crossEncoderModel } : {},
+      claimExtraction: claimExtraction.resolved,
+      dreaming: dreaming.resolved,
+      features: features.resolved,
+      dbPath: dbPath ?? options.defaultDbPath,
+      apiPort: apiPort ?? DEFAULT_API_PORT
+    }
+  };
+}
+function pushTopLevelIssues(value, issues) {
+  const allowedKeys = /* @__PURE__ */ new Set([
+    "auth",
+    "provider",
+    "model",
+    "credentials",
+    "embeddingModel",
+    "extractionContext",
+    "extractionModel",
+    "dedupModel",
+    "episodeModel",
+    "crossEncoderModel",
+    "claimExtraction",
+    "dreaming",
+    "features",
+    "dbPath",
+    "apiPort",
+    "apiKey",
+    "embeddingApiKey"
+  ]);
+  pushUnexpectedFields(value, allowedKeys, "", issues);
+  if ("apiKey" in value) {
+    pushIssue(issues, "apiKey", "Removed field. Move this value to credentials.openaiApiKey or credentials.anthropicApiKey, then delete apiKey.");
+  }
+  if ("embeddingApiKey" in value) {
+    pushIssue(issues, "embeddingApiKey", "Removed field. Move this value to credentials.openaiApiKey, then delete embeddingApiKey.");
+  }
+  if ("surgeon" in value) {
+    pushIssue(issues, "surgeon", 'Removed field. Rename the top-level "surgeon" block to "dreaming", then delete surgeon.');
+  }
+}
+function parseAuth(value, path3, issues) {
+  const normalized = parseOptionalTrimmedString(value, path3, issues);
+  if (!normalized) {
+    return void 0;
+  }
+  if (!isAgenrAuthMethod(normalized)) {
+    pushIssue(issues, path3, "Expected a supported auth method.");
+    return void 0;
+  }
+  return normalized;
+}
+function parseCredentials(value, path3, issues) {
+  if (value === void 0) {
+    return void 0;
+  }
+  if (!isRecord(value)) {
+    pushIssue(issues, path3, "Expected an object.");
+    return void 0;
+  }
+  const startIndex = issues.length;
+  pushUnexpectedFields(value, /* @__PURE__ */ new Set(["openaiApiKey", "anthropicApiKey", "anthropicOauthToken"]), path3, issues);
+  const openaiApiKey = parseOptionalTrimmedString(value.openaiApiKey, `${path3}.openaiApiKey`, issues);
+  const anthropicApiKey = parseOptionalTrimmedString(value.anthropicApiKey, `${path3}.anthropicApiKey`, issues);
+  const anthropicOauthToken = parseOptionalTrimmedString(value.anthropicOauthToken, `${path3}.anthropicOauthToken`, issues);
+  if (issues.length > startIndex) {
+    return void 0;
+  }
+  const credentials = {
+    ...openaiApiKey ? { openaiApiKey } : {},
+    ...anthropicApiKey ? { anthropicApiKey } : {},
+    ...anthropicOauthToken ? { anthropicOauthToken } : {}
+  };
+  return hasStoredCredentials(credentials) ? credentials : void 0;
+}
+function parseClaimExtractionConfig(value, path3, issues) {
+  const defaults = createDefaultClaimExtractionConfig();
+  if (value === void 0) {
+    return {
+      resolved: defaults
+    };
+  }
+  if (!isRecord(value)) {
+    pushIssue(issues, path3, "Expected an object.");
+    return {
+      resolved: defaults
+    };
+  }
+  const startIndex = issues.length;
+  pushUnexpectedFields(value, /* @__PURE__ */ new Set(["enabled", "confidenceThreshold", "eligibleTypes", "concurrency", "model"]), path3, issues);
+  const enabled = parseOptionalBoolean(value.enabled, `${path3}.enabled`, issues);
+  const confidenceThreshold = parseOptionalUnitInterval(value.confidenceThreshold, `${path3}.confidenceThreshold`, issues);
+  const eligibleTypes = parseEligibleTypes(value.eligibleTypes, `${path3}.eligibleTypes`, issues);
+  const concurrency = parseOptionalIntegerInRange(value.concurrency, `${path3}.concurrency`, issues, {
+    min: 1
+  });
+  const model = parseModelConfig(value.model, `${path3}.model`, issues);
+  if (issues.length > startIndex) {
+    return {
+      resolved: defaults
+    };
+  }
+  const input = {
+    ...enabled !== void 0 ? { enabled } : {},
+    ...confidenceThreshold !== void 0 ? { confidenceThreshold } : {},
+    ...eligibleTypes ? { eligibleTypes } : {},
+    ...concurrency !== void 0 ? { concurrency } : {},
+    ...model ? { model } : {}
+  };
+  return {
+    ...hasClaimExtractionInput(input) ? { input } : {},
+    resolved: {
+      enabled: enabled ?? defaults.enabled,
+      confidenceThreshold: confidenceThreshold ?? defaults.confidenceThreshold,
+      eligibleTypes: eligibleTypes ?? defaults.eligibleTypes,
+      concurrency: concurrency ?? defaults.concurrency,
+      ...model ? { model } : {}
+    }
+  };
+}
+function parseOptionalUnitInterval(value, path3, issues) {
+  if (value === void 0) {
+    return void 0;
+  }
+  if (typeof value !== "number" || !Number.isFinite(value) || value < 0 || value > 1) {
+    pushIssue(issues, path3, "Expected a number from 0 to 1.");
+    return void 0;
+  }
+  return value;
+}
+function parseEligibleTypes(value, path3, issues) {
+  if (value === void 0) {
+    return void 0;
+  }
+  if (!Array.isArray(value)) {
+    pushIssue(issues, path3, "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, `${path3}.${index}`, "Expected a supported entry type.");
+      continue;
+    }
+    const trimmed = item.trim();
+    if (!isDurableKind(trimmed)) {
+      pushIssue(issues, `${path3}.${index}`, "Expected a supported entry type.");
+      continue;
+    }
+    if (!seen.has(trimmed)) {
+      seen.add(trimmed);
+      normalized.push(trimmed);
+    }
+  }
+  if (normalized.length === 0) {
+    pushIssue(issues, path3, "Expected at least one supported entry type.");
+    return void 0;
+  }
+  return normalized;
+}
+function createDefaultClaimExtractionConfig() {
+  return {
+    enabled: true,
+    confidenceThreshold: DEFAULT_CLAIM_EXTRACTION_CONFIDENCE_THRESHOLD,
+    eligibleTypes: [...DEFAULT_CLAIM_EXTRACTION_ELIGIBLE_TYPES],
+    concurrency: DEFAULT_CLAIM_EXTRACTION_CONCURRENCY
+  };
+}
+function hasStoredCredentials(credentials) {
+  return Boolean(credentials?.openaiApiKey || credentials?.anthropicApiKey || credentials?.anthropicOauthToken);
+}
+function hasClaimExtractionInput(value) {
+  return value.enabled !== void 0 || value.confidenceThreshold !== void 0 || value.eligibleTypes !== void 0 || value.concurrency !== void 0 || hasModelConfig(value.model);
+}
+function toClaimExtractionInput(value) {
+  const input = {
+    ...value.enabled !== true ? { enabled: value.enabled } : {},
+    ...value.confidenceThreshold !== DEFAULT_CLAIM_EXTRACTION_CONFIDENCE_THRESHOLD ? { confidenceThreshold: value.confidenceThreshold } : {},
+    ...!sameEligibleKinds(value.eligibleTypes, DEFAULT_CLAIM_EXTRACTION_ELIGIBLE_TYPES) ? { eligibleTypes: [...value.eligibleTypes] } : {},
+    ...value.concurrency !== DEFAULT_CLAIM_EXTRACTION_CONCURRENCY ? { concurrency: value.concurrency } : {},
+    ...hasModelConfig(value.model) ? { model: value.model } : {}
+  };
+  return hasClaimExtractionInput(input) ? input : void 0;
+}
+
+// src/config.ts
+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;
+function resolveConfigDir(env = process.env) {
+  return env.AGENR_CONFIG_DIR ?? DEFAULT_CONFIG_DIR;
+}
+function resolveConfigPath(options = {}) {
+  const env = options.env ?? process.env;
+  const envConfigPath = normalizeOptionalString(env.AGENR_CONFIG_PATH);
+  if (envConfigPath) {
+    return envConfigPath;
+  }
+  const explicitConfigPath = normalizeOptionalString(options.configPath);
+  if (explicitConfigPath) {
+    return explicitConfigPath;
+  }
+  const adjacentConfigPath = resolveAdjacentConfigPath(options.dbPath);
+  if (adjacentConfigPath) {
+    return adjacentConfigPath;
+  }
+  return path2.join(resolveConfigDir(env), "config.json");
+}
+function resolveDbPath(config, env = process.env) {
+  return normalizeOptionalString(env.AGENR_DB_PATH) ?? normalizeOptionalString(config?.dbPath) ?? resolvePersistedDefaultDbPath(env);
+}
+function resolveClaimExtractionConfig(config) {
+  if (config && "enabled" in (config.claimExtraction ?? {})) {
+    const claimExtraction = config.claimExtraction;
+    if (typeof claimExtraction.enabled === "boolean" && typeof claimExtraction.confidenceThreshold === "number" && Array.isArray(claimExtraction.eligibleTypes) && typeof claimExtraction.concurrency === "number") {
+      return {
+        enabled: claimExtraction.enabled,
+        confidenceThreshold: claimExtraction.confidenceThreshold,
+        eligibleTypes: [...claimExtraction.eligibleTypes],
+        concurrency: claimExtraction.concurrency
+      };
+    }
+  }
+  const parsed = parseAgenrConfig(
+    {
+      ...config?.claimExtraction ? { claimExtraction: config.claimExtraction } : {}
+    },
+    { defaultDbPath: resolvePersistedDefaultDbPath() }
+  );
+  if (!parsed.ok) {
+    return {
+      enabled: true,
+      confidenceThreshold: DEFAULT_CLAIM_EXTRACTION_CONFIDENCE_THRESHOLD,
+      eligibleTypes: [...DEFAULT_CLAIM_EXTRACTION_ELIGIBLE_TYPES],
+      concurrency: DEFAULT_CLAIM_EXTRACTION_CONCURRENCY
+    };
+  }
+  return {
+    enabled: parsed.value.claimExtraction.enabled,
+    confidenceThreshold: parsed.value.claimExtraction.confidenceThreshold,
+    eligibleTypes: [...parsed.value.claimExtraction.eligibleTypes],
+    concurrency: parsed.value.claimExtraction.concurrency
+  };
+}
+function readConfig(options = {}) {
+  const configPath = resolveConfigFilesystemPath(resolveConfigPath(options));
+  const defaultDbPath = resolveReadDefaultDbPath(options);
+  if (!fs.existsSync(configPath)) {
+    const parsed2 = parseAgenrConfig(void 0, { defaultDbPath });
+    if (!parsed2.ok) {
+      throw new Error("Internal config parser failure for empty config.");
+    }
+    return parsed2.value;
+  }
+  let parsedJson;
+  try {
+    const raw = fs.readFileSync(configPath, "utf-8");
+    parsedJson = JSON.parse(raw);
+  } catch (error) {
+    const message = error instanceof Error ? error.message : String(error);
+    throw new Error(`Invalid agenr config at ${configPath}: JSON parse failed - ${message}`, {
+      cause: error
+    });
+  }
+  const parsed = parseAgenrConfig(parsedJson, { defaultDbPath });
+  if (!parsed.ok) {
+    throw new Error(formatConfigValidationError(configPath, parsed.issues));
+  }
+  return parsed.value;
+}
+function configFileExists(options = {}) {
+  return fs.existsSync(resolveConfigFilesystemPath(resolveConfigPath(options)));
+}
+function writeConfig(config, options = {}) {
+  const configPath = resolveConfigFilesystemPath(resolveConfigPath(options));
+  const configDir = path2.dirname(configPath);
+  const canonical = canonicalizeAgenrConfigInput(config, {
+    defaultDbPath: resolvePersistedDefaultDbPath()
+  });
+  if (!canonical.ok) {
+    throw new Error(formatConfigValidationError(configPath, canonical.issues));
+  }
+  fs.mkdirSync(configDir, { recursive: true, mode: CONFIG_DIR_MODE });
+  try {
+    fs.chmodSync(configDir, CONFIG_DIR_MODE);
+  } catch {
+  }
+  fs.writeFileSync(configPath, `${JSON.stringify(canonical.value, null, 2)}
+`, {
+    encoding: "utf-8",
+    mode: CONFIG_FILE_MODE
+  });
+  try {
+    fs.chmodSync(configPath, CONFIG_FILE_MODE);
+  } catch {
+  }
+}
+function resolveAdjacentConfigPath(dbPath) {
+  const normalizedDbPath = normalizeOptionalString(dbPath);
+  if (!normalizedDbPath || normalizedDbPath === ":memory:") {
+    return void 0;
+  }
+  if (normalizedDbPath.startsWith("file:")) {
+    const filePath = resolveLocalFilesystemPath(normalizedDbPath);
+    return filePath ? path2.join(path2.dirname(filePath), "config.json") : void 0;
+  }
+  return path2.join(path2.dirname(normalizedDbPath), "config.json");
+}
+function normalizeOptionalString(value) {
+  const normalized = value?.trim();
+  return normalized && normalized.length > 0 ? normalized : void 0;
+}
+function resolvePersistedDefaultDbPath(env = process.env) {
+  return path2.join(resolveConfigDir(env), DEFAULT_DB_NAME);
+}
+function resolveReadDefaultDbPath(options) {
+  const env = options.env ?? process.env;
+  return normalizeOptionalString(env.AGENR_DB_PATH) ?? normalizeOptionalString(options.dbPath) ?? resolvePersistedDefaultDbPath(env);
+}
+function formatConfigValidationError(configPath, issues) {
+  const details = issues.map((issue) => `${issue.path}: ${issue.message}`).join("; ");
+  return `Invalid agenr config at ${configPath}: ${details}`;
+}
+
+// src/core/directives/model.ts
+var MEMORY_DIRECTIVE_CLAIM_KEY_PREFIX = "user/memory_directive/";
+var DEFAULT_PROACTIVE_DIRECTIVE_TRIGGER = "session_start";
+var DEFAULT_ABSTAIN_DIRECTIVE_TRIGGER = "always";
+var MIN_DIRECTIVE_TOPIC_LENGTH = 2;
+function isDirectiveDurable(entry) {
+  const claimKey = entry.claim_key?.trim();
+  return entry.type === "directive" || claimKey !== void 0 && claimKey.startsWith(MEMORY_DIRECTIVE_CLAIM_KEY_PREFIX) && claimKey.length > MEMORY_DIRECTIVE_CLAIM_KEY_PREFIX.length;
+}
+function parseDirectiveTrigger(value) {
+  if (typeof value !== "string") {
+    return void 0;
+  }
+  const normalized = normalizeForDirective(value);
+  if (DIRECTIVE_BASE_TRIGGERS.includes(normalized)) {
+    return normalized;
+  }
+  if (!normalized.startsWith("topic:")) {
+    return void 0;
+  }
+  const topic = normalizeForDirective(normalized.slice("topic:".length));
+  return topic.length >= MIN_DIRECTIVE_TOPIC_LENGTH ? `topic:${topic}` : void 0;
+}
+function parseDirectivePolarity(value) {
+  if (typeof value !== "string") {
+    return void 0;
+  }
+  const normalized = normalizeForDirective(value);
+  return DIRECTIVE_POLARITIES.includes(normalized) ? normalized : void 0;
+}
+function normalizeMemoryDirectiveClaimKey(value) {
+  if (typeof value !== "string") {
+    return void 0;
+  }
+  const segments = value.split("/").map((segment) => normalizeClaimKeySegment(segment)).filter((segment) => segment.length > 0);
+  if (segments.length !== 3 || segments[0] !== "user" || segments[1] !== "memory_directive") {
+    return void 0;
+  }
+  return `${MEMORY_DIRECTIVE_CLAIM_KEY_PREFIX}${segments[2]}`;
+}
+function parseDirectiveMetadata(entry) {
+  if (!isDirectiveDurable(entry)) {
+    return null;
+  }
+  const polarity = parseDirectivePolarity(entry.directive_polarity ?? "abstain");
+  if (!polarity) {
+    return null;
+  }
+  const trigger = entry.directive_trigger === void 0 ? defaultDirectiveTrigger(polarity) : parseDirectiveTrigger(entry.directive_trigger);
+  return trigger ? { polarity, trigger } : null;
+}
+function isProactiveDirectiveDurable(entry) {
+  return parseDirectiveMetadata(entry)?.polarity === "proactive";
+}
+function defaultDirectiveTrigger(polarity) {
+  return polarity === "proactive" ? DEFAULT_PROACTIVE_DIRECTIVE_TRIGGER : DEFAULT_ABSTAIN_DIRECTIVE_TRIGGER;
+}
+function normalizeForDirective(value) {
+  return value.replace(/\s+/gu, " ").trim().normalize("NFKC").toLocaleLowerCase();
+}
+
+// src/core/store/embedding-text.ts
+function composeEmbeddingText(entry) {
+  return `${entry.type}: ${entry.subject} - ${entry.content}`;
+}
+
+// src/core/claim-key-lifecycle.ts
+var PRECOMPUTED_LIFECYCLE_FIELDS = ["claim_key_status", "claim_key_source", "claim_key_confidence", "claim_key_rationale"];
+function parseClaimKeyStatus(value) {
+  return parseStringEnum(value, CLAIM_KEY_STATUSES);
+}
+function parseClaimKeySource(value) {
+  return parseStringEnum(value, CLAIM_KEY_SOURCES);
+}
+function parseClaimSupportMode(value) {
+  return parseStringEnum(value, CLAIM_SUPPORT_MODES);
+}
+function parseClaimKeyConfidence(value) {
+  return typeof value === "number" && Number.isFinite(value) && value >= 0 && value <= 1 ? value : void 0;
+}
+function requireClaimKeyStatus(value, label) {
+  const parsed = parseClaimKeyStatus(value);
+  if (!parsed) {
+    throw new Error(`Invalid ${label}: expected one of ${CLAIM_KEY_STATUSES.join(", ")}.`);
+  }
+  return parsed;
+}
+function requireClaimKeySource(value, label) {
+  const parsed = parseClaimKeySource(value);
+  if (!parsed) {
+    throw new Error(`Invalid ${label}: expected one of ${CLAIM_KEY_SOURCES.join(", ")}.`);
+  }
+  return parsed;
+}
+function requireClaimSupportMode(value, label) {
+  const parsed = parseClaimSupportMode(value);
+  if (!parsed) {
+    throw new Error(`Invalid ${label}: expected one of ${CLAIM_SUPPORT_MODES.join(", ")}.`);
+  }
+  return parsed;
+}
+function hasPrecomputedClaimKeyLifecycleFields(input) {
+  return PRECOMPUTED_LIFECYCLE_FIELDS.some((field) => input[field] !== void 0);
+}
+function buildManualClaimKeyLifecycle(params) {
+  return {
+    claim_key: params.claimKey,
+    claim_key_raw: buildClaimKeyRaw(params.rawClaimKey, params.claimKey),
+    claim_key_status: "trusted",
+    claim_key_source: "manual",
+    claim_key_confidence: 1,
+    claim_key_rationale: "manual claim key supplied by caller",
+    claim_support_source_kind: normalizeOptionalString2(params.supportSourceKind),
+    claim_support_locator: normalizeOptionalString2(params.supportLocator),
+    claim_support_observed_at: normalizeOptionalString2(params.supportObservedAt),
+    claim_support_mode: params.supportMode
+  };
+}
+function normalizeManualClaimKeyUpdate(params) {
+  const normalized = normalizeLifecycleClaimKeyInput(params.claimKey, params.rawClaimKey, "claim_key");
+  return {
+    claimKey: normalized.claimKey,
+    updateFields: lifecycleToUpdateFields(
+      buildManualClaimKeyLifecycle({
+        claimKey: normalized.claimKey,
+        rawClaimKey: normalized.rawClaimKey,
+        supportSourceKind: params.supportSourceKind,
+        supportLocator: params.supportLocator,
+        supportObservedAt: params.supportObservedAt,
+        supportMode: params.supportMode
+      })
+    )
+  };
+}
+function buildClaimKeyLifecycleUpdateFields(lifecycle) {
+  return lifecycleToUpdateFields(lifecycle);
+}
+function buildClaimKeyLifecycleAuditDetails(lifecycle) {
+  return {
+    claim_key_raw: lifecycle.claim_key_raw,
+    claim_key_status: lifecycle.claim_key_status,
+    claim_key_source: lifecycle.claim_key_source,
+    claim_key_confidence: lifecycle.claim_key_confidence,
+    claim_key_rationale: lifecycle.claim_key_rationale
+  };
+}
+function buildPrecomputedClaimKeyLifecycle(input) {
+  const claimKey = normalizeOptionalString2(input.claim_key);
+  const status = parseClaimKeyStatus(input.claim_key_status);
+  const source = parseClaimKeySource(input.claim_key_source);
+  const confidence = parseClaimKeyConfidence(input.claim_key_confidence);
+  const rationale = normalizeOptionalString2(input.claim_key_rationale);
+  const supportMode = parseClaimSupportMode(input.claim_support_mode);
+  if (!claimKey || !status || !source || confidence === void 0 || !rationale) {
+    return void 0;
+  }
+  return {
+    claim_key: claimKey,
+    claim_key_raw: buildClaimKeyRaw(input.claim_key_raw, claimKey),
+    claim_key_status: status,
+    claim_key_source: source,
+    claim_key_confidence: confidence,
+    claim_key_rationale: rationale,
+    claim_support_source_kind: normalizeOptionalString2(input.claim_support_source_kind),
+    claim_support_locator: normalizeOptionalString2(input.claim_support_locator),
+    claim_support_observed_at: normalizeOptionalString2(input.claim_support_observed_at),
+    claim_support_mode: supportMode
+  };
+}
+function validateDirectClaimKeyLifecycleUpdate(fields) {
+  if (!hasDirectLifecycleFields(fields)) {
+    return void 0;
+  }
+  const missingRequired = REQUIRED_DIRECT_LIFECYCLE_FIELDS.filter((field) => fields[field] === void 0);
+  if (missingRequired.length > 0) {
+    throw new Error(`Direct claim-key lifecycle updates require a complete lifecycle payload. Missing: ${missingRequired.join(", ")}.`);
+  }
+  const normalizedClaimKey = normalizeLifecycleClaimKeyInput(fields.claim_key, fields.claim_key_raw, "claim_key");
+  const claimSupportObservedAt = normalizeOptionalString2(fields.claim_support_observed_at);
+  if (claimSupportObservedAt !== void 0 && Number.isNaN(Date.parse(claimSupportObservedAt))) {
+    throw new Error("Invalid claim_support_observed_at: expected an ISO 8601 timestamp.");
+  }
+  const lifecycle = buildPrecomputedClaimKeyLifecycle({
+    claim_key: normalizedClaimKey.claimKey,
+    claim_key_raw: normalizedClaimKey.rawClaimKey,
+    claim_key_status: requireClaimKeyStatus(fields.claim_key_status, "claim_key_status"),
+    claim_key_source: requireClaimKeySource(fields.claim_key_source, "claim_key_source"),
+    claim_key_confidence: requireClaimKeyConfidence(fields.claim_key_confidence, "claim_key_confidence"),
+    claim_key_rationale: requireNonEmptyString(fields.claim_key_rationale, "claim_key_rationale"),
+    claim_support_source_kind: normalizeOptionalString2(fields.claim_support_source_kind),
+    claim_support_locator: normalizeOptionalString2(fields.claim_support_locator),
+    claim_support_observed_at: claimSupportObservedAt,
+    claim_support_mode: normalizeOptionalString2(fields.claim_support_mode) === void 0 ? void 0 : requireClaimSupportMode(fields.claim_support_mode, "claim_support_mode")
+  });
+  if (!lifecycle) {
+    throw new Error("Direct claim-key lifecycle update could not be normalized.");
+  }
+  return lifecycle;
+}
+function buildExtractedClaimKeyLifecycle(extracted, supportContext = {}) {
+  if (!extracted.claimKey) {
+    return void 0;
+  }
+  const source = extracted.path;
+  const rationalePrefix = source === "deterministic_repair" ? "claim key inferred by deterministic possessive-slot repair" : `claim key extracted from ${source} output`;
+  return {
+    claim_key: extracted.claimKey,
+    claim_key_raw: buildClaimKeyRaw(formatExtractedRawClaimKey(extracted), extracted.claimKey),
+    claim_key_status: source === "deterministic_repair" ? "tentative" : "trusted",
+    claim_key_source: source,
+    claim_key_confidence: extracted.confidence,
+    claim_key_rationale: [rationalePrefix, extracted.compactionReason, extracted.acceptanceRationale].filter((value) => Boolean(value)).join("; "),
+    claim_support_source_kind: normalizeOptionalString2(supportContext.sourceKind),
+    claim_support_locator: normalizeOptionalString2(supportContext.locator),
+    claim_support_observed_at: normalizeOptionalString2(supportContext.observedAt),
+    claim_support_mode: supportContext.mode
+  };
+}
+function applyClaimKeyLifecycle(entry, lifecycle) {
+  entry.claim_key = lifecycle.claim_key;
+  entry.claim_key_raw = lifecycle.claim_key_raw;
+  entry.claim_key_status = lifecycle.claim_key_status;
+  entry.claim_key_source = lifecycle.claim_key_source;
+  entry.claim_key_confidence = lifecycle.claim_key_confidence;
+  entry.claim_key_rationale = lifecycle.claim_key_rationale;
+  entry.claim_support_source_kind = lifecycle.claim_support_source_kind;
+  entry.claim_support_locator = lifecycle.claim_support_locator;
+  entry.claim_support_observed_at = lifecycle.claim_support_observed_at;
+  entry.claim_support_mode = lifecycle.claim_support_mode;
+}
+function buildInferredIngestClaimKeySupportContext(entry) {
+  const sourceFile = normalizeOptionalString2(entry.source_file);
+  const sourceContext = normalizeOptionalString2(entry.source_context);
+  const observedAt = normalizeOptionalString2(entry.claim_support_observed_at ?? entry.created_at);
+  if (!sourceFile) {
+    return {};
+  }
+  return {
+    sourceKind: normalizeOptionalString2(entry.claim_support_source_kind) ?? "transcript_ingest",
+    locator: normalizeOptionalString2(entry.claim_support_locator) ?? buildInferredIngestSupportLocator(sourceFile, observedAt, sourceContext),
+    observedAt,
+    mode: entry.claim_support_mode ?? "inferred"
+  };
+}
+function buildExplicitClaimKeyPreservationMetadata(entry, context) {
+  if (!entry.claim_key) {
+    return {};
+  }
+  const claimSupportObservedAt = normalizeOptionalString2(entry.claim_support_observed_at ?? context.observedAt ?? entry.created_at);
+  return {
+    ...buildClaimKeyRaw(entry.claim_key_raw ?? entry.claim_key, entry.claim_key) !== void 0 ? { claim_key_raw: buildClaimKeyRaw(entry.claim_key_raw ?? entry.claim_key, entry.claim_key) } : {},
+    ...normalizeOptionalString2(entry.claim_support_source_kind ?? context.sourceKind) !== void 0 ? { claim_support_source_kind: normalizeOptionalString2(entry.claim_support_source_kind ?? context.sourceKind) } : {},
+    ...normalizeOptionalString2(entry.claim_support_locator ?? context.locator) !== void 0 ? { claim_support_locator: normalizeOptionalString2(entry.claim_support_locator ?? context.locator) } : {},
+    ...claimSupportObservedAt !== void 0 ? { claim_support_observed_at: claimSupportObservedAt } : {},
+    ...(entry.claim_support_mode ?? context.mode) !== void 0 ? { claim_support_mode: entry.claim_support_mode ?? context.mode } : {}
+  };
+}
+function mergeExplicitClaimKeyMetadata(entry, candidate) {
+  if (!candidate.claim_key) {
+    return entry;
+  }
+  if (entry.claim_key && entry.claim_key !== candidate.claim_key) {
+    return entry;
+  }
+  const preserved = buildExplicitClaimKeyPreservationMetadata(candidate, {});
+  return {
+    ...entry,
+    claim_key: entry.claim_key ?? candidate.claim_key,
+    claim_key_raw: entry.claim_key_raw ?? preserved.claim_key_raw,
+    claim_support_source_kind: entry.claim_support_source_kind ?? preserved.claim_support_source_kind,
+    claim_support_locator: entry.claim_support_locator ?? preserved.claim_support_locator,
+    claim_support_observed_at: entry.claim_support_observed_at ?? preserved.claim_support_observed_at,
+    claim_support_mode: entry.claim_support_mode ?? preserved.claim_support_mode
+  };
+}
+function buildReconcileAppliedClaimKeyLifecycle(input) {
+  const source = resolveReconcileClaimKeySource(input.source, input.compactness) ?? "dreaming_reconcile";
+  return {
+    rawClaimKey: resolveLifecycleRawClaimKey({
+      targetClaimKey: input.targetClaimKey,
+      priorClaimKeyRaw: input.priorClaimKeyRaw,
+      rawClaimKey: input.rawClaimKey,
+      priorClaimKey: input.priorClaimKey
+    }),
+    status: resolveReconcileClaimKeyStatus({
+      proposedClaimKeys: [input.targetClaimKey],
+      source: input.source,
+      support: input.support,
+      compactness: input.compactness
+    }),
+    source
+  };
+}
+function buildReconcileAppliedClaimKeyLifecycleBundle(input) {
+  const lifecycle = buildReconcileAppliedClaimKeyLifecycle(input);
+  return {
+    claim_key: input.targetClaimKey,
+    claim_key_raw: lifecycle.rawClaimKey,
+    claim_key_status: lifecycle.status,
+    claim_key_source: lifecycle.source,
+    claim_key_confidence: input.confidence,
+    claim_key_rationale: input.rationale
+  };
+}
+function buildReconcileProposalClaimKeyLifecycle(input) {
+  const proposedClaimKeys = normalizeStringArray(input.proposedClaimKeys);
+  const targetClaimKey = proposedClaimKeys[0];
+  if (!targetClaimKey) {
+    return {
+      deferredUntilReview: true,
+      proposedStatus: "unresolved"
+    };
+  }
+  return {
+    deferredUntilReview: true,
+    proposedStatus: resolveReconcileClaimKeyStatus({
+      proposedClaimKeys,
+      source: input.source,
+      support: input.support,
+      compactness: input.compactness
+    }),
+    proposedSource: resolveReconcileClaimKeySource(input.source, input.compactness),
+    proposedRawClaimKey: resolveLifecycleRawClaimKey({
+      targetClaimKey,
+      rawClaimKey: input.rawClaimKey
+    })
+  };
+}
+function buildReconcileProposalClaimKeyAuditDetails(lifecycle) {
+  if (!lifecycle) {
+    return {};
+  }
+  return {
+    proposal_deferred_until_review: lifecycle.deferredUntilReview,
+    proposal_claim_key_status: lifecycle.proposedStatus,
+    proposal_claim_key_source: lifecycle.proposedSource,
+    proposal_claim_key_raw: lifecycle.proposedRawClaimKey
+  };
+}
+function resolveReconcileClaimKeySource(source, compactness) {
+  if (source === "metadata_backfill_rewrite" || source === "metadata_rewrite") {
+    return "dreaming_reconcile";
+  }
+  if (source === "trusted_group_reuse" || source === "mixed_group_consensus" || source === "entity_family_auto_convergence" || source === "entity_family_canonical_candidate" || source === "entity_family_collision") {
+    return "dreaming_reconcile";
+  }
+  if (source === "normalize" || compactness?.compactedFrom) {
+    return "dreaming_reconcile";
+  }
+  return parseClaimKeySource(source);
+}
+function resolveReconcileClaimKeyStatus(input) {
+  if (normalizeStringArray(input.proposedClaimKeys).length === 0) {
+    return "unresolved";
+  }
+  const lifecycleSource = resolveReconcileClaimKeySource(input.source, input.compactness);
+  if (lifecycleSource === "deterministic_repair" && !input.support?.autoApplyClass) {
+    return "tentative";
+  }
+  return "trusted";
+}
+function buildClaimKeyRaw(rawClaimKey, canonicalClaimKey) {
+  const normalizedRawClaimKey = normalizeOptionalString2(rawClaimKey);
+  if (!normalizedRawClaimKey || normalizedRawClaimKey === canonicalClaimKey) {
+    return void 0;
+  }
+  return normalizedRawClaimKey;
+}
+function buildReconcileProposalLifecycleRationale(baseRationale, lifecycle) {
+  const normalizedBase = baseRationale.trim();
+  if (lifecycle.proposedStatus === "unresolved" || !lifecycle.proposedSource) {
+    return `${normalizedBase} The entry stays unchanged until review because no safe lifecycle write is ready yet.`;
+  }
+  const rawText = lifecycle.proposedRawClaimKey ? ` and claim_key_raw "${lifecycle.proposedRawClaimKey}"` : "";
+  return `${normalizedBase} The entry stays unchanged until review. If approved, the replacement would persist claim_key_status "${lifecycle.proposedStatus}" with claim_key_source "${lifecycle.proposedSource}"${rawText}.`;
+}
+function formatExtractedRawClaimKey(extracted) {
+  const rawEntity = normalizeOptionalString2(extracted.rawEntity);
+  const rawAttribute = normalizeOptionalString2(extracted.rawAttribute);
+  if (!rawEntity || !rawAttribute) {
+    return extracted.compactedFrom ?? void 0;
+  }
+  return `${rawEntity}/${rawAttribute}`;
+}
+function resolveLifecycleRawClaimKey(input) {
+  const candidates = [input.priorClaimKeyRaw, input.rawClaimKey ?? void 0, input.priorClaimKey ?? void 0];
+  for (const candidate of candidates) {
+    const rawClaimKey = buildClaimKeyRaw(candidate, input.targetClaimKey);
+    if (rawClaimKey) {
+      return rawClaimKey;
+    }
+  }
+  return void 0;
+}
+var DIRECT_LIFECYCLE_FIELDS = [
+  "claim_key",
+  "claim_key_raw",
+  "claim_key_status",
+  "claim_key_source",
+  "claim_key_confidence",
+  "claim_key_rationale",
+  "claim_support_source_kind",
+  "claim_support_locator",
+  "claim_support_observed_at",
+  "claim_support_mode"
+];
+var REQUIRED_DIRECT_LIFECYCLE_FIELDS = [
+  "claim_key",
+  "claim_key_status",
+  "claim_key_source",
+  "claim_key_confidence",
+  "claim_key_rationale"
+];
+function hasDirectLifecycleFields(fields) {
+  return DIRECT_LIFECYCLE_FIELDS.some((field) => fields[field] !== void 0);
+}
+function normalizeLifecycleClaimKeyInput(claimKey, rawClaimKey, label) {
+  const normalizedClaimKeyInput = requireNonEmptyString(claimKey, label);
+  const normalizedClaimKey = normalizeClaimKey(normalizedClaimKeyInput);
+  if (!normalizedClaimKey.ok) {
+    throw new Error(`Invalid ${label}: ${describeClaimKeyNormalizationFailure(normalizedClaimKey.reason)}. Use canonical entity/attribute format.`);
+  }
+  return {
+    claimKey: normalizedClaimKey.value.claimKey,
+    rawClaimKey: buildClaimKeyRaw(rawClaimKey ?? normalizedClaimKeyInput, normalizedClaimKey.value.claimKey)
+  };
+}
+function lifecycleToUpdateFields(lifecycle) {
+  return {
+    claim_key: lifecycle.claim_key,
+    claim_key_raw: lifecycle.claim_key_raw,
+    claim_key_status: lifecycle.claim_key_status,
+    claim_key_source: lifecycle.claim_key_source,
+    claim_key_confidence: lifecycle.claim_key_confidence,
+    claim_key_rationale: lifecycle.claim_key_rationale,
+    claim_support_source_kind: lifecycle.claim_support_source_kind,
+    claim_support_locator: lifecycle.claim_support_locator,
+    claim_support_observed_at: lifecycle.claim_support_observed_at,
+    claim_support_mode: lifecycle.claim_support_mode
+  };
+}
+function buildInferredIngestSupportLocator(sourceFile, observedAt, sourceContext) {
+  if (observedAt && sourceContext) {
+    return `${sourceFile}#observed_at:${observedAt}#context:${encodeURIComponent(sourceContext)}`;
+  }
+  if (observedAt) {
+    return `${sourceFile}#observed_at:${observedAt}`;
+  }
+  if (sourceContext) {
+    return `${sourceFile}#context:${encodeURIComponent(sourceContext)}`;
+  }
+  return sourceFile;
+}
+function parseStringEnum(value, values) {
+  return typeof value === "string" && values.includes(value) ? value : void 0;
+}
+function requireNonEmptyString(value, label) {
+  const normalized = normalizeOptionalString2(value);
+  if (!normalized) {
+    throw new Error(`Invalid ${label}: expected a non-empty string.`);
+  }
+  return normalized;
+}
+function normalizeOptionalString2(value) {
+  const normalized = value?.trim();
+  return normalized && normalized.length > 0 ? normalized : void 0;
+}
+function requireClaimKeyConfidence(value, label) {
+  const parsed = parseClaimKeyConfidence(value);
+  if (parsed !== void 0) {
+    return parsed;
+  }
+  throw new Error(`Invalid ${label}: expected a finite number between 0 and 1.`);
+}
+function normalizeStringArray(values) {
+  return Array.from(new Set(values.map((value) => value.trim()).filter((value) => value.length > 0)));
+}
+
+export {
+  toAbsoluteFileUrl,
+  resolveLocalFilesystemPath,
+  DURABLE_KINDS,
+  EXPIRY_LEVELS,
+  CLAIM_KEY_STATUSES,
+  CLAIM_KEY_SOURCES,
+  CLAIM_SUPPORT_MODES,
+  EPISODE_ACTIVITY_LEVELS,
+  PROCEDURE_STEP_KINDS,
+  PROCEDURE_CONDITION_KINDS,
+  PROCEDURE_SOURCE_KINDS,
+  parseClaimKeyStatus,
+  parseClaimKeySource,
+  parseClaimSupportMode,
+  parseClaimKeyConfidence,
+  requireClaimKeyStatus,
+  requireClaimKeySource,
+  requireClaimSupportMode,
+  hasPrecomputedClaimKeyLifecycleFields,
+  buildManualClaimKeyLifecycle,
+  normalizeManualClaimKeyUpdate,
+  buildClaimKeyLifecycleUpdateFields,
+  buildClaimKeyLifecycleAuditDetails,
+  buildPrecomputedClaimKeyLifecycle,
+  validateDirectClaimKeyLifecycleUpdate,
+  buildExtractedClaimKeyLifecycle,
+  applyClaimKeyLifecycle,
+  buildInferredIngestClaimKeySupportContext,
+  buildExplicitClaimKeyPreservationMetadata,
+  mergeExplicitClaimKeyMetadata,
+  buildReconcileAppliedClaimKeyLifecycleBundle,
+  buildReconcileProposalClaimKeyLifecycle,
+  buildReconcileProposalClaimKeyAuditDetails,
+  buildReconcileProposalLifecycleRationale,
+  isRecord,
+  readOptionalTrimmedString,
+  readOptionalFiniteNumber,
+  pushIssue,
+  pushUnexpectedFields,
+  parseRequiredTrimmedString,
+  parseOptionalTrimmedString,
+  parseOptionalBoolean,
+  parseOptionalIntegerInRange,
+  parseOptionalTimestampString,
+  AGENR_FEATURE_FLAG_KEYS,
+  DEFAULT_AGENR_FEATURE_FLAGS,
+  createAllEnabledFeatureFlagConfig,
+  DEFAULT_DREAMING_DAILY_COST_CAP,
+  DEFAULT_DREAMING_PRUNE_PROTECT_RECALLED_DAYS,
+  DEFAULT_DREAMING_PRUNE_PROTECT_MIN_IMPORTANCE,
+  DEFAULT_DREAMING_IMPORTANCE_THRESHOLD,
+  DEFAULT_DREAMING_MIN_INTERVAL_MINUTES,
+  DEFAULT_DREAMING_EXTRACT_MAX_SESSIONS,
+  DEFAULT_DREAMING_LIGHT_MAX_SESSIONS,
+  DEFAULT_CLAIM_EXTRACTION_CONCURRENCY,
+  isAgenrAuthMethod,
+  authMethodToProvider,
+  getAuthMethodDefinition,
+  toAgenrConfigInput,
+  resolveConfigPath,
+  resolveDbPath,
+  resolveClaimExtractionConfig,
+  readConfig,
+  configFileExists,
+  writeConfig,
+  MEMORY_DIRECTIVE_CLAIM_KEY_PREFIX,
+  isDirectiveDurable,
+  parseDirectiveTrigger,
+  parseDirectivePolarity,
+  normalizeMemoryDirectiveClaimKey,
+  parseDirectiveMetadata,
+  isProactiveDirectiveDurable,
+  defaultDirectiveTrigger,
+  composeEmbeddingText
+};