@agenr/agenr-plugin 2.0.1 → 2.1.0

package/dist/{chunk-Y2BC7RCE.js → chunk-7TDALVPY.js}

@@ -1,14 +1,27 @@
 import {
+  DEFAULT_CROSS_ENCODER_ALPHA,
+  DEFAULT_CROSS_ENCODER_TOP_K,
+  DEFAULT_MMR_LAMBDA,
+  DEFAULT_SEEDED_RERANK_WEIGHT,
+  DEFAULT_STRONG_SEED_SCORE_GAP,
+  DEFAULT_STRONG_SEED_TOP_N,
+  applyCrossEncoderRerank,
   buildLexicalPlan,
-  combinedRelevance,
   computeLexicalScore,
   cosineSimilarity,
   describeClaimKeyNormalizationFailure,
+  maximalMarginalRelevance,
   normalizeClaimKey,
   recall,
   resolveClaimSlotPolicy,
+  rrfFuse,
+  rrfFuseVectorLexical,
+  seededRerank,
+  selectStrongSeeds,
+  sharesEpisodeLineage,
+  sharesProcedureLineage,
   tokenize
-} from "./chunk-MEHOGUZE.js";
+} from "./chunk-6T5RXGIR.js";
 
 // src/adapters/db/client.ts
 import fs from "fs/promises";
@@ -1476,14 +1489,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 path3 = readOptionalProcedureString(record.path, `${label}.path`, filePath);
+  const path4 = 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 (!path3) {
+      if (!path4) {
         throw new Error(`Invalid procedure ${filePath}: ${label}.${kind} sources require a path.`);
       }
       break;
@@ -1501,7 +1514,7 @@ function normalizeProcedureSource(record, label, filePath) {
   }
   return {
     kind,
-    ...path3 ? { path: path3 } : {},
+    ...path4 ? { path: path4 } : {},
     ...locator ? { locator } : {},
     ...sourceLabel ? { label: sourceLabel } : {}
   };
@@ -3518,8 +3531,8 @@ import { fileURLToPath } from "url";
 function isRecord2(value) {
   return typeof value === "object" && value !== null && !Array.isArray(value);
 }
-function pushIssue(issues, path3, message) {
-  issues.push({ path: path3, message });
+function pushIssue(issues, path4, message) {
+  issues.push({ path: path4, message });
 }
 function pushUnexpectedFields(value, allowedKeys, basePath, issues) {
   for (const key of Object.keys(value)) {
@@ -3529,68 +3542,68 @@ function pushUnexpectedFields(value, allowedKeys, basePath, issues) {
     pushIssue(issues, joinPath(basePath, key), "Unexpected field.");
   }
 }
-function parseRequiredTrimmedString(value, path3, issues, message = "Expected a non-empty string.") {
+function parseRequiredTrimmedString(value, path4, issues, message = "Expected a non-empty string.") {
   if (typeof value !== "string") {
-    pushIssue(issues, path3, message);
+    pushIssue(issues, path4, message);
     return void 0;
   }
   const normalized = value.trim();
   if (normalized.length === 0) {
-    pushIssue(issues, path3, message);
+    pushIssue(issues, path4, message);
     return void 0;
   }
   return normalized;
 }
-function parseOptionalTrimmedString(value, path3, issues, typeMessage = "Expected a string.", emptyMessage = "Expected a non-empty string.") {
+function parseOptionalTrimmedString(value, path4, 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);
+    pushIssue(issues, path4, typeMessage);
     return void 0;
   }
   const normalized = value.trim();
   if (normalized.length === 0) {
-    pushIssue(issues, path3, emptyMessage);
+    pushIssue(issues, path4, emptyMessage);
     return void 0;
   }
   return normalized;
 }
-function parseOptionalBoolean(value, path3, issues, message = "Expected a boolean.") {
+function parseOptionalBoolean(value, path4, issues, message = "Expected a boolean.") {
   if (value === void 0) {
     return void 0;
   }
   if (typeof value !== "boolean") {
-    pushIssue(issues, path3, message);
+    pushIssue(issues, path4, message);
     return void 0;
   }
   return value;
 }
-function parseOptionalIntegerInRange(value, path3, issues, bounds) {
+function parseOptionalIntegerInRange(value, path4, issues, bounds) {
   if (value === void 0) {
     return void 0;
   }
   if (typeof value !== "number" || !Number.isFinite(value) || !Number.isInteger(value)) {
-    pushIssue(issues, path3, integerRangeMessage(bounds));
+    pushIssue(issues, path4, integerRangeMessage(bounds));
     return void 0;
   }
   if (bounds.min !== void 0 && value < bounds.min) {
-    pushIssue(issues, path3, integerRangeMessage(bounds));
+    pushIssue(issues, path4, integerRangeMessage(bounds));
     return void 0;
   }
   if (bounds.max !== void 0 && value > bounds.max) {
-    pushIssue(issues, path3, integerRangeMessage(bounds));
+    pushIssue(issues, path4, integerRangeMessage(bounds));
     return void 0;
   }
   return value;
 }
-function parseOptionalTimestampString(value, path3, issues, message = "Expected a valid timestamp string.") {
-  const timestamp = parseOptionalTrimmedString(value, path3, issues);
+function parseOptionalTimestampString(value, path4, issues, message = "Expected a valid timestamp string.") {
+  const timestamp = parseOptionalTrimmedString(value, path4, issues);
   if (timestamp === void 0) {
     return void 0;
   }
   if (Number.isNaN(Date.parse(timestamp))) {
-    pushIssue(issues, path3, message);
+    pushIssue(issues, path4, message);
     return void 0;
   }
   return timestamp;
@@ -3716,7 +3729,8 @@ function toAgenrConfigInput(config, options = {}) {
     ...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.episodeModel) ? { episodeModel: config.episodeModel } : {},
+    ...hasModelConfig(config.crossEncoderModel) ? { crossEncoderModel: config.crossEncoderModel } : {}
   };
   const claimExtraction = toClaimExtractionInput(config.claimExtraction);
   if (claimExtraction) {
@@ -3766,6 +3780,7 @@ function normalizeAgenrConfig(value, options) {
   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 surgeon = parseSurgeonConfig(value.surgeon, "surgeon", issues);
   const dbPath = parseOptionalTrimmedString(value.dbPath, "dbPath", issues);
@@ -3792,6 +3807,7 @@ function normalizeAgenrConfig(value, options) {
     ...extractionModel ? { extractionModel } : {},
     ...dedupModel ? { dedupModel } : {},
     ...episodeModel ? { episodeModel } : {},
+    ...crossEncoderModel ? { crossEncoderModel } : {},
     ...claimExtraction.input ? { claimExtraction: claimExtraction.input } : {},
     ...surgeon.input ? { surgeon: surgeon.input } : {},
     ...dbPath ? { dbPath } : {},
@@ -3810,6 +3826,7 @@ function normalizeAgenrConfig(value, options) {
       ...extractionModel ? { extractionModel } : {},
       ...dedupModel ? { dedupModel } : {},
       ...episodeModel ? { episodeModel } : {},
+      ...crossEncoderModel ? { crossEncoderModel } : {},
       claimExtraction: claimExtraction.resolved,
       surgeon: surgeon.resolved,
       dbPath: dbPath ?? options.defaultDbPath,
@@ -3828,6 +3845,7 @@ function pushTopLevelIssues(value, issues) {
     "extractionModel",
     "dedupModel",
     "episodeModel",
+    "crossEncoderModel",
     "claimExtraction",
     "surgeon",
     "dbPath",
@@ -3843,41 +3861,41 @@ function pushTopLevelIssues(value, issues) {
     pushIssue(issues, "embeddingApiKey", "Removed field. Move this value to credentials.openaiApiKey, then delete embeddingApiKey.");
   }
 }
-function parseAuth(value, path3, issues) {
-  const normalized = parseOptionalTrimmedString(value, path3, issues);
+function parseAuth(value, path4, issues) {
+  const normalized = parseOptionalTrimmedString(value, path4, issues);
   if (!normalized) {
     return void 0;
   }
   if (!isAgenrAuthMethod(normalized)) {
-    pushIssue(issues, path3, "Expected a supported auth method.");
+    pushIssue(issues, path4, "Expected a supported auth method.");
     return void 0;
   }
   return normalized;
 }
-function parseProvider(value, path3, issues) {
-  const normalized = parseOptionalTrimmedString(value, path3, issues);
+function parseProvider(value, path4, issues) {
+  const normalized = parseOptionalTrimmedString(value, path4, issues);
   if (!normalized) {
     return void 0;
   }
   if (!isAgenrProvider(normalized)) {
-    pushIssue(issues, path3, "Expected a supported provider.");
+    pushIssue(issues, path4, "Expected a supported provider.");
     return void 0;
   }
   return normalized;
 }
-function parseCredentials(value, path3, issues) {
+function parseCredentials(value, path4, issues) {
   if (value === void 0) {
     return void 0;
   }
   if (!isRecord2(value)) {
-    pushIssue(issues, path3, "Expected an object.");
+    pushIssue(issues, path4, "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);
+  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);
   if (issues.length > startIndex) {
     return void 0;
   }
@@ -3888,20 +3906,20 @@ function parseCredentials(value, path3, issues) {
   };
   return hasStoredCredentials(credentials) ? credentials : void 0;
 }
-function parseModelConfig(value, path3, issues) {
+function parseModelConfig(value, path4, issues) {
   if (value === void 0) {
     return void 0;
   }
   if (!isRecord2(value)) {
-    pushIssue(issues, path3, "Expected an object.");
+    pushIssue(issues, path4, "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);
+  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);
   if (!provider && !model) {
-    pushIssue(issues, path3, "Expected at least one of provider or model.");
+    pushIssue(issues, path4, "Expected at least one of provider or model.");
   }
   if (issues.length > startIndex) {
     return void 0;
@@ -3911,7 +3929,7 @@ function parseModelConfig(value, path3, issues) {
     ...model ? { model } : {}
   };
 }
-function parseClaimExtractionConfig(value, path3, issues) {
+function parseClaimExtractionConfig(value, path4, issues) {
   const defaults = createDefaultClaimExtractionConfig();
   if (value === void 0) {
     return {
@@ -3919,20 +3937,20 @@ function parseClaimExtractionConfig(value, path3, issues) {
     };
   }
   if (!isRecord2(value)) {
-    pushIssue(issues, path3, "Expected an object.");
+    pushIssue(issues, path4, "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, {
+  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, {
     min: 1
   });
-  const model = parseModelConfig(value.model, `${path3}.model`, issues);
+  const model = parseModelConfig(value.model, `${path4}.model`, issues);
   if (issues.length > startIndex) {
     return {
       resolved: defaults
@@ -3956,7 +3974,7 @@ function parseClaimExtractionConfig(value, path3, issues) {
     }
   };
 }
-function parseSurgeonConfig(value, path3, issues) {
+function parseSurgeonConfig(value, path4, issues) {
   const defaults = createDefaultSurgeonConfig();
   if (value === void 0) {
     return {
@@ -3964,19 +3982,19 @@ function parseSurgeonConfig(value, path3, issues) {
     };
   }
   if (!isRecord2(value)) {
-    pushIssue(issues, path3, "Expected an object.");
+    pushIssue(issues, path4, "Expected an object.");
     return {
       resolved: defaults
     };
   }
   const startIndex = issues.length;
-  pushUnexpectedFields(value, /* @__PURE__ */ new Set(["model", "costCap", "dailyCostCap", "contextLimit", "customInstructions", "passes"]), path3, issues);
-  const model = parseModelConfig(value.model, `${path3}.model`, issues);
-  const costCap = parseOptionalPositiveNumber(value.costCap, `${path3}.costCap`, issues);
-  const dailyCostCap = parseOptionalNonNegativeNumber(value.dailyCostCap, `${path3}.dailyCostCap`, issues);
-  const contextLimit = parseOptionalIntegerInRange(value.contextLimit, `${path3}.contextLimit`, issues, { min: 0 });
-  const customInstructions = parseOptionalTrimmedString(value.customInstructions, `${path3}.customInstructions`, issues);
-  const retirement = parseRetirementPassConfig(value.passes, `${path3}.passes`, issues);
+  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);
   if (issues.length > startIndex) {
     return {
       resolved: defaults
@@ -4008,7 +4026,7 @@ function parseSurgeonConfig(value, path3, issues) {
     }
   };
 }
-function parseRetirementPassConfig(value, path3, issues) {
+function parseRetirementPassConfig(value, path4, issues) {
   const defaults = createDefaultRetirementPassConfig();
   if (value === void 0) {
     return {
@@ -4016,36 +4034,36 @@ function parseRetirementPassConfig(value, path3, issues) {
     };
   }
   if (!isRecord2(value)) {
-    pushIssue(issues, path3, "Expected an object.");
+    pushIssue(issues, path4, "Expected an object.");
     return {
       resolved: defaults
     };
   }
   const startIndex = issues.length;
-  pushUnexpectedFields(value, /* @__PURE__ */ new Set(["retirement"]), path3, issues);
+  pushUnexpectedFields(value, /* @__PURE__ */ new Set(["retirement"]), path4, issues);
   const retirement = value.retirement;
   if (retirement === void 0) {
     if (issues.length === startIndex) {
-      pushIssue(issues, path3, "Expected a retirement config when passes is provided.");
+      pushIssue(issues, path4, "Expected a retirement config when passes is provided.");
     }
     return {
       resolved: defaults
     };
   }
   if (!isRecord2(retirement)) {
-    pushIssue(issues, `${path3}.retirement`, "Expected an object.");
+    pushIssue(issues, `${path4}.retirement`, "Expected an object.");
     return {
       resolved: defaults
     };
   }
-  pushUnexpectedFields(retirement, /* @__PURE__ */ new Set(["protectRecalledDays", "protectMinImportance", "skipRecentlyEvaluatedDays"]), `${path3}.retirement`, issues);
-  const protectRecalledDays = parseOptionalIntegerInRange(retirement.protectRecalledDays, `${path3}.retirement.protectRecalledDays`, issues, {
+  pushUnexpectedFields(retirement, /* @__PURE__ */ new Set(["protectRecalledDays", "protectMinImportance", "skipRecentlyEvaluatedDays"]), `${path4}.retirement`, issues);
+  const protectRecalledDays = parseOptionalIntegerInRange(retirement.protectRecalledDays, `${path4}.retirement.protectRecalledDays`, issues, {
     min: 0
   });
-  const protectMinImportance = parseOptionalIntegerInRange(retirement.protectMinImportance, `${path3}.retirement.protectMinImportance`, issues, {
+  const protectMinImportance = parseOptionalIntegerInRange(retirement.protectMinImportance, `${path4}.retirement.protectMinImportance`, issues, {
     min: 0
   });
-  const skipRecentlyEvaluatedDays = parseOptionalIntegerInRange(retirement.skipRecentlyEvaluatedDays, `${path3}.retirement.skipRecentlyEvaluatedDays`, issues, {
+  const skipRecentlyEvaluatedDays = parseOptionalIntegerInRange(retirement.skipRecentlyEvaluatedDays, `${path4}.retirement.skipRecentlyEvaluatedDays`, issues, {
     min: 0
   });
   if (issues.length > startIndex) {
@@ -4067,54 +4085,54 @@ function parseRetirementPassConfig(value, path3, issues) {
     }
   };
 }
-function parseOptionalUnitInterval(value, path3, issues) {
+function parseOptionalUnitInterval(value, path4, 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.");
+    pushIssue(issues, path4, "Expected a number from 0 to 1.");
     return void 0;
   }
   return value;
 }
-function parseOptionalPositiveNumber(value, path3, issues) {
+function parseOptionalPositiveNumber(value, path4, issues) {
   if (value === void 0) {
     return void 0;
   }
   if (typeof value !== "number" || !Number.isFinite(value) || value <= 0) {
-    pushIssue(issues, path3, "Expected a positive number.");
+    pushIssue(issues, path4, "Expected a positive number.");
     return void 0;
   }
   return value;
 }
-function parseOptionalNonNegativeNumber(value, path3, issues) {
+function parseOptionalNonNegativeNumber(value, path4, 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.");
+    pushIssue(issues, path4, "Expected a non-negative number.");
     return void 0;
   }
   return value;
 }
-function parseEligibleTypes(value, path3, issues) {
+function parseEligibleTypes(value, path4, issues) {
   if (value === void 0) {
     return void 0;
   }
   if (!Array.isArray(value)) {
-    pushIssue(issues, path3, "Expected an array of entry types.");
+    pushIssue(issues, path4, "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.");
+      pushIssue(issues, `${path4}.${index}`, "Expected a supported entry type.");
       continue;
     }
     const trimmed = item.trim();
     if (!isEntryType(trimmed)) {
-      pushIssue(issues, `${path3}.${index}`, "Expected a supported entry type.");
+      pushIssue(issues, `${path4}.${index}`, "Expected a supported entry type.");
       continue;
     }
     if (!seen.has(trimmed)) {
@@ -4123,7 +4141,7 @@ function parseEligibleTypes(value, path3, issues) {
     }
   }
   if (normalized.length === 0) {
-    pushIssue(issues, path3, "Expected at least one supported entry type.");
+    pushIssue(issues, path4, "Expected at least one supported entry type.");
     return void 0;
   }
   return normalized;
@@ -4526,6 +4544,604 @@ async function sleep(durationMs) {
   });
 }
 
+// src/adapters/llm.ts
+import { createHash as createHash2 } from "crypto";
+import fs3 from "fs";
+import os2 from "os";
+import path3 from "path";
+import { createRequire } from "module";
+import { completeSimple, getEnvApiKey, getModel } from "@mariozechner/pi-ai";
+var DEFAULT_REASONING = "medium";
+var require2 = createRequire(import.meta.url);
+var getModelWithStrings = getModel;
+function probeLlmCredentials(params) {
+  const candidate = resolveCredentialCandidate(params);
+  if (!candidate) {
+    return {
+      available: false,
+      guidance: credentialSetupGuidance(params.auth)
+    };
+  }
+  return {
+    available: true,
+    source: candidate.source,
+    guidance: "Credentials available.",
+    credentials: {
+      apiKey: candidate.token,
+      source: candidate.source,
+      auth: params.auth
+    }
+  };
+}
+function resolveAuthCredentials(params) {
+  const probe = probeLlmCredentials(params);
+  if (!probe.available || !probe.credentials) {
+    throw new Error(probe.guidance);
+  }
+  return probe.credentials;
+}
+function createLlmClient(provider, modelId, options = {}) {
+  const model = getModelWithStrings(provider, modelId);
+  const metadata = {
+    model,
+    contextWindowTokens: model.contextWindow,
+    maxOutputTokens: model.maxTokens,
+    supportsReasoning: model.reasoning,
+    usage: createEmptyUsageStats()
+  };
+  const resolvedApiKey = normalizeOptionalString6(options.apiKey);
+  const requestCompletion = async (systemPrompt, userMessage) => {
+    const response = await completeSimple(
+      model,
+      {
+        systemPrompt,
+        messages: [
+          {
+            role: "user",
+            content: userMessage,
+            timestamp: Date.now()
+          }
+        ]
+      },
+      {
+        apiKey: resolvedApiKey,
+        reasoning: metadata.supportsReasoning ? options.reasoning ?? DEFAULT_REASONING : void 0
+      }
+    );
+    accumulateUsage(metadata.usage, response.usage);
+    if (response.stopReason === "error") {
+      throw new Error(response.errorMessage ?? `LLM completion failed for ${provider}/${modelId}.`);
+    }
+    return response;
+  };
+  const complete = async (systemPrompt, userMessage) => {
+    const response = await requestCompletion(systemPrompt, userMessage);
+    return extractText(response);
+  };
+  return {
+    metadata,
+    complete,
+    completeJson: async (systemPrompt, userMessage) => {
+      const response = await requestCompletion(systemPrompt, userMessage);
+      const text = extractText(response);
+      return JSON.parse(stripCodeFence(text));
+    }
+  };
+}
+function resolveModel(config, stage) {
+  const override = resolveStageOverride(config, stage);
+  return {
+    provider: normalizeOptionalString6(override?.provider) ?? resolveStageDefaultProvider(config, stage),
+    modelId: normalizeOptionalString6(override?.model) ?? resolveStageDefaultModel(config, stage)
+  };
+}
+function resolveStageOverride(config, stage) {
+  switch (stage) {
+    case "extraction":
+      return config?.extractionModel;
+    case "dedup":
+      return config?.dedupModel;
+    case "episode":
+      return config?.episodeModel;
+    case "claim":
+      return config?.claimExtraction?.model ?? config?.extractionModel;
+    case "cross_encoder":
+      return config?.crossEncoderModel;
+  }
+}
+function resolveStageDefaultProvider(config, stage) {
+  if (stage === "cross_encoder") {
+    const topLevel = normalizeOptionalString6(config?.provider);
+    if (!topLevel || topLevel === "openai-codex") {
+      return "openai";
+    }
+    return topLevel;
+  }
+  return normalizeOptionalString6(config?.provider) ?? "openai";
+}
+function resolveStageDefaultModel(config, stage) {
+  if (stage === "cross_encoder") {
+    return defaultModelForStage(stage);
+  }
+  return normalizeOptionalString6(config?.model) ?? defaultModelForStage(stage);
+}
+function resolveLlmCredentials(config, provider, env = process.env) {
+  const normalizedProvider = normalizeOptionalString6(provider);
+  if (!normalizedProvider) {
+    throw new Error("Provider is required to resolve LLM credentials.");
+  }
+  const auth = normalizeAuthMethod(config?.auth);
+  if (auth && authMethodToProvider(auth) === normalizedProvider) {
+    return resolveAuthCredentials({
+      auth,
+      storedCredentials: config?.credentials,
+      env
+    });
+  }
+  const fallback = resolveProviderCredentialCandidate(config, normalizedProvider, env);
+  if (fallback) {
+    return {
+      apiKey: fallback.token,
+      source: fallback.source
+    };
+  }
+  if (normalizedProvider === "openai-codex") {
+    throw new Error("No OpenAI subscription credential found. Run `codex auth` or configure `auth` as `openai-api-key`.");
+  }
+  const exampleEnv = normalizedProvider === "anthropic" ? "ANTHROPIC_API_KEY" : "OPENAI_API_KEY";
+  throw new Error(`No credential found for provider "${normalizedProvider}". Set the appropriate auth method in config or provide ${exampleEnv}.`);
+}
+function resolveLlmApiKey(config, provider, env = process.env) {
+  return resolveLlmCredentials(config, provider, env).apiKey;
+}
+function stripCodeFence(text) {
+  const trimmed = text.trim();
+  const match = /^```(?:json)?\s*([\s\S]+?)\s*```$/i.exec(trimmed);
+  return match?.[1]?.trim() ?? trimmed;
+}
+function defaultModelForStage(stage) {
+  switch (stage) {
+    case "extraction":
+    case "episode":
+    case "claim":
+      return "gpt-5.4-mini";
+    case "dedup":
+    case "cross_encoder":
+      return "gpt-5.4-nano";
+  }
+}
+function normalizeOptionalString6(value) {
+  const trimmed = value?.trim();
+  return trimmed && trimmed.length > 0 ? trimmed : void 0;
+}
+function normalizeAuthMethod(value) {
+  const normalized = normalizeOptionalString6(value);
+  return normalized && isAgenrAuthMethod(normalized) ? normalized : void 0;
+}
+function safeReadJson(filePath) {
+  try {
+    const raw = fs3.readFileSync(filePath, "utf8");
+    return JSON.parse(raw);
+  } catch {
+    return null;
+  }
+}
+function resolveHomeDir(env) {
+  const home = normalizeOptionalString6(env.HOME);
+  return home ? resolveUserPath(home) : os2.homedir();
+}
+function resolveCodexHome(env) {
+  const configured = normalizeOptionalString6(env.CODEX_HOME) ?? "~/.codex";
+  const resolved = resolveUserPath(configured);
+  try {
+    return fs3.realpathSync.native(resolved);
+  } catch {
+    return resolved;
+  }
+}
+function resolveUserPath(value) {
+  const trimmed = value.trim();
+  if (trimmed === "~") {
+    return os2.homedir();
+  }
+  if (trimmed.startsWith("~/")) {
+    return path3.join(os2.homedir(), trimmed.slice(2));
+  }
+  if (trimmed.startsWith("~\\")) {
+    return path3.join(os2.homedir(), trimmed.slice(2));
+  }
+  return path3.resolve(trimmed);
+}
+function parseCodexFromFile(env) {
+  const authPath = path3.join(resolveCodexHome(env), "auth.json");
+  const parsed = safeReadJson(authPath);
+  if (!parsed || typeof parsed !== "object") {
+    return null;
+  }
+  const record = parsed;
+  const tokens = record.tokens;
+  const accessToken = tokens?.access_token;
+  if (typeof accessToken !== "string" || !accessToken.trim()) {
+    return null;
+  }
+  return {
+    token: accessToken.trim(),
+    source: `file:${authPath}`
+  };
+}
+function resolveCodexKeychainAccount(env) {
+  const hash = createHash2("sha256").update(resolveCodexHome(env)).digest("hex");
+  return `cli|${hash.slice(0, 16)}`;
+}
+function parseCodexFromKeychain(env) {
+  if (process.platform !== "darwin") {
+    return null;
+  }
+  try {
+    const account = resolveCodexKeychainAccount(env);
+    const { execSync } = require2("node:child_process");
+    const raw = execSync(`security find-generic-password -s "Codex Auth" -a "${account}" -w`, {
+      encoding: "utf8",
+      stdio: ["pipe", "pipe", "pipe"],
+      timeout: 5e3
+    }).trim();
+    const parsed = JSON.parse(raw);
+    const tokens = parsed.tokens;
+    const accessToken = tokens?.access_token;
+    if (typeof accessToken !== "string" || !accessToken.trim()) {
+      return null;
+    }
+    return {
+      token: accessToken.trim(),
+      source: "keychain:Codex Auth"
+    };
+  } catch {
+    return null;
+  }
+}
+function parseClaudeCredentialRecord(parsed, source) {
+  if (!parsed || typeof parsed !== "object") {
+    return null;
+  }
+  const record = parsed;
+  const claudeOauth = record.claudeAiOauth;
+  const accessToken = claudeOauth?.accessToken;
+  if (typeof accessToken !== "string" || !accessToken.trim()) {
+    return null;
+  }
+  return {
+    token: accessToken.trim(),
+    source
+  };
+}
+function parseClaudeFromFiles(env) {
+  const homeDir = resolveHomeDir(env);
+  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}`);
+    if (resolved) {
+      return resolved;
+    }
+  }
+  return null;
+}
+function parseClaudeFromKeychain() {
+  if (process.platform !== "darwin") {
+    return null;
+  }
+  try {
+    const { execSync } = require2("node:child_process");
+    const raw = execSync('security find-generic-password -s "Claude Code-credentials" -w', {
+      encoding: "utf8",
+      stdio: ["pipe", "pipe", "pipe"],
+      timeout: 5e3
+    }).trim();
+    return parseClaudeCredentialRecord(JSON.parse(raw), "keychain:Claude Code-credentials");
+  } catch {
+    return null;
+  }
+}
+function candidateFromToken(token, source) {
+  const normalized = normalizeOptionalString6(token);
+  if (!normalized) {
+    return null;
+  }
+  return {
+    token: normalized,
+    source
+  };
+}
+function resolveOpenAIApiKeyCandidate(storedCredentials, env) {
+  return candidateFromToken(env.OPENAI_API_KEY, "env:OPENAI_API_KEY") ?? candidateFromToken(storedCredentials?.openaiApiKey, "config:credentials.openaiApiKey");
+}
+function resolveAnthropicApiKeyCandidate(storedCredentials, env) {
+  return candidateFromToken(env.ANTHROPIC_API_KEY, "env:ANTHROPIC_API_KEY") ?? candidateFromToken(storedCredentials?.anthropicApiKey, "config:credentials.anthropicApiKey");
+}
+function resolveAnthropicTokenCandidate(storedCredentials, env) {
+  return candidateFromToken(env.ANTHROPIC_OAUTH_TOKEN, "env:ANTHROPIC_OAUTH_TOKEN") ?? candidateFromToken(storedCredentials?.anthropicOauthToken, "config:credentials.anthropicOauthToken");
+}
+function resolveAnthropicOauthCandidate(env) {
+  return parseClaudeFromFiles(env) ?? parseClaudeFromKeychain();
+}
+function resolveOpenAiSubscriptionCandidate(env) {
+  return parseCodexFromFile(env) ?? parseCodexFromKeychain(env);
+}
+function credentialSetupGuidance(auth) {
+  switch (auth) {
+    case "anthropic-oauth":
+      return "Claude Code credentials not found. Install Claude Code CLI and sign in with `claude`.";
+    case "anthropic-token":
+      return "No Anthropic long-lived token found. Set ANTHROPIC_OAUTH_TOKEN or save credentials.anthropicOauthToken.";
+    case "anthropic-api-key":
+      return "No Anthropic API key found. Set ANTHROPIC_API_KEY or save credentials.anthropicApiKey.";
+    case "openai-subscription":
+      return "Codex CLI credentials not found or expired. Run `codex auth`.";
+    case "openai-api-key":
+      return "No OpenAI API key found. Set OPENAI_API_KEY or save credentials.openaiApiKey.";
+  }
+}
+function resolveCredentialCandidate(params) {
+  const env = params.env ?? process.env;
+  switch (params.auth) {
+    case "anthropic-oauth":
+      return resolveAnthropicOauthCandidate(env);
+    case "anthropic-token":
+      return resolveAnthropicTokenCandidate(params.storedCredentials, env);
+    case "anthropic-api-key":
+      return resolveAnthropicApiKeyCandidate(params.storedCredentials, env);
+    case "openai-subscription":
+      return resolveOpenAiSubscriptionCandidate(env);
+    case "openai-api-key":
+      return resolveOpenAIApiKeyCandidate(params.storedCredentials, env);
+  }
+}
+function resolveProviderCredentialCandidate(config, provider, env) {
+  if (provider === "openai") {
+    return resolveOpenAIApiKeyCandidate(config?.credentials, env);
+  }
+  if (provider === "anthropic") {
+    const auth = normalizeAuthMethod(config?.auth);
+    if (auth && authMethodToProvider(auth) === "anthropic") {
+      return resolveCredentialCandidate({
+        auth,
+        storedCredentials: config?.credentials,
+        env
+      });
+    }
+    return resolveAnthropicApiKeyCandidate(config?.credentials, env);
+  }
+  const envApiKey = getEnvApiKey(provider) ?? getEnvApiKey(provider);
+  return candidateFromToken(envApiKey, `env:${provider}`);
+}
+function createEmptyUsageStats() {
+  return {
+    calls: 0,
+    inputTokens: 0,
+    outputTokens: 0,
+    cacheReadTokens: 0,
+    cacheWriteTokens: 0,
+    totalTokens: 0,
+    totalCost: 0
+  };
+}
+function accumulateUsage(target, usage) {
+  target.calls += 1;
+  target.inputTokens += usage.input;
+  target.outputTokens += usage.output;
+  target.cacheReadTokens += usage.cacheRead;
+  target.cacheWriteTokens += usage.cacheWrite;
+  target.totalTokens += usage.totalTokens;
+  target.totalCost += usage.cost.total;
+}
+function extractText(response) {
+  const blocks = [];
+  for (const contentBlock of response.content) {
+    if (contentBlock.type === "text") {
+      blocks.push(contentBlock.text);
+    }
+  }
+  return blocks.join("");
+}
+
+// src/adapters/cross-encoder/openai-cross-encoder.ts
+var OPENAI_CHAT_COMPLETIONS_URL = "https://api.openai.com/v1/chat/completions";
+var DEFAULT_MODEL = "gpt-5.4-nano";
+var DEFAULT_MAX_CONCURRENCY = 4;
+var DEFAULT_MAX_RETRIES = 2;
+var REQUEST_TIMEOUT_MS = 2e4;
+var SYSTEM_PROMPT = "You are an expert tasked with determining whether the passage is relevant to the query";
+function createOpenAICrossEncoder(options) {
+  const apiKey = options.apiKey.trim();
+  if (apiKey.length === 0) {
+    throw new Error("OpenAI cross-encoder adapter requires a non-empty API key.");
+  }
+  const model = normalizeOptional(options.model) ?? DEFAULT_MODEL;
+  const baseUrl = normalizeOptional(options.baseUrl) ?? OPENAI_CHAT_COMPLETIONS_URL;
+  const maxConcurrency = clampPositiveInteger(options.maxConcurrency, DEFAULT_MAX_CONCURRENCY);
+  const maxRetries = clampPositiveInteger(options.maxRetries, DEFAULT_MAX_RETRIES, { allowZero: true });
+  const requestTimeoutMs = clampPositiveInteger(options.requestTimeoutMs, REQUEST_TIMEOUT_MS);
+  const fetchImpl = options.fetchImpl ?? fetch;
+  return {
+    async rank(query, passages) {
+      if (passages.length === 0) {
+        return [];
+      }
+      const trimmedQuery = query.trim();
+      if (trimmedQuery.length === 0) {
+        return [];
+      }
+      const results = new Array(passages.length).fill(null);
+      let nextIndex = 0;
+      const workerCount = Math.max(1, Math.min(maxConcurrency, passages.length));
+      await Promise.all(
+        Array.from({ length: workerCount }, async () => {
+          while (true) {
+            const index = nextIndex;
+            nextIndex += 1;
+            if (index >= passages.length) {
+              return;
+            }
+            const passage = passages[index];
+            const score = await rankSinglePassage({
+              apiKey,
+              baseUrl,
+              model,
+              query: trimmedQuery,
+              passage,
+              fetchImpl,
+              maxRetries,
+              requestTimeoutMs
+            });
+            if (score !== null) {
+              results[index] = { id: passage.id, score };
+            }
+          }
+        })
+      );
+      return results.filter((result) => result !== null);
+    }
+  };
+}
+function resolveCrossEncoderApiKey(config) {
+  const candidates = [config?.credentials?.openaiApiKey, process.env.OPENAI_API_KEY];
+  for (const candidate of candidates) {
+    const normalized = candidate?.trim();
+    if (normalized && normalized.length > 0) {
+      return normalized;
+    }
+  }
+  throw new Error("Cross-encoder API key is required. Set config.credentials.openaiApiKey or OPENAI_API_KEY.");
+}
+async function rankSinglePassage(params) {
+  const body = JSON.stringify({
+    model: params.model,
+    temperature: 0,
+    // gpt-5.4 chat completions reject `max_tokens=1` and may return an
+    // empty completion when constrained below 4 completion tokens.
+    max_completion_tokens: 4,
+    logprobs: true,
+    top_logprobs: 2,
+    messages: [
+      {
+        role: "system",
+        content: SYSTEM_PROMPT
+      },
+      {
+        role: "user",
+        content: buildUserPrompt(params.query, params.passage.text)
+      }
+    ]
+  });
+  let attempt = 0;
+  while (true) {
+    const outcome = await performSingleRequest({
+      ...params,
+      body
+    });
+    if (outcome.kind === "score") {
+      return outcome.value;
+    }
+    if (outcome.kind === "fatal" || attempt >= params.maxRetries) {
+      return null;
+    }
+    attempt += 1;
+    await sleep2(backoffMs2(attempt));
+  }
+}
+async function performSingleRequest(params) {
+  const controller = new AbortController();
+  const timeout = setTimeout(() => controller.abort(), params.requestTimeoutMs);
+  try {
+    const response = await params.fetchImpl(params.baseUrl, {
+      method: "POST",
+      headers: {
+        Authorization: `Bearer ${params.apiKey}`,
+        "Content-Type": "application/json"
+      },
+      body: params.body,
+      signal: controller.signal
+    });
+    const rawBody = await response.text();
+    if (!response.ok) {
+      return isRetryableStatus2(response.status) ? { kind: "retryable" } : { kind: "fatal" };
+    }
+    const score = parseRelevanceScore(rawBody);
+    return score === null ? { kind: "fatal" } : { kind: "score", value: score };
+  } catch {
+    return { kind: "retryable" };
+  } finally {
+    clearTimeout(timeout);
+  }
+}
+function parseRelevanceScore(rawBody) {
+  let parsed;
+  try {
+    parsed = JSON.parse(rawBody);
+  } catch {
+    return null;
+  }
+  const firstChoice = parsed.choices?.[0];
+  const topLogprobs = firstChoice?.logprobs?.content?.[0]?.top_logprobs;
+  if (!Array.isArray(topLogprobs) || topLogprobs.length === 0) {
+    return null;
+  }
+  const top = topLogprobs[0];
+  if (!top || typeof top.logprob !== "number" || !Number.isFinite(top.logprob) || typeof top.token !== "string") {
+    return null;
+  }
+  const normalizedProb = Math.exp(top.logprob);
+  const tokenFirstWord = top.token.trim().split(/\s+/)[0]?.toLowerCase();
+  const score = tokenFirstWord === "true" ? normalizedProb : 1 - normalizedProb;
+  if (!Number.isFinite(score)) {
+    return null;
+  }
+  if (score <= 0) {
+    return 0;
+  }
+  if (score >= 1) {
+    return 1;
+  }
+  return score;
+}
+function buildUserPrompt(query, passage) {
+  return `Respond with "True" if PASSAGE is relevant to QUERY and "False" otherwise.
+<PASSAGE>
+${passage}
+</PASSAGE>
+<QUERY>
+${query}
+</QUERY>`;
+}
+function isRetryableStatus2(status) {
+  return status === 408 || status === 409 || status === 425 || status === 429 || status >= 500 && status < 600;
+}
+function clampPositiveInteger(value, fallback, opts) {
+  if (typeof value !== "number" || !Number.isFinite(value)) {
+    return fallback;
+  }
+  const floored = Math.floor(value);
+  if (floored < 0) {
+    return fallback;
+  }
+  if (floored === 0) {
+    return opts?.allowZero === true ? 0 : fallback;
+  }
+  return floored;
+}
+function normalizeOptional(value) {
+  const trimmed = value?.trim();
+  return trimmed && trimmed.length > 0 ? trimmed : void 0;
+}
+function backoffMs2(attempt) {
+  return Math.min(500 * 2 ** (attempt - 1), 5e3);
+}
+async function sleep2(durationMs) {
+  await new Promise((resolve) => {
+    setTimeout(resolve, durationMs);
+  });
+}
+
 // src/adapters/db/recall-adapter.ts
 var RECALL_CANDIDATE_SELECT_COLUMNS = `
   e.id,
@@ -4544,8 +5160,8 @@ var RECALL_CANDIDATE_SELECT_COLUMNS = `
   e.created_at
 `;
 var FTS_TIERS2 = ["exact", "all_tokens", "any_tokens"];
-var PREDECESSOR_EXPANSION_LIMIT_PER_SEED = 8;
-var PREDECESSOR_EXPANSION_MAX_RESULTS = 40;
+var NEIGHBORHOOD_DEFAULT_BUDGET_CAP = 40;
+var NEIGHBORHOOD_PER_SEED_BUDGET = 8;
 function createRecallAdapter(executor, embeddingPort) {
   return new LibsqlRecallAdapter(executor, embeddingPort);
 }
@@ -4646,23 +5262,34 @@ var LibsqlRecallAdapter = class {
     return Array.from(matches.values()).sort((left, right) => compareFtsCandidates(left, right)).slice(0, params.limit);
   }
   /**
-   * Finds historical predecessors scoped to a seed set of active candidate IDs.
+   * Expand a typed entry neighborhood around a seed set of candidate IDs.
    *
-   * Direct supersession links are preferred. Same-claim-key siblings are used as
-   * the structural lineage path, with retired same-subject entries preserved as
-   * a weaker fallback when explicit slot identity is unavailable.
+   * Honors the requested `families` exactly. `supersession_chain` adds rows
+   * that either supersede or are superseded by a seed. `claim_key_sibling`
+   * adds rows sharing a claim key with any seed. `topic_family` adds rows
+   * that share an exact subject with a seed and is the weakest fallback.
+   * `includeRetired` is applied as a hard gate so the default ranking
+   * profile never pulls retired rows into its candidate pool.
    */
-  async fetchPredecessors(params) {
-    const normalizedIds = normalizeStrings(params.activeEntryIds);
+  async expandNeighborhood(request) {
+    const normalizedIds = normalizeStrings(request.seedIds);
     if (normalizedIds.length === 0) {
       return [];
     }
+    const families = dedupeFamilies(request.families);
+    if (families.length === 0) {
+      return [];
+    }
+    const includeRetired = request.includeRetired === true;
+    const budget = normalizeNeighborhoodBudget(request.budget, normalizedIds.length);
     const placeholders = normalizedIds.map(() => "?").join(", ");
-    const expansionLimit = normalizePredecessorExpansionLimit(normalizedIds.length);
+    const retiredGate = includeRetired ? "" : "AND e.retired = 0";
+    const priorityExpression = buildNeighborhoodPriorityExpression(families, includeRetired);
+    const membershipExpression = buildNeighborhoodMembershipExpression(families);
     const result = await this.executor.execute({
       sql: `
         WITH seed AS (
-          SELECT id, subject, claim_key
+          SELECT id, subject, claim_key, superseded_by
           FROM entries
           WHERE id IN (${placeholders})
         ),
@@ -4676,47 +5303,26 @@ var LibsqlRecallAdapter = class {
           FROM seed
           WHERE claim_key IS NOT NULL
         ),
-        lineage AS (
+        seed_supersessions AS (
+          SELECT DISTINCT superseded_by AS target_id
+          FROM seed
+          WHERE superseded_by IS NOT NULL
+        ),
+        neighborhood AS (
           SELECT
             ${RECALL_CANDIDATE_SELECT_COLUMNS},
-            CASE
-              WHEN e.superseded_by IN (SELECT id FROM seed) THEN 0
-              WHEN e.claim_key IS NOT NULL
-                AND e.claim_key IN (SELECT claim_key FROM seed_claim_keys)
-                AND e.claim_key_status = 'trusted'
-                AND (e.retired = 1 OR e.superseded_by IS NOT NULL) THEN 1
-              WHEN e.claim_key IS NOT NULL
-                AND e.claim_key IN (SELECT claim_key FROM seed_claim_keys)
-                AND e.claim_key_status = 'trusted' THEN 2
-              WHEN e.claim_key IS NOT NULL
-                AND e.claim_key IN (SELECT claim_key FROM seed_claim_keys)
-                AND (e.retired = 1 OR e.superseded_by IS NOT NULL) THEN 3
-              WHEN e.claim_key IS NOT NULL
-                AND e.claim_key IN (SELECT claim_key FROM seed_claim_keys) THEN 4
-              WHEN e.retired = 1
-                AND e.subject IN (SELECT subject FROM seed_subjects) THEN 5
-              ELSE 6
-            END AS lineage_priority
+            ${priorityExpression} AS family_priority
           FROM entries AS e
           WHERE e.id NOT IN (SELECT id FROM seed)
-            AND (
-              e.superseded_by IN (SELECT id FROM seed)
-              OR (
-                e.claim_key IS NOT NULL
-                AND e.claim_key IN (SELECT claim_key FROM seed_claim_keys)
-              )
-              OR (
-                e.retired = 1
-                AND e.subject IN (SELECT subject FROM seed_subjects)
-              )
-            )
+            ${retiredGate}
+            AND (${membershipExpression})
         )
         SELECT *
-        FROM lineage
-        ORDER BY lineage_priority ASC, created_at ASC, id ASC
+        FROM neighborhood
+        ORDER BY family_priority ASC, created_at ASC, id ASC
         LIMIT ?
       `,
-      args: [...normalizedIds, expansionLimit]
+      args: [...normalizedIds, budget]
     });
     return result.rows.map((row) => mapRecallCandidateRow(row));
   }
@@ -4844,14 +5450,101 @@ function readOptionalClaimKeyStatus(row) {
   }
   return parsed;
 }
-function normalizePredecessorExpansionLimit(seedCount) {
-  return Math.min(PREDECESSOR_EXPANSION_MAX_RESULTS, seedCount * PREDECESSOR_EXPANSION_LIMIT_PER_SEED);
+function normalizeNeighborhoodBudget(requestedBudget, seedCount) {
+  const perSeedCap = seedCount * NEIGHBORHOOD_PER_SEED_BUDGET;
+  const safeRequested = Number.isFinite(requestedBudget) && requestedBudget > 0 ? Math.floor(requestedBudget) : perSeedCap;
+  return Math.max(1, Math.min(NEIGHBORHOOD_DEFAULT_BUDGET_CAP, perSeedCap, safeRequested));
+}
+function dedupeFamilies(families) {
+  return Array.from(new Set(families));
+}
+function buildNeighborhoodPriorityExpression(families, includeRetired) {
+  const branches = [];
+  if (families.includes("supersession_chain")) {
+    branches.push(`WHEN e.superseded_by IN (SELECT id FROM seed) THEN 0`);
+    branches.push(`WHEN e.id IN (SELECT target_id FROM seed_supersessions) THEN 1`);
+  }
+  if (families.includes("claim_key_sibling")) {
+    const retiredOrReplacedGuard = includeRetired ? "(e.retired = 1 OR e.superseded_by IS NOT NULL)" : "e.superseded_by IS NOT NULL";
+    branches.push(
+      `WHEN e.claim_key IS NOT NULL
+         AND e.claim_key IN (SELECT claim_key FROM seed_claim_keys)
+         AND e.claim_key_status = 'trusted'
+         AND ${retiredOrReplacedGuard} THEN 2`
+    );
+    branches.push(
+      `WHEN e.claim_key IS NOT NULL
+         AND e.claim_key IN (SELECT claim_key FROM seed_claim_keys)
+         AND e.claim_key_status = 'trusted' THEN 3`
+    );
+    branches.push(
+      `WHEN e.claim_key IS NOT NULL
+         AND e.claim_key IN (SELECT claim_key FROM seed_claim_keys)
+         AND ${retiredOrReplacedGuard} THEN 4`
+    );
+    branches.push(
+      `WHEN e.claim_key IS NOT NULL
+         AND e.claim_key IN (SELECT claim_key FROM seed_claim_keys) THEN 5`
+    );
+  }
+  if (families.includes("topic_family")) {
+    if (includeRetired) {
+      branches.push(`WHEN e.retired = 1 AND e.subject IN (SELECT subject FROM seed_subjects) THEN 6`);
+    } else {
+      branches.push(`WHEN e.subject IN (SELECT subject FROM seed_subjects) THEN 6`);
+    }
+  }
+  return `CASE ${branches.join("\n              ")} ELSE 9 END`;
+}
+function buildNeighborhoodMembershipExpression(families) {
+  const clauses = [];
+  if (families.includes("supersession_chain")) {
+    clauses.push(`e.superseded_by IN (SELECT id FROM seed)`);
+    clauses.push(`e.id IN (SELECT target_id FROM seed_supersessions)`);
+  }
+  if (families.includes("claim_key_sibling")) {
+    clauses.push(`(e.claim_key IS NOT NULL AND e.claim_key IN (SELECT claim_key FROM seed_claim_keys))`);
+  }
+  if (families.includes("topic_family")) {
+    clauses.push(`e.subject IN (SELECT subject FROM seed_subjects)`);
+  }
+  return clauses.length === 0 ? "0" : clauses.join("\n              OR ");
 }
 function wrapVectorError(error) {
   const message = error instanceof Error ? error.message : String(error);
   return new Error(`Vector search is unavailable: ${message}`);
 }
 
+// src/app/evals/recall/attach-cross-encoder.ts
+function attachCrossEncoderPort(ports, crossEncoder) {
+  if (!crossEncoder) {
+    return ports;
+  }
+  return {
+    async embed(text) {
+      return ports.embed(text);
+    },
+    async vectorSearch(params) {
+      return ports.vectorSearch(params);
+    },
+    async ftsSearch(params) {
+      return ports.ftsSearch(params);
+    },
+    ...ports.expandNeighborhood ? {
+      async expandNeighborhood(request) {
+        return ports.expandNeighborhood(request);
+      }
+    } : {},
+    crossEncoder,
+    async hydrateEntries(ids) {
+      return ports.hydrateEntries(ids);
+    },
+    async recordRecallEvents(params) {
+      return ports.recordRecallEvents(params);
+    }
+  };
+}
+
 // src/app/recall/claim-centric.ts
 function projectClaimCentricRecallEntries(entries, options = {}) {
   const families = /* @__PURE__ */ new Map();
@@ -4878,7 +5571,7 @@ function flattenClaimCentricRecallFamilies(families) {
 }
 function projectClaimCentricRecallEntry(recall2, options = {}) {
   const entry = recall2.entry;
-  const claimKey = normalizeOptionalString6(entry.claim_key);
+  const claimKey = normalizeOptionalString7(entry.claim_key);
   const familyKey = claimKey ?? `entry:${entry.id}`;
   const slotPolicy = resolveClaimSlotPolicy(claimKey, options.slotPolicyConfig).policy;
   const asOfResolution = buildAsOfResolution(recall2, options.asOf);
@@ -4904,38 +5597,38 @@ function resolveMemoryState(recall2, asOfResolution) {
       if (asOfResolution.relation === "active") {
         return "current";
       }
-      return normalizeOptionalString6(entry.superseded_by) ? "superseded" : "historical";
+      return normalizeOptionalString7(entry.superseded_by) ? "superseded" : "historical";
     }
     if (asOfResolution.relation === "observed_after" || asOfResolution.relation === "created_after") {
       return "historical";
     }
-    if (normalizeOptionalString6(entry.superseded_by)) {
+    if (normalizeOptionalString7(entry.superseded_by)) {
       return "superseded";
     }
-    if (entry.retired || normalizeOptionalString6(entry.valid_to)) {
+    if (entry.retired || normalizeOptionalString7(entry.valid_to)) {
       return "historical";
     }
     return "current";
   }
-  if (normalizeOptionalString6(entry.superseded_by)) {
+  if (normalizeOptionalString7(entry.superseded_by)) {
     return "superseded";
   }
-  if (entry.retired || normalizeOptionalString6(entry.valid_to)) {
+  if (entry.retired || normalizeOptionalString7(entry.valid_to)) {
     return "historical";
   }
   return "current";
 }
 function resolveClaimStatus(recall2) {
   const entry = recall2.entry;
-  if (!normalizeOptionalString6(entry.claim_key)) {
+  if (!normalizeOptionalString7(entry.claim_key)) {
     return "no_key";
   }
   return entry.claim_key_status ?? "legacy";
 }
 function buildFreshness(recall2, memoryState, asOfResolution) {
   const entry = recall2.entry;
-  const validFrom = normalizeOptionalString6(entry.valid_from);
-  const validTo = normalizeOptionalString6(entry.valid_to);
+  const validFrom = normalizeOptionalString7(entry.valid_from);
+  const validTo = normalizeOptionalString7(entry.valid_to);
   const createdAt = entry.created_at;
   const labelParts = [`created ${createdAt}`];
   if (validFrom || validTo) {
@@ -4963,12 +5656,12 @@ function buildFreshness(recall2, memoryState, asOfResolution) {
 function buildProvenance(recall2) {
   const entry = recall2.entry;
   return {
-    ...normalizeOptionalString6(entry.superseded_by) ? { supersededById: entry.superseded_by } : {},
-    ...normalizeOptionalString6(entry.supersession_kind) ? { supersessionKind: entry.supersession_kind } : {},
-    ...normalizeOptionalString6(entry.supersession_reason) ? { supersessionReason: entry.supersession_reason } : {},
-    ...normalizeOptionalString6(entry.claim_support_source_kind) ? { supportSourceKind: entry.claim_support_source_kind } : {},
-    ...normalizeOptionalString6(entry.claim_support_locator) ? { supportLocator: entry.claim_support_locator } : {},
-    ...normalizeOptionalString6(entry.claim_support_observed_at) ? { supportObservedAt: entry.claim_support_observed_at } : {},
+    ...normalizeOptionalString7(entry.superseded_by) ? { supersededById: entry.superseded_by } : {},
+    ...normalizeOptionalString7(entry.supersession_kind) ? { supersessionKind: entry.supersession_kind } : {},
+    ...normalizeOptionalString7(entry.supersession_reason) ? { supersessionReason: entry.supersession_reason } : {},
+    ...normalizeOptionalString7(entry.claim_support_source_kind) ? { supportSourceKind: entry.claim_support_source_kind } : {},
+    ...normalizeOptionalString7(entry.claim_support_locator) ? { supportLocator: entry.claim_support_locator } : {},
+    ...normalizeOptionalString7(entry.claim_support_observed_at) ? { supportObservedAt: entry.claim_support_observed_at } : {},
     ...entry.claim_support_mode ? { supportMode: entry.claim_support_mode } : {}
   };
 }
@@ -5004,12 +5697,12 @@ function buildWhySurfaced(recall2, asOfResolution) {
 function formatScore(value) {
   return value.toFixed(2);
 }
-function normalizeOptionalString6(value) {
+function normalizeOptionalString7(value) {
   const normalized = value?.trim();
   return normalized && normalized.length > 0 ? normalized : void 0;
 }
 function buildAsOfResolution(recall2, asOf) {
-  const normalizedAsOf = normalizeOptionalString6(asOf);
+  const normalizedAsOf = normalizeOptionalString7(asOf);
   if (!normalizedAsOf) {
     return void 0;
   }
@@ -5073,12 +5766,296 @@ function formatAsOfRelation(relation) {
   }
 }
 function parseTimestamp(value) {
-  const normalized = normalizeOptionalString6(value);
+  const normalized = normalizeOptionalString7(value);
   if (!normalized) {
     return void 0;
   }
-  const parsed = new Date(normalized);
-  return Number.isFinite(parsed.getTime()) ? parsed : void 0;
+  const parsed = new Date(normalized);
+  return Number.isFinite(parsed.getTime()) ? parsed : void 0;
+}
+
+// src/app/procedures/recall/service.ts
+var DEFAULT_LIMIT = 5;
+var DEFAULT_CANONICAL_THRESHOLD = 0.55;
+var DEFAULT_CANONICAL_MARGIN = 0.08;
+var LEXICAL_CANDIDATE_MULTIPLIER = 3;
+var VECTOR_CANDIDATE_MULTIPLIER = 4;
+var VECTOR_ONLY_CANONICAL_FLOOR = 0.6;
+var LEXICAL_ONLY_NOTICE = "Semantic procedure search unavailable - using lexical-only procedure ranking.";
+var LEXICAL_ONLY_FALLBACK_NOTICE = "Semantic procedure search failed during procedure recall - using lexical-only procedure ranking.";
+async function runProcedureRecall(input, deps) {
+  const text = input.text.trim();
+  const limit = normalizeLimit(input.limit);
+  if (text.length === 0 || limit === 0) {
+    return {
+      candidates: [],
+      notices: []
+    };
+  }
+  const lexicalLimit = limit * LEXICAL_CANDIDATE_MULTIPLIER;
+  const vectorLimit = limit * VECTOR_CANDIDATE_MULTIPLIER;
+  const notices = [];
+  const lexicalMatches = await deps.db.procedureFtsSearch({
+    text,
+    limit: lexicalLimit
+  });
+  const queryEmbedding = await maybeEmbedQuery(text, deps.embedQuery, notices);
+  const vectorMatches = queryEmbedding.length > 0 ? await deps.db.procedureVectorSearch({
+    embedding: queryEmbedding,
+    limit: vectorLimit
+  }).catch(() => {
+    notices.push(LEXICAL_ONLY_FALLBACK_NOTICE);
+    return [];
+  }) : [];
+  const diversified = applyProcedureMmrDiversification(rankProcedureCandidates(text, lexicalMatches, vectorMatches), queryEmbedding, input.mmr);
+  const reranked = await applyProcedureCrossEncoderRerank(diversified, text, input.crossEncoder);
+  const ranked = reranked.slice(0, limit);
+  const canonicalProcedure = selectCanonicalProcedure(ranked, input.threshold);
+  return {
+    ...canonicalProcedure ? { canonicalProcedure } : {},
+    candidates: ranked,
+    notices: dedupePreservingOrder(notices)
+  };
+}
+async function applyProcedureCrossEncoderRerank(candidates, query, options) {
+  if (!options || !options.enabled || candidates.length === 0) {
+    return candidates;
+  }
+  const rerank = await applyCrossEncoderRerank({
+    query,
+    candidates: candidates.map((candidate) => ({
+      id: candidate.procedure.id,
+      text: buildProcedureCrossEncoderText(candidate.procedure),
+      score: candidate.score,
+      candidate
+    })),
+    port: options.port,
+    topK: options.topK ?? DEFAULT_CROSS_ENCODER_TOP_K,
+    alpha: options.alpha ?? DEFAULT_CROSS_ENCODER_ALPHA
+  });
+  return rerank.candidates.map((entry) => {
+    const base = entry.candidate;
+    const nextScore = entry.score;
+    if (typeof entry.crossEncoderScore !== "number" && nextScore === base.score) {
+      return base;
+    }
+    return {
+      ...base,
+      score: nextScore,
+      scores: {
+        ...base.scores,
+        relevance: nextScore,
+        rrf: nextScore,
+        ...typeof entry.crossEncoderScore === "number" ? { crossEncoder: entry.crossEncoderScore } : {}
+      }
+    };
+  });
+}
+function buildProcedureCrossEncoderText(procedure) {
+  const title = procedure.title?.trim() ?? "";
+  const recallText = procedure.recall_text?.trim() ?? "";
+  if (title.length === 0) {
+    return recallText;
+  }
+  if (recallText.length === 0) {
+    return title;
+  }
+  return `${title}
+
+${recallText}`;
+}
+async function maybeEmbedQuery(text, embedQuery, notices) {
+  if (!embedQuery) {
+    notices.push(LEXICAL_ONLY_NOTICE);
+    return [];
+  }
+  try {
+    const embedding = await embedQuery(text);
+    if (embedding.length === 0) {
+      notices.push(LEXICAL_ONLY_NOTICE);
+      return [];
+    }
+    return embedding;
+  } catch {
+    notices.push(LEXICAL_ONLY_FALLBACK_NOTICE);
+    return [];
+  }
+}
+function rankProcedureCandidates(query, lexicalMatches, vectorMatches) {
+  const merged = /* @__PURE__ */ new Map();
+  for (const match of lexicalMatches) {
+    const lexical = computeProcedureLexicalScore(query, match.procedure);
+    merged.set(match.procedure.id, {
+      procedure: match.procedure,
+      lexical,
+      vector: 0
+    });
+  }
+  for (const match of vectorMatches) {
+    const existing = merged.get(match.procedure.id);
+    merged.set(match.procedure.id, {
+      procedure: match.procedure,
+      lexical: existing?.lexical ?? computeProcedureLexicalScore(query, match.procedure),
+      vector: Math.max(existing?.vector ?? 0, match.vectorSim)
+    });
+  }
+  const lexicalRanks = rankByDescending(merged, (signals) => signals.lexical);
+  const vectorRanks = rankByDescending(merged, (signals) => signals.vector);
+  const relevanceByProcedureId = rrfFuseVectorLexical(vectorRanks, lexicalRanks);
+  const ranked = Array.from(merged.values()).map((candidate) => {
+    const relevance = relevanceByProcedureId.get(candidate.procedure.id) ?? 0;
+    return {
+      procedure: candidate.procedure,
+      score: relevance,
+      scores: {
+        relevance,
+        rrf: relevance,
+        lexical: candidate.lexical,
+        vector: candidate.vector
+      }
+    };
+  }).filter((candidate) => candidate.score > 0);
+  return applySeededProcedureRerank(ranked).sort(compareProcedureCandidates);
+}
+function applyProcedureMmrDiversification(candidates, queryEmbedding, options) {
+  if (!options || !options.enabled || candidates.length < 2 || queryEmbedding.length === 0) {
+    return candidates;
+  }
+  const reorder = maximalMarginalRelevance({
+    queryVector: queryEmbedding,
+    candidates: candidates.map((candidate) => ({
+      id: candidate.procedure.id,
+      relevance: candidate.score,
+      ...candidate.procedure.embedding ? { embedding: candidate.procedure.embedding } : {}
+    })),
+    lambda: resolveProcedureMmrLambda(options.lambda),
+    ...typeof options.minPoolSize === "number" ? { minPoolSize: options.minPoolSize } : {}
+  });
+  if (!reorder.applied) {
+    return candidates;
+  }
+  const candidatesById = new Map(candidates.map((candidate) => [candidate.procedure.id, candidate]));
+  return reorder.orderedIds.flatMap((id) => {
+    const candidate = candidatesById.get(id);
+    return candidate ? [candidate] : [];
+  });
+}
+function resolveProcedureMmrLambda(value) {
+  if (typeof value !== "number" || !Number.isFinite(value)) {
+    return DEFAULT_MMR_LAMBDA;
+  }
+  return Math.max(0, Math.min(1, value));
+}
+function applySeededProcedureRerank(candidates) {
+  if (candidates.length === 0) {
+    return candidates;
+  }
+  const seeds = selectStrongSeeds(
+    candidates.map((candidate) => ({ id: candidate.procedure.id, score: candidate.score, procedure: candidate.procedure })),
+    {
+      topN: DEFAULT_STRONG_SEED_TOP_N,
+      scoreGapFloor: DEFAULT_STRONG_SEED_SCORE_GAP
+    }
+  );
+  if (seeds.length === 0) {
+    return candidates;
+  }
+  const payloads = candidates.map((candidate) => ({
+    id: candidate.procedure.id,
+    score: candidate.score,
+    procedure: candidate.procedure
+  }));
+  const reranked = seededRerank(payloads, seeds, (candidate, seed) => sharesProcedureLineage(candidate.procedure, seed.procedure), {
+    weight: DEFAULT_SEEDED_RERANK_WEIGHT
+  });
+  const scoreById = new Map(reranked.candidates.map((candidate) => [candidate.id, candidate.score]));
+  return candidates.map((candidate) => {
+    const nextScore = scoreById.get(candidate.procedure.id);
+    if (nextScore === void 0 || nextScore === candidate.score) {
+      return candidate;
+    }
+    return {
+      ...candidate,
+      score: nextScore,
+      scores: {
+        ...candidate.scores,
+        relevance: nextScore,
+        rrf: nextScore
+      }
+    };
+  });
+}
+function computeProcedureLexicalScore(query, procedure) {
+  return computeLexicalScore(query, procedure.title, procedure.recall_text);
+}
+function rankByDescending(merged, signalOf) {
+  return Array.from(merged.values()).filter((signals) => signalOf(signals) > 0).sort((left, right) => {
+    const delta = signalOf(right) - signalOf(left);
+    if (delta !== 0) {
+      return delta;
+    }
+    return left.procedure.procedure_key.localeCompare(right.procedure.procedure_key);
+  }).map((signals) => signals.procedure.id);
+}
+function selectCanonicalProcedure(ranked, threshold) {
+  const leader = ranked[0];
+  if (!leader) {
+    return void 0;
+  }
+  const minimumScore = normalizeThreshold(threshold);
+  if (leader.score < minimumScore) {
+    return void 0;
+  }
+  if (leader.scores.lexical === 0 && leader.scores.vector < VECTOR_ONLY_CANONICAL_FLOOR) {
+    return void 0;
+  }
+  const runnerUp = ranked[1];
+  if (runnerUp && signalStrength(leader) - signalStrength(runnerUp) < DEFAULT_CANONICAL_MARGIN) {
+    return void 0;
+  }
+  return leader.procedure;
+}
+function signalStrength(candidate) {
+  return Math.max(candidate.scores.vector, candidate.scores.lexical);
+}
+function compareProcedureCandidates(left, right) {
+  if (left.score !== right.score) {
+    return right.score - left.score;
+  }
+  if (left.scores.lexical !== right.scores.lexical) {
+    return right.scores.lexical - left.scores.lexical;
+  }
+  if (left.scores.vector !== right.scores.vector) {
+    return right.scores.vector - left.scores.vector;
+  }
+  if (left.procedure.updated_at !== right.procedure.updated_at) {
+    return right.procedure.updated_at.localeCompare(left.procedure.updated_at);
+  }
+  return left.procedure.procedure_key.localeCompare(right.procedure.procedure_key);
+}
+function normalizeLimit(value) {
+  if (value === void 0 || !Number.isFinite(value)) {
+    return DEFAULT_LIMIT;
+  }
+  return Math.max(0, Math.trunc(value));
+}
+function normalizeThreshold(value) {
+  if (value === void 0 || !Number.isFinite(value)) {
+    return DEFAULT_CANONICAL_THRESHOLD;
+  }
+  return Math.min(1, Math.max(0, value));
+}
+function dedupePreservingOrder(values) {
+  const seen = /* @__PURE__ */ new Set();
+  const deduped = [];
+  for (const value of values) {
+    if (seen.has(value)) {
+      continue;
+    }
+    seen.add(value);
+    deduped.push(value);
+  }
+  return deduped;
 }
 
 // src/core/episode/temporal-window.ts
@@ -5561,12 +6538,12 @@ function compareAscending(left, right) {
 }
 
 // src/core/episode/search.ts
-var DEFAULT_LIMIT = 10;
+var DEFAULT_LIMIT2 = 10;
 var MIN_CANDIDATE_LIMIT = 25;
 var MAX_CANDIDATE_LIMIT = 100;
 var CANDIDATE_MULTIPLIER = 5;
 async function searchEpisodes(query, database, now = /* @__PURE__ */ new Date()) {
-  const limit = normalizeLimit(query.limit);
+  const limit = normalizeLimit2(query.limit);
   if (limit === 0) {
     return [];
   }
@@ -5589,14 +6566,139 @@ async function searchEpisodes(query, database, now = /* @__PURE__ */ new Date())
     return matches.map((match) => buildSemanticResult(match.episode, match.vectorSim, now)).sort(compareSemanticEpisodeResults).slice(0, limit);
   }
   const candidates = await database.listEpisodesByTimeWindow(query.timeWindow, computeCandidateLimit(limit));
-  return candidates.map((episode) => buildHybridResult(episode, normalizedEmbedding, bounds, now)).sort(compareSemanticEpisodeResults).slice(0, limit);
+  const hybridResults = candidates.map((episode) => buildHybridResult(episode, normalizedEmbedding, bounds, now));
+  const fused = fuseHybridResultsWithRrf(hybridResults);
+  const diversified = applyEpisodeMmrDiversification(fused, normalizedEmbedding, query.mmr);
+  const reranked = await applyEpisodeCrossEncoderRerank(diversified, query.text, query.crossEncoder);
+  return reranked.slice(0, limit);
+}
+async function applyEpisodeCrossEncoderRerank(results, query, options) {
+  if (!options || !options.enabled || results.length === 0) {
+    return results;
+  }
+  const rerank = await applyCrossEncoderRerank({
+    query,
+    candidates: results.map((result) => ({
+      id: result.episode.id,
+      text: buildEpisodeCrossEncoderText(result.episode),
+      score: result.score,
+      candidate: result
+    })),
+    port: options.port,
+    topK: options.topK ?? DEFAULT_CROSS_ENCODER_TOP_K,
+    alpha: options.alpha ?? DEFAULT_CROSS_ENCODER_ALPHA
+  });
+  return rerank.candidates.map((entry) => {
+    const base = entry.candidate;
+    const nextScore = Number(entry.score.toFixed(6));
+    if (typeof entry.crossEncoderScore !== "number" && nextScore === base.score) {
+      return base;
+    }
+    return {
+      ...base,
+      score: nextScore,
+      scores: {
+        ...base.scores,
+        ...typeof entry.crossEncoderScore === "number" ? { crossEncoder: Number(entry.crossEncoderScore.toFixed(6)) } : {}
+      }
+    };
+  });
 }
-function normalizeLimit(value) {
+function buildEpisodeCrossEncoderText(episode) {
+  const summary = episode.summary?.trim() ?? "";
+  if (summary.length > 0) {
+    return summary;
+  }
+  const source = episode.source ?? "";
+  const ref = episode.sourceRef ?? episode.sourceId ?? "";
+  return `${source} ${ref}`.trim();
+}
+function applyEpisodeMmrDiversification(results, queryEmbedding, options) {
+  if (!options || !options.enabled || results.length < 2 || queryEmbedding.length === 0) {
+    return results;
+  }
+  const reorder = maximalMarginalRelevance({
+    queryVector: queryEmbedding,
+    candidates: results.map((result) => ({
+      id: result.episode.id,
+      relevance: result.score,
+      ...result.episode.embedding ? { embedding: result.episode.embedding } : {}
+    })),
+    lambda: resolveEpisodeMmrLambda(options.lambda),
+    ...typeof options.minPoolSize === "number" ? { minPoolSize: options.minPoolSize } : {}
+  });
+  if (!reorder.applied) {
+    return results;
+  }
+  const resultsById = new Map(results.map((result) => [result.episode.id, result]));
+  return reorder.orderedIds.flatMap((id) => {
+    const result = resultsById.get(id);
+    return result ? [result] : [];
+  });
+}
+function resolveEpisodeMmrLambda(value) {
+  if (typeof value !== "number" || !Number.isFinite(value)) {
+    return DEFAULT_MMR_LAMBDA;
+  }
+  return Math.max(0, Math.min(1, value));
+}
+function fuseHybridResultsWithRrf(hybridResults) {
+  if (hybridResults.length === 0) {
+    return [];
+  }
+  const temporalRanks = [...hybridResults].sort((left, right) => compareDescending2(left.scores.temporal, right.scores.temporal) || compareAscending2(left.episode.id, right.episode.id)).map((result) => result.episode.id);
+  const semanticRanks = [...hybridResults].filter((result) => result.scores.semantic > 0).sort((left, right) => compareDescending2(left.scores.semantic, right.scores.semantic) || compareAscending2(left.episode.id, right.episode.id)).map((result) => result.episode.id);
+  const fusedScores = rrfFuse([temporalRanks, semanticRanks]);
+  const fused = hybridResults.map((result) => ({
+    ...result,
+    score: Number((fusedScores.get(result.episode.id) ?? 0).toFixed(6))
+  }));
+  const reranked = applySeededEpisodeRerank(fused);
+  return reranked.sort(compareFusedEpisodeResults);
+}
+function applySeededEpisodeRerank(results) {
+  if (results.length === 0) {
+    return results;
+  }
+  const seeds = selectStrongSeeds(
+    results.map((result) => ({ id: result.episode.id, score: result.score, episode: result.episode })),
+    {
+      topN: DEFAULT_STRONG_SEED_TOP_N,
+      scoreGapFloor: DEFAULT_STRONG_SEED_SCORE_GAP
+    }
+  );
+  if (seeds.length === 0) {
+    return results;
+  }
+  const payloads = results.map((result) => ({
+    id: result.episode.id,
+    score: result.score,
+    episode: result.episode
+  }));
+  const reranked = seededRerank(payloads, seeds, (candidate, seed) => sharesEpisodeLineage(candidate.episode, seed.episode), {
+    weight: DEFAULT_SEEDED_RERANK_WEIGHT
+  });
+  const scoreById = new Map(reranked.candidates.map((candidate) => [candidate.id, candidate.score]));
+  return results.map((result) => {
+    const nextScore = scoreById.get(result.episode.id);
+    if (nextScore === void 0 || nextScore === result.score) {
+      return result;
+    }
+    return {
+      ...result,
+      score: Number(nextScore.toFixed(6))
+    };
+  });
+}
+function compareFusedEpisodeResults(left, right) {
+  return compareDescending2(left.score, right.score) || compareDescending2(left.scores.semantic, right.scores.semantic) || compareDescending2(left.scores.temporal, right.scores.temporal) || compareDescending2(left.scores.activity, right.scores.activity) || compareDescending2(left.scores.recency, right.scores.recency) || compareAscending2(left.episode.startedAt, right.episode.startedAt) || compareAscending2(left.episode.id, right.episode.id);
+}
+function normalizeLimit2(value) {
   if (value === void 0) {
-    return DEFAULT_LIMIT;
+    return DEFAULT_LIMIT2;
   }
   if (!Number.isFinite(value)) {
-    return DEFAULT_LIMIT;
+    return DEFAULT_LIMIT2;
   }
   return Math.max(0, Math.trunc(value));
 }
@@ -5653,156 +6755,6 @@ function compareAscending2(left, right) {
   return left.localeCompare(right);
 }
 
-// src/app/procedures/recall/service.ts
-var DEFAULT_LIMIT2 = 5;
-var DEFAULT_CANONICAL_THRESHOLD = 0.55;
-var DEFAULT_CANONICAL_MARGIN = 0.08;
-var LEXICAL_CANDIDATE_MULTIPLIER = 3;
-var VECTOR_CANDIDATE_MULTIPLIER = 4;
-var VECTOR_ONLY_CANONICAL_FLOOR = 0.6;
-var LEXICAL_ONLY_NOTICE = "Semantic procedure search unavailable - using lexical-only procedure ranking.";
-var LEXICAL_ONLY_FALLBACK_NOTICE = "Semantic procedure search failed during procedure recall - using lexical-only procedure ranking.";
-async function runProcedureRecall(input, deps) {
-  const text = input.text.trim();
-  const limit = normalizeLimit2(input.limit);
-  if (text.length === 0 || limit === 0) {
-    return {
-      candidates: [],
-      notices: []
-    };
-  }
-  const lexicalLimit = limit * LEXICAL_CANDIDATE_MULTIPLIER;
-  const vectorLimit = limit * VECTOR_CANDIDATE_MULTIPLIER;
-  const notices = [];
-  const lexicalMatches = await deps.db.procedureFtsSearch({
-    text,
-    limit: lexicalLimit
-  });
-  const queryEmbedding = await maybeEmbedQuery(text, deps.embedQuery, notices);
-  const vectorMatches = queryEmbedding.length > 0 ? await deps.db.procedureVectorSearch({
-    embedding: queryEmbedding,
-    limit: vectorLimit
-  }).catch(() => {
-    notices.push(LEXICAL_ONLY_FALLBACK_NOTICE);
-    return [];
-  }) : [];
-  const ranked = rankProcedureCandidates(text, lexicalMatches, vectorMatches).slice(0, limit);
-  const canonicalProcedure = selectCanonicalProcedure(ranked, input.threshold);
-  return {
-    ...canonicalProcedure ? { canonicalProcedure } : {},
-    candidates: ranked,
-    notices: dedupePreservingOrder(notices)
-  };
-}
-async function maybeEmbedQuery(text, embedQuery, notices) {
-  if (!embedQuery) {
-    notices.push(LEXICAL_ONLY_NOTICE);
-    return [];
-  }
-  try {
-    const embedding = await embedQuery(text);
-    if (embedding.length === 0) {
-      notices.push(LEXICAL_ONLY_NOTICE);
-      return [];
-    }
-    return embedding;
-  } catch {
-    notices.push(LEXICAL_ONLY_FALLBACK_NOTICE);
-    return [];
-  }
-}
-function rankProcedureCandidates(query, lexicalMatches, vectorMatches) {
-  const merged = /* @__PURE__ */ new Map();
-  for (const match of lexicalMatches) {
-    const lexical = computeProcedureLexicalScore(query, match.procedure);
-    merged.set(match.procedure.id, {
-      procedure: match.procedure,
-      lexical,
-      vector: 0
-    });
-  }
-  for (const match of vectorMatches) {
-    const existing = merged.get(match.procedure.id);
-    merged.set(match.procedure.id, {
-      procedure: match.procedure,
-      lexical: existing?.lexical ?? computeProcedureLexicalScore(query, match.procedure),
-      vector: Math.max(existing?.vector ?? 0, match.vectorSim)
-    });
-  }
-  return Array.from(merged.values()).map((candidate) => {
-    const relevance = combinedRelevance(candidate.vector, candidate.lexical);
-    return {
-      procedure: candidate.procedure,
-      score: relevance,
-      scores: {
-        relevance,
-        lexical: candidate.lexical,
-        vector: candidate.vector
-      }
-    };
-  }).filter((candidate) => candidate.score > 0).sort(compareProcedureCandidates);
-}
-function computeProcedureLexicalScore(query, procedure) {
-  return computeLexicalScore(query, procedure.title, procedure.recall_text);
-}
-function selectCanonicalProcedure(ranked, threshold) {
-  const leader = ranked[0];
-  if (!leader) {
-    return void 0;
-  }
-  const minimumScore = normalizeThreshold(threshold);
-  if (leader.score < minimumScore) {
-    return void 0;
-  }
-  if (leader.scores.lexical === 0 && leader.scores.vector < VECTOR_ONLY_CANONICAL_FLOOR) {
-    return void 0;
-  }
-  const runnerUp = ranked[1];
-  if (runnerUp && leader.score - runnerUp.score < DEFAULT_CANONICAL_MARGIN) {
-    return void 0;
-  }
-  return leader.procedure;
-}
-function compareProcedureCandidates(left, right) {
-  if (left.score !== right.score) {
-    return right.score - left.score;
-  }
-  if (left.scores.lexical !== right.scores.lexical) {
-    return right.scores.lexical - left.scores.lexical;
-  }
-  if (left.scores.vector !== right.scores.vector) {
-    return right.scores.vector - left.scores.vector;
-  }
-  if (left.procedure.updated_at !== right.procedure.updated_at) {
-    return right.procedure.updated_at.localeCompare(left.procedure.updated_at);
-  }
-  return left.procedure.procedure_key.localeCompare(right.procedure.procedure_key);
-}
-function normalizeLimit2(value) {
-  if (value === void 0 || !Number.isFinite(value)) {
-    return DEFAULT_LIMIT2;
-  }
-  return Math.max(0, Math.trunc(value));
-}
-function normalizeThreshold(value) {
-  if (value === void 0 || !Number.isFinite(value)) {
-    return DEFAULT_CANONICAL_THRESHOLD;
-  }
-  return Math.min(1, Math.max(0, value));
-}
-function dedupePreservingOrder(values) {
-  const seen = /* @__PURE__ */ new Set();
-  const deduped = [];
-  for (const value of values) {
-    if (seen.has(value)) {
-      continue;
-    }
-    seen.add(value);
-    deduped.push(value);
-  }
-  return deduped;
-}
-
 // src/app/recall/transitions.ts
 function buildClaimTransitionExplanations(params) {
   if (params.families.length === 0 || params.detectedIntent === "temporal_narrative") {
@@ -5939,14 +6891,32 @@ var PROCEDURAL_REGEX_PATTERNS = [
   /\b(?:checklist|playbook|runbook|procedure|process|instructions?|workflow|method)\b.*\b(?:for|to)\b/u,
   /\bwhat(?:'s| is) the (?:best|recommended|right) way to\b/u
 ];
+var ENTITY_ATTRIBUTE_MAX_WORDS = 5;
+var ENTITY_ATTRIBUTE_CONTEXTUAL_PREFIX_RE = /^(?:on|in|at|for|about|during|after|before)\b/u;
+var ENTITY_ATTRIBUTE_CONTEXTUAL_TIME_RE = /\b(?:today|tomorrow|yesterday|tonight|currently|right now|this week|next week|last week|this month|next month|last month|this year|next year|last year)\b/u;
+var ENTITY_ATTRIBUTE_CONTEXTUAL_ACTIVITY_RE = /\b(?:on call|available|working|assigned|scheduled|responsible)\b/u;
+var ENTITY_ATTRIBUTE_GENERIC_ENTITY_RE = /^(?:it|this|that|these|those|they|them|he|she|someone|anyone|anything|everything)\b/u;
+var ENTITY_ATTRIBUTE_KIND_TOKENS = {
+  identity: ["identity", "profile", "bio", "biography", "summary"],
+  location: ["location", "live", "lives", "reside", "resides", "located", "home", "city"],
+  email: ["email", "e-mail", "mail"],
+  phone: ["phone", "number", "mobile", "cell", "telephone"],
+  address: ["address", "street", "mailing"]
+};
 async function runUnifiedRecall(input, deps) {
   const now = deps.now ?? /* @__PURE__ */ new Date();
   const requested = normalizeMode(input.mode);
   const parsedTimeWindow = parseTemporalWindow(input.text, now);
   const hasEntryFilters = hasEntryScopedFilters(input);
   const topicAnchor = hasTopicAnchor(input.text, hasEntryFilters);
+  const entityAttributeQuery = detectEntityAttributeQuery(input.text);
   const historicalStatePattern = detectHistoricalStatePattern(input.text);
   const proceduralPattern = detectProceduralPattern(input.text);
+  if (entityAttributeQuery) {
+    deps.debugLog?.(
+      `[agenr] unified recall matched entity-attribute kind=${JSON.stringify(entityAttributeQuery.attributeKind)} entity=${JSON.stringify(entityAttributeQuery.entityText)} query=${JSON.stringify(input.text)}`
+    );
+  }
   if (historicalStatePattern) {
     deps.debugLog?.(`[agenr] unified recall matched historical-state pattern=${JSON.stringify(historicalStatePattern)} query=${JSON.stringify(input.text)}`);
   }
@@ -5967,7 +6937,9 @@ async function runUnifiedRecall(input, deps) {
     detectedIntent: routing.detectedIntent,
     parsedTimeWindow,
     topicAnchor,
-    embedQuery: deps.embedQuery
+    embedQuery: deps.embedQuery,
+    rankingPolicy: deps.recallOptions?.rankingPolicy,
+    crossEncoder: deps.recall.crossEncoder
   }) : {
     notices: []
   };
@@ -5979,11 +6951,15 @@ async function runUnifiedRecall(input, deps) {
   if (routing.queried.includes("episodes") && hasEntryScopedFilters(input)) {
     notices.push(ENTRY_FILTER_NOTICE);
   }
+  const procedureMmr = resolveProcedureMmrOptions(deps.recallOptions?.rankingPolicy);
+  const procedureCrossEncoder = resolveProcedureCrossEncoderOptions(deps.recallOptions?.rankingPolicy, deps.recall.crossEncoder);
   const procedureResults = routing.queried.includes("procedures") ? await runProcedureRecall(
     {
       text: input.text,
       ...input.limit !== void 0 ? { limit: input.limit } : {},
-      ...input.threshold !== void 0 ? { threshold: input.threshold } : {}
+      ...input.threshold !== void 0 ? { threshold: input.threshold } : {},
+      ...procedureMmr ? { mmr: procedureMmr } : {},
+      ...procedureCrossEncoder ? { crossEncoder: procedureCrossEncoder } : {}
     },
     {
       db: deps.procedures,
@@ -6044,13 +7020,14 @@ function routeRecall(params) {
   const lower = params.text.trim().toLowerCase();
   const factual = /^(when did|when was|what decision|what preference|what(?:'s| is) the default|which version|what threshold)\b/.test(lower);
   const narrative = /\b(what happened|what were we doing|what was going on|summarize|catch me up)\b/.test(lower);
+  const entityAttributeQuery = detectEntityAttributeQuery(params.text);
   const historicalState = detectHistoricalStatePattern(params.text) !== void 0;
   const procedural = detectProceduralPattern(params.text) !== void 0;
   const topicAnchor = hasTopicAnchor(params.text, params.hasEntryFilters);
   if (params.requested === "entries") {
     return {
       requested: params.requested,
-      detectedIntent: historicalState ? "historical_state" : factual ? "factual" : params.parsedTimeWindow ? "mixed" : "factual",
+      detectedIntent: entityAttributeQuery ? "entity_attribute" : historicalState ? "historical_state" : factual ? "factual" : params.parsedTimeWindow ? "mixed" : "factual",
       queried: ["entries"],
       reason: "Explicit mode=entries override."
     };
@@ -6071,6 +7048,14 @@ function routeRecall(params) {
       reason: "Explicit mode=procedures override."
     };
   }
+  if (entityAttributeQuery) {
+    return {
+      requested: params.requested,
+      detectedIntent: "entity_attribute",
+      queried: ["entries"],
+      reason: "The query asks for a specific entity attribute, so precision-first entry recall was used."
+    };
+  }
   if (historicalState) {
     return {
       requested: params.requested,
@@ -6173,16 +7158,65 @@ async function buildEpisodeQueryPlan(params) {
       notices
     };
   }
+  const mmr = resolveEpisodeMmrOptions(params.detectedIntent, params.rankingPolicy);
+  const crossEncoder = resolveEpisodeCrossEncoderOptions(params.rankingPolicy, params.crossEncoder);
   return {
     query: {
       text: params.text,
       ...params.limit !== void 0 ? { limit: params.limit } : {},
       ...params.parsedTimeWindow ? { timeWindow: params.parsedTimeWindow.window } : {},
-      ...embedding ? { embedding } : {}
+      ...embedding ? { embedding } : {},
+      ...mmr ? { mmr } : {},
+      ...crossEncoder ? { crossEncoder } : {}
     },
     notices
   };
 }
+function resolveEpisodeMmrOptions(detectedIntent, rankingPolicy) {
+  if (rankingPolicy?.mmr === "disabled") {
+    return void 0;
+  }
+  if (detectedIntent !== "factual" && detectedIntent !== "mixed") {
+    return void 0;
+  }
+  return {
+    enabled: true,
+    ...typeof rankingPolicy?.mmrLambda === "number" ? { lambda: rankingPolicy.mmrLambda } : {},
+    ...typeof rankingPolicy?.mmrMinPoolSize === "number" ? { minPoolSize: rankingPolicy.mmrMinPoolSize } : {}
+  };
+}
+function resolveProcedureMmrOptions(rankingPolicy) {
+  if (rankingPolicy?.mmr === "disabled") {
+    return void 0;
+  }
+  return {
+    enabled: true,
+    ...typeof rankingPolicy?.mmrLambda === "number" ? { lambda: rankingPolicy.mmrLambda } : {},
+    ...typeof rankingPolicy?.mmrMinPoolSize === "number" ? { minPoolSize: rankingPolicy.mmrMinPoolSize } : {}
+  };
+}
+function resolveEpisodeCrossEncoderOptions(rankingPolicy, crossEncoder) {
+  if (!crossEncoder || rankingPolicy?.crossEncoder === "disabled") {
+    return void 0;
+  }
+  return {
+    enabled: true,
+    port: crossEncoder,
+    ...typeof rankingPolicy?.crossEncoderTopK === "number" ? { topK: rankingPolicy.crossEncoderTopK } : {},
+    ...typeof rankingPolicy?.crossEncoderAlpha === "number" ? { alpha: rankingPolicy.crossEncoderAlpha } : {}
+  };
+}
+function resolveProcedureCrossEncoderOptions(rankingPolicy, crossEncoder) {
+  if (!crossEncoder || rankingPolicy?.crossEncoder === "disabled") {
+    return void 0;
+  }
+  return {
+    enabled: true,
+    port: crossEncoder,
+    ...typeof rankingPolicy?.crossEncoderTopK === "number" ? { topK: rankingPolicy.crossEncoderTopK } : {},
+    ...typeof rankingPolicy?.crossEncoderAlpha === "number" ? { alpha: rankingPolicy.crossEncoderAlpha } : {}
+  };
+}
 async function maybeRunEntryRecall(params) {
   if (!params.routing.queried.includes("entries")) {
     return {
@@ -6219,6 +7253,7 @@ function composeRecallTrace(upstream, onSummary) {
   };
 }
 function buildEntryRecallInput(input, parsedTimeWindow, routing) {
+  const entityAttributeQuery = routing.detectedIntent === "entity_attribute" ? detectEntityAttributeQuery(input.text) : void 0;
   const request = {
     text: input.text,
     ...input.limit !== void 0 ? { limit: input.limit } : {},
@@ -6227,7 +7262,9 @@ function buildEntryRecallInput(input, parsedTimeWindow, routing) {
     ...input.tags && input.tags.length > 0 ? { tags: input.tags } : {},
     ...input.sessionKey ? { sessionKey: input.sessionKey } : {},
     ...input.asOf ? { asOf: input.asOf } : {},
-    ...routing.detectedIntent === "historical_state" ? { rankingProfile: "historical_state" } : {}
+    ...routing.detectedIntent === "historical_state" ? { rankingProfile: "historical_state" } : {},
+    ...routing.detectedIntent === "entity_attribute" ? { rankingProfile: "entity_attribute" } : {},
+    ...entityAttributeQuery ? { queryShape: entityAttributeQuery } : {}
   };
   if (!parsedTimeWindow || input.asOf) {
     return request;
@@ -6262,6 +7299,90 @@ function detectProceduralPattern(text) {
   const regexPattern = PROCEDURAL_REGEX_PATTERNS.find((pattern) => pattern.test(lower));
   return regexPattern?.source;
 }
+function detectEntityAttributeQuery(text) {
+  const normalizedText = normalizeEntityAttributeWhitespace(text);
+  const whereDoesLive = /^where\s+does\s+(.+?)\s+live[?!.,]*$/iu.exec(normalizedText);
+  if (whereDoesLive) {
+    return buildEntityAttributeQueryShape(whereDoesLive[1], "location");
+  }
+  const whereIs = /^where\s+is\s+(.+?)[?!.,]*$/iu.exec(normalizedText);
+  if (whereIs) {
+    return buildEntityAttributeQueryShape(whereIs[1], "location");
+  }
+  const possessiveAttribute = /^(?:what\s+is|what's)\s+(.+?)'s\s+(.+?)[?!.,]*$/iu.exec(normalizedText);
+  if (possessiveAttribute) {
+    const attributeKind = resolveEntityAttributeKind(possessiveAttribute[2]);
+    if (attributeKind) {
+      return buildEntityAttributeQueryShape(possessiveAttribute[1], attributeKind);
+    }
+  }
+  const whoIs = /^(?:who\s+is|who's)\s+(.+?)(?:\s+again)?[?!.,]*$/iu.exec(normalizedText);
+  if (whoIs) {
+    return buildEntityAttributeQueryShape(whoIs[1], "identity");
+  }
+  const whatIs = /^what\s+is\s+(.+?)(?:\s+again)?[?!.,]*$/iu.exec(normalizedText);
+  if (whatIs) {
+    return buildEntityAttributeQueryShape(whatIs[1], "identity");
+  }
+  return void 0;
+}
+function buildEntityAttributeQueryShape(rawEntityText, attributeKind) {
+  const entityText = normalizeEntityAttributeEntity(rawEntityText);
+  if (!entityText) {
+    return void 0;
+  }
+  const entityTokens = tokenize(entityText);
+  if (entityTokens.length === 0) {
+    return void 0;
+  }
+  return {
+    kind: "entity_attribute",
+    entityText,
+    normalizedEntity: normalizeEntityAttributeText(entityText),
+    entityTokens,
+    attributeKind,
+    attributeTokens: [...ENTITY_ATTRIBUTE_KIND_TOKENS[attributeKind]]
+  };
+}
+function resolveEntityAttributeKind(rawAttributeText) {
+  const tokens = tokenize(rawAttributeText ?? "");
+  if (tokens.some((token) => token === "email" || token === "e-mail" || token === "mail")) {
+    return "email";
+  }
+  if (tokens.some((token) => token === "phone" || token === "number" || token === "mobile" || token === "cell" || token === "telephone")) {
+    return "phone";
+  }
+  if (tokens.some((token) => token === "address" || token === "street" || token === "mailing")) {
+    return "address";
+  }
+  if (tokens.some(
+    (token) => token === "location" || token === "live" || token === "lives" || token === "reside" || token === "resides" || token === "located" || token === "home" || token === "city"
+  )) {
+    return "location";
+  }
+  if (tokens.some((token) => ENTITY_ATTRIBUTE_KIND_TOKENS.identity.includes(token))) {
+    return "identity";
+  }
+  return void 0;
+}
+function normalizeEntityAttributeEntity(rawEntityText) {
+  const cleaned = rawEntityText ? normalizeEntityAttributeWhitespace(rawEntityText).replace(/^[("'`]+/u, "").replace(/[)"'`?!.,]+$/u, "").replace(/^(?:the|a|an)\s+/iu, "").trim() : "";
+  if (cleaned.length === 0) {
+    return void 0;
+  }
+  const normalized = normalizeEntityAttributeText(cleaned);
+  const wordCount = cleaned.split(/\s+/u).filter((token) => token.length > 0).length;
+  if (wordCount === 0 || wordCount > ENTITY_ATTRIBUTE_MAX_WORDS || ENTITY_ATTRIBUTE_GENERIC_ENTITY_RE.test(normalized) || ENTITY_ATTRIBUTE_CONTEXTUAL_PREFIX_RE.test(normalized) || ENTITY_ATTRIBUTE_CONTEXTUAL_TIME_RE.test(normalized) || ENTITY_ATTRIBUTE_CONTEXTUAL_ACTIVITY_RE.test(normalized)) {
+    return void 0;
+  }
+  return cleaned;
+}
+function normalizeEntityAttributeWhitespace(text) {
+  return text.replace(/\s+/gu, " ").trim();
+}
+function normalizeEntityAttributeText(text) {
+  return normalizeEntityAttributeWhitespace(text).normalize("NFKC").toLocaleLowerCase();
+}
 function normalizeMode(value) {
   return value === "entries" || value === "episodes" || value === "procedures" ? value : "auto";
 }
@@ -6362,7 +7483,6 @@ export {
   DEFAULT_SURGEON_RETIREMENT_PROTECT_MIN_IMPORTANCE,
   DEFAULT_SURGEON_SKIP_RECENTLY_EVALUATED_DAYS,
   DEFAULT_CLAIM_EXTRACTION_CONCURRENCY,
-  isAgenrAuthMethod,
   authMethodToProvider,
   getAuthMethodDefinition,
   toAgenrConfigInput,
@@ -6378,7 +7498,16 @@ export {
   createEmbeddingClient,
   resolveEmbeddingApiKey,
   resolveEmbeddingModel,
+  probeLlmCredentials,
+  createLlmClient,
+  resolveModel,
+  resolveLlmCredentials,
+  resolveLlmApiKey,
+  createOpenAICrossEncoder,
+  resolveCrossEncoderApiKey,
   createRecallAdapter,
+  attachCrossEncoderPort,
   projectClaimCentricRecallEntry,
+  runProcedureRecall,
   runUnifiedRecall
 };