@agenr/agenr-plugin 1.7.4 → 1.8.1

package/dist/chunk-IZDGXMTQ.js

@@ -1,839 +0,0 @@
-import {
-  cosineSimilarity,
-  recall
-} from "./chunk-7WL5EAQZ.js";
-
-// src/core/episode/temporal-window.ts
-var DAY_IN_MILLISECONDS = 24 * 60 * 60 * 1e3;
-var DEFAULT_ANCHOR_RADIUS_DAYS = 3;
-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]
-]);
-var WEEKDAY_INDEX = /* @__PURE__ */ new Map([
-  ["sunday", 0],
-  ["monday", 1],
-  ["tuesday", 2],
-  ["wednesday", 3],
-  ["thursday", 4],
-  ["friday", 5],
-  ["saturday", 6]
-]);
-function parseTemporalWindow(text, now = /* @__PURE__ */ new Date()) {
-  const normalizedText = text.trim();
-  const referenceNow = asValidDate(now);
-  if (normalizedText.length === 0 || !referenceNow) {
-    return null;
-  }
-  const timezone = getSystemTimeZone();
-  const lower = normalizedText.toLowerCase();
-  if (/\btoday\b/.test(lower)) {
-    return buildResolvedWindow({
-      window: {
-        kind: "interval",
-        start: startOfDayLocal(referenceNow),
-        end: referenceNow,
-        source: "inferred"
-      },
-      resolvedFrom: "today",
-      timezone,
-      now: referenceNow
-    });
-  }
-  if (/\byesterday\b/.test(lower)) {
-    const target = addDaysLocal(referenceNow, -1);
-    return buildResolvedWindow({
-      window: {
-        kind: "interval",
-        start: startOfDayLocal(target),
-        end: endOfDayLocal(target),
-        source: "inferred"
-      },
-      resolvedFrom: "yesterday",
-      timezone,
-      now: referenceNow
-    });
-  }
-  const monthDayMatch = normalizedText.match(
-    /\b(?:on\s+)?((january|february|march|april|may|june|july|august|september|october|november|december)\s+(\d{1,2})(?:st|nd|rd|th)?)\b/i
-  );
-  if (monthDayMatch?.[1] && monthDayMatch[2] && monthDayMatch[3]) {
-    const targetDate = resolveMostRecentMonthDay(monthDayMatch[2].toLowerCase(), Number(monthDayMatch[3]), referenceNow);
-    if (targetDate) {
-      return buildResolvedWindow({
-        window: {
-          kind: "interval",
-          start: startOfDayLocal(targetDate),
-          end: endOfDayLocal(targetDate),
-          source: "inferred"
-        },
-        resolvedFrom: monthDayMatch[1],
-        timezone,
-        now: referenceNow
-      });
-    }
-  }
-  const weekdayMatch = normalizedText.match(/\b(last\s+(monday|tuesday|wednesday|thursday|friday|saturday|sunday))\b/i);
-  if (weekdayMatch?.[1] && weekdayMatch[2]) {
-    const targetDate = resolveLastWeekday(weekdayMatch[2].toLowerCase(), referenceNow);
-    if (targetDate) {
-      return buildResolvedWindow({
-        window: {
-          kind: "interval",
-          start: startOfDayLocal(targetDate),
-          end: endOfDayLocal(targetDate),
-          source: "inferred"
-        },
-        resolvedFrom: weekdayMatch[1],
-        timezone,
-        now: referenceNow
-      });
-    }
-  }
-  if (/\bthis week\b/.test(lower)) {
-    return buildResolvedWindow({
-      window: {
-        kind: "interval",
-        start: startOfWeekLocal(referenceNow),
-        end: referenceNow,
-        source: "inferred"
-      },
-      resolvedFrom: "this week",
-      timezone,
-      now: referenceNow
-    });
-  }
-  if (/\blast week\b/.test(lower)) {
-    const previousWeekDate = addDaysLocal(startOfWeekLocal(referenceNow), -1);
-    const start = startOfWeekLocal(previousWeekDate);
-    return buildResolvedWindow({
-      window: {
-        kind: "interval",
-        start,
-        end: endOfWeekLocal(previousWeekDate),
-        source: "inferred"
-      },
-      resolvedFrom: "last week",
-      timezone,
-      now: referenceNow
-    });
-  }
-  if (/\bthis month\b/.test(lower)) {
-    return buildResolvedWindow({
-      window: {
-        kind: "interval",
-        start: startOfMonthLocal(referenceNow),
-        end: referenceNow,
-        source: "inferred"
-      },
-      resolvedFrom: "this month",
-      timezone,
-      now: referenceNow
-    });
-  }
-  if (/\blast month\b/.test(lower)) {
-    const previousMonthDate = new Date(referenceNow.getFullYear(), referenceNow.getMonth() - 1, 1, 12);
-    return buildResolvedWindow({
-      window: {
-        kind: "interval",
-        start: startOfMonthLocal(previousMonthDate),
-        end: endOfMonthLocal(previousMonthDate),
-        source: "inferred"
-      },
-      resolvedFrom: "last month",
-      timezone,
-      now: referenceNow
-    });
-  }
-  const relativeMatch = lower.match(/\b(\d+)\s+(day|days|week|weeks|month|months)\s+ago\b/);
-  if (relativeMatch?.[1] && relativeMatch[2]) {
-    const amount = Number(relativeMatch[1]);
-    if (Number.isFinite(amount) && amount > 0) {
-      const unit = relativeMatch[2];
-      if (unit.startsWith("day")) {
-        const target = addDaysLocal(referenceNow, -amount);
-        return buildResolvedWindow({
-          window: {
-            kind: "interval",
-            start: startOfDayLocal(target),
-            end: endOfDayLocal(target),
-            source: "inferred"
-          },
-          resolvedFrom: relativeMatch[0],
-          timezone,
-          now: referenceNow
-        });
-      }
-      if (unit.startsWith("week")) {
-        return buildResolvedWindow({
-          window: {
-            kind: "anchor",
-            anchor: addDaysLocal(referenceNow, -amount * 7),
-            radiusDays: DEFAULT_ANCHOR_RADIUS_DAYS,
-            source: "inferred"
-          },
-          resolvedFrom: relativeMatch[0],
-          timezone,
-          now: referenceNow
-        });
-      }
-      if (unit.startsWith("month")) {
-        return buildResolvedWindow({
-          window: {
-            kind: "anchor",
-            anchor: subtractCalendarMonths(referenceNow, amount),
-            radiusDays: DEFAULT_ANCHOR_RADIUS_DAYS,
-            source: "inferred"
-          },
-          resolvedFrom: relativeMatch[0],
-          timezone,
-          now: referenceNow
-        });
-      }
-    }
-  }
-  const monthMatch = lower.match(/\bin\s+(january|february|march|april|may|june|july|august|september|october|november|december)\b/);
-  if (monthMatch?.[1]) {
-    const targetMonth = resolveMostRecentMonth(monthMatch[1], referenceNow);
-    if (targetMonth) {
-      return buildResolvedWindow({
-        window: {
-          kind: "interval",
-          start: startOfMonthLocal(targetMonth),
-          end: endOfMonthLocal(targetMonth),
-          source: "inferred"
-        },
-        resolvedFrom: monthMatch[0],
-        timezone,
-        now: referenceNow
-      });
-    }
-  }
-  const isoDateMatch = normalizedText.match(/\b(\d{4}-\d{2}-\d{2})(?:[tT][0-9:.+-Zz]+)?\b/);
-  if (isoDateMatch?.[1]) {
-    const targetDate = parseIsoDateLocal(isoDateMatch[1]);
-    if (targetDate) {
-      return buildResolvedWindow({
-        window: {
-          kind: "interval",
-          start: startOfDayLocal(targetDate),
-          end: endOfDayLocal(targetDate),
-          source: "inferred"
-        },
-        resolvedFrom: isoDateMatch[1],
-        timezone,
-        now: referenceNow
-      });
-    }
-  }
-  return null;
-}
-function resolveTemporalWindowBounds(window, now = /* @__PURE__ */ new Date()) {
-  switch (window.kind) {
-    case "interval":
-      return window.start && window.end ? { start: window.start, end: window.end } : null;
-    case "anchor":
-      if (!window.anchor || window.radiusDays === void 0 || window.radiusDays < 0) {
-        return null;
-      }
-      return {
-        start: new Date(window.anchor.getTime() - Math.trunc(window.radiusDays) * DAY_IN_MILLISECONDS),
-        end: new Date(window.anchor.getTime() + Math.trunc(window.radiusDays) * DAY_IN_MILLISECONDS)
-      };
-    case "open_end":
-      return window.start ? { start: window.start, end: asValidDate(now) ?? /* @__PURE__ */ new Date() } : null;
-    case "open_start":
-      return null;
-    default:
-      return null;
-  }
-}
-function getSystemTimeZone() {
-  return Intl.DateTimeFormat().resolvedOptions().timeZone || "UTC";
-}
-function buildResolvedWindow(params) {
-  const bounds = resolveTemporalWindowBounds(params.window, params.now);
-  if (!bounds) {
-    return null;
-  }
-  return {
-    window: params.window,
-    bounds,
-    timezone: params.timezone,
-    resolvedFrom: params.resolvedFrom
-  };
-}
-function asValidDate(value) {
-  const normalized = new Date(value.getTime());
-  return Number.isNaN(normalized.getTime()) ? null : normalized;
-}
-function addDaysLocal(date, days) {
-  return new Date(date.getFullYear(), date.getMonth(), date.getDate() + days, date.getHours(), date.getMinutes(), date.getSeconds(), date.getMilliseconds());
-}
-function startOfDayLocal(date) {
-  return new Date(date.getFullYear(), date.getMonth(), date.getDate(), 0, 0, 0, 0);
-}
-function endOfDayLocal(date) {
-  return new Date(date.getFullYear(), date.getMonth(), date.getDate(), 23, 59, 59, 999);
-}
-function startOfWeekLocal(date) {
-  const weekStart = resolveWeekStartDay();
-  const currentDay = date.getDay();
-  const offset = (currentDay - weekStart + 7) % 7;
-  return startOfDayLocal(addDaysLocal(date, -offset));
-}
-function endOfWeekLocal(date) {
-  return endOfDayLocal(addDaysLocal(startOfWeekLocal(date), 6));
-}
-function startOfMonthLocal(date) {
-  return new Date(date.getFullYear(), date.getMonth(), 1, 0, 0, 0, 0);
-}
-function endOfMonthLocal(date) {
-  return new Date(date.getFullYear(), date.getMonth() + 1, 0, 23, 59, 59, 999);
-}
-function resolveMostRecentMonth(monthName, now) {
-  const monthIndex = MONTH_INDEX.get(monthName);
-  if (monthIndex === void 0) {
-    return null;
-  }
-  const year = monthIndex <= now.getMonth() ? now.getFullYear() : now.getFullYear() - 1;
-  return new Date(year, monthIndex, 15, 12, 0, 0, 0);
-}
-function resolveMostRecentMonthDay(monthName, day, now) {
-  const monthIndex = MONTH_INDEX.get(monthName);
-  if (monthIndex === void 0) {
-    return null;
-  }
-  const currentYearCandidate = buildLocalDateAtNoon(now.getFullYear(), monthIndex, day);
-  if (!currentYearCandidate) {
-    return null;
-  }
-  if (startOfDayLocal(currentYearCandidate).getTime() <= startOfDayLocal(now).getTime()) {
-    return currentYearCandidate;
-  }
-  return buildLocalDateAtNoon(now.getFullYear() - 1, monthIndex, day);
-}
-function parseIsoDateLocal(value) {
-  const match = value.match(/^(\d{4})-(\d{2})-(\d{2})$/);
-  if (!match?.[1] || !match[2] || !match[3]) {
-    return null;
-  }
-  const year = Number(match[1]);
-  const month = Number(match[2]) - 1;
-  const day = Number(match[3]);
-  return buildLocalDateAtNoon(year, month, day);
-}
-function subtractCalendarMonths(date, months) {
-  const targetMonthIndex = date.getMonth() - months;
-  const targetYear = date.getFullYear() + Math.floor(targetMonthIndex / 12);
-  const normalizedMonth = (targetMonthIndex % 12 + 12) % 12;
-  const targetLastDay = new Date(targetYear, normalizedMonth + 1, 0).getDate();
-  const day = Math.min(date.getDate(), targetLastDay);
-  return new Date(targetYear, normalizedMonth, day, date.getHours(), date.getMinutes(), date.getSeconds(), date.getMilliseconds());
-}
-function resolveLastWeekday(weekdayName, now) {
-  const targetDay = WEEKDAY_INDEX.get(weekdayName);
-  if (targetDay === void 0) {
-    return null;
-  }
-  const today = startOfDayLocal(now);
-  const currentDay = today.getDay();
-  const daysBack = (currentDay - targetDay + 7) % 7 || 7;
-  return addDaysLocal(today, -daysBack);
-}
-function buildLocalDateAtNoon(year, month, day) {
-  const parsed = new Date(year, month, day, 12, 0, 0, 0);
-  if (parsed.getFullYear() !== year || parsed.getMonth() !== month || parsed.getDate() !== day) {
-    return null;
-  }
-  return parsed;
-}
-function resolveWeekStartDay() {
-  try {
-    const locale = Intl.DateTimeFormat().resolvedOptions().locale;
-    const info = new Intl.Locale(locale).weekInfo;
-    const firstDay = info?.firstDay;
-    if (typeof firstDay === "number" && firstDay >= 1 && firstDay <= 7) {
-      return firstDay % 7;
-    }
-  } catch {
-  }
-  return 1;
-}
-
-// src/core/episode/scoring.ts
-var DAY_IN_MILLISECONDS2 = 24 * 60 * 60 * 1e3;
-function scoreEpisodeMatch(episode, bounds, now = /* @__PURE__ */ new Date()) {
-  const episodeStart = parseEpisodeDate(episode.startedAt);
-  const episodeEnd = parseEpisodeDate(episode.endedAt ?? episode.startedAt);
-  const overlapQuality = computeOverlapQuality(episodeStart, episodeEnd, bounds.start, bounds.end);
-  const midpointProximity = computeMidpointProximity(episodeStart, episodeEnd, bounds.start, bounds.end);
-  const activity = activityScore(episode.activityLevel);
-  const recency = recencyScore(episodeEnd, now);
-  const finalScore = overlapQuality * 0.75 + midpointProximity * 0.2 + activity * 0.04 + recency * 0.01;
-  return {
-    result: {
-      episode,
-      score: Number(finalScore.toFixed(6)),
-      scores: {
-        temporal: Number(overlapQuality.toFixed(6)),
-        semantic: 0,
-        activity: Number(activity.toFixed(6)),
-        recency: Number(recency.toFixed(6))
-      }
-    },
-    explanation: {
-      overlapQuality: Number(overlapQuality.toFixed(6)),
-      midpointProximity: Number(midpointProximity.toFixed(6)),
-      activity: Number(activity.toFixed(6)),
-      recency: Number(recency.toFixed(6))
-    }
-  };
-}
-function compareEpisodeMatches(left, right) {
-  return compareDescending(left.explanation.overlapQuality, right.explanation.overlapQuality) || compareDescending(left.explanation.midpointProximity, right.explanation.midpointProximity) || compareDescending(left.explanation.activity, right.explanation.activity) || compareDescending(left.explanation.recency, right.explanation.recency) || compareDescending(left.result.score, right.result.score) || compareAscending(left.result.episode.startedAt, right.result.episode.startedAt) || compareAscending(left.result.episode.id, right.result.episode.id);
-}
-function computeOverlapQuality(episodeStart, episodeEnd, queryStart, queryEnd) {
-  const overlapStart = Math.max(episodeStart.getTime(), queryStart.getTime());
-  const overlapEnd = Math.min(episodeEnd.getTime(), queryEnd.getTime());
-  const overlapMs = Math.max(0, overlapEnd - overlapStart);
-  if (overlapMs <= 0) {
-    return 0;
-  }
-  const queryDurationMs = Math.max(1, queryEnd.getTime() - queryStart.getTime());
-  const episodeDurationMs = Math.max(1, episodeEnd.getTime() - episodeStart.getTime());
-  const coverage = overlapMs / queryDurationMs;
-  const precision = overlapMs / episodeDurationMs;
-  if (coverage <= 0 || precision <= 0) {
-    return 0;
-  }
-  const beta = 0.5;
-  const betaSquared = beta * beta;
-  return (1 + betaSquared) * precision * coverage / (betaSquared * precision + coverage);
-}
-function computeMidpointProximity(episodeStart, episodeEnd, queryStart, queryEnd) {
-  const episodeMidpoint = (episodeStart.getTime() + episodeEnd.getTime()) / 2;
-  const queryMidpoint = (queryStart.getTime() + queryEnd.getTime()) / 2;
-  const queryDurationMs = Math.max(1, queryEnd.getTime() - queryStart.getTime());
-  const distanceMs = Math.abs(episodeMidpoint - queryMidpoint);
-  return 1 / (1 + distanceMs / queryDurationMs);
-}
-function activityScore(value) {
-  switch (value) {
-    case "substantial":
-      return 1;
-    case "minimal":
-      return 0.5;
-    case "none":
-      return 0;
-    default:
-      return 0.25;
-  }
-}
-function recencyScore(episodeEnd, now) {
-  const ageMs = Math.max(0, now.getTime() - episodeEnd.getTime());
-  const ageDays = ageMs / DAY_IN_MILLISECONDS2;
-  return 1 / (1 + ageDays / 90);
-}
-function parseEpisodeDate(value) {
-  const parsed = new Date(value);
-  if (Number.isNaN(parsed.getTime())) {
-    throw new Error(`Episode timestamp is invalid: ${value}`);
-  }
-  return parsed;
-}
-function compareDescending(left, right) {
-  if (left === right) {
-    return 0;
-  }
-  return right > left ? 1 : -1;
-}
-function compareAscending(left, right) {
-  return left.localeCompare(right);
-}
-
-// src/core/episode/search.ts
-var DEFAULT_LIMIT = 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);
-  if (limit === 0) {
-    return [];
-  }
-  const normalizedEmbedding = normalizeEmbedding(query.embedding);
-  const bounds = query.timeWindow ? resolveTemporalWindowBounds(query.timeWindow, now) : null;
-  const hasTemporal = bounds !== null;
-  const hasSemantic = normalizedEmbedding.length > 0;
-  if (!hasTemporal && !hasSemantic) {
-    return [];
-  }
-  if (hasTemporal && !hasSemantic) {
-    const candidates2 = await database.listEpisodesByTimeWindow(query.timeWindow, computeCandidateLimit(limit));
-    return candidates2.map((episode) => scoreEpisodeMatch(episode, bounds, now)).sort(compareEpisodeMatches).slice(0, limit).map((match) => match.result);
-  }
-  if (!hasTemporal) {
-    const matches = await database.episodeVectorSearch({
-      embedding: normalizedEmbedding,
-      limit
-    });
-    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);
-}
-function normalizeLimit(value) {
-  if (value === void 0) {
-    return DEFAULT_LIMIT;
-  }
-  if (!Number.isFinite(value)) {
-    return DEFAULT_LIMIT;
-  }
-  return Math.max(0, Math.trunc(value));
-}
-function computeCandidateLimit(limit) {
-  return Math.min(Math.max(limit * CANDIDATE_MULTIPLIER, MIN_CANDIDATE_LIMIT), MAX_CANDIDATE_LIMIT);
-}
-function normalizeEmbedding(embedding) {
-  if (!embedding || embedding.length === 0) {
-    return [];
-  }
-  return embedding.map((value) => Number.isFinite(value) ? value : 0);
-}
-function buildSemanticResult(episode, semantic, now) {
-  const parsedEpisodeEnd = new Date(episode.endedAt ?? episode.startedAt);
-  const episodeEnd = Number.isNaN(parsedEpisodeEnd.getTime()) ? now : parsedEpisodeEnd;
-  const activity = activityScore(episode.activityLevel);
-  const recency = recencyScore(episodeEnd, now);
-  const normalizedSemantic = Number(semantic.toFixed(6));
-  return {
-    episode,
-    score: normalizedSemantic,
-    scores: {
-      temporal: 0,
-      semantic: normalizedSemantic,
-      activity: Number(activity.toFixed(6)),
-      recency: Number(recency.toFixed(6))
-    }
-  };
-}
-function buildHybridResult(episode, queryEmbedding, bounds, now) {
-  const temporalMatch = scoreEpisodeMatch(episode, bounds, now);
-  const semantic = Number(cosineSimilarity(queryEmbedding, episode.embedding ?? []).toFixed(6));
-  return {
-    episode,
-    score: semantic,
-    scores: {
-      temporal: temporalMatch.result.scores.temporal,
-      semantic,
-      activity: temporalMatch.result.scores.activity,
-      recency: temporalMatch.result.scores.recency
-    }
-  };
-}
-function compareSemanticEpisodeResults(left, right) {
-  return 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) || compareDescending2(left.score, right.score) || compareAscending2(left.episode.startedAt, right.episode.startedAt) || compareAscending2(left.episode.id, right.episode.id);
-}
-function compareDescending2(left, right) {
-  if (left === right) {
-    return 0;
-  }
-  return right > left ? 1 : -1;
-}
-function compareAscending2(left, right) {
-  return left.localeCompare(right);
-}
-
-// src/app/recall/unified.ts
-var EPISODE_FRESHNESS_NOTICE = "Episodes cover consolidated prior sessions only; the most recent completed session may not appear yet.";
-var EPISODE_SEMANTIC_FALLBACK_NOTICE = "Semantic episode search unavailable - showing temporal results only.";
-var EPISODE_SEMANTIC_UNAVAILABLE_NOTICE = "Semantic episode search unavailable - no semantic episode results could be returned.";
-var ENTRY_FILTER_NOTICE = "Threshold, type filters, and tag filters were applied to entries only.";
-var HISTORICAL_STATE_PATTERNS = [
-  "what was the previous",
-  "what was the earlier",
-  "what did we use before",
-  "what was the old",
-  "what changed",
-  "changed from",
-  "replaced by",
-  "before we switched",
-  "before we migrated",
-  "previous approach",
-  "earlier plan",
-  "old workflow"
-];
-var HISTORICAL_STATE_REGEX_PATTERNS = [
-  /\bwhat\b.*\bused?\b.*\bbefore\b/u,
-  /\bwhat\b.*\bworkflow\b.*\bbefore\b/u,
-  /\bwhat\b.*\bplan\b.*\bearlier\b/u,
-  /\bwhat\b.*\bplan\b.*\bbefore\b/u
-];
-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 historicalStatePattern = detectHistoricalStatePattern(input.text);
-  if (historicalStatePattern) {
-    deps.debugLog?.(`[agenr] unified recall matched historical-state pattern=${JSON.stringify(historicalStatePattern)} query=${JSON.stringify(input.text)}`);
-  }
-  const routing = routeRecall({
-    requested,
-    text: input.text,
-    parsedTimeWindow: parsedTimeWindow !== null,
-    hasEntryFilters
-  });
-  const notices = [];
-  const episodePlan = routing.queried.includes("episodes") ? await buildEpisodeQueryPlan({
-    text: input.text,
-    limit: input.limit,
-    requested,
-    detectedIntent: routing.detectedIntent,
-    parsedTimeWindow,
-    topicAnchor,
-    embedQuery: deps.embedQuery
-  }) : {
-    notices: []
-  };
-  const episodes = routing.queried.includes("episodes") && episodePlan.query ? await searchEpisodes(episodePlan.query, deps.database, now) : [];
-  if (routing.queried.includes("episodes")) {
-    notices.push(EPISODE_FRESHNESS_NOTICE);
-    notices.push(...episodePlan.notices);
-  }
-  if (routing.queried.includes("episodes") && hasEntryScopedFilters(input)) {
-    notices.push(ENTRY_FILTER_NOTICE);
-  }
-  const entries = await maybeRunEntryRecall({
-    input,
-    deps,
-    parsedTimeWindow,
-    routing
-  });
-  if (routing.queried.includes("entries") && entries.kind === "skipped") {
-    notices.push(entries.notice);
-  }
-  return {
-    routing,
-    ...parsedTimeWindow ? {
-      parsedTimeWindow,
-      timeWindow: {
-        start: parsedTimeWindow.bounds.start.toISOString(),
-        end: parsedTimeWindow.bounds.end.toISOString(),
-        timezone: parsedTimeWindow.timezone,
-        resolvedFrom: parsedTimeWindow.resolvedFrom
-      }
-    } : {},
-    episodes,
-    entries: entries.kind === "results" ? entries.results : [],
-    notices: dedupePreservingOrder(notices),
-    count: episodes.length + (entries.kind === "results" ? entries.results.length : 0)
-  };
-}
-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 historicalState = detectHistoricalStatePattern(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",
-      queried: ["entries"],
-      reason: "Explicit mode=entries override."
-    };
-  }
-  if (params.requested === "episodes") {
-    return {
-      requested: params.requested,
-      detectedIntent: historicalState ? "historical_state" : params.parsedTimeWindow ? "temporal_narrative" : "mixed",
-      queried: ["episodes"],
-      reason: params.parsedTimeWindow ? "Explicit mode=episodes override with a resolved time window." : "Explicit mode=episodes override without a resolved time window."
-    };
-  }
-  if (historicalState) {
-    return {
-      requested: params.requested,
-      detectedIntent: "historical_state",
-      queried: ["entries", "episodes"],
-      reason: params.parsedTimeWindow ? "The query asks about a previous state or transition and includes a supported time expression, so both entries and episodes were queried." : "The query asks about a previous state or transition, so both entries and episodes were queried."
-    };
-  }
-  if (factual && params.parsedTimeWindow) {
-    return {
-      requested: params.requested,
-      detectedIntent: "mixed",
-      queried: ["entries", "episodes"],
-      reason: "The query combines a factual phrase with a supported time expression, so both entries and episodes were queried."
-    };
-  }
-  if (factual) {
-    return {
-      requested: params.requested,
-      detectedIntent: "factual",
-      queried: ["entries"],
-      reason: "The query looks like an exact fact lookup, so entry recall was used."
-    };
-  }
-  if (params.parsedTimeWindow && narrative && topicAnchor) {
-    return {
-      requested: params.requested,
-      detectedIntent: "mixed",
-      queried: ["episodes", "entries"],
-      reason: "The query combines narrative time-based recall with a topic anchor, so both episodes and entries were queried."
-    };
-  }
-  if (params.parsedTimeWindow && narrative) {
-    return {
-      requested: params.requested,
-      detectedIntent: "temporal_narrative",
-      queried: ["episodes"],
-      reason: "The query asks for what happened during a time period, so episode recall was used first."
-    };
-  }
-  if (params.parsedTimeWindow && topicAnchor) {
-    return {
-      requested: params.requested,
-      detectedIntent: "mixed",
-      queried: ["episodes", "entries"],
-      reason: "The query contains both a supported time expression and a topic anchor, so both episodes and entries were queried."
-    };
-  }
-  return {
-    requested: params.requested,
-    detectedIntent: "factual",
-    queried: ["entries"],
-    reason: params.parsedTimeWindow ? "The query did not clearly ask for narrative recall, so entry recall was used." : "No supported episode time window was detected, so entry recall was used."
-  };
-}
-async function buildEpisodeQueryPlan(params) {
-  const notices = [];
-  const shouldUseSemantic = params.detectedIntent === "historical_state" || (params.parsedTimeWindow ? params.topicAnchor : params.requested === "episodes");
-  let embedding;
-  if (shouldUseSemantic) {
-    embedding = await maybeEmbedEpisodeQuery(params.text, params.embedQuery);
-    if (!embedding) {
-      notices.push(params.parsedTimeWindow ? EPISODE_SEMANTIC_FALLBACK_NOTICE : EPISODE_SEMANTIC_UNAVAILABLE_NOTICE);
-    }
-  }
-  if (!params.parsedTimeWindow && !embedding) {
-    return {
-      notices
-    };
-  }
-  return {
-    query: {
-      text: params.text,
-      ...params.limit !== void 0 ? { limit: params.limit } : {},
-      ...params.parsedTimeWindow ? { timeWindow: params.parsedTimeWindow.window } : {},
-      ...embedding ? { embedding } : {}
-    },
-    notices
-  };
-}
-async function maybeRunEntryRecall(params) {
-  if (!params.routing.queried.includes("entries")) {
-    return {
-      kind: "results",
-      results: []
-    };
-  }
-  if (!params.deps.embeddingAvailable) {
-    const message = params.deps.embeddingError ?? "Embeddings are unavailable, so entry recall could not run.";
-    if (params.routing.requested === "entries") {
-      throw new Error(message);
-    }
-    return {
-      kind: "skipped",
-      notice: `${message} Entry recall was skipped.`
-    };
-  }
-  return {
-    kind: "results",
-    results: await recall(buildEntryRecallInput(params.input, params.parsedTimeWindow, params.routing), params.deps.recall, params.deps.recallOptions)
-  };
-}
-function buildEntryRecallInput(input, parsedTimeWindow, routing) {
-  const request = {
-    text: input.text,
-    ...input.limit !== void 0 ? { limit: input.limit } : {},
-    ...input.threshold !== void 0 ? { threshold: input.threshold } : {},
-    ...input.types && input.types.length > 0 ? { types: input.types } : {},
-    ...input.tags && input.tags.length > 0 ? { tags: input.tags } : {},
-    ...input.sessionKey ? { sessionKey: input.sessionKey } : {},
-    ...routing.detectedIntent === "historical_state" ? { rankingProfile: "historical_state" } : {}
-  };
-  if (!parsedTimeWindow) {
-    return request;
-  }
-  const start = parsedTimeWindow.bounds.start;
-  const end = parsedTimeWindow.bounds.end;
-  const midpoint = new Date((start.getTime() + end.getTime()) / 2);
-  const radiusDays = Math.max(1, Math.ceil((end.getTime() - start.getTime()) / 2 / (24 * 60 * 60 * 1e3)));
-  return {
-    ...request,
-    since: start.toISOString(),
-    until: end.toISOString(),
-    around: midpoint.toISOString(),
-    aroundRadius: radiusDays
-  };
-}
-function detectHistoricalStatePattern(text) {
-  const lower = text.trim().toLowerCase();
-  const explicitPattern = HISTORICAL_STATE_PATTERNS.find((pattern) => lower.includes(pattern));
-  if (explicitPattern) {
-    return explicitPattern;
-  }
-  const regexPattern = HISTORICAL_STATE_REGEX_PATTERNS.find((pattern) => pattern.test(lower));
-  return regexPattern?.source;
-}
-function normalizeMode(value) {
-  return value === "entries" || value === "episodes" ? value : "auto";
-}
-function hasEntryScopedFilters(input) {
-  return Boolean(input.threshold !== void 0 || (input.types?.length ?? 0) > 0 || (input.tags?.length ?? 0) > 0);
-}
-function hasTopicAnchor(text, hasEntryFilters) {
-  const lower = text.trim().toLowerCase();
-  return hasEntryFilters || /\b(about|regarding|with)\b/.test(lower) || /\bon\s+[a-z][a-z0-9_-]{1,}\b/.test(lower);
-}
-async function maybeEmbedEpisodeQuery(text, embedQuery) {
-  if (!embedQuery) {
-    return void 0;
-  }
-  try {
-    const embedding = await embedQuery(text);
-    return embedding.length > 0 ? embedding : void 0;
-  } catch {
-    return void 0;
-  }
-}
-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;
-}
-
-export {
-  runUnifiedRecall
-};