@agenr/skeln-plugin 3.3.0

package/dist/chunk-5LADPJ4C.js

@@ -0,0 +1,2436 @@
+// src/core/recall/cross-encoder.ts
+var DEFAULT_CROSS_ENCODER_TOP_K = 10;
+var DEFAULT_CROSS_ENCODER_ALPHA = 0.6;
+async function applyCrossEncoderRerank(options) {
+  const candidates = [...options.candidates];
+  const k = resolveTopK(options.topK, candidates.length);
+  const alpha = resolveAlpha(options.alpha);
+  const startedAt = Date.now();
+  const passthrough = (degradedReason) => ({
+    applied: false,
+    k,
+    alpha,
+    latencyMs: elapsedMs(startedAt),
+    ...degradedReason ? { degradedReason } : {},
+    candidates: candidates.map((candidate) => ({
+      candidate: candidate.candidate,
+      score: candidate.score
+    })),
+    rescoredIds: []
+  });
+  if (options.disabled === true) {
+    return passthrough("disabled");
+  }
+  if (!options.port) {
+    return passthrough("not_configured");
+  }
+  if (candidates.length === 0) {
+    return passthrough("no_candidates");
+  }
+  const shortlist = candidates.slice(0, k);
+  const tail = candidates.slice(k);
+  const query = options.query.trim();
+  if (query.length === 0 || shortlist.length === 0) {
+    return passthrough("no_candidates");
+  }
+  let scores;
+  try {
+    scores = await options.port.rank(
+      query,
+      shortlist.map((candidate) => ({ id: candidate.id, text: candidate.text }))
+    );
+  } catch {
+    return passthrough("provider_error");
+  }
+  if (!Array.isArray(scores)) {
+    return passthrough("provider_error");
+  }
+  const scoreById = /* @__PURE__ */ new Map();
+  for (const entry of scores) {
+    if (!entry || typeof entry.id !== "string" || typeof entry.score !== "number" || !Number.isFinite(entry.score)) {
+      continue;
+    }
+    scoreById.set(entry.id, clampUnit(entry.score));
+  }
+  if (scoreById.size === 0) {
+    return passthrough("provider_error");
+  }
+  const rescoredIds = [];
+  const rescoredShortlist = shortlist.map((candidate) => {
+    const crossEncoderScore = scoreById.get(candidate.id);
+    if (crossEncoderScore === void 0) {
+      return {
+        candidate: candidate.candidate,
+        score: candidate.score,
+        id: candidate.id,
+        rescored: false
+      };
+    }
+    const nextScore = clampUnit(alpha * crossEncoderScore + (1 - alpha) * candidate.score);
+    if (nextScore !== candidate.score) {
+      rescoredIds.push(candidate.id);
+    }
+    return {
+      candidate: candidate.candidate,
+      score: nextScore,
+      crossEncoderScore,
+      id: candidate.id,
+      rescored: true
+    };
+  });
+  const reorderedShortlist = [...rescoredShortlist].sort((left, right) => {
+    if (left.score !== right.score) {
+      return right.score - left.score;
+    }
+    return shortlist.findIndex((candidate) => candidate.id === left.id) - shortlist.findIndex((candidate) => candidate.id === right.id);
+  });
+  const shortlistOutput = reorderedShortlist.map(({ candidate, score, crossEncoderScore }) => ({
+    candidate,
+    score,
+    ...typeof crossEncoderScore === "number" ? { crossEncoderScore } : {}
+  }));
+  const tailOutput = tail.map((candidate) => ({
+    candidate: candidate.candidate,
+    score: candidate.score
+  }));
+  return {
+    applied: true,
+    k,
+    alpha,
+    latencyMs: elapsedMs(startedAt),
+    candidates: [...shortlistOutput, ...tailOutput],
+    rescoredIds
+  };
+}
+function resolveTopK(value, total) {
+  if (total <= 0) {
+    return 0;
+  }
+  const raw = typeof value === "number" && Number.isFinite(value) && value > 0 ? Math.floor(value) : DEFAULT_CROSS_ENCODER_TOP_K;
+  return Math.max(1, Math.min(total, raw));
+}
+function resolveAlpha(value) {
+  if (typeof value !== "number" || !Number.isFinite(value)) {
+    return DEFAULT_CROSS_ENCODER_ALPHA;
+  }
+  return clampUnit(value);
+}
+function clampUnit(value) {
+  if (!Number.isFinite(value) || value <= 0) {
+    return 0;
+  }
+  return value >= 1 ? 1 : value;
+}
+function elapsedMs(startedAt) {
+  return Math.max(0, Date.now() - startedAt);
+}
+
+// src/core/recall/fusion.ts
+var DEFAULT_RRF_RANK_CONSTANT = 60;
+var DEFAULT_RRF_SMALL_POOL_RANK_CONSTANT = 8;
+var SMALL_POOL_RRF_POOL_SIZE = 4;
+function rrfFuse(channels, rankConstant = DEFAULT_RRF_RANK_CONSTANT) {
+  const k = sanitizeRankConstant(rankConstant);
+  const nonEmptyChannels = channels.filter((channel) => channel.length > 0);
+  const scores = /* @__PURE__ */ new Map();
+  if (nonEmptyChannels.length === 0) {
+    return scores;
+  }
+  for (const channel of nonEmptyChannels) {
+    const seenInChannel = /* @__PURE__ */ new Set();
+    let compactedRank = 0;
+    for (const id of channel) {
+      if (id === void 0 || seenInChannel.has(id)) {
+        continue;
+      }
+      seenInChannel.add(id);
+      const contribution = 1 / (compactedRank + k);
+      scores.set(id, (scores.get(id) ?? 0) + contribution);
+      compactedRank += 1;
+    }
+  }
+  const normalizationDenominator = nonEmptyChannels.length * (1 / k);
+  for (const [id, score] of scores) {
+    scores.set(id, clampUnit2(score / normalizationDenominator));
+  }
+  return scores;
+}
+function rrfFuseVectorLexical(vectorRanks, lexicalRanks, rankConstant = DEFAULT_RRF_RANK_CONSTANT) {
+  return rrfFuse([vectorRanks, lexicalRanks], rankConstant);
+}
+function sanitizeRankConstant(value) {
+  if (!Number.isFinite(value) || value <= 0) {
+    return DEFAULT_RRF_RANK_CONSTANT;
+  }
+  return value;
+}
+function clampUnit2(value) {
+  if (!Number.isFinite(value) || value <= 0) {
+    return 0;
+  }
+  return value >= 1 ? 1 : value;
+}
+
+// src/core/recall/lexical.ts
+var STOP_WORDS = /* @__PURE__ */ new Set([
+  "the",
+  "a",
+  "an",
+  "is",
+  "are",
+  "was",
+  "were",
+  "be",
+  "been",
+  "being",
+  "have",
+  "has",
+  "had",
+  "do",
+  "does",
+  "did",
+  "will",
+  "would",
+  "could",
+  "should",
+  "may",
+  "might",
+  "shall",
+  "can",
+  "need",
+  "must",
+  "i",
+  "me",
+  "my",
+  "we",
+  "our",
+  "you",
+  "your",
+  "he",
+  "him",
+  "his",
+  "she",
+  "her",
+  "it",
+  "its",
+  "they",
+  "them",
+  "their",
+  "this",
+  "that",
+  "these",
+  "those",
+  "what",
+  "which",
+  "who",
+  "whom",
+  "in",
+  "on",
+  "at",
+  "to",
+  "for",
+  "of",
+  "with",
+  "by",
+  "from",
+  "up",
+  "about",
+  "into",
+  "through",
+  "during",
+  "before",
+  "after",
+  "above",
+  "below",
+  "and",
+  "or",
+  "but",
+  "not",
+  "no",
+  "nor",
+  "so",
+  "if",
+  "then",
+  "else",
+  "when",
+  "where",
+  "how",
+  "all",
+  "each",
+  "every",
+  "both",
+  "few",
+  "more",
+  "some",
+  "any",
+  "other",
+  "than"
+]);
+var FTS_OPERATOR_TOKENS = /* @__PURE__ */ new Set(["or", "not", "near"]);
+var LEXICAL_TOKEN_PATTERN = /[\p{L}\p{N}][\p{L}\p{N}._-]*/gu;
+function tokenize(text) {
+  const matches = normalizeLexicalText(text).match(LEXICAL_TOKEN_PATTERN) ?? [];
+  return matches.filter((token) => token.length >= 2 && !STOP_WORDS.has(token));
+}
+function buildLexicalPlan(text) {
+  const trimmed = text.trim();
+  if (trimmed.length === 0) {
+    return [];
+  }
+  const tokens = tokenize(trimmed).filter((token) => !FTS_OPERATOR_TOKENS.has(token));
+  if (tokens.length === 0) {
+    return [
+      {
+        tier: "exact",
+        text: trimmed
+      }
+    ];
+  }
+  if (tokens.length === 1) {
+    return [
+      {
+        tier: "exact",
+        text: trimmed
+      },
+      {
+        tier: "all_tokens",
+        tokens
+      }
+    ];
+  }
+  return [
+    {
+      tier: "exact",
+      text: trimmed
+    },
+    {
+      tier: "all_tokens",
+      tokens
+    },
+    {
+      tier: "any_tokens",
+      tokens
+    }
+  ];
+}
+function computeLexicalScore(query, subject, content) {
+  const queryTokens = tokenize(query);
+  const subjectTokens = tokenize(subject);
+  const contentTokens = tokenize(content);
+  const subjectTokenSet = new Set(subjectTokens);
+  const contentTokenSet = new Set(contentTokens);
+  const tokenOverlap = queryTokens.length === 0 ? 0 : queryTokens.filter((token) => subjectTokenSet.has(token) || contentTokenSet.has(token)).length / queryTokens.length;
+  const phraseMatches = countPhraseMatches(queryTokens, subjectTokens, contentTokens);
+  const phraseBonus = Math.min(0.4, phraseMatches * 0.2);
+  const subjectBonus = normalizeText(query) === normalizeText(subject) && normalizeText(query).length > 0 ? 0.3 : 0;
+  return Math.min(1, tokenOverlap + phraseBonus + subjectBonus);
+}
+var normalizeText = (text) => normalizeLexicalText(text).trim();
+var normalizeLexicalText = (text) => text.normalize("NFKC").toLocaleLowerCase();
+var countPhraseMatches = (queryTokens, subjectTokens, contentTokens) => {
+  if (queryTokens.length < 2) {
+    return 0;
+  }
+  const matchedPhrases = /* @__PURE__ */ new Set();
+  for (let size = 2; size <= queryTokens.length; size += 1) {
+    for (let index = 0; index + size <= queryTokens.length; index += 1) {
+      const phraseTokens = queryTokens.slice(index, index + size);
+      if (hasConsecutivePhrase(subjectTokens, phraseTokens) || hasConsecutivePhrase(contentTokens, phraseTokens)) {
+        matchedPhrases.add(phraseTokens.join(" "));
+      }
+    }
+  }
+  return matchedPhrases.size;
+};
+var hasConsecutivePhrase = (haystack, needle) => {
+  if (needle.length === 0 || haystack.length < needle.length) {
+    return false;
+  }
+  for (let index = 0; index + needle.length <= haystack.length; index += 1) {
+    let matches = true;
+    for (let offset = 0; offset < needle.length; offset += 1) {
+      if (haystack[index + offset] !== needle[offset]) {
+        matches = false;
+        break;
+      }
+    }
+    if (matches) {
+      return true;
+    }
+  }
+  return false;
+};
+
+// src/core/recall/scoring.ts
+var DAY_IN_MILLISECONDS = 1e3 * 60 * 60 * 24;
+var IMPORTANCE_FLOOR = 0.4;
+var RELEVANCE_WEIGHT = 0.5;
+var RECENCY_WEIGHT = 0.25;
+var IMPORTANCE_WEIGHT = 0.25;
+function recencyScore(createdAt, expiry, now = /* @__PURE__ */ new Date()) {
+  if (expiry === "core") {
+    return 1;
+  }
+  const createdDate = asValidDate(createdAt);
+  const nowDate = asValidDate(now);
+  if (!createdDate || !nowDate) {
+    return 0;
+  }
+  const halfLifeDays = expiry === "permanent" ? 365 : 30;
+  const daysOld = Math.max(0, (nowDate.getTime() - createdDate.getTime()) / DAY_IN_MILLISECONDS);
+  return clampUnit3(Math.pow(0.5, daysOld / halfLifeDays));
+}
+function gaussianRecency(createdAt, aroundDate, radiusDays) {
+  const createdDate = asValidDate(createdAt);
+  const anchorDate = asValidDate(aroundDate);
+  const normalizedRadius = sanitizeNonNegative(radiusDays);
+  if (!createdDate || !anchorDate) {
+    return 0;
+  }
+  if (normalizedRadius <= 0) {
+    return createdDate.getTime() === anchorDate.getTime() ? 1 : 0;
+  }
+  const daysDelta = Math.abs(createdDate.getTime() - anchorDate.getTime()) / DAY_IN_MILLISECONDS;
+  return clampUnit3(Math.exp(-0.5 * (daysDelta / normalizedRadius) ** 2));
+}
+function importanceScore(importance) {
+  const clampedImportance = clampRange(sanitizeNonNegative(importance), 1, 10);
+  return clampUnit3(IMPORTANCE_FLOOR + (clampedImportance - 1) / 9 * (1 - IMPORTANCE_FLOOR));
+}
+function scoreCandidate(params) {
+  const vector = clampUnit3(sanitizeNonNegative(params.vectorSim));
+  const lexical = clampUnit3(sanitizeNonNegative(params.lexical));
+  const recency = clampUnit3(sanitizeNonNegative(params.recency));
+  const importance = clampUnit3(sanitizeNonNegative(params.importance));
+  const relevance = clampUnit3(sanitizeNonNegative(params.relevance));
+  const score = clampUnit3(relevance * RELEVANCE_WEIGHT + recency * RECENCY_WEIGHT + importance * IMPORTANCE_WEIGHT);
+  return {
+    score,
+    scores: {
+      relevance,
+      vector,
+      lexical,
+      recency,
+      importance
+    }
+  };
+}
+function cosineSimilarity(left, right) {
+  const size = Math.min(left.length, right.length);
+  if (size === 0) {
+    return 0;
+  }
+  let dot = 0;
+  let leftNorm = 0;
+  let rightNorm = 0;
+  for (let index = 0; index < size; index += 1) {
+    const leftValue = sanitizeFinite(left[index]);
+    const rightValue = sanitizeFinite(right[index]);
+    dot += leftValue * rightValue;
+    leftNorm += leftValue * leftValue;
+    rightNorm += rightValue * rightValue;
+  }
+  if (leftNorm <= 0 || rightNorm <= 0) {
+    return 0;
+  }
+  return clampUnit3(dot / (Math.sqrt(leftNorm) * Math.sqrt(rightNorm)));
+}
+var asValidDate = (value) => {
+  const date = value instanceof Date ? new Date(value.getTime()) : new Date(value);
+  return Number.isNaN(date.getTime()) ? null : date;
+};
+var clampUnit3 = (value) => clampRange(sanitizeNonNegative(value), 0, 1);
+var clampRange = (value, min, max) => Math.min(max, Math.max(min, value));
+var sanitizeFinite = (value) => typeof value === "number" && Number.isFinite(value) ? value : 0;
+var sanitizeNonNegative = (value) => Math.max(0, sanitizeFinite(value));
+
+// src/core/recall/mmr.ts
+var DEFAULT_MMR_LAMBDA = 0.7;
+var DEFAULT_MMR_MIN_POOL_SIZE = 4;
+var NEAR_DUPLICATE_SIMILARITY = 0.95;
+function maximalMarginalRelevance(options) {
+  const lambda = clampUnit4(sanitizeNumber(options.lambda, DEFAULT_MMR_LAMBDA));
+  const inputIds = options.candidates.map((candidate) => candidate.id);
+  const limit = resolveLimit(options.limit, inputIds.length);
+  const minPoolSize = resolveMinPoolSize(options.minPoolSize);
+  const embeddedCandidates = options.candidates.filter((candidate) => hasUsableEmbedding(candidate.embedding));
+  const unembeddedIds = options.candidates.filter((candidate) => !hasUsableEmbedding(candidate.embedding)).map((candidate) => candidate.id);
+  const poolBelowGate = minPoolSize > 0 && options.candidates.length <= minPoolSize;
+  const canApplyMmr = !poolBelowGate && options.queryVector.length > 0 && embeddedCandidates.length >= 2;
+  if (!canApplyMmr) {
+    return {
+      applied: false,
+      lambda,
+      orderedIds: sliceOrDefault(inputIds, limit),
+      droppedDuplicateCount: 0,
+      reorderedIds: []
+    };
+  }
+  const relevanceById = /* @__PURE__ */ new Map();
+  for (const candidate of embeddedCandidates) {
+    const overriddenRelevance = sanitizeUnit(candidate.relevance);
+    const derivedRelevance = overriddenRelevance ?? cosineSimilarity(options.queryVector, candidate.embedding ?? []);
+    relevanceById.set(candidate.id, derivedRelevance);
+  }
+  const pairwiseMaxById = computePairwiseMaxSimilarity(embeddedCandidates);
+  const mmrScoreById = /* @__PURE__ */ new Map();
+  for (const candidate of embeddedCandidates) {
+    const relevance = relevanceById.get(candidate.id) ?? 0;
+    const maxPairwise = pairwiseMaxById.get(candidate.id) ?? 0;
+    mmrScoreById.set(candidate.id, lambda * relevance - (1 - lambda) * maxPairwise);
+  }
+  const rankedEmbeddedIds = [...embeddedCandidates].sort((left, right) => {
+    const leftScore = mmrScoreById.get(left.id) ?? 0;
+    const rightScore = mmrScoreById.get(right.id) ?? 0;
+    if (leftScore !== rightScore) {
+      return rightScore - leftScore;
+    }
+    return inputIds.indexOf(left.id) - inputIds.indexOf(right.id);
+  }).map((candidate) => candidate.id);
+  const orderedIds = sliceOrDefault([...rankedEmbeddedIds, ...unembeddedIds], limit);
+  const reorderedIds = inputIds.filter((id, index) => orderedIds[index] !== id);
+  const droppedDuplicateCount = countDroppedDuplicates(rankedEmbeddedIds, inputIds, pairwiseMaxById);
+  return {
+    applied: true,
+    lambda,
+    orderedIds,
+    droppedDuplicateCount,
+    reorderedIds
+  };
+}
+function computePairwiseMaxSimilarity(embeddedCandidates) {
+  const result = /* @__PURE__ */ new Map();
+  for (const candidate of embeddedCandidates) {
+    result.set(candidate.id, 0);
+  }
+  for (let outer = 0; outer < embeddedCandidates.length; outer += 1) {
+    for (let inner = outer + 1; inner < embeddedCandidates.length; inner += 1) {
+      const left = embeddedCandidates[outer];
+      const right = embeddedCandidates[inner];
+      const similarity = cosineSimilarity(left.embedding ?? [], right.embedding ?? []);
+      if (similarity > (result.get(left.id) ?? 0)) {
+        result.set(left.id, similarity);
+      }
+      if (similarity > (result.get(right.id) ?? 0)) {
+        result.set(right.id, similarity);
+      }
+    }
+  }
+  return result;
+}
+function countDroppedDuplicates(rankedEmbeddedIds, inputIds, pairwiseMaxById) {
+  const inputRankById = /* @__PURE__ */ new Map();
+  inputIds.forEach((id, index) => inputRankById.set(id, index));
+  let droppedDuplicates = 0;
+  rankedEmbeddedIds.forEach((id, mmrRank) => {
+    const inputRank = inputRankById.get(id);
+    if (inputRank === void 0 || mmrRank <= inputRank) {
+      return;
+    }
+    const maxSimilarity = pairwiseMaxById.get(id) ?? 0;
+    if (maxSimilarity >= NEAR_DUPLICATE_SIMILARITY) {
+      droppedDuplicates += 1;
+    }
+  });
+  return droppedDuplicates;
+}
+function sliceOrDefault(ids, limit) {
+  if (limit === null || limit >= ids.length) {
+    return [...ids];
+  }
+  return ids.slice(0, limit);
+}
+function resolveLimit(value, totalCandidates) {
+  if (value === void 0 || !Number.isFinite(value) || value <= 0) {
+    return null;
+  }
+  return Math.min(totalCandidates, Math.floor(value));
+}
+function hasUsableEmbedding(embedding) {
+  return Array.isArray(embedding) && embedding.length > 0;
+}
+function clampUnit4(value) {
+  if (!Number.isFinite(value) || value <= 0) {
+    return 0;
+  }
+  return value >= 1 ? 1 : value;
+}
+function resolveMinPoolSize(value) {
+  if (typeof value !== "number" || !Number.isFinite(value)) {
+    return DEFAULT_MMR_MIN_POOL_SIZE;
+  }
+  if (value < 0) {
+    return DEFAULT_MMR_MIN_POOL_SIZE;
+  }
+  return Math.floor(value);
+}
+function sanitizeNumber(value, fallback) {
+  if (typeof value !== "number" || !Number.isFinite(value)) {
+    return fallback;
+  }
+  return value;
+}
+function sanitizeUnit(value) {
+  if (typeof value !== "number" || !Number.isFinite(value)) {
+    return null;
+  }
+  return clampUnit4(value);
+}
+
+// src/core/recall/neighborhood.ts
+var DEFAULT_NEIGHBORHOOD_BUDGET = 24;
+var DEFAULT_STRONG_SEED_TOP_N = 3;
+var DEFAULT_STRONG_SEED_SCORE_GAP = 0.05;
+var DEFAULT_SEEDED_RERANK_WEIGHT = 0.03;
+function selectStrongSeeds(candidates, options = {}) {
+  if (candidates.length === 0) {
+    return [];
+  }
+  const topN = Math.max(1, sanitizeInteger(options.topN, DEFAULT_STRONG_SEED_TOP_N));
+  const floor = sanitizeUnit2(options.scoreGapFloor ?? DEFAULT_STRONG_SEED_SCORE_GAP);
+  const ordered = [...candidates].sort((left, right) => right.score - left.score);
+  const leader = ordered[0];
+  if (!leader || leader.score <= 0) {
+    return [];
+  }
+  const followerScore = ordered[topN]?.score ?? 0;
+  if (leader.score - followerScore < floor) {
+    return [];
+  }
+  const cutoff = Math.max(leader.score - floor, followerScore);
+  return ordered.slice(0, topN).filter((candidate) => candidate.score >= cutoff);
+}
+function seededRerank(candidates, seeds, sharesLineage, options = {}) {
+  const boostedIds = [];
+  if (candidates.length === 0 || seeds.length === 0) {
+    return { candidates: [...candidates], boostedIds };
+  }
+  const weight = sanitizeUnit2(options.weight ?? DEFAULT_SEEDED_RERANK_WEIGHT);
+  if (weight <= 0) {
+    return { candidates: [...candidates], boostedIds };
+  }
+  const seedIds = new Set(seeds.map((seed) => seed.id));
+  const reranked = candidates.map((candidate) => {
+    if (seedIds.has(candidate.id)) {
+      return candidate;
+    }
+    const match = seeds.find((seed) => seed.id !== candidate.id && sharesLineage(candidate, seed));
+    if (!match) {
+      return candidate;
+    }
+    boostedIds.push(candidate.id);
+    return {
+      ...candidate,
+      score: clampUnit5(candidate.score + weight)
+    };
+  });
+  return { candidates: reranked, boostedIds };
+}
+function sharesEntryLineage(candidate, seed) {
+  if (candidate.id === seed.id) {
+    return false;
+  }
+  if (candidate.claim_key && seed.claim_key && candidate.claim_key === seed.claim_key) {
+    return true;
+  }
+  if (candidate.superseded_by === seed.id || seed.superseded_by === candidate.id) {
+    return true;
+  }
+  return sharesTopicPrefix(candidate.subject, seed.subject);
+}
+function sharesEpisodeLineage(candidate, seed) {
+  if (candidate.id === seed.id) {
+    return false;
+  }
+  if (candidate.source === seed.source && candidate.sourceId !== void 0 && candidate.sourceId === seed.sourceId) {
+    return true;
+  }
+  if (candidate.transcriptHash && seed.transcriptHash && candidate.transcriptHash === seed.transcriptHash) {
+    return true;
+  }
+  return false;
+}
+function sharesProcedureLineage(candidate, seed) {
+  if (candidate.id === seed.id) {
+    return false;
+  }
+  return candidate.procedure_key === seed.procedure_key;
+}
+var TOPIC_PREFIX_SHARED_MIN = 2;
+var TOPIC_PREFIX_COVERAGE_MIN = 0.6;
+function sharesTopicPrefix(leftSubject, rightSubject) {
+  const leftTokens = tokenize(leftSubject);
+  const rightTokens = tokenize(rightSubject);
+  if (leftTokens.length === 0 || rightTokens.length === 0) {
+    return false;
+  }
+  const length = Math.min(leftTokens.length, rightTokens.length);
+  let shared = 0;
+  for (let index = 0; index < length; index += 1) {
+    if (leftTokens[index] !== rightTokens[index]) {
+      break;
+    }
+    shared += 1;
+  }
+  if (shared < TOPIC_PREFIX_SHARED_MIN) {
+    return false;
+  }
+  return shared / length >= TOPIC_PREFIX_COVERAGE_MIN;
+}
+function clampUnit5(value) {
+  if (!Number.isFinite(value) || value <= 0) {
+    return 0;
+  }
+  return value >= 1 ? 1 : value;
+}
+function sanitizeUnit2(value) {
+  if (typeof value !== "number" || !Number.isFinite(value) || value < 0) {
+    return 0;
+  }
+  return Math.min(1, value);
+}
+function sanitizeInteger(value, fallback) {
+  if (typeof value !== "number" || !Number.isFinite(value) || value < 1) {
+    return fallback;
+  }
+  return Math.floor(value);
+}
+
+// src/core/claim-key.ts
+var UNKNOWN_SEGMENT = "unknown";
+var SELF_REFERENTIAL_ENTITIES = /* @__PURE__ */ new Set(["i", "me", "myself", "the_user", "user", "we", "our_team", "the_project", "this_project"]);
+var GENERIC_ENTITIES = /* @__PURE__ */ new Set([
+  "app",
+  "company",
+  "config",
+  "data",
+  "device",
+  "entity",
+  "environment",
+  "item",
+  "organization",
+  "person",
+  "place",
+  "project",
+  "service",
+  "setting",
+  "system",
+  "team",
+  "thing",
+  "user",
+  "workspace"
+]);
+var GENERIC_ATTRIBUTES = /* @__PURE__ */ new Set(["info", "details", "config", "stuff", "thing", "data"]);
+var COMPACTION_RELATION_TOKENS = /* @__PURE__ */ new Set([
+  "after",
+  "before",
+  "depend",
+  "depends",
+  "follows",
+  "follow",
+  "keep",
+  "keeps",
+  "maintain",
+  "maintains",
+  "need",
+  "needs",
+  "precede",
+  "precedes",
+  "preserve",
+  "preserves",
+  "require",
+  "required",
+  "requires",
+  "retain",
+  "retains"
+]);
+var COMPACTION_BREAK_TOKENS = /* @__PURE__ */ new Set(["about", "across", "and", "between", "during", "for", "from", "into", "onto", "or", "to", "with"]);
+var COMPACTION_WEAK_LEADING_TOKENS = /* @__PURE__ */ new Set(["actual", "authoritative", "canonical", "concrete", "current", "durable", "existing", "real"]);
+var ACTION_CONDITION_TOKENS = /* @__PURE__ */ new Set(["activate", "activation", "apply", "fire", "launch", "run", "start", "trigger"]);
+var TRAILING_OBJECT_COMPACTION_PREPOSITIONS = /* @__PURE__ */ new Set(["about", "for", "from", "into", "onto", "to", "with"]);
+var TRAILING_OBJECT_TRANSFER_HEADS = /* @__PURE__ */ new Set([
+  "access",
+  "boundary",
+  "condition",
+  "contract",
+  "guide",
+  "path",
+  "policy",
+  "preference",
+  "process",
+  "rule",
+  "schedule",
+  "support",
+  "surface",
+  "window",
+  "workflow"
+]);
+var STABLE_ATTRIBUTE_HEADS = /* @__PURE__ */ new Set([
+  "access",
+  "boundary",
+  "condition",
+  "contract",
+  "default",
+  "dependency",
+  "guide",
+  "mode",
+  "order",
+  "path",
+  "policy",
+  "preference",
+  "preservation",
+  "process",
+  "requirement",
+  "rule",
+  "schedule",
+  "setting",
+  "status",
+  "strategy",
+  "support",
+  "surface",
+  "timezone",
+  "truth",
+  "version",
+  "window",
+  "workflow"
+]);
+function normalizeClaimKeySegment(value) {
+  return value.trim().toLowerCase().replace(/[^a-z0-9]+/g, "_").replace(/_+/g, "_").replace(/^_+|_+$/g, "");
+}
+function normalizeClaimKey(value) {
+  const trimmed = value.trim();
+  if (trimmed.length === 0) {
+    return { ok: false, reason: "empty" };
+  }
+  const slashCount = Array.from(trimmed).filter((character) => character === "/").length;
+  if (slashCount === 0) {
+    return { ok: false, reason: "missing_separator" };
+  }
+  if (slashCount !== 1) {
+    return { ok: false, reason: "too_many_segments" };
+  }
+  const [rawEntity = "", rawAttribute = ""] = trimmed.split("/");
+  const entity = normalizeClaimKeySegment(rawEntity);
+  if (entity.length === 0) {
+    return { ok: false, reason: "empty_entity" };
+  }
+  const attribute = normalizeClaimKeySegment(rawAttribute);
+  if (attribute.length === 0) {
+    return { ok: false, reason: "empty_attribute" };
+  }
+  if (entity === UNKNOWN_SEGMENT && attribute === UNKNOWN_SEGMENT) {
+    return { ok: false, reason: "unknown_pair" };
+  }
+  return {
+    ok: true,
+    value: {
+      claimKey: `${entity}/${attribute}`,
+      entity,
+      attribute
+    }
+  };
+}
+function compactClaimKey(claimKey) {
+  const normalized = normalizeClaimKey(claimKey);
+  if (!normalized.ok) {
+    return null;
+  }
+  let attributeTokens = normalized.value.attribute.split("_").filter((token) => token.length > 0);
+  const entityTokens = normalized.value.entity.split("_").filter((token) => token.length > 0);
+  const reasons = [];
+  if (entityTokens.length > 0 && startsWithTokens(attributeTokens, entityTokens) && attributeTokens.length > entityTokens.length) {
+    attributeTokens = attributeTokens.slice(entityTokens.length);
+    reasons.push("removed duplicated entity prefix from attribute");
+  }
+  if (entityTokens.length > 0 && attributeTokens.length > entityTokens.length + 1 && endsWithTokens(attributeTokens, entityTokens) && TRAILING_OBJECT_COMPACTION_PREPOSITIONS.has(attributeTokens[attributeTokens.length - entityTokens.length - 1] ?? "")) {
+    attributeTokens = attributeTokens.slice(0, attributeTokens.length - entityTokens.length - 1);
+    reasons.push("removed duplicated entity suffix from attribute");
+  }
+  const sourceOfTruthCompaction = compactSourceOfTruthAttribute(attributeTokens);
+  if (sourceOfTruthCompaction) {
+    attributeTokens = sourceOfTruthCompaction.attributeTokens;
+    reasons.push(sourceOfTruthCompaction.reason);
+  } else {
+    const relationCompaction = compactRelationAttribute(attributeTokens);
+    if (relationCompaction) {
+      attributeTokens = relationCompaction.attributeTokens;
+      reasons.push(relationCompaction.reason);
+    } else {
+      const trailingObjectCompaction = compactTrailingObjectAttribute(attributeTokens);
+      if (trailingObjectCompaction) {
+        attributeTokens = trailingObjectCompaction.attributeTokens;
+        reasons.push(trailingObjectCompaction.reason);
+      }
+    }
+  }
+  const attribute = attributeTokens.join("_");
+  if (attribute.length === 0) {
+    return {
+      claimKey: normalized.value.claimKey,
+      entity: normalized.value.entity,
+      attribute: normalized.value.attribute,
+      compactedFrom: null,
+      reason: null
+    };
+  }
+  const compactedClaimKey = `${normalized.value.entity}/${attribute}`;
+  return {
+    claimKey: compactedClaimKey,
+    entity: normalized.value.entity,
+    attribute,
+    compactedFrom: compactedClaimKey !== normalized.value.claimKey ? normalized.value.claimKey : null,
+    reason: reasons.length > 0 ? joinCompactionReasons(reasons) : null
+  };
+}
+function validateExtractedClaimKey(claimKey) {
+  if (SELF_REFERENTIAL_ENTITIES.has(claimKey.entity)) {
+    return {
+      ok: false,
+      reason: "self_referential_entity",
+      value: claimKey
+    };
+  }
+  if (GENERIC_ATTRIBUTES.has(claimKey.attribute)) {
+    return {
+      ok: false,
+      reason: "generic_attribute",
+      value: claimKey
+    };
+  }
+  if (isValueShapedAttribute(claimKey.attribute)) {
+    return {
+      ok: false,
+      reason: "value_shaped_attribute",
+      value: claimKey
+    };
+  }
+  return {
+    ok: true,
+    value: claimKey
+  };
+}
+function inspectClaimKey(value) {
+  const rawClaimKey = value.trim();
+  const normalized = normalizeClaimKey(rawClaimKey);
+  if (!normalized.ok) {
+    return {
+      rawClaimKey,
+      canonical: false,
+      normalizationFailure: normalized.reason,
+      suspectReasons: []
+    };
+  }
+  const suspectReasons = /* @__PURE__ */ new Set();
+  const validation = validateExtractedClaimKey(normalized.value);
+  if (!validation.ok) {
+    suspectReasons.add(validation.reason);
+  }
+  if (GENERIC_ENTITIES.has(normalized.value.entity)) {
+    suspectReasons.add("generic_entity");
+  }
+  return {
+    rawClaimKey,
+    canonical: normalized.value.claimKey === rawClaimKey,
+    normalized: normalized.value,
+    suspectReasons: [...suspectReasons]
+  };
+}
+function isTrustedClaimKeyForCleanup(value) {
+  const inspection = inspectClaimKey(value);
+  return Boolean(inspection.canonical && inspection.normalized && inspection.suspectReasons.length === 0);
+}
+function describeClaimKeyNormalizationFailure(reason) {
+  switch (reason) {
+    case "empty":
+      return "claim key was empty";
+    case "missing_separator":
+      return "claim key must contain exactly one '/'";
+    case "too_many_segments":
+      return "claim key must contain exactly one '/'";
+    case "empty_entity":
+      return "claim key entity was empty after normalization";
+    case "empty_attribute":
+      return "claim key attribute was empty after normalization";
+    case "unknown_pair":
+      return 'claim key "unknown/unknown" is not allowed';
+  }
+}
+function describeExtractedClaimKeyRejection(reason, claimKey) {
+  switch (reason) {
+    case "self_referential_entity":
+      return `entity "${claimKey.entity}" is self-referential`;
+    case "generic_attribute":
+      return `attribute "${claimKey.attribute}" is too generic`;
+    case "value_shaped_attribute":
+      return `attribute "${claimKey.attribute}" looks value-shaped`;
+  }
+}
+function describeClaimKeySuspicion(reason, claimKey) {
+  switch (reason) {
+    case "generic_entity":
+      return `entity "${claimKey.entity}" is too generic`;
+    case "self_referential_entity":
+    case "generic_attribute":
+    case "value_shaped_attribute":
+      return describeExtractedClaimKeyRejection(reason, claimKey);
+  }
+}
+function isValueShapedAttribute(attribute) {
+  return /^\d+(?:_\d+)*$/u.test(attribute) || /^v\d+(?:_\d+)*$/u.test(attribute);
+}
+function compactSourceOfTruthAttribute(attributeTokens) {
+  const sourceOfTruthIndex = findSourceOfTruthPhraseIndex(attributeTokens);
+  if (sourceOfTruthIndex === -1) {
+    return null;
+  }
+  const normalizedPhrase = ["source", "of", "truth"];
+  if (attributeTokens.length === normalizedPhrase.length && startsWithTokens(attributeTokens, normalizedPhrase)) {
+    return null;
+  }
+  const before = attributeTokens.slice(0, sourceOfTruthIndex);
+  const after = attributeTokens.slice(sourceOfTruthIndex + normalizedPhrase.length);
+  const leadingAllowed = before.every((token) => COMPACTION_WEAK_LEADING_TOKENS.has(token));
+  const hasMixedStableFamily = before.some((token) => STABLE_ATTRIBUTE_HEADS.has(token)) || after.some((token) => STABLE_ATTRIBUTE_HEADS.has(token));
+  const hasConjunctionNoise = before.includes("and") || before.includes("or") || after.includes("and") || after.includes("or");
+  if (!leadingAllowed || hasMixedStableFamily || hasConjunctionNoise) {
+    return null;
+  }
+  return {
+    attributeTokens: normalizedPhrase,
+    reason: "collapsed source-of-truth phrasing into the stable canonical slot"
+  };
+}
+function compactRelationAttribute(attributeTokens) {
+  const relationIndex = attributeTokens.findIndex((token) => COMPACTION_RELATION_TOKENS.has(token));
+  if (relationIndex === -1) {
+    return null;
+  }
+  const relation = attributeTokens[relationIndex] ?? "";
+  const left = attributeTokens.slice(0, relationIndex);
+  const right = attributeTokens.slice(relationIndex + 1);
+  if (left.length === 0 && right.length === 0) {
+    return null;
+  }
+  if (isRequirementRelation(relation)) {
+    const conditionAction = extractConditionAction(right);
+    if (conditionAction) {
+      return {
+        attributeTokens: [conditionAction, "condition"],
+        reason: `collapsed a sentence-like ${conditionAction} requirement into a stable condition slot`
+      };
+    }
+    const requirementFocus = extractCompactionFocus(right, 2) ?? extractCompactionFocus(left, 2);
+    if (!requirementFocus) {
+      return null;
+    }
+    return {
+      attributeTokens: [...requirementFocus, "requirement"],
+      reason: "collapsed a sentence-like requirement phrase into a stable requirement slot"
+    };
+  }
+  if (isOrderingRelation(relation)) {
+    const orderingFocus = extractCompactionFocus(right, 2) ?? extractCompactionFocus(left, 2);
+    if (!orderingFocus) {
+      return null;
+    }
+    return {
+      attributeTokens: [...orderingFocus, "order"],
+      reason: "collapsed a sentence-like ordering phrase into a stable order slot"
+    };
+  }
+  if (isPreservationRelation(relation)) {
+    const preservationFocus = extractCompactionFocus(right, 2) ?? extractCompactionFocus(left, 2);
+    if (!preservationFocus) {
+      return null;
+    }
+    return {
+      attributeTokens: [...preservationFocus, "preservation"],
+      reason: "collapsed a sentence-like preservation phrase into a stable preservation slot"
+    };
+  }
+  return null;
+}
+function compactTrailingObjectAttribute(attributeTokens) {
+  const prepositionIndex = attributeTokens.findIndex((token) => TRAILING_OBJECT_COMPACTION_PREPOSITIONS.has(token));
+  if (prepositionIndex <= 0 || prepositionIndex >= attributeTokens.length - 1) {
+    return null;
+  }
+  const left = trimWeakLeadingTokens(attributeTokens.slice(0, prepositionIndex));
+  const right = attributeTokens.slice(prepositionIndex + 1);
+  if (left.length === 0 || left.length > 3 || left.includes("and") || left.includes("or") || left.some((token) => COMPACTION_RELATION_TOKENS.has(token))) {
+    return null;
+  }
+  const head = left[left.length - 1];
+  if (!head || !TRAILING_OBJECT_TRANSFER_HEADS.has(head)) {
+    return null;
+  }
+  const objectFocus = extractCompactionFocus(right, 2);
+  if (!objectFocus) {
+    return null;
+  }
+  const headCore = extractStableHeadCore(left, 2);
+  if (!headCore) {
+    return null;
+  }
+  return {
+    attributeTokens: [...objectFocus, ...headCore],
+    reason: "collapsed a trailing object phrase into a compact stable slot name"
+  };
+}
+function findSourceOfTruthPhraseIndex(tokens) {
+  for (let index = 0; index <= tokens.length - 3; index += 1) {
+    if (tokens[index] === "source" && tokens[index + 1] === "of" && tokens[index + 2] === "truth") {
+      return index;
+    }
+  }
+  return -1;
+}
+function extractConditionAction(tokens) {
+  for (let index = tokens.length - 1; index >= 0; index -= 1) {
+    const token = tokens[index];
+    if (token && ACTION_CONDITION_TOKENS.has(token)) {
+      return token;
+    }
+  }
+  return null;
+}
+function extractCompactionFocus(tokens, limit) {
+  const compactable = trimWeakLeadingTokens(tokens).filter((token) => token.length > 0);
+  const segments = splitTokensOnBreaks(compactable).filter((segment) => segment.length > 0);
+  const preferredSegment = segments[0];
+  if (!preferredSegment || preferredSegment.length === 0) {
+    return null;
+  }
+  return preferredSegment.slice(0, limit);
+}
+function extractStableHeadCore(tokens, limit) {
+  const compactable = trimWeakLeadingTokens(tokens).filter((token) => token.length > 0);
+  const head = compactable[compactable.length - 1];
+  if (!head || !STABLE_ATTRIBUTE_HEADS.has(head)) {
+    return null;
+  }
+  return compactable.slice(Math.max(0, compactable.length - limit));
+}
+function splitTokensOnBreaks(tokens) {
+  const segments = [];
+  let current = [];
+  for (const token of tokens) {
+    if (COMPACTION_BREAK_TOKENS.has(token)) {
+      if (current.length > 0) {
+        segments.push(current);
+        current = [];
+      }
+      continue;
+    }
+    current.push(token);
+  }
+  if (current.length > 0) {
+    segments.push(current);
+  }
+  return segments;
+}
+function trimWeakLeadingTokens(tokens) {
+  let start = 0;
+  while (start < tokens.length && COMPACTION_WEAK_LEADING_TOKENS.has(tokens[start] ?? "")) {
+    start += 1;
+  }
+  return tokens.slice(start);
+}
+function joinCompactionReasons(reasons) {
+  if (reasons.length <= 1) {
+    return reasons[0] ?? "";
+  }
+  return `${reasons.slice(0, -1).join(", ")} and ${reasons[reasons.length - 1]}`;
+}
+function isRequirementRelation(token) {
+  return token === "depend" || token === "depends" || token === "need" || token === "needs" || token === "required" || token === "require" || token === "requires";
+}
+function isOrderingRelation(token) {
+  return token === "after" || token === "before" || token === "follow" || token === "follows" || token === "precede" || token === "precedes";
+}
+function isPreservationRelation(token) {
+  return token === "keep" || token === "keeps" || token === "maintain" || token === "maintains" || token === "preserve" || token === "preserves" || token === "retain" || token === "retains";
+}
+function startsWithTokens(tokens, prefix) {
+  return prefix.every((token, index) => tokens[index] === token);
+}
+function endsWithTokens(tokens, suffix) {
+  return suffix.every((token, index) => tokens[tokens.length - suffix.length + index] === token);
+}
+
+// src/core/claim-slot-policy.ts
+var MULTIVALUED_ATTRIBUTE_HEADS = /* @__PURE__ */ new Set(["access", "dependency", "guide", "integration", "preference", "requirement", "support"]);
+function resolveClaimSlotPolicy(claimKey, config) {
+  const normalized = normalizeClaimKey(claimKey ?? "");
+  if (!normalized.ok) {
+    return {
+      policy: "exclusive",
+      reason: "No canonical claim key was available, so the slot policy defaulted to exclusive."
+    };
+  }
+  const { claimKey: canonicalClaimKey, entity, attribute } = normalized.value;
+  const attributeHead = attribute.split("_")[0] ?? attribute;
+  const configuredPolicy = resolveConfiguredAttributeHeadPolicy(attributeHead, config);
+  if (configuredPolicy) {
+    return {
+      claimKey: canonicalClaimKey,
+      entity,
+      attribute,
+      attributeHead,
+      policy: configuredPolicy,
+      reason: `Attribute head "${attributeHead}" is configured as ${configuredPolicy} by runtime policy.`
+    };
+  }
+  if (MULTIVALUED_ATTRIBUTE_HEADS.has(attributeHead)) {
+    return {
+      claimKey: canonicalClaimKey,
+      entity,
+      attribute,
+      attributeHead,
+      policy: "multivalued",
+      reason: `Attribute head "${attributeHead}" is registered as multivalued.`
+    };
+  }
+  return {
+    claimKey: canonicalClaimKey,
+    entity,
+    attribute,
+    attributeHead,
+    policy: "exclusive",
+    reason: `Attribute head "${attributeHead}" defaults to exclusive current-state shaping.`
+  };
+}
+function resolveConfiguredAttributeHeadPolicy(attributeHead, config) {
+  const configuredPolicy = config?.attributeHeads?.[attributeHead];
+  if (configuredPolicy) {
+    return configuredPolicy;
+  }
+  const loweredAttributeHead = attributeHead.toLowerCase();
+  if (loweredAttributeHead === attributeHead) {
+    return void 0;
+  }
+  return config?.attributeHeads?.[loweredAttributeHead];
+}
+
+// src/core/recall/temporal.ts
+var DAY_IN_MILLISECONDS2 = 1e3 * 60 * 60 * 24;
+var MONTH_INDEX = /* @__PURE__ */ new Map([
+  ["january", 0],
+  ["february", 1],
+  ["march", 2],
+  ["april", 3],
+  ["may", 4],
+  ["june", 5],
+  ["july", 6],
+  ["august", 7],
+  ["september", 8],
+  ["october", 9],
+  ["november", 10],
+  ["december", 11]
+]);
+function inferAroundDate(text, now = /* @__PURE__ */ new Date()) {
+  const normalized = text.trim().toLowerCase();
+  const referenceNow = asValidDate2(now);
+  if (normalized.length === 0 || !referenceNow) {
+    return null;
+  }
+  let inferred = null;
+  if (/\byesterday\b/.test(normalized)) {
+    inferred = offsetDays(referenceNow, 1);
+  } else if (/\blast week\b/.test(normalized)) {
+    inferred = offsetDays(referenceNow, 7);
+  } else if (/\blast month\b/.test(normalized)) {
+    inferred = offsetDays(referenceNow, 30);
+  } else if (/\blast year\b/.test(normalized)) {
+    inferred = offsetDays(referenceNow, 365);
+  } else if (/\bthis week\b/.test(normalized)) {
+    inferred = offsetDays(referenceNow, 3);
+  } else if (/\bthis month\b/.test(normalized)) {
+    inferred = offsetDays(referenceNow, 15);
+  } else {
+    const relativeMatch = normalized.match(/\b(\d+)\s+(day|days|week|weeks|month|months)\s+ago\b/);
+    if (relativeMatch) {
+      const amount = Number(relativeMatch[1]);
+      const unit = relativeMatch[2];
+      const multiplier = unit?.startsWith("week") ? 7 : unit?.startsWith("month") ? 30 : 1;
+      inferred = Number.isFinite(amount) ? offsetDays(referenceNow, amount * multiplier) : null;
+    } else {
+      const monthMatch = normalized.match(/\bin\s+(january|february|march|april|may|june|july|august|september|october|november|december)\b/);
+      if (monthMatch?.[1]) {
+        inferred = inferMonthAnchor(monthMatch[1], referenceNow);
+      }
+    }
+  }
+  if (!inferred) {
+    return null;
+  }
+  return inferred.getTime() > referenceNow.getTime() ? new Date(referenceNow.getTime()) : inferred;
+}
+function parseRelativeDate(input, now = /* @__PURE__ */ new Date()) {
+  const trimmed = input.trim();
+  const referenceNow = asValidDate2(now);
+  if (trimmed.length === 0 || !referenceNow) {
+    return null;
+  }
+  const durationMatch = trimmed.match(/^(\d+)d$/i);
+  if (durationMatch?.[1]) {
+    const days = Number(durationMatch[1]);
+    return Number.isFinite(days) ? offsetDays(referenceNow, days) : null;
+  }
+  const parsed = new Date(trimmed);
+  return Number.isNaN(parsed.getTime()) ? null : parsed;
+}
+var asValidDate2 = (value) => {
+  const date = new Date(value.getTime());
+  return Number.isNaN(date.getTime()) ? null : date;
+};
+var offsetDays = (date, days) => new Date(date.getTime() - days * DAY_IN_MILLISECONDS2);
+var inferMonthAnchor = (monthName, now) => {
+  const monthIndex = MONTH_INDEX.get(monthName);
+  if (monthIndex === void 0) {
+    return null;
+  }
+  const year = monthIndex <= now.getUTCMonth() ? now.getUTCFullYear() : now.getUTCFullYear() - 1;
+  return new Date(Date.UTC(year, monthIndex, 15));
+};
+
+// src/core/recall/trace.ts
+var NOOP_RECALL_TRACE_SINK = {
+  reportSummary() {
+  }
+};
+function createNoopRecallTraceSink() {
+  return NOOP_RECALL_TRACE_SINK;
+}
+
+// src/core/recall/search.ts
+var HISTORICAL_NEIGHBORHOOD_FAMILIES = ["supersession_chain", "claim_key_sibling", "topic_family"];
+var MIN_VECTOR_ONLY_EVIDENCE = 0.3;
+var HISTORICAL_STATE_FLAT_RECENCY = 0.5;
+var HISTORICAL_PREDECESSOR_BOOST = 0.08;
+var HISTORICAL_RETIRED_PREDECESSOR_BOOST = 0.06;
+var HISTORICAL_OLDER_STATE_BOOST = 0.08;
+var HISTORICAL_LINEAGE_GAP_MARGIN = 0.02;
+var HISTORICAL_LINEAGE_MAX_BONUS = 0.45;
+var HISTORICAL_TOPIC_SHARED_PREFIX_MIN = 2;
+var HISTORICAL_TOPIC_PREFIX_OF_CANDIDATE_MIN = 0.6;
+var CLAIM_KEY_TENTATIVE_CURRENT_PENALTY = 0.08;
+var CLAIM_KEY_REDUNDANT_TRUSTED_SLOT_PENALTY = 0.05;
+var CLAIM_KEY_REDUNDANT_TRUSTED_SLOT_MAX_PENALTY = 0.15;
+var QUERY_EMBEDDING_FAILURE_NOTICE = "Embeddings failed during recall, so Agenr fell back to lexical-only entry ranking.";
+var VECTOR_SEARCH_FAILURE_NOTICE = "Vector search failed during recall, so Agenr continued with lexical entry candidates only.";
+var ENTITY_ATTRIBUTE_IDENTITY_WRAPPERS = /* @__PURE__ */ new Set(["identity", "profile", "bio", "biography", "summary"]);
+var WEAK_QUERY_GROUNDING_TOKENS = /* @__PURE__ */ new Set([
+  "earlier",
+  "last",
+  "mention",
+  "mentioned",
+  "number",
+  "order",
+  "remember",
+  "remind",
+  "reminder",
+  "run",
+  "runs",
+  "thing",
+  "time",
+  "use",
+  "uses",
+  "using"
+]);
+var WEAKLY_GROUNDED_REMINDER_PATTERN = /\b(earlier|last time|mention(?:ed)?|remember|remind(?:er)?)\b/iu;
+var MIN_VECTOR_WITHOUT_GROUNDED_LEXICAL_SUPPORT = 0.45;
+var GROUNDING_SORT_MAX_SCORE_GAP = 0.03;
+async function recall(query, ports, options = {}) {
+  const text = query.text.trim();
+  const limit = normalizeLimit(query.limit);
+  const threshold = normalizeThreshold(query.threshold);
+  const budget = normalizeBudget(query.budget);
+  const asOfDate = query.asOf ? parseAroundDate(query.asOf) : null;
+  const aroundDate = query.around !== void 0 ? parseAroundDate(query.around) : inferAroundDate(text);
+  const since = query.since ? parseRelativeDate(query.since) : null;
+  const until = query.until ? parseRelativeDate(query.until) : null;
+  const filters = buildEntryFilters(query.types, query.tags, since, until);
+  const trace = options.trace ?? createNoopRecallTraceSink();
+  const slotPolicyConfig = options.slotPolicyConfig;
+  const summary = buildRecallTraceSummary({
+    filters,
+    limit,
+    threshold,
+    budget,
+    asOfDate,
+    aroundDate,
+    aroundSource: query.around !== void 0 ? "explicit" : "inferred",
+    aroundRadius: aroundDate ? normalizeAroundRadius(query.aroundRadius) : void 0
+  });
+  let traceReported = false;
+  const reportTrace = (noResultReason) => {
+    if (traceReported) {
+      return;
+    }
+    traceReported = true;
+    finishRecallTrace(summary, trace, noResultReason);
+  };
+  if (text.length === 0) {
+    reportTrace("empty_query");
+    return [];
+  }
+  if (limit === 0) {
+    reportTrace("limit_zero");
+    return [];
+  }
+  try {
+    let queryEmbedding = [];
+    try {
+      queryEmbedding = await ports.embed(text);
+    } catch {
+      markRecallDegraded(summary, "query_embedding_failed", QUERY_EMBEDDING_FAILURE_NOTICE);
+    }
+    const vectorSearchLimit = limit * 4;
+    const lexicalSearchLimit = limit * 2;
+    const [vectorCandidates, ftsCandidates] = queryEmbedding.length > 0 ? await Promise.all([
+      ports.vectorSearch({
+        embedding: queryEmbedding,
+        limit: vectorSearchLimit,
+        filters
+      }).catch(() => {
+        markRecallDegraded(summary, "vector_search_failed", VECTOR_SEARCH_FAILURE_NOTICE);
+        return [];
+      }),
+      ports.ftsSearch({
+        text,
+        limit: lexicalSearchLimit,
+        filters
+      })
+    ]) : [
+      [],
+      await ports.ftsSearch({
+        text,
+        limit: lexicalSearchLimit,
+        filters
+      })
+    ];
+    summary.degraded.lexicalOnly = summary.degraded.active && queryEmbedding.length === 0;
+    const mergeStartedAt = Date.now();
+    const mergeOutcome = mergeCandidates(vectorCandidates, ftsCandidates);
+    const neighborhoodEnabled = options.rankingPolicy?.neighborhood !== "disabled";
+    const expansionRanks = neighborhoodEnabled ? await expandEntryNeighborhood(mergeOutcome.merged, queryEmbedding, ports, {
+      rankingProfile: query.rankingProfile,
+      neighborhoodTrace: summary.neighborhood
+    }) : [];
+    const relevanceByEntryId = resolveEntryRelevance({
+      vectorRanks: mergeOutcome.vectorRanks,
+      ftsRanks: mergeOutcome.ftsRanks,
+      expansionRanks,
+      policy: options.rankingPolicy,
+      trace: summary.rrf
+    });
+    summary.candidateCounts.merged = mergeOutcome.merged.size;
+    summary.timings.mergeCandidatesMs = elapsedMs2(mergeStartedAt);
+    const scoreStartedAt = Date.now();
+    const historicallyBoosted = applyHistoricalLineageBoosts(
+      Array.from(mergeOutcome.merged.values()).map(
+        (candidate) => scoreMergedCandidate(candidate, text, queryEmbedding, relevanceByEntryId.get(candidate.entry.id) ?? 0, {
+          asOfDate,
+          aroundDate,
+          aroundRadius: query.aroundRadius,
+          rankingProfile: query.rankingProfile
+        })
+      ),
+      {
+        aroundDate,
+        rankingProfile: query.rankingProfile
+      },
+      summary.claimKey,
+      slotPolicyConfig
+    );
+    const rerankedCandidates = neighborhoodEnabled ? applySeededEntryRerank(historicallyBoosted, summary.neighborhood) : historicallyBoosted;
+    const shaped = applyClaimKeyResultShaping(rerankedCandidates, summary.claimKey, slotPolicyConfig).sort((left, right) => right.score - left.score);
+    const diversified = applyMmrDiversification(shaped, queryEmbedding, options.rankingPolicy, summary.mmr);
+    const scored = await applyEntryCrossEncoderRerank(diversified, text, ports.crossEncoder, options.rankingPolicy, summary.crossEncoder);
+    summary.timings.scoreCandidatesMs = elapsedMs2(scoreStartedAt);
+    const thresholdStartedAt = Date.now();
+    const thresholded = scored.filter((result) => hasSufficientReturnEvidence(result, query) && result.score >= threshold);
+    summary.candidateCounts.thresholdQualified = thresholded.length;
+    summary.timings.thresholdMs = elapsedMs2(thresholdStartedAt);
+    if (thresholded.length === 0) {
+      reportTrace(resolveNoResultReason(summary, scored.length === 0 ? "no_candidates" : "below_threshold"));
+      return [];
+    }
+    const budgetStartedAt = Date.now();
+    const budgeted = budget === null ? thresholded : applyBudget(thresholded, budget);
+    summary.candidateCounts.budgetAccepted = budgeted.length;
+    summary.timings.budgetMs = budget === null ? 0 : elapsedMs2(budgetStartedAt);
+    const ranked = sortAcceptedCandidates(budgeted.slice(0, limit), text, query.rankingProfile);
+    summary.candidateCounts.finalRanked = ranked.length;
+    if (ranked.length === 0) {
+      reportTrace("limit_zero");
+      return [];
+    }
+    const hydratedEntries = await ports.hydrateEntries(ranked.map((result) => result.entry.id));
+    const shapeStartedAt = Date.now();
+    const hydratedById = new Map(hydratedEntries.map((entry) => [entry.id, entry]));
+    const results = ranked.flatMap((result) => {
+      const entry = hydratedById.get(result.entry.id);
+      if (!entry) {
+        return [];
+      }
+      return [
+        {
+          entry,
+          score: result.score,
+          scores: result.scores
+        }
+      ];
+    });
+    summary.candidateCounts.returned = results.length;
+    summary.timings.shapeResultsMs = elapsedMs2(shapeStartedAt);
+    if (results.length === 0) {
+      reportTrace(resolveNoResultReason(summary, "hydrate_missing"));
+      return [];
+    }
+    if (results.length > 0) {
+      await ports.recordRecallEvents({
+        entryIds: results.map((result) => result.entry.id),
+        query: text,
+        sessionKey: query.sessionKey
+      }).catch(() => void 0);
+    }
+    reportTrace();
+    return results;
+  } catch (error) {
+    reportTrace();
+    throw error;
+  }
+}
+function buildRecallTraceSummary(params) {
+  return {
+    filtering: {
+      types: params.filters?.types ?? [],
+      tags: params.filters?.tags ?? [],
+      since: params.filters?.since?.toISOString(),
+      until: params.filters?.until?.toISOString(),
+      around: params.aroundDate ? {
+        source: params.aroundSource,
+        anchor: params.aroundDate.toISOString(),
+        radiusDays: params.aroundRadius ?? 14
+      } : void 0,
+      ...params.asOfDate ? {
+        asOf: {
+          anchor: params.asOfDate.toISOString()
+        }
+      } : {}
+    },
+    ranking: {
+      limit: params.limit,
+      threshold: params.threshold,
+      budget: params.budget
+    },
+    candidateCounts: {
+      merged: 0,
+      thresholdQualified: 0,
+      budgetAccepted: 0,
+      finalRanked: 0,
+      returned: 0
+    },
+    claimKey: {
+      historicalBoosted: 0,
+      tentativeLineageSuppressed: 0,
+      trustPenalized: 0,
+      redundancyPenalized: 0
+    },
+    rrf: {
+      applied: false,
+      channelCount: 0,
+      rankConstant: DEFAULT_RRF_RANK_CONSTANT,
+      fusedCandidateCount: 0,
+      maxFusedScore: 0
+    },
+    neighborhood: {
+      expansionRequested: false,
+      expansionAvailable: false,
+      familiesRequested: [],
+      includeRetired: false,
+      seedIds: [],
+      expansionCandidates: 0,
+      strongSeedIds: [],
+      rerankBoostedIds: []
+    },
+    mmr: {
+      applied: false,
+      lambda: DEFAULT_MMR_LAMBDA,
+      droppedDuplicateCount: 0,
+      reorderedIds: []
+    },
+    crossEncoder: {
+      applied: false,
+      k: 0,
+      alpha: DEFAULT_CROSS_ENCODER_ALPHA,
+      latencyMs: 0,
+      rescoredIds: []
+    },
+    timings: {
+      mergeCandidatesMs: 0,
+      scoreCandidatesMs: 0,
+      thresholdMs: 0,
+      budgetMs: 0,
+      shapeResultsMs: 0
+    },
+    degraded: {
+      active: false,
+      reasons: [],
+      lexicalOnly: false,
+      notices: []
+    }
+  };
+}
+function finishRecallTrace(summary, trace, noResultReason) {
+  if (noResultReason) {
+    summary.ranking.noResultReason = noResultReason;
+  }
+  trace.reportSummary(summary);
+}
+function markRecallDegraded(summary, reason, notice) {
+  summary.degraded.active = true;
+  if (!summary.degraded.reasons.includes(reason)) {
+    summary.degraded.reasons.push(reason);
+  }
+  if (!summary.degraded.notices.includes(notice)) {
+    summary.degraded.notices.push(notice);
+  }
+}
+function resolveNoResultReason(summary, reason) {
+  if (!summary.degraded.active) {
+    return reason;
+  }
+  if (reason === "no_candidates") {
+    return "degraded_no_candidates";
+  }
+  if (reason === "below_threshold") {
+    return "degraded_below_threshold";
+  }
+  return reason;
+}
+function scoreMergedCandidate(candidate, queryText, queryEmbedding, rrfScore, params) {
+  const vector = candidate.vectorSim ?? cosineSimilarity(candidate.entry.embedding ?? [], queryEmbedding);
+  const lexical = computeLexicalScore(queryText, candidate.entry.subject, candidate.entry.content);
+  const recency = resolveRecencyScore(candidate.entry, params);
+  const importance = importanceScore(candidate.entry.importance);
+  const scored = scoreCandidate({
+    relevance: rrfScore,
+    vectorSim: vector,
+    lexical,
+    recency,
+    importance
+  });
+  return {
+    entry: candidate.entry,
+    score: scored.score,
+    scores: {
+      ...scored.scores,
+      // `rrf` mirrors `relevance` and makes the reciprocal rank fusion source
+      // explicit for trace summaries and cross-stage reasoning in later phases.
+      rrf: scored.scores.relevance,
+      historicalLineage: 0,
+      neighborhoodBoost: 0,
+      claimKeyTrustPenalty: 0,
+      claimKeyRedundancyPenalty: 0
+    }
+  };
+}
+function resolveEntryRelevance(params) {
+  const { vectorRanks, ftsRanks, expansionRanks, policy, trace } = params;
+  if (policy?.rrf === "disabled") {
+    const fallbackChannel = vectorRanks.length > 0 ? vectorRanks : ftsRanks;
+    const fallback = /* @__PURE__ */ new Map();
+    fallbackChannel.forEach((id, index) => {
+      if (!fallback.has(id)) {
+        fallback.set(id, 1 / (index + 1));
+      }
+    });
+    trace.applied = false;
+    trace.channelCount = fallbackChannel.length > 0 ? 1 : 0;
+    trace.rankConstant = resolveRrfRankConstant(policy, fallback.size);
+    trace.fusedCandidateCount = fallback.size;
+    trace.maxFusedScore = fallback.size > 0 ? Math.max(...fallback.values()) : 0;
+    return fallback;
+  }
+  const channels = [Array.from(vectorRanks), Array.from(ftsRanks), Array.from(expansionRanks)];
+  const activeChannels = channels.filter((channel) => channel.length > 0);
+  const uniqueFusedIds = /* @__PURE__ */ new Set();
+  for (const channel of channels) {
+    for (const id of channel) {
+      uniqueFusedIds.add(id);
+    }
+  }
+  const rankConstant = resolveRrfRankConstant(policy, uniqueFusedIds.size);
+  trace.rankConstant = rankConstant;
+  const fused = rrfFuse(channels, rankConstant);
+  trace.applied = fused.size > 0;
+  trace.channelCount = activeChannels.length;
+  trace.fusedCandidateCount = fused.size;
+  trace.maxFusedScore = fused.size > 0 ? Math.max(...fused.values()) : 0;
+  return fused;
+}
+function resolveRrfRankConstant(policy, fusedPoolSize) {
+  const rawGeneral = policy?.rrfRankConstant;
+  const hasExplicitGeneral = typeof rawGeneral === "number" && Number.isFinite(rawGeneral) && rawGeneral > 0;
+  const generalConstant = hasExplicitGeneral ? rawGeneral : DEFAULT_RRF_RANK_CONSTANT;
+  const isSmallPool = Number.isFinite(fusedPoolSize) && fusedPoolSize > 0 && fusedPoolSize <= SMALL_POOL_RRF_POOL_SIZE;
+  if (!isSmallPool) {
+    return generalConstant;
+  }
+  const rawSmall = policy?.rrfSmallPoolRankConstant;
+  if (typeof rawSmall === "number" && Number.isFinite(rawSmall) && rawSmall > 0) {
+    return rawSmall;
+  }
+  if (hasExplicitGeneral) {
+    return generalConstant;
+  }
+  return DEFAULT_RRF_SMALL_POOL_RANK_CONSTANT;
+}
+async function expandEntryNeighborhood(mergedCandidates, queryEmbedding, ports, params) {
+  const trace = params.neighborhoodTrace;
+  trace.expansionAvailable = Boolean(ports.expandNeighborhood);
+  if (mergedCandidates.size === 0 || !ports.expandNeighborhood || params.rankingProfile !== "historical_state") {
+    return [];
+  }
+  const families = HISTORICAL_NEIGHBORHOOD_FAMILIES;
+  const includeRetired = true;
+  const seedIds = Array.from(mergedCandidates.keys());
+  trace.expansionRequested = true;
+  trace.familiesRequested = [...families];
+  trace.includeRetired = includeRetired;
+  trace.seedIds = seedIds;
+  const expanded = await ports.expandNeighborhood({
+    seedIds,
+    budget: DEFAULT_NEIGHBORHOOD_BUDGET,
+    families,
+    includeRetired
+  });
+  const ranked = expanded.filter((entry) => !mergedCandidates.has(entry.id)).map((entry) => ({
+    entry,
+    vectorSim: cosineSimilarity(entry.embedding ?? [], queryEmbedding)
+  })).sort((left, right) => right.vectorSim - left.vectorSim || left.entry.id.localeCompare(right.entry.id));
+  for (const candidate of ranked) {
+    mergedCandidates.set(candidate.entry.id, {
+      entry: candidate.entry,
+      vectorSim: candidate.vectorSim
+    });
+  }
+  trace.expansionCandidates = ranked.length;
+  return ranked.map((candidate) => candidate.entry.id);
+}
+function applySeededEntryRerank(candidates, trace) {
+  if (candidates.length === 0) {
+    return candidates;
+  }
+  const seeds = selectStrongSeeds(
+    candidates.map((candidate) => ({ id: candidate.entry.id, score: candidate.score, entry: candidate.entry })),
+    {
+      topN: DEFAULT_STRONG_SEED_TOP_N,
+      scoreGapFloor: DEFAULT_STRONG_SEED_SCORE_GAP
+    }
+  );
+  if (seeds.length === 0) {
+    return candidates;
+  }
+  trace.strongSeedIds = seeds.map((seed) => seed.id);
+  const payloads = candidates.map((candidate) => ({
+    id: candidate.entry.id,
+    score: candidate.score,
+    entry: candidate.entry
+  }));
+  const reranked = seededRerank(payloads, seeds, (candidate, seed) => sharesEntryLineage(candidate.entry, seed.entry), {
+    weight: DEFAULT_SEEDED_RERANK_WEIGHT
+  });
+  trace.rerankBoostedIds = reranked.boostedIds;
+  const scoreById = new Map(reranked.candidates.map((candidate) => [candidate.id, candidate.score]));
+  return candidates.map((candidate) => {
+    const nextScore = scoreById.get(candidate.entry.id) ?? candidate.score;
+    const delta = nextScore - candidate.score;
+    if (delta <= 0) {
+      return candidate;
+    }
+    return {
+      ...candidate,
+      score: nextScore,
+      scores: {
+        ...candidate.scores,
+        neighborhoodBoost: candidate.scores.neighborhoodBoost + delta
+      }
+    };
+  });
+}
+function resolveRecencyScore(entry, params) {
+  if (params.asOfDate) {
+    return resolveAsOfScore(entry, params.asOfDate);
+  }
+  if (params.aroundDate) {
+    return gaussianRecency(entry.created_at, params.aroundDate, normalizeAroundRadius(params.aroundRadius));
+  }
+  if (params.rankingProfile === "historical_state") {
+    return HISTORICAL_STATE_FLAT_RECENCY;
+  }
+  return recencyScore(entry.created_at, entry.expiry);
+}
+function resolveAsOfScore(entry, asOfDate) {
+  const validFrom = parseTimestamp(entry.valid_from);
+  const validTo = parseTimestamp(entry.valid_to);
+  if (validFrom || validTo) {
+    const startMs = validFrom?.getTime() ?? Number.NEGATIVE_INFINITY;
+    const endMs = validTo?.getTime() ?? Number.POSITIVE_INFINITY;
+    const asOfMs = asOfDate.getTime();
+    if (asOfMs >= startMs && asOfMs <= endMs) {
+      return 1;
+    }
+    const nearestBoundaryMs = asOfMs < startMs ? startMs : endMs;
+    return Math.max(0.1, gaussianRecency(new Date(nearestBoundaryMs).toISOString(), asOfDate, 21) * 0.65);
+  }
+  const observedAt = parseTimestamp(entry.claim_support_observed_at);
+  if (observedAt) {
+    const observedBeforeAsOf = observedAt.getTime() <= asOfDate.getTime();
+    const proximity = gaussianRecency(observedAt.toISOString(), asOfDate, 30);
+    return observedBeforeAsOf ? Math.max(0.45, proximity * 0.8) : Math.max(0.05, proximity * 0.2);
+  }
+  const createdAt = parseTimestamp(entry.created_at);
+  if (createdAt) {
+    const createdBeforeAsOf = createdAt.getTime() <= asOfDate.getTime();
+    const proximity = gaussianRecency(createdAt.toISOString(), asOfDate, 45);
+    return createdBeforeAsOf ? Math.max(0.35, proximity * 0.7) : Math.max(0.05, proximity * 0.15);
+  }
+  return HISTORICAL_STATE_FLAT_RECENCY;
+}
+function applyHistoricalLineageBoosts(candidates, params, claimKeyTrace, slotPolicyConfig) {
+  if (params.rankingProfile !== "historical_state") {
+    return candidates;
+  }
+  const entries = candidates.map((candidate) => candidate.entry);
+  const scoresById = new Map(candidates.map((candidate) => [candidate.entry.id, candidate.score]));
+  return candidates.map((candidate) => {
+    const decision = resolveHistoricalLineageBonus(candidate.entry, entries, scoresById, candidate.score, params.aroundDate, slotPolicyConfig);
+    if (decision.tentativeLineageSuppressed) {
+      claimKeyTrace.tentativeLineageSuppressed += 1;
+    }
+    const bonus = decision.bonus;
+    if (bonus <= 0) {
+      return candidate;
+    }
+    claimKeyTrace.historicalBoosted += 1;
+    return {
+      ...candidate,
+      score: clampRecallScore(candidate.score + bonus),
+      scores: {
+        ...candidate.scores,
+        historicalLineage: candidate.scores.historicalLineage + bonus
+      }
+    };
+  });
+}
+function resolveHistoricalLineageBonus(entry, entries, scoresById, candidateScore, aroundDate, slotPolicyConfig) {
+  const directSuccessor = entries.find((peer) => peer.id !== entry.id && entry.superseded_by === peer.id);
+  if (directSuccessor) {
+    const successorScore = scoresById.get(directSuccessor.id) ?? 0;
+    return {
+      bonus: shapeHistoricalLineageBonus(HISTORICAL_PREDECESSOR_BOOST, candidateScore, successorScore),
+      tentativeLineageSuppressed: false
+    };
+  }
+  if (aroundDate) {
+    return {
+      bonus: 0,
+      tentativeLineageSuppressed: false
+    };
+  }
+  let tentativeLineageSuppressed = false;
+  let bestPeerScore = 0;
+  let peerMatched = false;
+  for (const peer of entries) {
+    if (peer.id === entry.id || !isPotentialCurrentPeer(peer) || createdAtMs(entry.created_at) >= createdAtMs(peer.created_at)) {
+      continue;
+    }
+    const relation = resolveHistoricalPeerRelation(entry, peer, entries, slotPolicyConfig);
+    if (relation === "tentative_claim_key_suppressed") {
+      tentativeLineageSuppressed = true;
+      continue;
+    }
+    if (relation === null) {
+      continue;
+    }
+    peerMatched = true;
+    const peerScore = scoresById.get(peer.id) ?? 0;
+    if (peerScore > bestPeerScore) {
+      bestPeerScore = peerScore;
+    }
+  }
+  if (!peerMatched) {
+    return {
+      bonus: 0,
+      tentativeLineageSuppressed
+    };
+  }
+  const base = entry.retired ? HISTORICAL_RETIRED_PREDECESSOR_BOOST : HISTORICAL_OLDER_STATE_BOOST;
+  return {
+    bonus: shapeHistoricalLineageBonus(base, candidateScore, bestPeerScore),
+    tentativeLineageSuppressed
+  };
+}
+function shapeHistoricalLineageBonus(base, candidateScore, successorScore) {
+  const gap = successorScore - candidateScore;
+  const needed = gap > 0 ? gap + HISTORICAL_LINEAGE_GAP_MARGIN : 0;
+  return Math.min(HISTORICAL_LINEAGE_MAX_BONUS, Math.max(base, needed));
+}
+function isPotentialCurrentPeer(entry) {
+  return !entry.retired && entry.superseded_by === void 0;
+}
+function resolveHistoricalPeerRelation(left, right, entries, slotPolicyConfig) {
+  if (left.claim_key && right.claim_key && left.claim_key === right.claim_key) {
+    if (resolveClaimSlotPolicy(left.claim_key, slotPolicyConfig).policy === "multivalued") {
+      return null;
+    }
+    return canUseClaimKeyLineage(left, entries, slotPolicyConfig) ? "claim_key" : "tentative_claim_key_suppressed";
+  }
+  return sharesHistoricalTopic(left, right) ? "topic" : null;
+}
+function canUseClaimKeyLineage(entry, entries, slotPolicyConfig) {
+  if (!entry.claim_key) {
+    return false;
+  }
+  if (resolveClaimSlotPolicy(entry.claim_key, slotPolicyConfig).policy === "multivalued") {
+    return false;
+  }
+  if (!hasTrustedClaimKeyEvidence(entries, entry.claim_key)) {
+    return true;
+  }
+  return entry.claim_key_status === "trusted";
+}
+function hasTrustedClaimKeyEvidence(entries, claimKey) {
+  return entries.some((entry) => entry.claim_key === claimKey && entry.claim_key_status === "trusted");
+}
+function sharesHistoricalTopic(left, right) {
+  const leftTokens = tokenize(left.subject);
+  const rightTokens = tokenize(right.subject);
+  if (leftTokens.length === 0 || rightTokens.length === 0) {
+    return false;
+  }
+  const sharedPrefixCount = countSharedPrefixTokens(leftTokens, rightTokens);
+  return sharedPrefixCount >= HISTORICAL_TOPIC_SHARED_PREFIX_MIN && sharedPrefixCount / leftTokens.length >= HISTORICAL_TOPIC_PREFIX_OF_CANDIDATE_MIN;
+}
+function createdAtMs(value) {
+  return parseTimestamp(value)?.getTime() ?? 0;
+}
+function parseTimestamp(value) {
+  const normalized = value?.trim();
+  if (!normalized) {
+    return null;
+  }
+  const timestamp = new Date(normalized);
+  return Number.isFinite(timestamp.getTime()) ? timestamp : null;
+}
+function countSharedPrefixTokens(leftTokens, rightTokens) {
+  const length = Math.min(leftTokens.length, rightTokens.length);
+  let sharedPrefixCount = 0;
+  for (let index = 0; index < length; index += 1) {
+    if (leftTokens[index] !== rightTokens[index]) {
+      break;
+    }
+    sharedPrefixCount += 1;
+  }
+  return sharedPrefixCount;
+}
+function applyMmrDiversification(candidates, queryEmbedding, policy, trace) {
+  if (candidates.length < 2 || policy?.mmr === "disabled") {
+    trace.applied = false;
+    trace.lambda = resolveMmrLambda(policy);
+    return candidates;
+  }
+  const reorder = maximalMarginalRelevance({
+    queryVector: queryEmbedding,
+    candidates: candidates.map((candidate) => ({
+      id: candidate.entry.id,
+      relevance: candidate.score,
+      ...candidate.entry.embedding ? { embedding: candidate.entry.embedding } : {}
+    })),
+    lambda: resolveMmrLambda(policy),
+    minPoolSize: resolveMmrMinPoolSize(policy)
+  });
+  trace.applied = reorder.applied;
+  trace.lambda = reorder.lambda;
+  trace.droppedDuplicateCount = reorder.droppedDuplicateCount;
+  trace.reorderedIds = reorder.reorderedIds;
+  if (!reorder.applied) {
+    return candidates;
+  }
+  const candidatesById = new Map(candidates.map((candidate) => [candidate.entry.id, candidate]));
+  return reorder.orderedIds.flatMap((id) => {
+    const candidate = candidatesById.get(id);
+    return candidate ? [candidate] : [];
+  });
+}
+async function applyEntryCrossEncoderRerank(candidates, query, crossEncoder, policy, trace) {
+  const result = await applyCrossEncoderRerank({
+    query,
+    candidates: candidates.map((candidate) => ({
+      id: candidate.entry.id,
+      text: buildCrossEncoderPassageText(candidate.entry),
+      score: candidate.score,
+      candidate
+    })),
+    port: crossEncoder,
+    disabled: policy?.crossEncoder === "disabled",
+    topK: policy?.crossEncoderTopK ?? DEFAULT_CROSS_ENCODER_TOP_K,
+    alpha: policy?.crossEncoderAlpha ?? DEFAULT_CROSS_ENCODER_ALPHA
+  });
+  trace.applied = result.applied;
+  trace.k = result.k;
+  trace.alpha = result.alpha;
+  trace.latencyMs = result.latencyMs;
+  trace.rescoredIds = [...result.rescoredIds];
+  if (result.degradedReason) {
+    trace.degradedReason = result.degradedReason;
+  } else {
+    delete trace.degradedReason;
+  }
+  return result.candidates.map((entry) => {
+    const scoredCandidate = entry.candidate;
+    const nextScore = entry.score;
+    if (typeof entry.crossEncoderScore !== "number" && nextScore === scoredCandidate.score) {
+      return scoredCandidate;
+    }
+    return {
+      ...scoredCandidate,
+      score: nextScore,
+      scores: {
+        ...scoredCandidate.scores,
+        ...typeof entry.crossEncoderScore === "number" ? { crossEncoder: entry.crossEncoderScore } : {}
+      }
+    };
+  });
+}
+function buildCrossEncoderPassageText(entry) {
+  const subject = entry.subject.trim();
+  const content = entry.content.trim();
+  if (subject.length === 0) {
+    return content;
+  }
+  if (content.length === 0) {
+    return subject;
+  }
+  return `${subject}
+
+${content}`;
+}
+function resolveMmrLambda(policy) {
+  const rawLambda = policy?.mmrLambda;
+  if (typeof rawLambda !== "number" || !Number.isFinite(rawLambda)) {
+    return DEFAULT_MMR_LAMBDA;
+  }
+  return Math.max(0, Math.min(1, rawLambda));
+}
+function resolveMmrMinPoolSize(policy) {
+  const raw = policy?.mmrMinPoolSize;
+  if (typeof raw !== "number" || !Number.isFinite(raw) || raw < 0) {
+    return DEFAULT_MMR_MIN_POOL_SIZE;
+  }
+  return Math.floor(raw);
+}
+function applyClaimKeyResultShaping(candidates, claimKeyTrace, slotPolicyConfig) {
+  if (candidates.length === 0) {
+    return candidates;
+  }
+  const trustedActiveClaimKeys = new Set(
+    candidates.map((candidate) => candidate.entry).filter(
+      (entry) => isPotentialCurrentPeer(entry) && entry.claim_key && entry.claim_key_status === "trusted" && resolveClaimSlotPolicy(entry.claim_key, slotPolicyConfig).policy === "exclusive"
+    ).map((entry) => entry.claim_key)
+  );
+  const trustedSlotRankById = rankTrustedSlotSiblings(candidates, slotPolicyConfig);
+  return candidates.map((candidate) => {
+    const trustPenalty = shouldPenalizeTentativeCurrentSibling(candidate.entry, trustedActiveClaimKeys) ? CLAIM_KEY_TENTATIVE_CURRENT_PENALTY : 0;
+    const redundancyPenalty = resolveTrustedSlotRedundancyPenalty(candidate.entry.id, trustedSlotRankById);
+    if (trustPenalty <= 0 && redundancyPenalty <= 0) {
+      return candidate;
+    }
+    if (trustPenalty > 0) {
+      claimKeyTrace.trustPenalized += 1;
+    }
+    if (redundancyPenalty > 0) {
+      claimKeyTrace.redundancyPenalized += 1;
+    }
+    return {
+      ...candidate,
+      score: clampRecallScore(candidate.score - trustPenalty - redundancyPenalty),
+      scores: {
+        ...candidate.scores,
+        claimKeyTrustPenalty: trustPenalty,
+        claimKeyRedundancyPenalty: redundancyPenalty
+      }
+    };
+  });
+}
+function rankTrustedSlotSiblings(candidates, slotPolicyConfig) {
+  const candidatesById = new Map(candidates.map((candidate) => [candidate.entry.id, candidate]));
+  const trustedByClaimKey = /* @__PURE__ */ new Map();
+  for (const candidate of candidates) {
+    const claimKey = candidate.entry.claim_key;
+    if (!claimKey || candidate.entry.claim_key_status !== "trusted" || !isPotentialCurrentPeer(candidate.entry) || resolveClaimSlotPolicy(claimKey, slotPolicyConfig).policy !== "exclusive") {
+      continue;
+    }
+    const siblings = trustedByClaimKey.get(claimKey) ?? [];
+    siblings.push(candidate);
+    trustedByClaimKey.set(claimKey, siblings);
+  }
+  const ranks = /* @__PURE__ */ new Map();
+  for (const siblings of trustedByClaimKey.values()) {
+    siblings.slice().sort(compareCandidatesForTrustedSlotRank).forEach((candidate, index) => {
+      if (candidatesById.has(candidate.entry.id)) {
+        ranks.set(candidate.entry.id, index);
+      }
+    });
+  }
+  return ranks;
+}
+function compareCandidatesForTrustedSlotRank(left, right) {
+  return right.score - left.score || createdAtMs(right.entry.created_at) - createdAtMs(left.entry.created_at) || left.entry.id.localeCompare(right.entry.id);
+}
+function shouldPenalizeTentativeCurrentSibling(entry, trustedActiveClaimKeys) {
+  return isPotentialCurrentPeer(entry) && entry.claim_key !== void 0 && entry.claim_key_status !== "trusted" && trustedActiveClaimKeys.has(entry.claim_key);
+}
+function resolveTrustedSlotRedundancyPenalty(entryId, trustedSlotRankById) {
+  const rank = trustedSlotRankById.get(entryId) ?? 0;
+  if (rank <= 0) {
+    return 0;
+  }
+  return Math.min(CLAIM_KEY_REDUNDANT_TRUSTED_SLOT_MAX_PENALTY, rank * CLAIM_KEY_REDUNDANT_TRUSTED_SLOT_PENALTY);
+}
+function clampRecallScore(value) {
+  return Math.max(0, Math.min(1, value));
+}
+function hasSufficientReturnEvidence(candidate, query) {
+  if (query.rankingProfile === "entity_attribute") {
+    return hasEntityAttributeEvidence(candidate.entry, query.queryShape);
+  }
+  const groundedLexicalSupport = hasGroundedLexicalSupport(candidate.entry, query.text);
+  if (candidate.scores.lexical > 0) {
+    if (groundedLexicalSupport) {
+      return true;
+    }
+    return candidate.scores.vector >= MIN_VECTOR_WITHOUT_GROUNDED_LEXICAL_SUPPORT;
+  }
+  if (isWeaklyGroundedReminderQuery(query.text) && !groundedLexicalSupport) {
+    return false;
+  }
+  return candidate.scores.vector >= MIN_VECTOR_ONLY_EVIDENCE;
+}
+function hasGroundedLexicalSupport(entry, queryText) {
+  const groundingTokens = getGroundingTokens(queryText);
+  if (groundingTokens.length === 0) {
+    return false;
+  }
+  const candidateTokens = new Set(tokenize(`${entry.subject} ${entry.content}`).map(canonicalizeRecallToken));
+  return groundingTokens.some((token) => candidateTokens.has(token));
+}
+function isWeaklyGroundedReminderQuery(queryText) {
+  return WEAKLY_GROUNDED_REMINDER_PATTERN.test(queryText);
+}
+function hasEntityAttributeEvidence(entry, queryShape) {
+  if (queryShape?.kind !== "entity_attribute") {
+    return false;
+  }
+  const normalizedSubject = normalizeEntityAttributeText(entry.subject);
+  const normalizedContent = normalizeEntityAttributeText(entry.content);
+  const combinedTokens = new Set(tokenize(`${entry.subject} ${entry.content}`));
+  const entityTokenMatches = countTokenMatches(queryShape.entityTokens, combinedTokens);
+  const attributeTokenMatches = countTokenMatches(queryShape.attributeTokens, combinedTokens);
+  if (queryShape.attributeKind === "identity") {
+    if (normalizedSubject === queryShape.normalizedEntity || isIdentityWrapperSubject(normalizedSubject, queryShape.normalizedEntity)) {
+      return true;
+    }
+  }
+  if ((containsNormalizedPhrase(normalizedSubject, queryShape.normalizedEntity) || containsNormalizedPhrase(normalizedContent, queryShape.normalizedEntity)) && (queryShape.entityTokens.length >= 2 || attributeTokenMatches >= 1)) {
+    return true;
+  }
+  return entityTokenMatches >= 2 && attributeTokenMatches >= 1;
+}
+function countTokenMatches(expectedTokens, availableTokens) {
+  let matches = 0;
+  for (const token of expectedTokens) {
+    if (availableTokens.has(token)) {
+      matches += 1;
+    }
+  }
+  return matches;
+}
+function isIdentityWrapperSubject(normalizedSubject, normalizedEntity) {
+  return Array.from(ENTITY_ATTRIBUTE_IDENTITY_WRAPPERS).some((wrapper) => normalizedSubject === `${normalizedEntity} ${wrapper}`);
+}
+function containsNormalizedPhrase(normalizedText, normalizedPhrase) {
+  return normalizedPhrase.length > 0 && normalizedText.includes(normalizedPhrase);
+}
+function normalizeEntityAttributeText(text) {
+  return text.replace(/\s+/gu, " ").trim().normalize("NFKC").toLocaleLowerCase();
+}
+function mergeCandidates(vectorCandidates, ftsCandidates) {
+  const merged = /* @__PURE__ */ new Map();
+  const vectorRanks = [];
+  const ftsRanks = [];
+  for (const candidate of vectorCandidates) {
+    if (!merged.has(candidate.entry.id)) {
+      vectorRanks.push(candidate.entry.id);
+    }
+    merged.set(candidate.entry.id, {
+      entry: candidate.entry,
+      vectorSim: candidate.vectorSim
+    });
+  }
+  for (const candidate of ftsCandidates) {
+    ftsRanks.push(candidate.entry.id);
+    const existing = merged.get(candidate.entry.id);
+    if (existing) {
+      existing.entry = existing.entry.embedding ? existing.entry : candidate.entry;
+      continue;
+    }
+    merged.set(candidate.entry.id, {
+      entry: candidate.entry
+    });
+  }
+  return {
+    merged,
+    vectorRanks,
+    ftsRanks
+  };
+}
+function buildEntryFilters(types, tags, since, until) {
+  const filters = {};
+  if (types && types.length > 0) {
+    filters.types = types;
+  }
+  if (tags && tags.length > 0) {
+    filters.tags = tags;
+  }
+  if (since) {
+    filters.since = since;
+  }
+  if (until) {
+    filters.until = until;
+  }
+  return Object.keys(filters).length > 0 ? filters : void 0;
+}
+function applyBudget(results, budget) {
+  if (results.length === 0) {
+    return [];
+  }
+  const accepted = [results[0]];
+  let consumed = estimateTokens(results[0].entry);
+  for (const result of results.slice(1)) {
+    const estimate = estimateTokens(result.entry);
+    if (consumed + estimate > budget) {
+      continue;
+    }
+    accepted.push(result);
+    consumed += estimate;
+  }
+  return accepted;
+}
+function sortAcceptedCandidates(candidates, queryText, rankingProfile) {
+  if (rankingProfile === "historical_state" || rankingProfile === "entity_attribute") {
+    return candidates.map((candidate, index) => ({ candidate, index })).sort((left, right) => right.candidate.score - left.candidate.score || left.index - right.index).map(({ candidate }) => candidate);
+  }
+  const groundingTokens = getGroundingTokens(queryText);
+  return candidates.map((candidate, index) => ({
+    candidate,
+    index,
+    grounding: computeGroundingSupport(candidate.entry, groundingTokens)
+  })).sort((left, right) => {
+    const scoreGap = Math.abs(left.candidate.score - right.candidate.score);
+    if (scoreGap > GROUNDING_SORT_MAX_SCORE_GAP || hasStructuralScoreShaping(left.candidate) || hasStructuralScoreShaping(right.candidate)) {
+      if (left.candidate.score !== right.candidate.score) {
+        return right.candidate.score - left.candidate.score;
+      }
+      return left.index - right.index;
+    }
+    if (left.grounding.phraseMatches !== right.grounding.phraseMatches) {
+      return right.grounding.phraseMatches - left.grounding.phraseMatches;
+    }
+    if (left.grounding.coverage !== right.grounding.coverage) {
+      return right.grounding.coverage - left.grounding.coverage;
+    }
+    if (left.candidate.scores.lexical !== right.candidate.scores.lexical) {
+      return right.candidate.scores.lexical - left.candidate.scores.lexical;
+    }
+    if (left.candidate.score !== right.candidate.score) {
+      return right.candidate.score - left.candidate.score;
+    }
+    if (left.candidate.scores.vector !== right.candidate.scores.vector) {
+      return right.candidate.scores.vector - left.candidate.scores.vector;
+    }
+    return left.index - right.index;
+  }).map(({ candidate }) => candidate);
+}
+function hasStructuralScoreShaping(candidate) {
+  return candidate.scores.historicalLineage > 0 || candidate.scores.neighborhoodBoost > 0 || candidate.scores.claimKeyTrustPenalty > 0 || candidate.scores.claimKeyRedundancyPenalty > 0;
+}
+function getGroundingTokens(queryText) {
+  const seen = /* @__PURE__ */ new Set();
+  const groundingTokens = [];
+  for (const token of tokenize(queryText)) {
+    if (WEAK_QUERY_GROUNDING_TOKENS.has(token)) {
+      continue;
+    }
+    const canonical = canonicalizeRecallToken(token);
+    if (seen.has(canonical)) {
+      continue;
+    }
+    seen.add(canonical);
+    groundingTokens.push(canonical);
+  }
+  return groundingTokens;
+}
+function canonicalizeRecallToken(token) {
+  const normalized = token.normalize("NFKC").toLocaleLowerCase();
+  if (normalized === "db" || normalized === "database" || normalized === "databases") {
+    return "db";
+  }
+  if (normalized === "resolve" || normalized === "resolves" || normalized === "resolved" || normalized === "resolving" || normalized === "resolution") {
+    return "resolve";
+  }
+  if (normalized === "branches") {
+    return "branch";
+  }
+  if (normalized === "prefix" || normalized === "prefixes") {
+    return "prefix";
+  }
+  if (normalized.endsWith("ies") && normalized.length > 4) {
+    return `${normalized.slice(0, -3)}y`;
+  }
+  if (normalized.endsWith("es") && normalized.length > 4) {
+    return normalized.slice(0, -2);
+  }
+  if (normalized.endsWith("s") && normalized.length > 3) {
+    return normalized.slice(0, -1);
+  }
+  return normalized;
+}
+function computeGroundingSupport(entry, groundingTokens) {
+  if (groundingTokens.length === 0) {
+    return {
+      phraseMatches: 0,
+      coverage: 0
+    };
+  }
+  const subjectTokens = tokenize(entry.subject).map(canonicalizeRecallToken);
+  const contentTokens = tokenize(entry.content).map(canonicalizeRecallToken);
+  const candidateTokens = /* @__PURE__ */ new Set([...subjectTokens, ...contentTokens]);
+  const matchedTokens = groundingTokens.filter((token) => candidateTokens.has(token));
+  return {
+    phraseMatches: countCanonicalPhraseMatches(groundingTokens, subjectTokens, contentTokens),
+    coverage: matchedTokens.length / groundingTokens.length
+  };
+}
+function countCanonicalPhraseMatches(queryTokens, subjectTokens, contentTokens) {
+  if (queryTokens.length < 2) {
+    return 0;
+  }
+  const matchedPhrases = /* @__PURE__ */ new Set();
+  for (let size = 2; size <= queryTokens.length; size += 1) {
+    for (let index = 0; index + size <= queryTokens.length; index += 1) {
+      const phraseTokens = queryTokens.slice(index, index + size);
+      if (hasCanonicalConsecutivePhrase(subjectTokens, phraseTokens) || hasCanonicalConsecutivePhrase(contentTokens, phraseTokens)) {
+        matchedPhrases.add(phraseTokens.join(" "));
+      }
+    }
+  }
+  return matchedPhrases.size;
+}
+function hasCanonicalConsecutivePhrase(haystack, needle) {
+  if (needle.length === 0 || haystack.length < needle.length) {
+    return false;
+  }
+  for (let index = 0; index + needle.length <= haystack.length; index += 1) {
+    let matches = true;
+    for (let offset = 0; offset < needle.length; offset += 1) {
+      if (haystack[index + offset] !== needle[offset]) {
+        matches = false;
+        break;
+      }
+    }
+    if (matches) {
+      return true;
+    }
+  }
+  return false;
+}
+function estimateTokens(entry) {
+  return (entry.subject.length + entry.content.length) / 4;
+}
+function parseAroundDate(value) {
+  return parseRelativeDate(value) ?? inferAroundDate(value);
+}
+function normalizeLimit(value) {
+  if (typeof value !== "number" || !Number.isFinite(value)) {
+    return 10;
+  }
+  return Math.max(0, Math.floor(value));
+}
+function normalizeThreshold(value) {
+  if (typeof value !== "number" || !Number.isFinite(value)) {
+    return 0;
+  }
+  return Math.min(1, Math.max(0, value));
+}
+function normalizeBudget(value) {
+  if (typeof value !== "number" || !Number.isFinite(value)) {
+    return null;
+  }
+  return Math.max(0, value);
+}
+function normalizeAroundRadius(value) {
+  if (typeof value !== "number" || !Number.isFinite(value) || value <= 0) {
+    return 14;
+  }
+  return value;
+}
+function elapsedMs2(startedAt) {
+  return Math.max(0, Date.now() - startedAt);
+}
+
+export {
+  recencyScore,
+  gaussianRecency,
+  importanceScore,
+  scoreCandidate,
+  cosineSimilarity,
+  normalizeClaimKeySegment,
+  normalizeClaimKey,
+  compactClaimKey,
+  validateExtractedClaimKey,
+  inspectClaimKey,
+  isTrustedClaimKeyForCleanup,
+  describeClaimKeyNormalizationFailure,
+  describeExtractedClaimKeyRejection,
+  describeClaimKeySuspicion,
+  tokenize,
+  buildLexicalPlan,
+  computeLexicalScore,
+  inferAroundDate,
+  parseRelativeDate,
+  resolveClaimSlotPolicy,
+  DEFAULT_CROSS_ENCODER_TOP_K,
+  DEFAULT_CROSS_ENCODER_ALPHA,
+  applyCrossEncoderRerank,
+  DEFAULT_RRF_RANK_CONSTANT,
+  rrfFuse,
+  rrfFuseVectorLexical,
+  DEFAULT_MMR_LAMBDA,
+  NEAR_DUPLICATE_SIMILARITY,
+  maximalMarginalRelevance,
+  DEFAULT_NEIGHBORHOOD_BUDGET,
+  DEFAULT_STRONG_SEED_TOP_N,
+  DEFAULT_STRONG_SEED_SCORE_GAP,
+  DEFAULT_SEEDED_RERANK_WEIGHT,
+  selectStrongSeeds,
+  seededRerank,
+  sharesEntryLineage,
+  sharesEpisodeLineage,
+  sharesProcedureLineage,
+  recall
+};