@agenr/openclaw-plugin 1.2.0 → 1.3.0

package/dist/index.js

@@ -635,6 +635,793 @@ function elapsedMs(startedAt) {
   return Math.max(0, Date.now() - startedAt);
 }
 
+// ../../src/core/episode/temporal-window.ts
+var DAY_IN_MILLISECONDS3 = 24 * 60 * 60 * 1e3;
+var DEFAULT_ANCHOR_RADIUS_DAYS = 3;
+var MONTH_INDEX2 = /* @__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 = asValidDate3(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_MILLISECONDS3),
+        end: new Date(window.anchor.getTime() + Math.trunc(window.radiusDays) * DAY_IN_MILLISECONDS3)
+      };
+    case "open_end":
+      return window.start ? { start: window.start, end: asValidDate3(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 asValidDate3(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_INDEX2.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_INDEX2.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_MILLISECONDS4 = 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 = recencyScore2(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 recencyScore2(episodeEnd, now) {
+  const ageMs = Math.max(0, now.getTime() - episodeEnd.getTime());
+  const ageDays = ageMs / DAY_IN_MILLISECONDS4;
+  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 = normalizeLimit2(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 normalizeLimit2(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 = recencyScore2(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.";
+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 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,
+    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 topicAnchor = hasTopicAnchor(params.text, params.hasEntryFilters);
+  if (params.requested === "entries") {
+    return {
+      requested: params.requested,
+      detectedIntent: factual ? "factual" : params.parsedTimeWindow ? "mixed" : "factual",
+      queried: ["entries"],
+      reason: "Explicit mode=entries override."
+    };
+  }
+  if (params.requested === "episodes") {
+    return {
+      requested: params.requested,
+      detectedIntent: 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 (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.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.deps.recall)
+  };
+}
+function buildEntryRecallInput(input, parsedTimeWindow) {
+  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 } : {}
+  };
+  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 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;
+}
+
 // ../../src/core/store/pipeline.ts
 import { randomUUID } from "crypto";
 
@@ -656,8 +1443,9 @@ function computeNormContentHash(content) {
 }
 
 // ../../src/core/types.ts
-var ENTRY_TYPES = ["fact", "decision", "preference", "lesson", "todo", "relationship", "event", "reflection"];
+var ENTRY_TYPES = ["fact", "decision", "preference", "lesson", "relationship", "milestone"];
 var EXPIRY_LEVELS = ["core", "permanent", "temporary"];
+var EPISODE_ACTIVITY_LEVELS = ["substantial", "minimal", "none"];
 
 // ../../src/core/store/validation.ts
 function validateEntriesWithIndexes(inputs) {
@@ -708,6 +1496,8 @@ function validateEntriesWithIndexes(inputs) {
         tags: normalizeTags(input.tags),
         source_file: normalizeOptionalString(input.source_file),
         source_context: normalizeOptionalString(input.source_context),
+        user_id: normalizeOptionalString(input.user_id),
+        project: normalizeOptionalString(input.project),
         created_at: normalizeOptionalString(input.created_at)
       }
     });
@@ -837,6 +1627,8 @@ function buildEntry(preparedEntry, embedding) {
     tags: preparedEntry.input.tags ?? [],
     source_file: preparedEntry.input.source_file,
     source_context: preparedEntry.input.source_context,
+    user_id: preparedEntry.input.user_id,
+    project: preparedEntry.input.project,
     embedding,
     content_hash: preparedEntry.contentHash,
     norm_content_hash: preparedEntry.normContentHash,
@@ -914,12 +1706,19 @@ function sortStoreDetails(details) {
 // ../../src/adapters/db/row-mapping.ts
 var DEFAULT_QUALITY_SCORE = 0.5;
 var ACTIVE_ENTRY_CLAUSE = "retired = 0 AND superseded_by IS NULL";
+var ACTIVE_EPISODE_CLAUSE = "retired = 0 AND superseded_by IS NULL";
 function buildActiveEntryClause(alias) {
   if (!alias) {
     return ACTIVE_ENTRY_CLAUSE;
   }
   return `${alias}.retired = 0 AND ${alias}.superseded_by IS NULL`;
 }
+function buildActiveEpisodeClause(alias) {
+  if (!alias) {
+    return ACTIVE_EPISODE_CLAUSE;
+  }
+  return `${alias}.retired = 0 AND ${alias}.superseded_by IS NULL`;
+}
 function serializeEmbeddingForVector(embedding) {
   if (embedding.length === 0) {
     return null;
@@ -1017,6 +1816,8 @@ function mapEntryRow(row) {
     last_recalled_at: readOptionalString(row, "last_recalled_at"),
     superseded_by: readOptionalString(row, "superseded_by"),
     cluster_id: readOptionalString(row, "cluster_id"),
+    user_id: readOptionalString(row, "user_id"),
+    project: readOptionalString(row, "project"),
     retired: readBoolean(row, "retired"),
     retired_at: readOptionalString(row, "retired_at"),
     retired_reason: readOptionalString(row, "retired_reason"),
@@ -1024,6 +1825,43 @@ function mapEntryRow(row) {
     updated_at: readRequiredString(row, "updated_at")
   };
 }
+function mapEpisodeRow(row) {
+  const source = readRequiredString(row, "source");
+  const activityLevel = readOptionalString(row, "activity_level");
+  return {
+    id: readRequiredString(row, "id"),
+    source,
+    sourceId: readOptionalString(row, "source_id"),
+    sourceRef: readOptionalString(row, "source_ref"),
+    transcriptHash: readOptionalString(row, "transcript_hash"),
+    summaryHash: readOptionalString(row, "summary_hash"),
+    agentId: readOptionalString(row, "agent_id"),
+    surface: readOptionalString(row, "surface"),
+    startedAt: readRequiredString(row, "started_at"),
+    endedAt: readOptionalString(row, "ended_at"),
+    summary: readRequiredString(row, "summary"),
+    tags: deserializeTags(row.tags),
+    activityLevel,
+    userId: readOptionalString(row, "user_id"),
+    project: readOptionalString(row, "project"),
+    genModel: readOptionalString(row, "gen_model"),
+    genVersion: readOptionalString(row, "gen_version"),
+    messageCount: readOptionalNumber(row, "message_count"),
+    embedding: readEmbedding(row, "embedding"),
+    retired: readBoolean(row, "retired"),
+    retiredAt: readOptionalString(row, "retired_at"),
+    retiredReason: readOptionalString(row, "retired_reason"),
+    supersededBy: readOptionalString(row, "superseded_by"),
+    createdAt: readRequiredString(row, "created_at"),
+    updatedAt: readRequiredString(row, "updated_at")
+  };
+}
+function readOptionalNumber(row, key) {
+  if (row[key] === null || row[key] === void 0) {
+    return void 0;
+  }
+  return readNumber(row, key, 0);
+}
 
 // ../../src/adapters/db/openclaw-plugin-queries.ts
 var ENTRY_SELECT_COLUMNS = `
@@ -1044,6 +1882,8 @@ var ENTRY_SELECT_COLUMNS = `
   last_recalled_at,
   superseded_by,
   cluster_id,
+  user_id,
+  project,
   retired,
   retired_at,
   retired_reason,
@@ -1201,11 +2041,12 @@ async function listRecallEvents(executor, entryId) {
 }
 
 // ../../src/adapters/openclaw/tools.ts
-var ENTRY_TYPE_DESCRIPTION = "Knowledge type to store. Use decision for rules or architecture, preference for user choices, lesson for learned guidance, fact for durable state, todo for important follow-up, reflection for synthesized summaries, and event or relationship only when that context will matter later.";
+var ENTRY_TYPE_DESCRIPTION = "Knowledge type to store. Use fact for durable information about people, places, systems, or how things work. Use decision for standing rules, constraints, or chosen approaches. Use preference for stated wants, values, or opinions. Use lesson for non-obvious insights learned from specific experience. Use milestone for notable one-time events worth remembering (a move, a launch, a life change, a hire, a trip). Use relationship for meaningful connections between people, groups, or systems.";
 var EXPIRY_DESCRIPTION = "Lifetime bucket: core (always injected at session start, use sparingly), permanent (durable and recalled on demand), or temporary (short-horizon).";
 var UPDATE_EXPIRY_DESCRIPTION = `${EXPIRY_DESCRIPTION} Accepted values: ${EXPIRY_LEVELS.join(", ")}.`;
 var DEFAULT_RECALL_LIMIT = 10;
 var RESULT_SUBJECT_LOG_LIMIT = 5;
+var RECALL_MODES = ["auto", "entries", "episodes"];
 var STORE_TOOL_PARAMETERS = {
   type: "object",
   additionalProperties: false,
@@ -1254,6 +2095,11 @@ var RECALL_TOOL_PARAMETERS = {
       type: "string",
       description: "What you need to remember. Use a focused natural-language query rather than a broad 'everything' search."
     },
+    mode: {
+      type: "string",
+      enum: [...RECALL_MODES],
+      description: "Recall mode: auto routes between entries and episodes, entries forces semantic recall, and episodes forces temporal session recall."
+    },
     limit: {
       type: "integer",
       minimum: 1,
@@ -1272,29 +2118,12 @@ var RECALL_TOOL_PARAMETERS = {
         type: "string",
         enum: [...ENTRY_TYPES]
       },
-      description: "Optional knowledge types to filter by, such as decision, preference, lesson, fact, or todo."
+      description: "Optional knowledge types to filter by, such as decision, preference, lesson, fact, milestone, or relationship."
     },
     tags: {
       type: "array",
       items: { type: "string" },
       description: "Optional tags to filter by once you already know the relevant entity, system, or theme."
-    },
-    since: {
-      type: "string",
-      description: "Only consider entries created on or after this time bound. Accepts ISO dates or relative dates such as 30d. Relative dates count backward from now: 7d means 7 days ago, 30d means 30 days ago."
-    },
-    until: {
-      type: "string",
-      description: "Only consider entries created on or before this time bound. Accepts ISO dates or relative dates such as 7d. Relative dates count backward from now: 7d means 7 days ago, 30d means 30 days ago."
-    },
-    around: {
-      type: "string",
-      description: "Bias ranking toward a specific date or period, such as 7d for one week ago or 2026-03-15 for a specific date. This is a temporal anchor, not a hard filter."
-    },
-    aroundRadius: {
-      type: "integer",
-      minimum: 1,
-      description: "Radius in days for around, e.g. 3 for a +/-3 day window around the anchor. Smaller values focus recall more tightly on that period."
     }
   },
   required: ["query"]
@@ -1445,32 +2274,25 @@ function createAgenrRecallTool(ctx, servicesPromise, logger) {
   return {
     name: "agenr_recall",
     label: "Agenr Recall",
-    description: "Retrieve knowledge from agenr long-term memory. Supports semantic search via query and temporal filtering via since, until, around, and aroundRadius; for time-based questions, always combine a focused query with temporal filters. Use this mid-session when you need context you do not already have. Session-start recall is already handled automatically.",
+    description: "Retrieve knowledge from agenr long-term memory. Use mode=auto for the normal path, mode=entries for exact facts and decisions, and mode=episodes for time-bounded 'what happened' questions. Time periods are parsed from the query text. Session-start recall is already handled automatically.",
     parameters: RECALL_TOOL_PARAMETERS,
     async execute(_toolCallId, rawParams) {
       try {
         const params = asRecord(rawParams);
         const query = readStringParam(params, "query", { required: true, label: "query" });
+        const mode = parseRecallMode(readStringParam(params, "mode"));
         const limit = readNumberParam(params, "limit", { integer: true, strict: true });
         const threshold = readNumberParam(params, "threshold", { strict: true });
-        const project = typeof params.project === "string" && params.project.trim().length > 0 ? params.project.trim() : void 0;
         const services = await servicesPromise;
         const types = parseEntryTypes(readStringArrayParam(params, "types"));
         const tags = normalizeStringArray(readStringArrayParam(params, "tags"));
-        const since = readStringParam(params, "since");
-        const until = readStringParam(params, "until");
-        const around = readStringParam(params, "around");
-        const aroundRadius = readNumberParam(params, "aroundRadius", { integer: true, strict: true });
         const request = {
           text: query,
+          ...mode ? { mode } : {},
           ...limit !== void 0 ? { limit } : {},
           ...threshold !== void 0 ? { threshold } : {},
           ...types.length > 0 ? { types } : {},
           ...tags.length > 0 ? { tags } : {},
-          ...since ? { since } : {},
-          ...until ? { until } : {},
-          ...around ? { around } : {},
-          ...aroundRadius !== void 0 ? { aroundRadius } : {},
           sessionKey: ctx.sessionKey
         };
         logToolCall(
@@ -1479,57 +2301,64 @@ function createAgenrRecallTool(ctx, servicesPromise, logger) {
           ctx,
           formatRecallToolSummary({
             query,
+            mode,
             limit,
             types,
-            tags,
-            since,
-            until,
-            around,
-            aroundRadius,
-            project
+            tags
           }),
           sanitizeRecallToolParams({
             query,
+            mode,
             limit,
             threshold,
             types,
-            tags,
-            since,
-            until,
-            around,
-            aroundRadius,
-            project
+            tags
           })
         );
-        if (!services.embeddingStatus.available) {
-          const message = services.embeddingStatus.error ?? "Embeddings are unavailable, so agenr recall cannot run.";
-          logToolFailure(logger, "agenr_recall", ctx, message);
-          return failedTextResult(message, {
-            status: "failed"
-          });
-        }
-        const results = await recall(request, services.recall);
-        logger.info(`[agenr] tool=agenr_recall ${formatToolSessionContext(ctx)} result: ${results.length} entries${formatRecallResultSubjects(results)}`);
-        if (results.length === 0) {
-          return textResult("No matching agenr memories found.", {
-            status: "ok",
-            count: 0,
-            results: []
-          });
-        }
-        return textResult(formatRecallResults(results), {
+        const result = await runUnifiedRecall(request, {
+          database: services.database,
+          recall: services.recall,
+          embeddingAvailable: services.embeddingStatus.available,
+          embeddingError: services.embeddingStatus.error,
+          embedQuery: services.embeddingStatus.available ? async (text) => {
+            const vectors = await services.embedding.embed([text]);
+            return vectors[0] ?? [];
+          } : void 0
+        });
+        logger.info(`[agenr] tool=agenr_recall ${formatToolSessionContext(ctx)} result: ${formatUnifiedRecallLogSummary(result)}`);
+        return textResult(formatUnifiedRecallResults(result), {
           status: "ok",
-          count: results.length,
-          results: results.map((result) => ({
-            id: result.entry.id,
-            subject: result.entry.subject,
-            type: result.entry.type,
-            expiry: result.entry.expiry,
-            importance: result.entry.importance,
-            score: result.score,
-            tags: result.entry.tags,
-            content: result.entry.content
-          }))
+          count: result.count,
+          routing: {
+            requested: result.routing.requested,
+            detectedIntent: result.routing.detectedIntent,
+            queried: result.routing.queried,
+            reason: result.routing.reason
+          },
+          ...result.timeWindow ? { timeWindow: result.timeWindow } : {},
+          episodes: result.episodes.map((episode) => ({
+            id: episode.episode.id,
+            source: episode.episode.source,
+            sourceId: episode.episode.sourceId,
+            startedAt: episode.episode.startedAt,
+            endedAt: episode.episode.endedAt,
+            tags: episode.episode.tags,
+            score: episode.score,
+            activityLevel: episode.episode.activityLevel,
+            summary: episode.episode.summary,
+            whyMatched: describeEpisodeMatch(episode)
+          })),
+          entries: result.entries.map((entry) => ({
+            id: entry.entry.id,
+            subject: entry.entry.subject,
+            type: entry.entry.type,
+            expiry: entry.entry.expiry,
+            importance: entry.entry.importance,
+            score: entry.score,
+            tags: entry.entry.tags,
+            content: entry.entry.content
+          })),
+          notices: result.notices
         });
       } catch (error) {
         logToolFailure(logger, "agenr_recall", ctx, error);
@@ -1704,6 +2533,15 @@ function readBooleanParam(params, key) {
 function parseEntryTypes(values) {
   return normalizeStringArray(values).map((value) => parseEntryType(value));
 }
+function parseRecallMode(value) {
+  if (value === void 0) {
+    return void 0;
+  }
+  if (value === "auto" || value === "entries" || value === "episodes") {
+    return value;
+  }
+  throw new Error(`Unsupported recall mode "${value}".`);
+}
 function parseEntryType(value) {
   if (ENTRY_TYPES.includes(value)) {
     return value;
@@ -1775,20 +2613,8 @@ function sanitizeStoreToolParams(params) {
 }
 function formatRecallToolSummary(params) {
   const parts = [`query=${JSON.stringify(truncate(params.query, 80))}`];
-  if (params.since) {
-    parts.push(`since=${params.since}`);
-  }
-  if (params.until) {
-    parts.push(`until=${params.until}`);
-  }
-  if (params.around) {
-    parts.push(`around=${params.around}`);
-  }
-  if (params.aroundRadius !== void 0) {
-    parts.push(`radius=${params.aroundRadius}`);
-  }
-  if (params.project) {
-    parts.push(`project=${JSON.stringify(params.project)}`);
+  if (params.mode) {
+    parts.push(`mode=${params.mode}`);
   }
   if (params.limit !== void 0 && params.limit !== DEFAULT_RECALL_LIMIT) {
     parts.push(`limit=${params.limit}`);
@@ -1804,15 +2630,11 @@ function formatRecallToolSummary(params) {
 function sanitizeRecallToolParams(params) {
   return {
     query: params.query,
+    ...params.mode ? { mode: params.mode } : {},
     ...params.limit !== void 0 ? { limit: params.limit } : {},
     ...params.threshold !== void 0 ? { threshold: params.threshold } : {},
     ...params.types.length > 0 ? { types: params.types } : {},
-    ...params.tags.length > 0 ? { tags: params.tags } : {},
-    ...params.since ? { since: params.since } : {},
-    ...params.until ? { until: params.until } : {},
-    ...params.around ? { around: params.around } : {},
-    ...params.aroundRadius !== void 0 ? { aroundRadius: params.aroundRadius } : {},
-    ...params.project ? { project: params.project } : {}
+    ...params.tags.length > 0 ? { tags: params.tags } : {}
   };
 }
 function sanitizeRetireToolParams(params) {
@@ -1837,27 +2659,69 @@ function sanitizeTraceToolParams(params) {
     ...params.last !== void 0 ? { last: params.last } : {}
   };
 }
-function formatRecallResults(results) {
-  const lines = [`Found ${results.length} matching agenr memories:`];
-  for (const [index, result] of results.entries()) {
-    lines.push(
-      `${index + 1}. ${result.entry.id} | ${result.entry.type} | ${result.entry.subject} | score ${result.score.toFixed(2)} | importance ${result.entry.importance}`
-    );
-    lines.push(`   ${truncate(result.entry.content, 220)}`);
+function formatUnifiedRecallResults(result) {
+  const lines = [
+    "Recall Route",
+    `requested=${result.routing.requested} detected=${result.routing.detectedIntent} queried=${result.routing.queried.join(", ") || "none"}`,
+    result.routing.reason,
+    ""
+  ];
+  if (result.timeWindow) {
+    lines.push("Resolved Time Window");
+    lines.push(`${result.timeWindow.start} -> ${result.timeWindow.end} (${result.timeWindow.timezone}) from ${JSON.stringify(result.timeWindow.resolvedFrom)}`);
+    lines.push("");
+  }
+  lines.push("Episode Matches");
+  if (result.episodes.length === 0) {
+    lines.push("None.");
+  } else {
+    for (const [index, episode] of result.episodes.entries()) {
+      lines.push(
+        `${index + 1}. ${episode.episode.id} | ${episode.episode.source} | ${episode.episode.startedAt} -> ${episode.episode.endedAt ?? episode.episode.startedAt} | score ${episode.score.toFixed(2)}`
+      );
+      lines.push(`   ${index < 3 ? episode.episode.summary.trim() : truncate(episode.episode.summary.trim(), 220)}`);
+      lines.push(`   why_matched=${describeEpisodeMatch(episode)}`);
+    }
+  }
+  lines.push("");
+  lines.push("Entry Matches");
+  if (result.entries.length === 0) {
+    lines.push("None.");
+  } else {
+    for (const [index, entry] of result.entries.entries()) {
+      lines.push(
+        `${index + 1}. ${entry.entry.id} | ${entry.entry.type} | ${entry.entry.subject} | score ${entry.score.toFixed(2)} | importance ${entry.entry.importance}`
+      );
+      lines.push(`   ${truncate(entry.entry.content, 220)}`);
+    }
+  }
+  if (result.notices.length > 0) {
+    lines.push("");
+    lines.push("Notices");
+    for (const notice of result.notices) {
+      lines.push(`- ${notice}`);
+    }
   }
   return lines.join("\n");
 }
-function formatRecallResultSubjects(results) {
-  const subjects = results.map((result) => result.entry.subject.trim()).filter((subject) => subject.length > 0);
-  if (subjects.length === 0) {
-    return "";
+function formatUnifiedRecallLogSummary(result) {
+  const entrySubjects = result.entries.map((entry) => entry.entry.subject.trim()).filter((subject) => subject.length > 0);
+  const displayed = entrySubjects.slice(0, RESULT_SUBJECT_LOG_LIMIT).map((subject) => JSON.stringify(truncate(subject, 80)));
+  const remaining = entrySubjects.length - RESULT_SUBJECT_LOG_LIMIT;
+  const suffix = displayed.length === 0 ? "" : ` [entry subjects: ${displayed.join(", ")}${remaining > 0 ? `, ... and ${remaining} more` : ""}]`;
+  return `${result.episodes.length} episode${result.episodes.length === 1 ? "" : "s"}, ${result.entries.length} entr${result.entries.length === 1 ? "y" : "ies"}${suffix}`;
+}
+function describeEpisodeMatch(result) {
+  if (result.scores.semantic > 0 && result.scores.temporal > 0) {
+    return "Semantic match within the resolved time window.";
+  }
+  if (result.scores.semantic > 0) {
+    return "Semantic match to the episode summary.";
   }
-  const displayed = subjects.slice(0, RESULT_SUBJECT_LOG_LIMIT).map((subject) => JSON.stringify(truncate(subject, 80)));
-  const remaining = subjects.length - RESULT_SUBJECT_LOG_LIMIT;
-  if (remaining > 0) {
-    displayed.push(`... and ${remaining} more`);
+  if (result.scores.temporal > 0) {
+    return "Session overlaps the resolved time window.";
   }
-  return ` [subjects: ${displayed.join(", ")}]`;
+  return "Matched episodic recall ranking.";
 }
 function formatTrace(entry, supersededBy, supersedes, recallEvents) {
   const lines = [
@@ -2014,9 +2878,10 @@ function buildAgenrMemoryPromptSection({
   const lines = [
     "## Memory Recall",
     "Before answering anything about prior work, decisions, preferences, people, dates, unfinished work, or past sessions, call agenr_recall first. Session-start recall is automatic; use agenr_recall mid-session when you need context you do not already have.",
-    "agenr_recall supports temporal recall: when the user asks about a specific time period, always use temporal filters - semantic search alone matches meaning, not dates.",
-    'Use around plus aroundRadius to bias recall toward a period: last week -> around: "7d", aroundRadius: 3; two weeks ago -> around: "14d", aroundRadius: 4.',
-    'Use since and until for hard bounds: in the last month -> since: "30d"; before March -> until: "2026-03-01". Combine temporal filters with a focused query.'
+    "agenr_recall supports two recall kinds behind one tool: use mode=entries for exact facts, decisions, thresholds, and versions; use mode=episodes or auto for what-happened questions tied to a time period.",
+    "For temporal narrative questions, put the time phrase in the query itself: examples include yesterday, last week, this month, 2 weeks ago, or in March.",
+    "Episode results are narrative summaries of completed prior sessions, not authoritative logs. Confirm exact details when precision matters.",
+    "The newest completed session may not be consolidated into episodes yet, so very recent work can be missing from episode recall."
   ];
   if (availableTools.has(MEMORY_TOOL_NAMES.store)) {
     lines.push(
@@ -2041,476 +2906,193 @@ function buildAgenrMemoryPromptSection({
   return lines;
 }
 
-// ../../src/adapters/openclaw/format/recall-format.ts
-var MAX_CONTENT_CHARS = 280;
-function formatAgenrSessionStartRecall(recall2) {
-  const sections = buildSections(recall2);
-  if (sections.length === 0) {
-    return "";
+// ../../src/adapters/openclaw/episode/episode-writer.ts
+import { promises as fs3 } from "fs";
+import os from "os";
+import path from "path";
+import { DEFAULT_MODEL, DEFAULT_PROVIDER, parseModelRef, resolveAgentEffectiveModelPrimary, resolveDefaultAgentId } from "openclaw/plugin-sdk/agent-runtime";
+
+// ../../src/core/episode/summary-prompt.ts
+var EPISODE_SUMMARY_SYSTEM_PROMPT = [
+  "You write strict JSON episode summaries for historical recall.",
+  "The transcript can be about any topic - technical work, casual conversation, planning, research, creative projects, life events, or anything else.",
+  "Do not assume any particular domain.",
+  "Describe only what happened in this session.",
+  "Do not carry inherited context or open loops forward unless the session actively worked on them.",
+  "Return exactly one JSON object with this shape:",
+  '{ "summary": string, "tags": string[], "activityLevel": "substantial" | "minimal" | "none", "project": string | null }',
+  "Requirements:",
+  "- summary must be 100 to 300 words in plain prose (roughly 4 to 10 sentences)",
+  "- describe what was discussed, decided, or accomplished - not a turn-by-turn replay",
+  "- preserve concrete details worth remembering: names, places, dates, specific decisions, key topics, and notable specifics that would help someone recall this session months later",
+  "- tags must be 3 to 8 short lowercase anchors drawn from the actual session content",
+  "- project should be null when no clear project scope appears",
+  "- activityLevel: use substantial when meaningful discussion or work occurred, minimal when the session was brief or lightweight, none when essentially nothing happened",
+  "- do not include Markdown fences or extra commentary"
+].join("\n");
+function buildEpisodeSummaryPrompt(transcript) {
+  return [
+    "Produce a historical episodic summary for this completed session.",
+    "Describe what was discussed, decided, or accomplished during this transcript window.",
+    "",
+    "Transcript:",
+    transcript
+  ].join("\n");
+}
+function parseEpisodeSummaryResponse(value) {
+  const parsed = parseJsonObject(value);
+  if (!parsed || typeof parsed !== "object" || Array.isArray(parsed)) {
+    return null;
   }
-  const lines = ["## Agenr Session Recall", "Use this as prior context. Confirm anything important if the current conversation conflicts with it.", ""];
-  for (const section of sections) {
-    lines.push(`### ${section.title}`);
-    for (const item of section.entries) {
-      lines.push(formatEntryHeader(item));
-      lines.push(formatEntryBody(item.entry));
-    }
-    lines.push("");
+  const parsedRecord = parsed;
+  const summary = normalizeSummary(parsedRecord.summary);
+  const activityLevel = normalizeActivityLevel(parsedRecord.activityLevel);
+  if (!summary || !activityLevel) {
+    return null;
   }
-  return lines.join("\n").trim();
+  return {
+    summary,
+    tags: normalizeTags2(parsedRecord.tags),
+    activityLevel,
+    ...normalizeProject(parsedRecord.project) ? { project: normalizeProject(parsedRecord.project) } : {}
+  };
 }
-function buildSections(recall2) {
-  const sections = [];
-  const coreEntries = recall2.core.map((entry) => ({ entry }));
-  if (coreEntries.length > 0) {
-    sections.push({ title: "Core Memory", entries: coreEntries });
+function normalizeSummary(value) {
+  if (typeof value !== "string") {
+    return null;
   }
-  return sections;
-}
-function formatEntryHeader(item) {
-  const metadata = [
-    item.entry.id,
-    item.entry.type,
-    item.entry.expiry,
-    `importance ${item.entry.importance}`,
-    item.score !== void 0 ? `score ${item.score.toFixed(2)}` : void 0
-  ].filter((value) => value !== void 0);
-  return `- [${metadata.join(" | ")}] ${item.entry.subject}`;
+  const normalized = value.replace(/\s+/gu, " ").trim();
+  return normalized ? normalized : null;
 }
-function formatEntryBody(entry) {
-  const content = truncate2(entry.content.trim(), MAX_CONTENT_CHARS);
-  const extra = [
-    entry.tags.length > 0 ? `tags: ${entry.tags.join(", ")}` : void 0,
-    entry.created_at ? `created: ${entry.created_at.slice(0, 10)}` : void 0
-  ].filter((value) => value !== void 0);
-  if (extra.length === 0) {
-    return `  ${content}`;
+function normalizeActivityLevel(value) {
+  if (typeof value !== "string") {
+    return null;
   }
-  return `  ${content} (${extra.join(" | ")})`;
+  const normalized = value.trim().toLowerCase();
+  return EPISODE_ACTIVITY_LEVELS.includes(normalized) ? normalized : null;
 }
-function truncate2(value, maxChars) {
-  if (value.length <= maxChars) {
-    return value;
+function normalizeTags2(value) {
+  if (!Array.isArray(value)) {
+    return [];
   }
-  return `${value.slice(0, maxChars - 3).trimEnd()}...`;
+  return Array.from(
+    new Set(
+      value.filter((tag) => typeof tag === "string").map((tag) => tag.trim().toLowerCase()).filter((tag) => tag.length > 0)
+    )
+  ).slice(0, 8);
 }
-
-// ../../src/adapters/openclaw/session/predecessor.ts
-import path2 from "path";
-
-// ../../src/adapters/openclaw/session/sessions-store-reader.ts
-import { promises as fs } from "fs";
-import path from "path";
-async function readOpenClawSessionsStore(sessionsDir, logger) {
-  const normalizedSessionsDir = sessionsDir.trim();
-  if (normalizedSessionsDir.length === 0) {
-    debugLog(logger, "sessions-store-reader", "skipping sessions.json read because sessionsDir is empty");
-    return [];
+function normalizeProject(value) {
+  if (typeof value !== "string") {
+    return void 0;
   }
-  const resolvedSessionsDir = path.resolve(normalizedSessionsDir);
-  const sessionsJsonPath = path.join(resolvedSessionsDir, "sessions.json");
-  try {
-    const raw = await fs.readFile(sessionsJsonPath, "utf8");
-    const parsed = JSON.parse(raw);
-    if (!isRecord2(parsed)) {
-      debugLog(logger, "sessions-store-reader", `sessions.json did not contain an object: path=${sessionsJsonPath}`);
-      return [];
-    }
-    const entries = [];
-    for (const [sessionKey, value] of Object.entries(parsed)) {
-      const normalizedSessionKey = sessionKey.trim();
-      if (normalizedSessionKey.length === 0) {
-        debugLog(logger, "sessions-store-reader", `skipping blank session key in ${sessionsJsonPath}`);
-        continue;
-      }
-      if (!isRecord2(value)) {
-        debugLog(logger, "sessions-store-reader", `skipping non-object entry for key=${normalizedSessionKey}`);
-        continue;
-      }
-      const sessionId = asTrimmedString(value["sessionId"]);
-      const sessionFile = asTrimmedString(value["sessionFile"]);
-      const updatedAt = asFiniteNumber(value["updatedAt"]);
-      entries.push({
-        sessionKey: normalizedSessionKey,
-        ...sessionId ? { sessionId } : {},
-        ...sessionFile ? { sessionFile: resolveSessionStorePath(sessionFile, resolvedSessionsDir) } : {},
-        ...updatedAt !== void 0 ? { updatedAt } : {}
-      });
-    }
-    debugLog(logger, "sessions-store-reader", `loaded sessions.json entries=${entries.length} path=${sessionsJsonPath}`);
-    return entries;
-  } catch (error) {
-    if (isFileNotFound(error)) {
-      debugLog(logger, "sessions-store-reader", `sessions.json missing at ${sessionsJsonPath}`);
-      return [];
+  const normalized = value.replace(/\s+/gu, " ").trim();
+  return normalized ? normalized : void 0;
+}
+function parseJsonObject(value) {
+  const candidates = collectJsonCandidates(value);
+  for (const candidate of candidates) {
+    try {
+      return JSON.parse(candidate);
+    } catch {
+      continue;
     }
-    if (error instanceof SyntaxError) {
-      debugLog(logger, "sessions-store-reader", `sessions.json parse failed at ${sessionsJsonPath}: ${error.message}`);
-      return [];
+  }
+  return null;
+}
+function collectJsonCandidates(value) {
+  const trimmed = value.trim();
+  const candidates = /* @__PURE__ */ new Set();
+  if (trimmed) {
+    candidates.add(trimmed);
+  }
+  const fencedMatches = trimmed.match(/```(?:json)?\s*([\s\S]*?)```/giu) ?? [];
+  for (const match of fencedMatches) {
+    const normalized = match.replace(/```(?:json)?/iu, "").replace(/```/gu, "").trim();
+    if (normalized) {
+      candidates.add(normalized);
     }
-    debugLog(logger, "sessions-store-reader", `sessions.json read failed at ${sessionsJsonPath}: ${formatErrorMessage2(error)}`);
-    return [];
   }
+  const objectStart = trimmed.indexOf("{");
+  const objectEnd = trimmed.lastIndexOf("}");
+  if (objectStart >= 0 && objectEnd > objectStart) {
+    candidates.add(trimmed.slice(objectStart, objectEnd + 1));
+  }
+  return [...candidates];
 }
-function resolveSessionStorePath(candidatePath, sessionsDir) {
-  return path.isAbsolute(candidatePath) ? path.resolve(candidatePath) : path.resolve(sessionsDir, candidatePath);
+
+// ../../src/core/episode/summary-generator.ts
+async function generateEpisodeSummary(transcript, llm) {
+  const response = await llm.complete(EPISODE_SUMMARY_SYSTEM_PROMPT, buildEpisodeSummaryPrompt(transcript));
+  return parseEpisodeSummaryResponse(response);
 }
-function isRecord2(value) {
-  return typeof value === "object" && value !== null;
+
+// ../../src/adapters/openclaw/logging.ts
+function formatSessionContext(sessionId, sessionKey) {
+  const normalizedSessionId = sessionId?.trim();
+  const normalizedSessionKey = sessionKey?.trim();
+  if (normalizedSessionId && normalizedSessionKey) {
+    return `session=${normalizedSessionId} key=${normalizedSessionKey}`;
+  }
+  if (normalizedSessionId) {
+    return `session=${normalizedSessionId}`;
+  }
+  if (normalizedSessionKey) {
+    return `key=${normalizedSessionKey}`;
+  }
+  return "session=unknown";
 }
-function asTrimmedString(value) {
-  return typeof value === "string" && value.trim().length > 0 ? value.trim() : void 0;
+function formatErrorMessage2(error) {
+  return error instanceof Error ? error.message : String(error);
 }
-function asFiniteNumber(value) {
-  return typeof value === "number" && Number.isFinite(value) ? value : void 0;
+
+// ../../src/adapters/openclaw/transcript/parser.ts
+import { createHash as createHash2 } from "crypto";
+import { promises as fs2 } from "fs";
+
+// ../../src/adapters/openclaw/transcript/jsonl.ts
+function parseJsonlLines(raw, warnings, onRecord) {
+  const lines = raw.split(/\r?\n/);
+  for (let index = 0; index < lines.length; index += 1) {
+    const line = lines[index]?.trim();
+    if (!line) {
+      continue;
+    }
+    let parsed;
+    try {
+      parsed = JSON.parse(line);
+    } catch {
+      warnings.push(`Skipped malformed JSONL line ${index + 1}`);
+      continue;
+    }
+    if (!parsed || typeof parsed !== "object" || Array.isArray(parsed)) {
+      continue;
+    }
+    onRecord(parsed, index + 1);
+  }
 }
-function debugLog(logger, subsystem, message) {
-  logger?.debug?.(`[agenr] ${subsystem}: ${message}`);
+
+// ../../src/adapters/openclaw/transcript/tool-summarization.ts
+var DEFAULT_TOOL_RESULT_DROP_NAMES = ["read", "web_fetch", "browser", "screenshot", "snapshot", "canvas", "tts"];
+var DEFAULT_TOOL_RESULT_KEEP_NAMES = ["web_search", "memory_search", "memory_get", "image"];
+var DEFAULT_TOOL_RESULT_DROP_NAME_SET = new Set(DEFAULT_TOOL_RESULT_DROP_NAMES);
+var DEFAULT_TOOL_RESULT_KEEP_NAME_SET = new Set(DEFAULT_TOOL_RESULT_KEEP_NAMES);
+function asRecord2(value) {
+  return value && typeof value === "object" && !Array.isArray(value) ? value : null;
 }
-function isFileNotFound(error) {
-  return typeof error === "object" && error !== null && "code" in error && error.code === "ENOENT";
+function getString(value) {
+  return typeof value === "string" && value.trim().length > 0 ? value : void 0;
 }
-function formatErrorMessage2(error) {
-  if (error instanceof Error) {
-    return error.message;
+function truncateInline(value, max) {
+  if (value.length <= max) {
+    return value;
   }
-  return String(error);
+  return value.slice(0, max);
 }
-
-// ../../src/adapters/openclaw/session/tui-lane.ts
-var TUI_SESSION_KEY_PATTERN = /^agent:([^:]+):([^:]+)$/i;
-var TUI_UUID_LANE_PATTERN = /^tui[a-z0-9]*-[0-9a-f]{8}-[0-9a-f]{4}-[0-9a-f]{4}-[0-9a-f]{4}-[0-9a-f]{12}$/i;
-var TUI_UUID_SUFFIX_PATTERN = /-[0-9a-f]{8}-[0-9a-f]{4}-[0-9a-f]{4}-[0-9a-f]{4}-[0-9a-f]{12}$/i;
-function parseTuiSessionKey(sessionKey) {
-  const normalizedSessionKey = sessionKey.trim();
-  if (normalizedSessionKey.length === 0) {
-    return null;
-  }
-  const match = TUI_SESSION_KEY_PATTERN.exec(normalizedSessionKey);
-  if (!match) {
-    return null;
-  }
-  const [, agentId, instanceLane] = match;
-  const normalizedAgentId = agentId?.trim();
-  const normalizedInstanceLane = instanceLane?.trim();
-  if (!normalizedAgentId || !normalizedInstanceLane || !normalizedInstanceLane.toLowerCase().startsWith("tui")) {
-    return null;
-  }
-  const stableLane = TUI_UUID_LANE_PATTERN.test(normalizedInstanceLane) ? normalizedInstanceLane.replace(TUI_UUID_SUFFIX_PATTERN, "") : normalizedInstanceLane;
-  return {
-    agentId: normalizedAgentId,
-    stableLane,
-    instanceLane: normalizedInstanceLane
-  };
-}
-
-// ../../src/adapters/openclaw/session/predecessor.ts
-async function resolveOpenClawSessionPredecessor(ctx, tracker, params) {
-  const sessionContext = formatSessionContext(ctx.sessionId, ctx.sessionKey);
-  debugLog2(params.logger, "predecessor", `resolving predecessor for ${sessionContext}`);
-  const trackedPredecessor = resolveTrackedPredecessor(ctx, tracker, params.logger);
-  if (trackedPredecessor) {
-    return trackedPredecessor;
-  }
-  const tuiIdentity = parseTuiSessionKey(ctx.sessionKey ?? "");
-  if (!tuiIdentity) {
-    debugLog2(params.logger, "predecessor", `skipping TUI fallback for ${sessionContext}: current session key is not TUI`);
-    return void 0;
-  }
-  const sessionsDir = resolveOpenClawSessionsDirectory(ctx, tuiIdentity.agentId, params.resolveStateDir);
-  if (!sessionsDir) {
-    params.logger?.info?.(`[agenr] predecessor: TUI fallback no predecessor found for ${sessionContext} reason=no_sessions_dir`);
-    return void 0;
-  }
-  params.logger?.info?.(
-    `[agenr] predecessor: TUI fallback activated for ${sessionContext} sessionKey=${ctx.sessionKey?.trim() ?? "unknown"} stableLane=${tuiIdentity.stableLane}`
-  );
-  debugLog2(
-    params.logger,
-    "predecessor",
-    `TUI fallback stable lane for ${sessionContext}: agentId=${tuiIdentity.agentId} instanceLane=${tuiIdentity.instanceLane} stableLane=${tuiIdentity.stableLane} sessionsDir=${sessionsDir}`
-  );
-  const fallbackResolution = await findTuiFallbackPredecessor(ctx.sessionKey ?? "", sessionsDir, params.logger);
-  if (!fallbackResolution.predecessor) {
-    params.logger?.info?.(`[agenr] predecessor: TUI fallback no predecessor found for ${sessionContext} reason=${fallbackResolution.reason}`);
-    return void 0;
-  }
-  params.logger?.info?.(
-    `[agenr] predecessor: TUI fallback predecessor found for ${sessionContext} predecessorKey=${fallbackResolution.predecessor.sessionKey} predecessor=${fallbackResolution.predecessor.sessionFile}`
-  );
-  return {
-    sessionFile: fallbackResolution.predecessor.sessionFile,
-    ...fallbackResolution.predecessor.sessionId ? { sessionId: fallbackResolution.predecessor.sessionId } : {}
-  };
-}
-function resolveTrackedPredecessor(ctx, tracker, logger) {
-  const sessionContext = formatSessionContext(ctx.sessionId, ctx.sessionKey);
-  const resetRecord = tracker.getLatestReset(ctx.sessionKey);
-  if (!resetRecord) {
-    debugLog2(logger, "predecessor", `no reset record found for ${sessionContext}`);
-    return void 0;
-  }
-  debugLog2(logger, "predecessor", `latest reset record for ${sessionContext}: ${formatResetRecord(resetRecord)}`);
-  const resumedFrom = tracker.getResumedFrom(ctx.sessionId);
-  if (resumedFrom) {
-    debugLog2(logger, "predecessor", `session_start resumedFrom for ${sessionContext}: ${resumedFrom}`);
-  } else {
-    debugLog2(logger, "predecessor", `session_start resumedFrom unavailable for ${sessionContext}`);
-  }
-  if (resumedFrom && resetRecord.sessionId && resetRecord.sessionId !== resumedFrom) {
-    debugLog2(
-      logger,
-      "predecessor",
-      `discarding stale reset record for ${sessionContext}: resumedFrom=${resumedFrom} resetRecordSession=${resetRecord.sessionId}`
-    );
-    return void 0;
-  }
-  return {
-    sessionFile: resetRecord.sessionFile,
-    ...resetRecord.sessionId ? { sessionId: resetRecord.sessionId } : {}
-  };
-}
-async function findTuiFallbackPredecessor(currentSessionKey, sessionsDir, logger) {
-  const currentIdentity = parseTuiSessionKey(currentSessionKey);
-  if (!currentIdentity) {
-    return { reason: "not_tui_session_key" };
-  }
-  const entries = await readOpenClawSessionsStore(sessionsDir, logger);
-  debugLog2(logger, "predecessor", `TUI fallback sessions.json read result for sessionKey=${currentSessionKey}: entries=${entries.length}`);
-  const sameAgentEntries = entries.filter((entry) => {
-    const parsedCandidate = parseSingleLaneSessionKey(entry.sessionKey);
-    if (!parsedCandidate) {
-      debugLog2(logger, "predecessor", `TUI fallback excluded candidate=${entry.sessionKey} reason=unsupported_session_key_shape`);
-      return false;
-    }
-    if (parsedCandidate.agentId !== currentIdentity.agentId) {
-      debugLog2(
-        logger,
-        "predecessor",
-        `TUI fallback excluded candidate=${entry.sessionKey} reason=agent_mismatch expected=${currentIdentity.agentId} actual=${parsedCandidate.agentId}`
-      );
-      return false;
-    }
-    return true;
-  });
-  debugLog2(logger, "predecessor", `TUI fallback candidate filtering for sessionKey=${currentSessionKey}: sameAgentCount=${sameAgentEntries.length}`);
-  const laneMatches = sameAgentEntries.filter((entry) => {
-    const normalizedCandidateKey = entry.sessionKey.trim();
-    if (normalizedCandidateKey === currentSessionKey.trim()) {
-      debugLog2(logger, "predecessor", `TUI fallback excluded candidate=${entry.sessionKey} reason=current_session`);
-      return false;
-    }
-    const candidateKey = parseSingleLaneSessionKey(entry.sessionKey);
-    if (!candidateKey) {
-      return false;
-    }
-    if (currentIdentity.stableLane === "tui" && candidateKey.lane === "main") {
-      return true;
-    }
-    const candidateIdentity = parseTuiSessionKey(entry.sessionKey);
-    if (!candidateIdentity) {
-      debugLog2(logger, "predecessor", `TUI fallback excluded candidate=${entry.sessionKey} reason=not_tui_candidate`);
-      return false;
-    }
-    if (!isSameTuiFallbackLane(currentIdentity.stableLane, candidateIdentity.stableLane)) {
-      debugLog2(
-        logger,
-        "predecessor",
-        `TUI fallback excluded candidate=${entry.sessionKey} reason=lane_mismatch currentStableLane=${currentIdentity.stableLane} candidateStableLane=${candidateIdentity.stableLane}`
-      );
-      return false;
-    }
-    return true;
-  });
-  debugLog2(logger, "predecessor", `TUI fallback candidate filtering for sessionKey=${currentSessionKey}: laneMatchCount=${laneMatches.length}`);
-  const sortedCandidates = laneMatches.filter((entry) => {
-    if (entry.updatedAt !== void 0) {
-      return true;
-    }
-    debugLog2(logger, "predecessor", `TUI fallback excluded candidate=${entry.sessionKey} reason=missing_updated_at`);
-    return false;
-  }).sort((left, right) => (right.updatedAt ?? 0) - (left.updatedAt ?? 0));
-  if (sortedCandidates.length === 0) {
-    return { reason: "no_matching_sessions" };
-  }
-  const predecessor = sortedCandidates[0];
-  if (!predecessor.sessionFile?.trim()) {
-    debugLog2(
-      logger,
-      "predecessor",
-      `TUI fallback top candidate missing session file for sessionKey=${currentSessionKey}: predecessorKey=${predecessor.sessionKey}`
-    );
-    return { reason: "missing_session_file" };
-  }
-  return {
-    reason: "resolved",
-    predecessor: {
-      sessionFile: predecessor.sessionFile,
-      ...predecessor.sessionId ? { sessionId: predecessor.sessionId } : {},
-      sessionKey: predecessor.sessionKey
-    }
-  };
-}
-function resolveOpenClawSessionsDirectory(ctx, fallbackAgentId, resolveStateDir) {
-  const agentId = ctx.agentId?.trim() || fallbackAgentId.trim();
-  if (!agentId) {
-    return void 0;
-  }
-  return path2.join(resolveStateDir(process.env), "agents", agentId, "sessions");
-}
-function parseSingleLaneSessionKey(sessionKey) {
-  const match = /^agent:([^:]+):([^:]+)$/i.exec(sessionKey.trim());
-  if (!match) {
-    return null;
-  }
-  const [, agentId, lane] = match;
-  const normalizedAgentId = agentId?.trim();
-  const normalizedLane = lane?.trim();
-  if (!normalizedAgentId || !normalizedLane) {
-    return null;
-  }
-  return {
-    agentId: normalizedAgentId,
-    lane: normalizedLane
-  };
-}
-function isSameTuiFallbackLane(currentStableLane, candidateStableLane) {
-  if (currentStableLane === "tui") {
-    return candidateStableLane.toLowerCase().startsWith("tui");
-  }
-  return currentStableLane === candidateStableLane;
-}
-function debugLog2(logger, subsystem, message) {
-  logger?.debug?.(`[agenr] ${subsystem}: ${message}`);
-}
-function formatSessionContext(sessionId, sessionKey) {
-  const normalizedSessionId = sessionId?.trim();
-  const normalizedSessionKey = sessionKey?.trim();
-  if (normalizedSessionId && normalizedSessionKey) {
-    return `session=${normalizedSessionId} key=${normalizedSessionKey}`;
-  }
-  if (normalizedSessionId) {
-    return `session=${normalizedSessionId}`;
-  }
-  if (normalizedSessionKey) {
-    return `key=${normalizedSessionKey}`;
-  }
-  return "session=unknown";
-}
-function formatResetRecord(record) {
-  return `sessionFile=${record.sessionFile}${record.sessionId ? ` sessionId=${record.sessionId}` : ""} recordedAt=${record.recordedAt}`;
-}
-
-// ../../src/adapters/openclaw/session/summary-reader.ts
-import { promises as fs2 } from "fs";
-import path3 from "path";
-function deriveOpenClawSessionIdFromFilePath(sessionFile, logger) {
-  const normalizedSessionFile = sessionFile.trim();
-  if (normalizedSessionFile.length === 0) {
-    debugLog3(logger, "summary-reader", "cannot derive session id from empty session file path");
-    return void 0;
-  }
-  const fileName = path3.basename(normalizedSessionFile);
-  const sessionId = fileName.replace(/\.jsonl(?:\..*)?$/i, "").trim();
-  debugLog3(logger, "summary-reader", `derived session id "${sessionId || "<empty>"}" from file=${normalizedSessionFile}`);
-  return sessionId.length > 0 ? sessionId : void 0;
-}
-function resolveOpenClawSessionSummaryPath(sessionFile, logger) {
-  const normalizedSessionFile = sessionFile.trim();
-  const sessionId = deriveOpenClawSessionIdFromFilePath(normalizedSessionFile, logger);
-  if (!sessionId) {
-    return void 0;
-  }
-  const summaryPath = path3.join(path3.dirname(normalizedSessionFile), `${sessionId}.summary.md`);
-  debugLog3(logger, "summary-reader", `resolved summary path for session=${sessionId}: ${summaryPath}`);
-  return summaryPath;
-}
-async function readOpenClawSessionSummaryFile(sessionFile, logger) {
-  const summaryPath = resolveOpenClawSessionSummaryPath(sessionFile, logger);
-  const sessionId = deriveOpenClawSessionIdFromFilePath(sessionFile, logger);
-  if (!summaryPath || !sessionId) {
-    return null;
-  }
-  try {
-    const content = (await fs2.readFile(summaryPath, "utf8")).trim();
-    if (content.length === 0) {
-      debugLog3(logger, "summary-reader", `summary file is empty for session=${sessionId} path=${summaryPath}`);
-      return null;
-    }
-    debugLog3(logger, "summary-reader", `loaded summary file for session=${sessionId} path=${summaryPath} chars=${content.length}`);
-    return {
-      sessionId,
-      summaryPath,
-      content
-    };
-  } catch (error) {
-    if (isFileNotFound2(error)) {
-      debugLog3(logger, "summary-reader", `summary file missing for session=${sessionId} path=${summaryPath}`);
-      return null;
-    }
-    throw error;
-  }
-}
-function debugLog3(logger, subsystem, message) {
-  logger?.debug?.(`[agenr] ${subsystem}: ${message}`);
-}
-function isFileNotFound2(error) {
-  return typeof error === "object" && error !== null && "code" in error && error.code === "ENOENT";
-}
-
-// ../../src/adapters/openclaw/session/summary.ts
-import { promises as fs5 } from "fs";
-import os from "os";
-import path4 from "path";
-import { DEFAULT_MODEL, DEFAULT_PROVIDER, parseModelRef, resolveAgentEffectiveModelPrimary, resolveDefaultAgentId } from "openclaw/plugin-sdk/agent-runtime";
-
-// ../../src/adapters/openclaw/transcript/parser.ts
-import { promises as fs4 } from "fs";
-
-// ../../src/adapters/openclaw/transcript/jsonl.ts
-function parseJsonlLines(raw, warnings, onRecord) {
-  const lines = raw.split(/\r?\n/);
-  for (let index = 0; index < lines.length; index += 1) {
-    const line = lines[index]?.trim();
-    if (!line) {
-      continue;
-    }
-    let parsed;
-    try {
-      parsed = JSON.parse(line);
-    } catch {
-      warnings.push(`Skipped malformed JSONL line ${index + 1}`);
-      continue;
-    }
-    if (!parsed || typeof parsed !== "object" || Array.isArray(parsed)) {
-      continue;
-    }
-    onRecord(parsed, index + 1);
-  }
-}
-
-// ../../src/adapters/openclaw/transcript/tool-summarization.ts
-var DEFAULT_TOOL_RESULT_DROP_NAMES = ["read", "web_fetch", "browser", "screenshot", "snapshot", "canvas", "tts"];
-var DEFAULT_TOOL_RESULT_KEEP_NAMES = ["web_search", "memory_search", "memory_get", "image"];
-var DEFAULT_TOOL_RESULT_DROP_NAME_SET = new Set(DEFAULT_TOOL_RESULT_DROP_NAMES);
-var DEFAULT_TOOL_RESULT_KEEP_NAME_SET = new Set(DEFAULT_TOOL_RESULT_KEEP_NAMES);
-function asRecord2(value) {
-  return value && typeof value === "object" && !Array.isArray(value) ? value : null;
-}
-function getString(value) {
-  return typeof value === "string" && value.trim().length > 0 ? value : void 0;
-}
-function truncateInline(value, max) {
-  if (value.length <= max) {
-    return value;
-  }
-  return value.slice(0, max);
-}
-function firstStringArgValue(args, max) {
-  for (const value of Object.values(args)) {
-    if (typeof value === "string" && value.trim().length > 0) {
-      return truncateInline(value.trim(), max);
-    }
+function firstStringArgValue(args, max) {
+  for (const value of Object.values(args)) {
+    if (typeof value === "string" && value.trim().length > 0) {
+      return truncateInline(value.trim(), max);
+    }
   }
   return void 0;
 }
@@ -2895,7 +3477,7 @@ function pushMessage(messages, role, text, timestamp) {
 }
 
 // ../../src/adapters/openclaw/transcript/timestamps.ts
-import { promises as fs3 } from "fs";
+import { promises as fs } from "fs";
 function parseTimestampValue(value) {
   if (typeof value === "string" && value.trim().length > 0) {
     const parsed = new Date(value);
@@ -2923,7 +3505,7 @@ function extractTimestamp(record) {
 }
 async function getFileMtimeTimestamp(filePath) {
   try {
-    const stat = await fs3.stat(filePath);
+    const stat = await fs.stat(filePath);
     return parseTimestampValue(stat.mtime.toISOString());
   } catch {
     return void 0;
@@ -2957,9 +3539,11 @@ var TOOL_RESULT_POLICY = {
   keepToolNames: new Set(DEFAULT_TOOL_RESULT_KEEP_NAMES.filter((name) => name !== "image"))
 };
 var RAW_TEXT_BLOCK_TYPES = /* @__PURE__ */ new Set(["input_text", "output_text", "text"]);
+var SENDER_METADATA_SENTINEL = "Sender (untrusted metadata):";
+var CONVERSATION_INFO_SENTINEL = "Conversation info (untrusted metadata):";
 var USER_METADATA_PREFIX_SENTINELS = /* @__PURE__ */ new Set([
-  "Sender (untrusted metadata):",
-  "Conversation info (untrusted metadata):",
+  SENDER_METADATA_SENTINEL,
+  CONVERSATION_INFO_SENTINEL,
   "Thread starter (untrusted, for context):",
   "Replied message (untrusted, for context):",
   "Forwarded message context (untrusted metadata):",
@@ -2982,7 +3566,10 @@ function createParseState() {
     modelsUsed: [],
     modelsUsedSet: /* @__PURE__ */ new Set(),
     pendingToolCalls: [],
-    pendingToolCallsById: /* @__PURE__ */ new Map()
+    pendingToolCallsById: /* @__PURE__ */ new Map(),
+    detectedSurface: null,
+    surfaceDetected: false,
+    firstUserRawText: null
   };
 }
 function extractRawMessageText(content) {
@@ -3080,12 +3667,105 @@ function addModelUsed(state, value) {
   state.modelsUsedSet.add(modelId);
   state.modelsUsed.push(modelId);
 }
-function resolveToolContext(state, message) {
-  const toolCallId = getString(message.toolCallId) ?? getString(message.tool_call_id) ?? getString(message.call_id) ?? getString(message.id);
-  if (toolCallId && state.pendingToolCallsById.has(toolCallId)) {
-    const context = state.pendingToolCallsById.get(toolCallId) ?? null;
-    state.pendingToolCallsById.delete(toolCallId);
-    if (context) {
+function setDetectedSurface(state, surface) {
+  if (state.surfaceDetected || !surface) {
+    return;
+  }
+  state.detectedSurface = surface;
+  state.surfaceDetected = true;
+}
+function readInboundSurface(record) {
+  const inboundMeta = asRecord2(record.inbound_meta);
+  const surface = getString(inboundMeta?.surface)?.trim().toLowerCase();
+  return surface || null;
+}
+function extractMetadataPayload(rawText, sentinel) {
+  const lines = rawText.split(/\r?\n/u);
+  for (let index = 0; index < lines.length; index += 1) {
+    if (lines[index]?.trim() !== sentinel) {
+      continue;
+    }
+    let fenceIndex = index + 1;
+    while (fenceIndex < lines.length && lines[fenceIndex]?.trim().length === 0) {
+      fenceIndex += 1;
+    }
+    if (fenceIndex >= lines.length || !/^```(?:json)?\s*$/iu.test(lines[fenceIndex]?.trim() ?? "")) {
+      continue;
+    }
+    fenceIndex += 1;
+    const jsonLines = [];
+    while (fenceIndex < lines.length && !/^```\s*$/u.test(lines[fenceIndex]?.trim() ?? "")) {
+      jsonLines.push(lines[fenceIndex] ?? "");
+      fenceIndex += 1;
+    }
+    if (fenceIndex >= lines.length) {
+      continue;
+    }
+    try {
+      const parsed = JSON.parse(jsonLines.join("\n").trim());
+      return asRecord2(parsed);
+    } catch {
+      continue;
+    }
+  }
+  return null;
+}
+function mapKnownSurface(value) {
+  if (!value) {
+    return null;
+  }
+  if (value.includes("telegram")) {
+    return "telegram";
+  }
+  if (value.includes("signal")) {
+    return "signal";
+  }
+  if (value.includes("discord")) {
+    return "discord";
+  }
+  if (value.includes("openclaw-tui")) {
+    return "tui";
+  }
+  if (value.includes("gateway-client") || value.includes("openclaw-control-ui") || value.includes("webchat")) {
+    return "webchat";
+  }
+  return null;
+}
+function extractSenderSurface(rawText) {
+  const payload = extractMetadataPayload(rawText, SENDER_METADATA_SENTINEL);
+  if (!payload) {
+    return null;
+  }
+  const label = getString(payload.label)?.trim().toLowerCase() ?? getString(payload.id)?.trim().toLowerCase() ?? "";
+  return mapKnownSurface(label);
+}
+function extractConversationInfoSurface(rawText) {
+  const payload = extractMetadataPayload(rawText, CONVERSATION_INFO_SENTINEL);
+  if (!payload) {
+    return null;
+  }
+  const senderId = getString(payload.sender_id)?.trim().toLowerCase() ?? "";
+  return mapKnownSurface(senderId);
+}
+function inferSurfaceFromContent(firstUserRawText) {
+  const normalized = firstUserRawText?.trim().toLowerCase() ?? "";
+  if (!normalized) {
+    return null;
+  }
+  if (normalized.includes("[subagent context]")) {
+    return "subagent";
+  }
+  if (normalized.includes("heartbeat.md")) {
+    return "heartbeat";
+  }
+  return null;
+}
+function resolveToolContext(state, message) {
+  const toolCallId = getString(message.toolCallId) ?? getString(message.tool_call_id) ?? getString(message.call_id) ?? getString(message.id);
+  if (toolCallId && state.pendingToolCallsById.has(toolCallId)) {
+    const context = state.pendingToolCallsById.get(toolCallId) ?? null;
+    state.pendingToolCallsById.delete(toolCallId);
+    if (context) {
       const queuedIndex = state.pendingToolCalls.findIndex((toolCall) => toolCall.id === toolCallId);
       if (queuedIndex >= 0) {
         state.pendingToolCalls.splice(queuedIndex, 1);
@@ -3098,6 +3778,19 @@ function resolveToolContext(state, message) {
 function handleMessageRecord(state, record, message) {
   state.stats.totalMessageRecords += 1;
   const role = normalizeOpenClawRole(message.role);
+  if (!state.surfaceDetected) {
+    setDetectedSurface(state, readInboundSurface(message));
+  }
+  if (!state.surfaceDetected && role === "user") {
+    const rawText = extractRawMessageText(message.content);
+    if (state.firstUserRawText === null) {
+      state.firstUserRawText = rawText;
+    }
+    setDetectedSurface(state, extractSenderSurface(rawText));
+    if (!state.surfaceDetected) {
+      setDetectedSurface(state, extractConversationInfoSurface(rawText));
+    }
+  }
   if (role === "system") {
     state.stats.systemDropped += 1;
     return;
@@ -3168,8 +3861,14 @@ function handleRecord(state, record) {
     state.sessionTimestamp = extractTimestamp(record) ?? state.sessionTimestamp;
     state.sessionLabel = normalizeSessionLabel(getString(record.conversation_label) ?? "") ?? state.sessionLabel;
     addModelUsed(state, record.model);
+    if (!state.surfaceDetected) {
+      setDetectedSurface(state, readInboundSurface(record));
+    }
     return;
   }
+  if (!state.surfaceDetected) {
+    setDetectedSurface(state, readInboundSurface(record));
+  }
   if (record.type === "model_change") {
     addModelUsed(state, record.modelId);
     state.stats.skippedRecordTypes += 1;
@@ -3197,212 +3896,253 @@ var OpenClawTranscriptParser = class {
    * @returns Parsed transcript messages, warnings, and metadata.
    */
   async parseFile(filePath, options) {
-    const raw = await fs4.readFile(filePath, "utf8");
+    const raw = await fs2.readFile(filePath, "utf8");
     const verbose = options?.verbose === true;
     const state = createParseState();
+    const transcriptHash = createHash2("sha256").update(raw).digest("hex");
     parseJsonlLines(raw, state.warnings, (record) => {
       handleRecord(state, record);
     });
+    if (!state.surfaceDetected && state.firstUserRawText) {
+      setDetectedSurface(state, inferSurfaceFromContent(state.firstUserRawText));
+    }
     const fallbackTimestamp = state.messages.length > 0 ? await applyMessageTimestampFallbacks(filePath, state.messages, { sessionTimestamp: state.sessionTimestamp }) : await resolveTimestampFallback(filePath, state.sessionTimestamp);
     if (verbose) {
       state.warnings.push(buildFilterWarning(state.stats));
     }
+    const startedAt = state.sessionTimestamp ?? state.messages[0]?.timestamp ?? fallbackTimestamp;
+    const endedAt = state.messages[state.messages.length - 1]?.timestamp ?? state.sessionTimestamp ?? fallbackTimestamp;
     return {
       messages: state.messages,
       warnings: state.warnings,
       metadata: {
         sessionId: state.sessionId,
         sessionLabel: state.sessionLabel,
-        startedAt: state.sessionTimestamp ?? state.messages[0]?.timestamp ?? fallbackTimestamp,
-        modelsUsed: state.modelsUsed.length > 0 ? state.modelsUsed : void 0
+        startedAt,
+        endedAt,
+        messageCount: state.messages.length,
+        transcriptHash,
+        modelsUsed: state.modelsUsed.length > 0 ? state.modelsUsed : void 0,
+        reconstructedSurface: state.detectedSurface,
+        surfaceReconstructionSource: state.surfaceDetected ? "reconstructed" : "none"
       }
     };
   }
 };
 var openClawTranscriptParser = new OpenClawTranscriptParser();
 
-// ../../src/adapters/openclaw/session/summary.ts
-var MIN_SUMMARY_MESSAGES = 4;
-var MAX_TRANSCRIPT_CHARS = 14e3;
-var SUMMARY_TIMEOUT_MS = 15e3;
-var SUMMARY_SYSTEM_PROMPT = [
-  "You write concise narrative summaries that help the next session continue smoothly.",
-  "The transcript can be about any domain. Do not assume technical, project, or coding context unless the transcript shows it.",
-  "Write 200 to 500 words in plain Markdown with no code fences.",
-  "Capture:",
-  "- what topics were discussed",
-  "- what was learned, decided, agreed on, or corrected",
-  "- what remains unfinished, open, or pending",
-  "- user preferences, clarifications, and constraints that matter for continuity",
-  "- the overall direction or intent of the conversation",
-  "Do not replay the transcript turn by turn. Do not invent facts. If something is uncertain, say so briefly."
-].join("\n");
-async function generateAndWriteOpenClawSessionSummary(params) {
-  const sessionFile = params.sessionFile.trim();
-  const summaryPath = resolveOpenClawSessionSummaryPath(sessionFile, params.logger);
-  if (!summaryPath) {
-    return {
-      status: "skipped",
-      reason: "missing_session_id"
-    };
+// ../../src/core/episode/transcript-render.ts
+var MIN_EPISODE_MESSAGES = 4;
+var MAX_EPISODE_TRANSCRIPT_CHARS = 14e3;
+function renderTranscript(messages) {
+  return messages.map((message) => `${message.role === "user" ? "User" : "Assistant"}: ${message.text.trim()}`).join("\n");
+}
+function capEpisodeTranscript(transcript, maxChars) {
+  if (transcript.length <= maxChars) {
+    return transcript;
   }
-  const parsedTranscript = await openClawTranscriptParser.parseFile(sessionFile);
-  const cleanedMessages = parsedTranscript.messages.filter((message) => message.text.trim().length > 0);
-  const transcript = renderTranscriptForSummary(cleanedMessages);
-  const normalizedTranscript = capTranscript(transcript, MAX_TRANSCRIPT_CHARS);
-  debugLog4(
-    params.logger,
-    "summary",
-    `transcript adapter output for file=${sessionFile}: messages=${cleanedMessages.length} chars=${normalizedTranscript.length}`
-  );
-  if (cleanedMessages.length === 0 || normalizedTranscript.length === 0) {
-    return {
-      status: "skipped",
-      reason: "empty",
-      summaryPath,
-      messageCount: cleanedMessages.length,
-      transcriptChars: normalizedTranscript.length
-    };
+  const omissionMarker = "\n\n[Earlier middle transcript omitted for brevity]\n\n";
+  const headBudget = Math.max(0, Math.floor((maxChars - omissionMarker.length) * 0.35));
+  const tailBudget = Math.max(0, maxChars - omissionMarker.length - headBudget);
+  const head = trimToBoundary(transcript.slice(0, headBudget), false);
+  const tail = trimToBoundary(transcript.slice(-tailBudget), true);
+  return `${head}${omissionMarker}${tail}`.trim();
+}
+function trimToBoundary(value, fromStart) {
+  if (value.length === 0) {
+    return value;
   }
-  if (cleanedMessages.length < MIN_SUMMARY_MESSAGES) {
-    return {
-      status: "skipped",
-      reason: "too_short",
-      summaryPath,
+  if (fromStart) {
+    const boundary = value.search(/\s/u);
+    return boundary >= 0 ? value.slice(boundary).trimStart() : value.trim();
+  }
+  const reversedBoundary = value.trimEnd().search(/\s\S*$/u);
+  return reversedBoundary >= 0 ? value.slice(0, reversedBoundary).trimEnd() : value.trim();
+}
+
+// ../../src/adapters/openclaw/episode/episode-summary-prompt.ts
+var OPENCLAW_EPISODE_GENERATOR_VERSION = "openclaw-episodic-summary-v1";
+
+// ../../src/adapters/openclaw/episode/episode-writer.ts
+var EPISODE_SUMMARY_TIMEOUT_MS = 45e3;
+var EPISODE_SUMMARY_TIMEOUT = /* @__PURE__ */ Symbol("episode-summary-timeout");
+var EPISODE_EMBEDDING_TIMEOUT = /* @__PURE__ */ Symbol("episode-embedding-timeout");
+var EPISODE_EMBEDDING_MIN_HEADROOM_MS = 5e3;
+var OpenClawEpisodeSummaryTimeoutError = class extends Error {
+  /**
+   * Creates a timeout error with a stable name for caller-side handling.
+   */
+  constructor() {
+    super("Episode summary generation timed out.");
+    this.name = "OpenClawEpisodeSummaryTimeoutError";
+  }
+};
+async function writeOpenClawPredecessorEpisode(params) {
+  const sessionContext = formatSessionContext(params.ctx.sessionId, params.ctx.sessionKey);
+  const writeStartedAtMs = Date.now();
+  if (!params.predecessor) {
+    params.logger.info(`[agenr] session-start predecessor episode write skipped for ${sessionContext} reason=no_predecessor`);
+    return;
+  }
+  params.logger.info(`[agenr] session-start predecessor episode write triggered for ${sessionContext} predecessor=${params.predecessor.sessionFile}`);
+  try {
+    const existingEpisode = await params.services.database.getEpisodeBySourceId("openclaw", params.predecessor.sessionId);
+    if (existingEpisode) {
+      params.logger.info(
+        `[agenr] session-start predecessor episode write skipped for ${sessionContext} predecessor=${params.predecessor.sessionFile} reason=already_exists episode=${existingEpisode.id}`
+      );
+      return;
+    }
+    const parsedTranscript = await openClawTranscriptParser.parseFile(params.predecessor.sessionFile);
+    const cleanedMessages = parsedTranscript.messages.filter((message) => message.text.trim().length > 0);
+    if (cleanedMessages.length < MIN_EPISODE_MESSAGES) {
+      params.logger.info(
+        `[agenr] session-start predecessor episode write skipped for ${sessionContext} predecessor=${params.predecessor.sessionFile} reason=too_short cleanedMessages=${cleanedMessages.length}`
+      );
+      return;
+    }
+    const startedAt = parsedTranscript.metadata.startedAt?.trim();
+    const endedAt = parsedTranscript.metadata.endedAt?.trim();
+    if (!startedAt || !endedAt) {
+      params.logger.info(
+        `[agenr] session-start predecessor episode write skipped for ${sessionContext} predecessor=${params.predecessor.sessionFile} reason=missing_metadata`
+      );
+      return;
+    }
+    const episodeExecution = resolveEpisodeSummaryExecution(params.services.openClaw, params.ctx.agentId);
+    const episodeModel = formatResolvedEpisodeSummaryModel(episodeExecution.provider, episodeExecution.model);
+    const transcript = capEpisodeTranscript(renderTranscript(cleanedMessages), MAX_EPISODE_TRANSCRIPT_CHARS);
+    const episodeSummaryLlm = createEpisodeSummaryLlm({
+      logger: params.logger,
+      model: episodeModel,
+      openClaw: params.services.openClaw,
+      sessionFile: params.predecessor.sessionFile,
+      summaryExecution: episodeExecution
+    });
+    const structured = await generateEpisodeSummary(transcript, episodeSummaryLlm);
+    if (!structured) {
+      params.logger.info(
+        `[agenr] session-start predecessor episode write failed for ${sessionContext} predecessor=${params.predecessor.sessionFile} reason=invalid_response model=${episodeModel}`
+      );
+      return;
+    }
+    const embedding = await maybeEmbedEpisodeSummary({
+      summary: structured.summary,
+      embedding: params.services.embedding,
+      embeddingAvailable: params.services.embeddingStatus.available,
+      logger: params.logger,
+      sessionContext,
+      predecessorFile: params.predecessor.sessionFile,
+      deadlineMs: writeStartedAtMs + EPISODE_SUMMARY_TIMEOUT_MS
+    });
+    const writeResult = await params.services.database.upsertEpisode({
+      source: "openclaw",
+      sourceId: params.predecessor.sessionId,
+      sourceRef: params.predecessor.sessionFile,
+      transcriptHash: parsedTranscript.metadata.transcriptHash,
+      agentId: params.ctx.agentId?.trim(),
+      surface: resolveSessionSurface(params.ctx),
+      startedAt,
+      endedAt,
+      summary: structured.summary,
+      tags: structured.tags,
+      activityLevel: structured.activityLevel,
+      project: structured.project,
+      genModel: episodeModel,
+      genVersion: OPENCLAW_EPISODE_GENERATOR_VERSION,
       messageCount: cleanedMessages.length,
-      transcriptChars: normalizedTranscript.length
-    };
+      ...embedding ? { embedding } : {}
+    });
+    const actionMessage = writeResult.action === "inserted" ? "written" : writeResult.action === "updated" ? "updated" : "unchanged";
+    params.logger.info(
+      `[agenr] session-start predecessor episode write ${actionMessage} for ${sessionContext} predecessor=${params.predecessor.sessionFile} episode=${writeResult.episode.id}`
+    );
+  } catch (error) {
+    if (error instanceof OpenClawEpisodeSummaryTimeoutError) {
+      params.logger.info(
+        `[agenr] session-start predecessor episode write timed_out for ${sessionContext} predecessor=${params.predecessor.sessionFile} timeoutMs=${EPISODE_SUMMARY_TIMEOUT_MS}`
+      );
+      return;
+    }
+    params.logger.info(
+      `[agenr] session-start predecessor episode write failed for ${sessionContext} predecessor=${params.predecessor.sessionFile} reason=${formatErrorMessage2(error)}`
+    );
   }
-  const summaryExecution = resolveSummaryExecution(params.openClaw, params.agentId);
-  const summaryModel = formatResolvedModel(summaryExecution.provider, summaryExecution.model);
-  const prompt = [
-    "Produce a concise continuity summary for the next session.",
-    "Prefer short paragraphs. Use a short 'Open loops' section only if it adds clarity.",
-    "",
-    "Transcript:",
-    normalizedTranscript
-  ].join("\n");
-  debugLog4(
-    params.logger,
-    "summary",
-    `sending summary prompt model=${summaryModel} promptChars=${prompt.length} transcriptChars=${normalizedTranscript.length}`
-  );
-  params.logger.info(
-    `[agenr] summary: using OpenClaw embedded agent provider=${summaryExecution.provider} model=${summaryExecution.model} agent=${summaryExecution.agentId}`
-  );
-  debugLog4(
-    params.logger,
-    "summary",
-    `resolved OpenClaw summary model for file=${sessionFile}: agentId=${summaryExecution.agentId} modelRef=${summaryExecution.modelRef ?? "default"} provider=${summaryExecution.provider} model=${summaryExecution.model}`
-  );
+}
+function resolveSessionSurface(ctx) {
+  const sessionKey = ctx.sessionKey?.trim() ?? "";
+  if (/^agent:[^:]+:tui/i.test(sessionKey)) {
+    return "tui";
+  }
+  const provider = ctx.messageProvider?.trim();
+  if (provider) {
+    return provider.toLowerCase();
+  }
+  return void 0;
+}
+function createEpisodeSummaryLlm(params) {
+  const complete = async (systemPrompt, userMessage) => {
+    const response = await generateEpisodeSummaryResponse({
+      logger: params.logger,
+      model: params.model,
+      openClaw: params.openClaw,
+      systemPrompt,
+      userMessage,
+      sessionFile: params.sessionFile,
+      summaryExecution: params.summaryExecution
+    });
+    if (response === EPISODE_SUMMARY_TIMEOUT) {
+      throw new OpenClawEpisodeSummaryTimeoutError();
+    }
+    return response;
+  };
+  return {
+    complete,
+    completeJson: async (systemPrompt, userMessage) => {
+      const response = await complete(systemPrompt, userMessage);
+      return JSON.parse(response);
+    }
+  };
+}
+async function generateEpisodeSummaryResponse(params) {
   const runEmbeddedPiAgent = params.openClaw.runtime.agent.runEmbeddedPiAgent;
   if (typeof runEmbeddedPiAgent !== "function") {
-    params.logger.warn?.(`[agenr] summary: OpenClaw embedded agent runner unavailable for file=${sessionFile}`);
-    return {
-      status: "skipped",
-      reason: "embedded_agent_unavailable",
-      summaryPath,
-      messageCount: cleanedMessages.length,
-      transcriptChars: normalizedTranscript.length,
-      model: summaryModel
-    };
+    throw new Error(`embedded_agent_unavailable model=${params.model}`);
   }
-  const startedAt = Date.now();
-  let tempSessionFile;
+  const tempSessionFile = await createTempEpisodeSummarySessionFile();
   try {
-    tempSessionFile = await createTempSummarySessionFile();
-    const runId = `agenr-summary-${Date.now()}`;
-    const response = extractEmbeddedAgentText(
-      await runEmbeddedPiAgent({
-        sessionId: runId,
-        sessionKey: "temp:agenr-summary",
-        agentId: summaryExecution.agentId,
+    const result = await awaitWithTimeout(
+      runEmbeddedPiAgent({
+        sessionId: `agenr-episode-summary-${Date.now()}`,
+        sessionKey: "temp:agenr-episode-summary",
+        agentId: params.summaryExecution.agentId,
         sessionFile: tempSessionFile,
-        workspaceDir: summaryExecution.workspaceDir,
-        agentDir: summaryExecution.agentDir,
+        workspaceDir: params.summaryExecution.workspaceDir,
+        agentDir: params.summaryExecution.agentDir,
         config: params.openClaw.config,
-        prompt,
-        provider: summaryExecution.provider,
-        model: summaryExecution.model,
-        timeoutMs: SUMMARY_TIMEOUT_MS,
-        runId,
+        prompt: params.userMessage,
+        provider: params.summaryExecution.provider,
+        model: params.summaryExecution.model,
+        timeoutMs: EPISODE_SUMMARY_TIMEOUT_MS,
+        runId: `agenr-episode-summary-${Date.now()}`,
         disableTools: true,
-        extraSystemPrompt: SUMMARY_SYSTEM_PROMPT
-      })
-    ).trim();
-    const durationMs = Date.now() - startedAt;
-    const normalizedSummary = normalizeSummary(response);
-    debugLog4(params.logger, "summary", `received summary response model=${summaryModel} durationMs=${durationMs} chars=${normalizedSummary.length}`);
-    if (normalizedSummary.length === 0) {
-      return {
-        status: "failed",
-        reason: "empty_response",
-        summaryPath,
-        messageCount: cleanedMessages.length,
-        transcriptChars: normalizedTranscript.length,
-        model: summaryModel,
-        durationMs
-      };
+        extraSystemPrompt: params.systemPrompt
+      }),
+      EPISODE_SUMMARY_TIMEOUT_MS
+    );
+    if (result === EPISODE_SUMMARY_TIMEOUT) {
+      return EPISODE_SUMMARY_TIMEOUT;
     }
-    const existingSummary = await readOpenClawSessionSummaryFile(sessionFile, params.logger);
-    if (existingSummary?.summaryPath === summaryPath) {
-      debugLog4(params.logger, "summary", `summary file already exists at write time path=${summaryPath} chars=${existingSummary.content.length}`);
-      return {
-        status: "skipped",
-        reason: "already_exists",
-        summaryPath,
-        content: existingSummary.content,
-        messageCount: cleanedMessages.length,
-        transcriptChars: normalizedTranscript.length,
-        model: summaryModel,
-        durationMs
-      };
+    const text = extractEmbeddedAgentText(result).trim();
+    if (!text) {
+      throw new Error(`empty_response model=${params.model}`);
     }
-    const summaryBytes = Buffer.byteLength(`${normalizedSummary}
-`, "utf8");
-    await fs5.writeFile(summaryPath, `${normalizedSummary}
-`, "utf8");
-    debugLog4(params.logger, "summary", `wrote summary file path=${summaryPath} chars=${normalizedSummary.length} bytes=${summaryBytes}`);
-    return {
-      status: "written",
-      summaryPath,
-      content: normalizedSummary,
-      messageCount: cleanedMessages.length,
-      transcriptChars: normalizedTranscript.length,
-      model: summaryModel,
-      durationMs,
-      bytesWritten: summaryBytes
-    };
-  } catch (error) {
-    const durationMs = Date.now() - startedAt;
-    debugLog4(params.logger, "summary", `summary generation error for file=${sessionFile}: ${formatErrorMessage3(error)}`);
-    return {
-      status: "failed",
-      reason: formatErrorMessage3(error),
-      summaryPath,
-      messageCount: cleanedMessages.length,
-      transcriptChars: normalizedTranscript.length,
-      model: summaryModel,
-      durationMs
-    };
+    return text;
   } finally {
-    await cleanupTempSummarySessionFile(tempSessionFile);
+    await cleanupTempEpisodeSummarySessionFile(tempSessionFile);
   }
 }
-async function writeOpenClawSessionSummary(params) {
-  return generateAndWriteOpenClawSessionSummary(params);
-}
-function renderTranscriptForSummary(messages) {
-  return messages.map((message) => `${message.role === "user" ? "User" : "Assistant"}: ${message.text.trim()}`).join("\n");
-}
-function debugLog4(logger, subsystem, message) {
-  logger.debug?.(`[agenr] ${subsystem}: ${message}`);
-}
-function normalizeSummary(value) {
-  const trimmed = value.trim();
-  return trimmed.replace(/^# .+\n+/u, "").trim();
-}
-function resolveSummaryExecution(openClaw, requestedAgentId) {
+function resolveEpisodeSummaryExecution(openClaw, requestedAgentId) {
   const agentId = requestedAgentId?.trim() || resolveDefaultAgentId(openClaw.config);
   const modelRef = resolveAgentEffectiveModelPrimary(openClaw.config, agentId);
   const parsedModelRef = modelRef ? parseModelRef(modelRef, DEFAULT_PROVIDER) : null;
@@ -3410,224 +4150,965 @@ function resolveSummaryExecution(openClaw, requestedAgentId) {
     agentId,
     agentDir: openClaw.runtime.agent.resolveAgentDir(openClaw.config, agentId),
     workspaceDir: openClaw.runtime.agent.resolveAgentWorkspaceDir(openClaw.config, agentId),
-    modelRef,
     provider: parsedModelRef?.provider ?? DEFAULT_PROVIDER,
     model: parsedModelRef?.model ?? DEFAULT_MODEL
   };
 }
-function formatResolvedModel(provider, model) {
+function formatResolvedEpisodeSummaryModel(provider, model) {
   return `${provider}/${model}`;
 }
-async function createTempSummarySessionFile() {
-  const tempDir = await fs5.mkdtemp(path4.join(os.tmpdir(), "agenr-summary-"));
-  return path4.join(tempDir, "session.jsonl");
-}
-async function cleanupTempSummarySessionFile(tempSessionFile) {
-  if (!tempSessionFile) {
-    return;
-  }
-  try {
-    await fs5.rm(path4.dirname(tempSessionFile), {
-      recursive: true,
-      force: true
-    });
-  } catch {
+async function maybeEmbedEpisodeSummary(params) {
+  if (!params.embeddingAvailable) {
+    params.logger.info(
+      `[agenr] session-start predecessor episode embedding skipped for ${params.sessionContext} predecessor=${params.predecessorFile} reason=embedding_unavailable`
+    );
+    return void 0;
   }
-}
-function extractEmbeddedAgentText(result) {
-  return result.payloads?.find((payload) => payload.text?.trim())?.text ?? "";
-}
-function formatErrorMessage3(error) {
-  return error instanceof Error ? error.message : String(error);
-}
-function capTranscript(transcript, maxChars) {
-  if (transcript.length <= maxChars) {
-    return transcript;
+  const remainingBudgetMs = params.deadlineMs - Date.now();
+  if (remainingBudgetMs < EPISODE_EMBEDDING_MIN_HEADROOM_MS) {
+    params.logger.info(
+      `[agenr] session-start predecessor episode embedding skipped for ${params.sessionContext} predecessor=${params.predecessorFile} reason=budget_tight remainingMs=${Math.max(
+        0,
+        remainingBudgetMs
+      )}`
+    );
+    return void 0;
   }
-  const omissionMarker = "\n\n[Earlier middle transcript omitted for brevity]\n\n";
-  const headBudget = Math.max(0, Math.floor((maxChars - omissionMarker.length) * 0.35));
+  try {
+    const result = await awaitEmbeddingWithTimeout(params.embedding.embed([params.summary]), remainingBudgetMs);
+    if (result === EPISODE_EMBEDDING_TIMEOUT) {
+      params.logger.info(
+        `[agenr] session-start predecessor episode embedding skipped for ${params.sessionContext} predecessor=${params.predecessorFile} reason=embedding_timeout budgetMs=${remainingBudgetMs}`
+      );
+      return void 0;
+    }
+    const vector = result[0]?.map((value) => Number.isFinite(value) ? value : 0);
+    if (!vector || vector.length === 0) {
+      params.logger.info(
+        `[agenr] session-start predecessor episode embedding skipped for ${params.sessionContext} predecessor=${params.predecessorFile} reason=empty_embedding`
+      );
+      return void 0;
+    }
+    return vector;
+  } catch (error) {
+    params.logger.info(
+      `[agenr] session-start predecessor episode embedding skipped for ${params.sessionContext} predecessor=${params.predecessorFile} reason=${formatErrorMessage2(error)}`
+    );
+    return void 0;
+  }
+}
+async function awaitWithTimeout(promise, timeoutMs) {
+  return new Promise((resolve, reject) => {
+    const timeout = setTimeout(() => {
+      resolve(EPISODE_SUMMARY_TIMEOUT);
+    }, timeoutMs);
+    promise.then(
+      (value) => {
+        clearTimeout(timeout);
+        resolve(value);
+      },
+      (error) => {
+        clearTimeout(timeout);
+        reject(error);
+      }
+    );
+  });
+}
+async function awaitEmbeddingWithTimeout(promise, timeoutMs) {
+  return new Promise((resolve, reject) => {
+    const timeout = setTimeout(() => {
+      resolve(EPISODE_EMBEDDING_TIMEOUT);
+    }, timeoutMs);
+    promise.then(
+      (value) => {
+        clearTimeout(timeout);
+        resolve(value);
+      },
+      (error) => {
+        clearTimeout(timeout);
+        reject(error);
+      }
+    );
+  });
+}
+async function createTempEpisodeSummarySessionFile() {
+  const tempDir = await fs3.mkdtemp(path.join(os.tmpdir(), "agenr-episode-summary-"));
+  return path.join(tempDir, "session.jsonl");
+}
+async function cleanupTempEpisodeSummarySessionFile(tempEpisodeSummarySessionFile) {
+  try {
+    await fs3.rm(path.dirname(tempEpisodeSummarySessionFile), {
+      recursive: true,
+      force: true
+    });
+  } catch {
+  }
+}
+function extractEmbeddedAgentText(result) {
+  return result.payloads?.find((payload) => payload.text?.trim())?.text ?? "";
+}
+
+// ../../src/adapters/openclaw/format/recall-format.ts
+var MAX_CONTENT_CHARS = 280;
+function formatAgenrSessionStartRecall(recall2) {
+  const sections = buildSections(recall2);
+  if (sections.length === 0) {
+    return "";
+  }
+  const lines = ["## Agenr Session Recall", "Use this as prior context. Confirm anything important if the current conversation conflicts with it.", ""];
+  for (const section of sections) {
+    lines.push(`### ${section.title}`);
+    for (const item of section.entries) {
+      lines.push(formatEntryHeader(item));
+      lines.push(formatEntryBody(item.entry));
+    }
+    lines.push("");
+  }
+  return lines.join("\n").trim();
+}
+function buildSections(recall2) {
+  const sections = [];
+  const coreEntries = recall2.core.map((entry) => ({ entry }));
+  if (coreEntries.length > 0) {
+    sections.push({ title: "Core Memory", entries: coreEntries });
+  }
+  return sections;
+}
+function formatEntryHeader(item) {
+  const metadata = [
+    item.entry.id,
+    item.entry.type,
+    item.entry.expiry,
+    `importance ${item.entry.importance}`,
+    item.score !== void 0 ? `score ${item.score.toFixed(2)}` : void 0
+  ].filter((value) => value !== void 0);
+  return `- [${metadata.join(" | ")}] ${item.entry.subject}`;
+}
+function formatEntryBody(entry) {
+  const content = truncate2(entry.content.trim(), MAX_CONTENT_CHARS);
+  const extra = [
+    entry.tags.length > 0 ? `tags: ${entry.tags.join(", ")}` : void 0,
+    entry.created_at ? `created: ${entry.created_at.slice(0, 10)}` : void 0
+  ].filter((value) => value !== void 0);
+  if (extra.length === 0) {
+    return `  ${content}`;
+  }
+  return `  ${content} (${extra.join(" | ")})`;
+}
+function truncate2(value, maxChars) {
+  if (value.length <= maxChars) {
+    return value;
+  }
+  return `${value.slice(0, maxChars - 3).trimEnd()}...`;
+}
+
+// ../../src/adapters/openclaw/session/continuity/continuity-summary-generator.ts
+import { promises as fs5 } from "fs";
+import os2 from "os";
+import path4 from "path";
+import { DEFAULT_MODEL as DEFAULT_MODEL2, DEFAULT_PROVIDER as DEFAULT_PROVIDER2, parseModelRef as parseModelRef2, resolveAgentEffectiveModelPrimary as resolveAgentEffectiveModelPrimary2, resolveDefaultAgentId as resolveDefaultAgentId2 } from "openclaw/plugin-sdk/agent-runtime";
+
+// ../../src/adapters/openclaw/session/continuity/continuity-summary-reader.ts
+import { promises as fs4 } from "fs";
+import path3 from "path";
+
+// ../../src/adapters/openclaw/session/session-id.ts
+import path2 from "path";
+function deriveOpenClawSessionIdFromFilePath(sessionFile, logger) {
+  const normalizedSessionFile = sessionFile.trim();
+  if (normalizedSessionFile.length === 0) {
+    debugLog(logger, "session-id", "cannot derive session id from empty session file path");
+    return void 0;
+  }
+  const fileName = path2.basename(normalizedSessionFile);
+  const sessionId = fileName.replace(/\.jsonl(?:\..*)?$/i, "").trim();
+  debugLog(logger, "session-id", `derived session id "${sessionId || "<empty>"}" from file=${normalizedSessionFile}`);
+  return sessionId.length > 0 ? sessionId : void 0;
+}
+function debugLog(logger, subsystem, message) {
+  logger?.debug?.(`[agenr] ${subsystem}: ${message}`);
+}
+
+// ../../src/adapters/openclaw/session/continuity/continuity-summary-reader.ts
+function resolveOpenClawContinuitySummaryPath(sessionFile, logger) {
+  const normalizedSessionFile = sessionFile.trim();
+  const sessionId = deriveOpenClawSessionIdFromFilePath(normalizedSessionFile, logger);
+  if (!sessionId) {
+    return void 0;
+  }
+  const continuitySummaryPath = path3.join(path3.dirname(normalizedSessionFile), `${sessionId}.continuity-summary.md`);
+  debugLog2(logger, "continuity-summary-reader", `resolved continuity summary path for session=${sessionId}: ${continuitySummaryPath}`);
+  return continuitySummaryPath;
+}
+async function readOpenClawContinuitySummaryFile(sessionFile, logger) {
+  const continuitySummaryPath = resolveOpenClawContinuitySummaryPath(sessionFile, logger);
+  const sessionId = deriveOpenClawSessionIdFromFilePath(sessionFile, logger);
+  if (!continuitySummaryPath || !sessionId) {
+    return null;
+  }
+  try {
+    const continuitySummaryContent = (await fs4.readFile(continuitySummaryPath, "utf8")).trim();
+    if (continuitySummaryContent.length === 0) {
+      debugLog2(logger, "continuity-summary-reader", `continuity summary file is empty for session=${sessionId} path=${continuitySummaryPath}`);
+      return null;
+    }
+    debugLog2(
+      logger,
+      "continuity-summary-reader",
+      `loaded continuity summary file for session=${sessionId} path=${continuitySummaryPath} chars=${continuitySummaryContent.length}`
+    );
+    return {
+      sessionId,
+      continuitySummaryPath,
+      content: continuitySummaryContent
+    };
+  } catch (error) {
+    if (isFileNotFound(error)) {
+      debugLog2(logger, "continuity-summary-reader", `continuity summary file missing for session=${sessionId} path=${continuitySummaryPath}`);
+      return null;
+    }
+    throw error;
+  }
+}
+function debugLog2(logger, subsystem, message) {
+  logger?.debug?.(`[agenr] ${subsystem}: ${message}`);
+}
+function isFileNotFound(error) {
+  return typeof error === "object" && error !== null && "code" in error && error.code === "ENOENT";
+}
+
+// ../../src/adapters/openclaw/session/continuity/continuity-summary-generator.ts
+var MIN_CONTINUITY_SUMMARY_MESSAGES = 4;
+var MAX_CONTINUITY_TRANSCRIPT_CHARS = 14e3;
+var CONTINUITY_SUMMARY_TIMEOUT_MS = 15e3;
+var CONTINUITY_SUMMARY_SYSTEM_PROMPT = [
+  "You write concise narrative continuity summaries that help the next session continue smoothly.",
+  "The transcript can be about any domain. Do not assume technical, project, or coding context unless the transcript shows it.",
+  "Write 200 to 500 words in plain Markdown with no code fences.",
+  "Capture:",
+  "- what topics were discussed",
+  "- what was learned, decided, agreed on, or corrected",
+  "- what remains unfinished, open, or pending",
+  "- user preferences, clarifications, and constraints that matter for continuity",
+  "- the overall direction or intent of the conversation",
+  "Do not replay the transcript turn by turn. Do not invent facts. If something is uncertain, say so briefly."
+].join("\n");
+async function generateAndWriteOpenClawContinuitySummary(params) {
+  const sessionFile = params.sessionFile.trim();
+  const continuitySummaryPath = resolveOpenClawContinuitySummaryPath(sessionFile, params.logger);
+  if (!continuitySummaryPath) {
+    return {
+      status: "skipped",
+      reason: "missing_session_id"
+    };
+  }
+  const parsedTranscript = await openClawTranscriptParser.parseFile(sessionFile);
+  const cleanedMessages = parsedTranscript.messages.filter((message) => message.text.trim().length > 0);
+  const transcript = renderTranscriptForContinuitySummary(cleanedMessages);
+  const normalizedTranscript = capContinuityTranscript(transcript, MAX_CONTINUITY_TRANSCRIPT_CHARS);
+  debugLog3(
+    params.logger,
+    "continuity-summary",
+    `transcript adapter output for file=${sessionFile}: messages=${cleanedMessages.length} chars=${normalizedTranscript.length}`
+  );
+  if (cleanedMessages.length === 0 || normalizedTranscript.length === 0) {
+    return {
+      status: "skipped",
+      reason: "empty",
+      continuitySummaryPath,
+      messageCount: cleanedMessages.length,
+      transcriptChars: normalizedTranscript.length
+    };
+  }
+  if (cleanedMessages.length < MIN_CONTINUITY_SUMMARY_MESSAGES) {
+    return {
+      status: "skipped",
+      reason: "too_short",
+      continuitySummaryPath,
+      messageCount: cleanedMessages.length,
+      transcriptChars: normalizedTranscript.length
+    };
+  }
+  const continuitySummaryExecution = resolveContinuitySummaryExecution(params.openClaw, params.agentId);
+  const continuitySummaryModel = formatResolvedContinuitySummaryModel(continuitySummaryExecution.provider, continuitySummaryExecution.model);
+  const prompt = [
+    "Produce a concise continuity summary for the next session.",
+    "Prefer short paragraphs. Use a short 'Open loops' section only if it adds clarity.",
+    "",
+    "Transcript:",
+    normalizedTranscript
+  ].join("\n");
+  debugLog3(
+    params.logger,
+    "continuity-summary",
+    `sending continuity summary prompt model=${continuitySummaryModel} promptChars=${prompt.length} transcriptChars=${normalizedTranscript.length}`
+  );
+  params.logger.info(
+    `[agenr] continuity-summary: using OpenClaw embedded agent provider=${continuitySummaryExecution.provider} model=${continuitySummaryExecution.model} agent=${continuitySummaryExecution.agentId}`
+  );
+  debugLog3(
+    params.logger,
+    "continuity-summary",
+    `resolved OpenClaw continuity summary model for file=${sessionFile}: agentId=${continuitySummaryExecution.agentId} modelRef=${continuitySummaryExecution.modelRef ?? "default"} provider=${continuitySummaryExecution.provider} model=${continuitySummaryExecution.model}`
+  );
+  const runEmbeddedPiAgent = params.openClaw.runtime.agent.runEmbeddedPiAgent;
+  if (typeof runEmbeddedPiAgent !== "function") {
+    params.logger.warn?.(`[agenr] continuity-summary: OpenClaw embedded agent runner unavailable for file=${sessionFile}`);
+    return {
+      status: "skipped",
+      reason: "embedded_agent_unavailable",
+      continuitySummaryPath,
+      messageCount: cleanedMessages.length,
+      transcriptChars: normalizedTranscript.length,
+      model: continuitySummaryModel
+    };
+  }
+  const startedAt = Date.now();
+  let tempContinuitySummarySessionFile;
+  try {
+    tempContinuitySummarySessionFile = await createTempContinuitySummarySessionFile();
+    const runId = `agenr-continuity-summary-${Date.now()}`;
+    const response = extractEmbeddedAgentText2(
+      await runEmbeddedPiAgent({
+        sessionId: runId,
+        sessionKey: "temp:agenr-continuity-summary",
+        agentId: continuitySummaryExecution.agentId,
+        sessionFile: tempContinuitySummarySessionFile,
+        workspaceDir: continuitySummaryExecution.workspaceDir,
+        agentDir: continuitySummaryExecution.agentDir,
+        config: params.openClaw.config,
+        prompt,
+        provider: continuitySummaryExecution.provider,
+        model: continuitySummaryExecution.model,
+        timeoutMs: CONTINUITY_SUMMARY_TIMEOUT_MS,
+        runId,
+        disableTools: true,
+        extraSystemPrompt: CONTINUITY_SUMMARY_SYSTEM_PROMPT
+      })
+    ).trim();
+    const durationMs = Date.now() - startedAt;
+    const normalizedContinuitySummary = normalizeContinuitySummary(response);
+    debugLog3(
+      params.logger,
+      "continuity-summary",
+      `received continuity summary response model=${continuitySummaryModel} durationMs=${durationMs} chars=${normalizedContinuitySummary.length}`
+    );
+    if (normalizedContinuitySummary.length === 0) {
+      return {
+        status: "failed",
+        reason: "empty_response",
+        continuitySummaryPath,
+        messageCount: cleanedMessages.length,
+        transcriptChars: normalizedTranscript.length,
+        model: continuitySummaryModel,
+        durationMs
+      };
+    }
+    const existingContinuitySummary = await readOpenClawContinuitySummaryFile(sessionFile, params.logger);
+    if (existingContinuitySummary?.continuitySummaryPath === continuitySummaryPath) {
+      debugLog3(
+        params.logger,
+        "continuity-summary",
+        `continuity summary file already exists at write time path=${continuitySummaryPath} chars=${existingContinuitySummary.content.length}`
+      );
+      return {
+        status: "skipped",
+        reason: "already_exists",
+        continuitySummaryPath,
+        content: existingContinuitySummary.content,
+        messageCount: cleanedMessages.length,
+        transcriptChars: normalizedTranscript.length,
+        model: continuitySummaryModel,
+        durationMs
+      };
+    }
+    const continuitySummaryBytes = Buffer.byteLength(`${normalizedContinuitySummary}
+`, "utf8");
+    await fs5.writeFile(continuitySummaryPath, `${normalizedContinuitySummary}
+`, "utf8");
+    debugLog3(
+      params.logger,
+      "continuity-summary",
+      `wrote continuity summary file path=${continuitySummaryPath} chars=${normalizedContinuitySummary.length} bytes=${continuitySummaryBytes}`
+    );
+    return {
+      status: "written",
+      continuitySummaryPath,
+      content: normalizedContinuitySummary,
+      messageCount: cleanedMessages.length,
+      transcriptChars: normalizedTranscript.length,
+      model: continuitySummaryModel,
+      durationMs,
+      bytesWritten: continuitySummaryBytes
+    };
+  } catch (error) {
+    const durationMs = Date.now() - startedAt;
+    debugLog3(params.logger, "continuity-summary", `continuity summary generation error for file=${sessionFile}: ${formatErrorMessage3(error)}`);
+    return {
+      status: "failed",
+      reason: formatErrorMessage3(error),
+      continuitySummaryPath,
+      messageCount: cleanedMessages.length,
+      transcriptChars: normalizedTranscript.length,
+      model: continuitySummaryModel,
+      durationMs
+    };
+  } finally {
+    await cleanupTempContinuitySummarySessionFile(tempContinuitySummarySessionFile);
+  }
+}
+function renderTranscriptForContinuitySummary(messages) {
+  return messages.map((message) => `${message.role === "user" ? "User" : "Assistant"}: ${message.text.trim()}`).join("\n");
+}
+function debugLog3(logger, subsystem, message) {
+  logger.debug?.(`[agenr] ${subsystem}: ${message}`);
+}
+function normalizeContinuitySummary(value) {
+  const trimmed = value.trim();
+  return trimmed.replace(/^# .+\n+/u, "").trim();
+}
+function resolveContinuitySummaryExecution(openClaw, requestedAgentId) {
+  const agentId = requestedAgentId?.trim() || resolveDefaultAgentId2(openClaw.config);
+  const modelRef = resolveAgentEffectiveModelPrimary2(openClaw.config, agentId);
+  const parsedModelRef = modelRef ? parseModelRef2(modelRef, DEFAULT_PROVIDER2) : null;
+  return {
+    agentId,
+    agentDir: openClaw.runtime.agent.resolveAgentDir(openClaw.config, agentId),
+    workspaceDir: openClaw.runtime.agent.resolveAgentWorkspaceDir(openClaw.config, agentId),
+    modelRef,
+    provider: parsedModelRef?.provider ?? DEFAULT_PROVIDER2,
+    model: parsedModelRef?.model ?? DEFAULT_MODEL2
+  };
+}
+function formatResolvedContinuitySummaryModel(provider, model) {
+  return `${provider}/${model}`;
+}
+async function createTempContinuitySummarySessionFile() {
+  const tempDir = await fs5.mkdtemp(path4.join(os2.tmpdir(), "agenr-continuity-summary-"));
+  return path4.join(tempDir, "session.jsonl");
+}
+async function cleanupTempContinuitySummarySessionFile(tempContinuitySummarySessionFile) {
+  if (!tempContinuitySummarySessionFile) {
+    return;
+  }
+  try {
+    await fs5.rm(path4.dirname(tempContinuitySummarySessionFile), {
+      recursive: true,
+      force: true
+    });
+  } catch {
+  }
+}
+function extractEmbeddedAgentText2(result) {
+  return result.payloads?.find((payload) => payload.text?.trim())?.text ?? "";
+}
+function formatErrorMessage3(error) {
+  return error instanceof Error ? error.message : String(error);
+}
+function capContinuityTranscript(transcript, maxChars) {
+  if (transcript.length <= maxChars) {
+    return transcript;
+  }
+  const omissionMarker = "\n\n[Earlier middle transcript omitted for brevity]\n\n";
+  const headBudget = Math.max(0, Math.floor((maxChars - omissionMarker.length) * 0.35));
   const tailBudget = Math.max(0, maxChars - omissionMarker.length - headBudget);
-  const head = trimToBoundary(transcript.slice(0, headBudget), false);
-  const tail = trimToBoundary(transcript.slice(-tailBudget), true);
+  const head = trimToBoundary2(transcript.slice(0, headBudget), false);
+  const tail = trimToBoundary2(transcript.slice(-tailBudget), true);
   return `${head}${omissionMarker}${tail}`.trim();
 }
-function trimToBoundary(value, fromStart) {
-  if (value.length === 0) {
-    return value;
+function trimToBoundary2(value, fromStart) {
+  if (value.length === 0) {
+    return value;
+  }
+  if (fromStart) {
+    const boundary = value.search(/\s/);
+    return boundary >= 0 ? value.slice(boundary).trimStart() : value.trim();
+  }
+  const reversedBoundary = value.trimEnd().search(/\s\S*$/u);
+  return reversedBoundary >= 0 ? value.slice(0, reversedBoundary).trimEnd() : value.trim();
+}
+
+// ../../src/adapters/openclaw/session/continuity/predecessor-resolver.ts
+import path6 from "path";
+
+// ../../src/adapters/openclaw/session/sessions-store-reader.ts
+import { promises as fs6 } from "fs";
+import path5 from "path";
+async function readOpenClawSessionsStore(sessionsDir, logger) {
+  const normalizedSessionsDir = sessionsDir.trim();
+  if (normalizedSessionsDir.length === 0) {
+    debugLog4(logger, "sessions-store-reader", "skipping sessions.json read because sessionsDir is empty");
+    return [];
+  }
+  const resolvedSessionsDir = path5.resolve(normalizedSessionsDir);
+  const sessionsJsonPath = path5.join(resolvedSessionsDir, "sessions.json");
+  try {
+    const raw = await fs6.readFile(sessionsJsonPath, "utf8");
+    const parsed = JSON.parse(raw);
+    if (!isRecord2(parsed)) {
+      debugLog4(logger, "sessions-store-reader", `sessions.json did not contain an object: path=${sessionsJsonPath}`);
+      return [];
+    }
+    const entries = [];
+    for (const [sessionKey, value] of Object.entries(parsed)) {
+      const normalizedSessionKey = sessionKey.trim();
+      if (normalizedSessionKey.length === 0) {
+        debugLog4(logger, "sessions-store-reader", `skipping blank session key in ${sessionsJsonPath}`);
+        continue;
+      }
+      if (!isRecord2(value)) {
+        debugLog4(logger, "sessions-store-reader", `skipping non-object entry for key=${normalizedSessionKey}`);
+        continue;
+      }
+      const sessionId = asTrimmedString(value["sessionId"]);
+      const sessionFile = asTrimmedString(value["sessionFile"]);
+      const origin = isRecord2(value["origin"]) ? value["origin"] : void 0;
+      const surface = asTrimmedString(origin?.["surface"]);
+      const provider = asTrimmedString(origin?.["provider"]);
+      const chatType = asTrimmedString(value["chatType"]);
+      const updatedAt = asFiniteNumber(value["updatedAt"]);
+      entries.push({
+        sessionKey: normalizedSessionKey,
+        ...sessionId ? { sessionId } : {},
+        ...sessionFile ? { sessionFile: resolveSessionStorePath(sessionFile, resolvedSessionsDir) } : {},
+        ...surface ? { surface } : {},
+        ...provider ? { provider } : {},
+        ...chatType ? { chatType } : {},
+        ...updatedAt !== void 0 ? { updatedAt } : {}
+      });
+    }
+    debugLog4(logger, "sessions-store-reader", `loaded sessions.json entries=${entries.length} path=${sessionsJsonPath}`);
+    return entries;
+  } catch (error) {
+    if (isFileNotFound2(error)) {
+      debugLog4(logger, "sessions-store-reader", `sessions.json missing at ${sessionsJsonPath}`);
+      return [];
+    }
+    if (error instanceof SyntaxError) {
+      debugLog4(logger, "sessions-store-reader", `sessions.json parse failed at ${sessionsJsonPath}: ${error.message}`);
+      return [];
+    }
+    debugLog4(logger, "sessions-store-reader", `sessions.json read failed at ${sessionsJsonPath}: ${formatErrorMessage4(error)}`);
+    return [];
+  }
+}
+function resolveSessionStorePath(candidatePath, sessionsDir) {
+  return path5.isAbsolute(candidatePath) ? path5.resolve(candidatePath) : path5.resolve(sessionsDir, candidatePath);
+}
+function isRecord2(value) {
+  return typeof value === "object" && value !== null;
+}
+function asTrimmedString(value) {
+  return typeof value === "string" && value.trim().length > 0 ? value.trim() : void 0;
+}
+function asFiniteNumber(value) {
+  return typeof value === "number" && Number.isFinite(value) ? value : void 0;
+}
+function debugLog4(logger, subsystem, message) {
+  logger?.debug?.(`[agenr] ${subsystem}: ${message}`);
+}
+function isFileNotFound2(error) {
+  return typeof error === "object" && error !== null && "code" in error && error.code === "ENOENT";
+}
+function formatErrorMessage4(error) {
+  if (error instanceof Error) {
+    return error.message;
+  }
+  return String(error);
+}
+
+// ../../src/adapters/openclaw/session/tui-lane.ts
+var TUI_SESSION_KEY_PATTERN = /^agent:([^:]+):([^:]+)$/i;
+var TUI_UUID_LANE_PATTERN = /^tui[a-z0-9]*-[0-9a-f]{8}-[0-9a-f]{4}-[0-9a-f]{4}-[0-9a-f]{4}-[0-9a-f]{12}$/i;
+var TUI_UUID_SUFFIX_PATTERN = /-[0-9a-f]{8}-[0-9a-f]{4}-[0-9a-f]{4}-[0-9a-f]{4}-[0-9a-f]{12}$/i;
+function parseTuiSessionKey(sessionKey) {
+  const normalizedSessionKey = sessionKey.trim();
+  if (normalizedSessionKey.length === 0) {
+    return null;
+  }
+  const match = TUI_SESSION_KEY_PATTERN.exec(normalizedSessionKey);
+  if (!match) {
+    return null;
+  }
+  const [, agentId, instanceLane] = match;
+  const normalizedAgentId = agentId?.trim();
+  const normalizedInstanceLane = instanceLane?.trim();
+  if (!normalizedAgentId || !normalizedInstanceLane || !normalizedInstanceLane.toLowerCase().startsWith("tui")) {
+    return null;
+  }
+  const stableLane = TUI_UUID_LANE_PATTERN.test(normalizedInstanceLane) ? normalizedInstanceLane.replace(TUI_UUID_SUFFIX_PATTERN, "") : normalizedInstanceLane;
+  return {
+    agentId: normalizedAgentId,
+    stableLane,
+    instanceLane: normalizedInstanceLane
+  };
+}
+
+// ../../src/adapters/openclaw/session/continuity/predecessor-resolver.ts
+async function resolveOpenClawSessionPredecessor(ctx, tracker, params) {
+  const sessionContext = formatSessionContext2(ctx.sessionId, ctx.sessionKey);
+  debugLog5(params.logger, "predecessor", `resolving predecessor for ${sessionContext}`);
+  const tuiIdentity = parseTuiSessionKey(ctx.sessionKey ?? "");
+  if (!tuiIdentity) {
+    debugLog5(params.logger, "predecessor", `skipping TUI predecessor resolution for ${sessionContext}: current session key is not TUI`);
+    return void 0;
+  }
+  const resumedFrom = tracker.getResumedFrom(ctx.sessionId);
+  if (resumedFrom) {
+    debugLog5(params.logger, "predecessor", `session_start resumedFrom for ${sessionContext}: ${resumedFrom}`);
+  } else {
+    debugLog5(params.logger, "predecessor", `session_start resumedFrom unavailable for ${sessionContext}`);
+  }
+  const sessionsDir = resolveOpenClawSessionsDirectory(ctx, tuiIdentity.agentId, params.resolveStateDir);
+  if (!sessionsDir) {
+    params.logger?.info?.(`[agenr] predecessor: TUI no predecessor found for ${sessionContext} reason=no_sessions_dir`);
+    return void 0;
+  }
+  params.logger?.info?.(
+    `[agenr] predecessor: TUI predecessor resolution for ${sessionContext} sessionKey=${ctx.sessionKey?.trim() ?? "unknown"} stableLane=${tuiIdentity.stableLane}`
+  );
+  debugLog5(
+    params.logger,
+    "predecessor",
+    `TUI stable lane for ${sessionContext}: agentId=${tuiIdentity.agentId} instanceLane=${tuiIdentity.instanceLane} stableLane=${tuiIdentity.stableLane} sessionsDir=${sessionsDir}`
+  );
+  const predecessorResolution = await findTuiPredecessor(ctx.sessionKey ?? "", sessionsDir, resumedFrom, params.logger);
+  if (!predecessorResolution.predecessor) {
+    params.logger?.info?.(`[agenr] predecessor: TUI no predecessor found for ${sessionContext} reason=${predecessorResolution.reason}`);
+    return void 0;
+  }
+  params.logger?.info?.(
+    `[agenr] predecessor: TUI predecessor found for ${sessionContext} predecessorKey=${predecessorResolution.predecessor.sessionKey} predecessor=${predecessorResolution.predecessor.sessionFile}`
+  );
+  return {
+    sessionFile: predecessorResolution.predecessor.sessionFile,
+    sessionId: predecessorResolution.predecessor.sessionId
+  };
+}
+async function findTuiPredecessor(currentSessionKey, sessionsDir, resumedFrom, logger) {
+  const currentIdentity = parseTuiSessionKey(currentSessionKey);
+  if (!currentIdentity) {
+    return { reason: "not_tui_session_key" };
+  }
+  const entries = await readOpenClawSessionsStore(sessionsDir, logger);
+  debugLog5(logger, "predecessor", `TUI sessions.json read result for sessionKey=${currentSessionKey}: entries=${entries.length}`);
+  const sameAgentEntries = entries.filter((entry) => {
+    const parsedCandidate = parseSingleLaneSessionKey(entry.sessionKey);
+    if (!parsedCandidate) {
+      debugLog5(logger, "predecessor", `TUI excluded candidate=${entry.sessionKey} reason=unsupported_session_key_shape`);
+      return false;
+    }
+    if (parsedCandidate.agentId !== currentIdentity.agentId) {
+      debugLog5(
+        logger,
+        "predecessor",
+        `TUI excluded candidate=${entry.sessionKey} reason=agent_mismatch expected=${currentIdentity.agentId} actual=${parsedCandidate.agentId}`
+      );
+      return false;
+    }
+    return true;
+  });
+  debugLog5(logger, "predecessor", `TUI candidate filtering for sessionKey=${currentSessionKey}: sameAgentCount=${sameAgentEntries.length}`);
+  if (resumedFrom) {
+    const resumedFromMatch = sameAgentEntries.find((entry) => entry.sessionId === resumedFrom);
+    if (resumedFromMatch) {
+      if (!resumedFromMatch.sessionFile?.trim()) {
+        debugLog5(
+          logger,
+          "predecessor",
+          `TUI ignored session_start resumedFrom match for sessionKey=${currentSessionKey}: resumedFrom=${resumedFrom} reason=missing_session_file`
+        );
+      } else {
+        const resolvedPredecessor = toResolvedTuiPredecessor(resumedFromMatch, logger);
+        if (!resolvedPredecessor) {
+          debugLog5(
+            logger,
+            "predecessor",
+            `TUI ignored session_start resumedFrom match for sessionKey=${currentSessionKey}: resumedFrom=${resumedFrom} reason=missing_session_id`
+          );
+        } else {
+          debugLog5(
+            logger,
+            "predecessor",
+            `TUI matched session_start resumedFrom for sessionKey=${currentSessionKey}: resumedFrom=${resumedFrom} predecessorKey=${resumedFromMatch.sessionKey}`
+          );
+          return {
+            reason: "resolved",
+            predecessor: resolvedPredecessor
+          };
+        }
+      }
+    } else {
+      debugLog5(logger, "predecessor", `TUI found no session_start resumedFrom match for sessionKey=${currentSessionKey}: resumedFrom=${resumedFrom}`);
+    }
+  }
+  const laneMatches = sameAgentEntries.filter((entry) => {
+    const normalizedCandidateKey = entry.sessionKey.trim();
+    if (normalizedCandidateKey === currentSessionKey.trim()) {
+      debugLog5(logger, "predecessor", `TUI excluded candidate=${entry.sessionKey} reason=current_session`);
+      return false;
+    }
+    const candidateKey = parseSingleLaneSessionKey(entry.sessionKey);
+    if (!candidateKey) {
+      return false;
+    }
+    if (currentIdentity.stableLane === "tui" && candidateKey.lane === "main") {
+      return true;
+    }
+    const candidateIdentity = parseTuiSessionKey(entry.sessionKey);
+    if (!candidateIdentity) {
+      debugLog5(logger, "predecessor", `TUI excluded candidate=${entry.sessionKey} reason=not_tui_candidate`);
+      return false;
+    }
+    if (!isSameTuiLane(currentIdentity.stableLane, candidateIdentity.stableLane)) {
+      debugLog5(
+        logger,
+        "predecessor",
+        `TUI excluded candidate=${entry.sessionKey} reason=lane_mismatch currentStableLane=${currentIdentity.stableLane} candidateStableLane=${candidateIdentity.stableLane}`
+      );
+      return false;
+    }
+    return true;
+  });
+  debugLog5(logger, "predecessor", `TUI candidate filtering for sessionKey=${currentSessionKey}: laneMatchCount=${laneMatches.length}`);
+  const sortedCandidates = laneMatches.filter((entry) => {
+    if (!entry.sessionFile?.trim()) {
+      debugLog5(logger, "predecessor", `TUI excluded candidate=${entry.sessionKey} reason=missing_session_file`);
+      return false;
+    }
+    if (entry.updatedAt !== void 0) {
+      return true;
+    }
+    debugLog5(logger, "predecessor", `TUI excluded candidate=${entry.sessionKey} reason=missing_updated_at`);
+    return false;
+  }).sort((left, right) => (right.updatedAt ?? 0) - (left.updatedAt ?? 0));
+  if (sortedCandidates.length === 0) {
+    return { reason: "no_matching_sessions" };
+  }
+  for (const predecessor of sortedCandidates) {
+    const resolvedPredecessor = toResolvedTuiPredecessor(predecessor, logger);
+    if (!resolvedPredecessor) {
+      debugLog5(
+        logger,
+        "predecessor",
+        `TUI excluded candidate=${predecessor.sessionKey} reason=missing_session_id predecessor=${predecessor.sessionFile ?? "unknown"}`
+      );
+      continue;
+    }
+    return {
+      reason: "resolved",
+      predecessor: resolvedPredecessor
+    };
+  }
+  return { reason: "missing_session_id" };
+}
+function resolvePredecessorSessionId(sessionId, sessionFile, logger) {
+  const normalizedSessionId = sessionId?.trim();
+  if (normalizedSessionId) {
+    return normalizedSessionId;
   }
-  if (fromStart) {
-    const boundary = value.search(/\s/);
-    return boundary >= 0 ? value.slice(boundary).trimStart() : value.trim();
+  if (!sessionFile?.trim()) {
+    return void 0;
   }
-  const reversedBoundary = value.trimEnd().search(/\s\S*$/u);
-  return reversedBoundary >= 0 ? value.slice(0, reversedBoundary).trimEnd() : value.trim();
+  return deriveOpenClawSessionIdFromFilePath(sessionFile, logger);
 }
-
-// ../../src/adapters/openclaw/hooks/before-prompt-build.ts
-var CORE_ENTRY_LIMIT = 4;
-var RECENT_SESSION_MESSAGE_LIMIT = 6;
-var RECENT_SESSION_MAX_CHARS = 1800;
-var READ_TIME_SUMMARY_TIMEOUT_MS = 2e4;
-var READ_TIME_SUMMARY_TIMEOUT = /* @__PURE__ */ Symbol("read-time-summary-timeout");
-async function handleAgenrBeforePromptBuild(_event, ctx, params) {
-  const sessionContext = formatSessionContext2(ctx.sessionId, ctx.sessionKey);
-  const trackerState = params.tracker.consume(ctx.sessionId, ctx.sessionKey);
-  if (!trackerState.isFirst) {
-    debugLog5(params.logger, "before_prompt_build", `session tracker duplicate blocked for ${sessionContext}`);
-    debugLog5(params.logger, "before_prompt_build", `session tracker active count=${trackerState.activeCount}`);
-    params.logger.info(`[agenr] session-start recall skipped (already ran) for ${sessionContext}`);
+function toResolvedTuiPredecessor(candidate, logger) {
+  const sessionFile = candidate.sessionFile?.trim();
+  if (!sessionFile) {
     return void 0;
   }
-  debugLog5(params.logger, "before_prompt_build", `session tracker first start for ${sessionContext}`);
-  debugLog5(params.logger, "before_prompt_build", `session tracker active count=${trackerState.activeCount}`);
-  params.logger.info(`[agenr] session-start recall for ${sessionContext}`);
-  try {
-    const services = await params.servicesPromise;
-    const sessionStartRecall = await runAgenrSessionStartRecall(services);
-    const previousSessionContext = await buildPreviousSessionContext(ctx, params.tracker, services, params.logger);
-    const memoryContext = formatAgenrSessionStartRecall(sessionStartRecall);
-    const prependContext = [previousSessionContext, memoryContext].filter((value) => value.trim().length > 0).join("\n\n");
-    params.logger.info(`[agenr] session-start recall: ${sessionStartRecall.core.length} core entries for ${sessionContext}`);
-    debugLog5(params.logger, "before_prompt_build", `session-start core entries for ${sessionContext}: ${formatEntryRefs(sessionStartRecall.core)}`);
-    debugLog5(params.logger, "before_prompt_build", `session-start prependContext length for ${sessionContext}: ${prependContext.length} chars`);
-    if (prependContext.length === 0) {
-      params.logger.info(`[agenr] session-start recall: nothing to inject for ${sessionContext}`);
-      return void 0;
-    }
-    return { prependContext };
-  } catch (error) {
-    params.logger.warn(`[agenr] session-start recall failed for ${sessionContext}: ${formatErrorMessage4(error)}`);
+  const sessionId = resolvePredecessorSessionId(candidate.sessionId, sessionFile, logger);
+  if (!sessionId) {
     return void 0;
   }
+  return {
+    sessionFile,
+    sessionId,
+    sessionKey: candidate.sessionKey
+  };
 }
-async function runAgenrSessionStartRecall(services) {
-  const core = await listOpenClawCoreEntries(services.database, CORE_ENTRY_LIMIT);
+function resolveOpenClawSessionsDirectory(ctx, parsedAgentId, resolveStateDir) {
+  const agentId = ctx.agentId?.trim() || parsedAgentId.trim();
+  if (!agentId) {
+    return void 0;
+  }
+  return path6.join(resolveStateDir(process.env), "agents", agentId, "sessions");
+}
+function parseSingleLaneSessionKey(sessionKey) {
+  const match = /^agent:([^:]+):([^:]+)$/i.exec(sessionKey.trim());
+  if (!match) {
+    return null;
+  }
+  const [, agentId, lane] = match;
+  const normalizedAgentId = agentId?.trim();
+  const normalizedLane = lane?.trim();
+  if (!normalizedAgentId || !normalizedLane) {
+    return null;
+  }
   return {
-    core
+    agentId: normalizedAgentId,
+    lane: normalizedLane
   };
 }
-async function buildPreviousSessionContext(ctx, tracker, services, logger) {
-  const sessionContext = formatSessionContext2(ctx.sessionId, ctx.sessionKey);
+function isSameTuiLane(currentStableLane, candidateStableLane) {
+  if (currentStableLane === "tui") {
+    return candidateStableLane.toLowerCase().startsWith("tui");
+  }
+  return currentStableLane === candidateStableLane;
+}
+function debugLog5(logger, subsystem, message) {
+  logger?.debug?.(`[agenr] ${subsystem}: ${message}`);
+}
+function formatSessionContext2(sessionId, sessionKey) {
+  const normalizedSessionId = sessionId?.trim();
+  const normalizedSessionKey = sessionKey?.trim();
+  if (normalizedSessionId && normalizedSessionKey) {
+    return `session=${normalizedSessionId} key=${normalizedSessionKey}`;
+  }
+  if (normalizedSessionId) {
+    return `session=${normalizedSessionId}`;
+  }
+  if (normalizedSessionKey) {
+    return `key=${normalizedSessionKey}`;
+  }
+  return "session=unknown";
+}
+
+// ../../src/adapters/openclaw/session/continuity/recent-session.ts
+var RECENT_SESSION_MESSAGE_LIMIT = 6;
+var RECENT_SESSION_MAX_CHARS = 1800;
+async function renderRecentSessionSection(sessionFile, logger) {
+  try {
+    const transcript = await openClawTranscriptParser.parseFile(sessionFile);
+    const tail = transcript.messages.slice(-RECENT_SESSION_MESSAGE_LIMIT);
+    const body = capRecentSession(tail.map((message) => `${message.role === "user" ? "U" : "A"}: ${message.text}`).join("\n"), RECENT_SESSION_MAX_CHARS);
+    logger.debug?.(`[agenr] before_prompt_build: recent session tail for file=${sessionFile}: messages=${tail.length} chars=${body.length}`);
+    return body;
+  } catch (error) {
+    logger.debug?.(`[agenr] before_prompt_build: failed to build recent session tail for file=${sessionFile}: ${formatErrorMessage5(error)}`);
+    return "";
+  }
+}
+function formatErrorMessage5(error) {
+  return error instanceof Error ? error.message : String(error);
+}
+function capRecentSession(value, maxChars) {
+  if (value.length <= maxChars) {
+    return value;
+  }
+  const marker = "[...truncated earlier recent session...]\n";
+  return `${marker}${value.slice(-(maxChars - marker.length)).trimStart()}`;
+}
+
+// ../../src/adapters/openclaw/session/continuity/index.ts
+var READ_TIME_CONTINUITY_SUMMARY_TIMEOUT_MS = 2e4;
+var READ_TIME_CONTINUITY_SUMMARY_TIMEOUT = /* @__PURE__ */ Symbol("read-time-continuity-summary-timeout");
+async function resolvePredecessorContinuity(ctx, tracker, services, logger) {
+  const sessionContext = formatSessionContext(ctx.sessionId, ctx.sessionKey);
   const predecessor = await resolveOpenClawSessionPredecessor(ctx, tracker, {
     logger,
     resolveStateDir: services.openClaw.runtime.state.resolveStateDir
   });
   if (!predecessor) {
-    logger.info(`[agenr] session-start predecessor summary not found for ${sessionContext} reason=no_predecessor`);
-    return "";
-  }
-  const sections = [];
-  const summaryContent = await loadPredecessorSummaryContent(sessionContext, predecessor.sessionFile, ctx.agentId, services, logger);
-  if (summaryContent.length > 0) {
-    sections.push(`## Previous session summary
-${summaryContent}`);
-  }
-  const recentSession = await renderRecentSessionSection(predecessor.sessionFile, logger);
-  if (recentSession.length > 0) {
-    sections.push(`## Recent session
-${recentSession}`);
+    logger.info(`[agenr] session-start predecessor continuity summary not found for ${sessionContext} reason=no_predecessor`);
+    return {
+      continuitySummaryContent: "",
+      recentSessionContent: ""
+    };
   }
-  return sections.join("\n\n");
+  return {
+    predecessor,
+    continuitySummaryContent: await loadPredecessorContinuitySummaryContent(sessionContext, predecessor.sessionFile, ctx.agentId, services, logger),
+    recentSessionContent: await renderRecentSessionSection(predecessor.sessionFile, logger)
+  };
 }
-async function loadPredecessorSummaryContent(sessionContext, sessionFile, agentId, services, logger) {
+async function loadPredecessorContinuitySummaryContent(sessionContext, sessionFile, agentId, services, logger) {
   try {
-    const summary = await readOpenClawSessionSummaryFile(sessionFile, logger);
-    if (summary) {
+    const existingContinuitySummary = await readOpenClawContinuitySummaryFile(sessionFile, logger);
+    if (existingContinuitySummary) {
       logger.info(
-        `[agenr] session-start read-time summary generation skipped for ${sessionContext} predecessor=${sessionFile} reason=already_exists path=${summary.summaryPath}`
+        `[agenr] session-start read-time continuity summary generation skipped for ${sessionContext} predecessor=${sessionFile} reason=already_exists path=${existingContinuitySummary.continuitySummaryPath}`
       );
-      logger.info(`[agenr] session-start predecessor summary found for ${sessionContext} path=${summary.summaryPath}`);
-      return summary.content;
+      logger.info(`[agenr] session-start predecessor continuity summary found for ${sessionContext} path=${existingContinuitySummary.continuitySummaryPath}`);
+      return existingContinuitySummary.content;
     }
-    logger.info(`[agenr] session-start predecessor summary not found for ${sessionContext} predecessor=${sessionFile}`);
+    logger.info(`[agenr] session-start predecessor continuity summary not found for ${sessionContext} predecessor=${sessionFile}`);
   } catch (error) {
-    logger.info(`[agenr] session-start predecessor summary not found for ${sessionContext} predecessor=${sessionFile} reason=${formatErrorMessage4(error)}`);
-    debugLog5(logger, "before_prompt_build", `failed reading predecessor summary for ${sessionContext}: ${formatErrorMessage4(error)}`);
+    logger.info(
+      `[agenr] session-start predecessor continuity summary not found for ${sessionContext} predecessor=${sessionFile} reason=${formatErrorMessage2(error)}`
+    );
+    logger.debug?.(`[agenr] before_prompt_build: failed reading predecessor continuity summary for ${sessionContext}: ${formatErrorMessage2(error)}`);
     return "";
   }
-  logger.info(`[agenr] session-start read-time summary generation triggered for ${sessionContext} predecessor=${sessionFile} reason=no_existing_summary`);
+  logger.info(
+    `[agenr] session-start read-time continuity summary generation triggered for ${sessionContext} predecessor=${sessionFile} reason=no_existing_continuity_summary`
+  );
   const startedAt = Date.now();
   try {
-    const result = await awaitWithTimeout(
-      generateAndWriteOpenClawSessionSummary({
+    const result = await awaitWithTimeout2(
+      generateAndWriteOpenClawContinuitySummary({
         sessionFile,
         agentId,
         openClaw: services.openClaw,
         logger
       }),
-      READ_TIME_SUMMARY_TIMEOUT_MS
+      READ_TIME_CONTINUITY_SUMMARY_TIMEOUT_MS
     );
     const elapsedMs2 = Date.now() - startedAt;
-    if (result === READ_TIME_SUMMARY_TIMEOUT) {
+    if (result === READ_TIME_CONTINUITY_SUMMARY_TIMEOUT) {
       logger.info(
-        `[agenr] session-start read-time summary generation failed for ${sessionContext} predecessor=${sessionFile} reason=timeout elapsedMs=${elapsedMs2}`
+        `[agenr] session-start read-time continuity summary generation failed for ${sessionContext} predecessor=${sessionFile} reason=timeout elapsedMs=${elapsedMs2}`
       );
-      debugLog5(
-        logger,
-        "before_prompt_build",
-        `read-time summary generation timed out for ${sessionContext}: predecessor=${sessionFile} timeoutMs=${READ_TIME_SUMMARY_TIMEOUT_MS}`
+      logger.debug?.(
+        `[agenr] before_prompt_build: read-time continuity summary generation timed out for ${sessionContext}: predecessor=${sessionFile} timeoutMs=${READ_TIME_CONTINUITY_SUMMARY_TIMEOUT_MS}`
       );
       return "";
     }
-    return handleReadTimeSummaryResult(sessionContext, sessionFile, result, elapsedMs2, logger);
+    return handleReadTimeContinuitySummaryResult(sessionContext, sessionFile, result, elapsedMs2, logger);
   } catch (error) {
     const elapsedMs2 = Date.now() - startedAt;
     logger.info(
-      `[agenr] session-start read-time summary generation failed for ${sessionContext} predecessor=${sessionFile} reason=${formatErrorMessage4(error)} elapsedMs=${elapsedMs2}`
+      `[agenr] session-start read-time continuity summary generation failed for ${sessionContext} predecessor=${sessionFile} reason=${formatErrorMessage2(error)} elapsedMs=${elapsedMs2}`
+    );
+    logger.debug?.(
+      `[agenr] before_prompt_build: unexpected read-time continuity summary generation failure for ${sessionContext}: ${formatErrorMessage2(error)}`
     );
-    debugLog5(logger, "before_prompt_build", `unexpected read-time summary generation failure for ${sessionContext}: ${formatErrorMessage4(error)}`);
     return "";
   }
 }
-function handleReadTimeSummaryResult(sessionContext, sessionFile, result, elapsedMs2, logger) {
-  if (result.status === "written" && result.content && result.summaryPath) {
+function handleReadTimeContinuitySummaryResult(sessionContext, sessionFile, result, elapsedMs2, logger) {
+  if (result.status === "written" && result.content && result.continuitySummaryPath) {
     logger.info(
-      `[agenr] session-start read-time summary generation completed for ${sessionContext} predecessor=${sessionFile} elapsedMs=${elapsedMs2} path=${result.summaryPath}`
+      `[agenr] session-start read-time continuity summary generation completed for ${sessionContext} predecessor=${sessionFile} elapsedMs=${elapsedMs2} path=${result.continuitySummaryPath}`
     );
-    logger.info(`[agenr] session-start predecessor summary found for ${sessionContext} path=${result.summaryPath}`);
+    logger.info(`[agenr] session-start predecessor continuity summary found for ${sessionContext} path=${result.continuitySummaryPath}`);
     return result.content;
   }
   if (result.status === "skipped") {
     logger.info(
-      `[agenr] session-start read-time summary generation skipped for ${sessionContext} predecessor=${sessionFile} reason=${result.reason ?? "unknown"} path=${result.summaryPath ?? "n/a"}`
+      `[agenr] session-start read-time continuity summary generation skipped for ${sessionContext} predecessor=${sessionFile} reason=${result.reason ?? "unknown"} path=${result.continuitySummaryPath ?? "n/a"}`
     );
-    debugLog5(
-      logger,
-      "before_prompt_build",
-      `read-time summary generation skipped for ${sessionContext}: predecessor=${sessionFile} transcriptChars=${result.transcriptChars ?? 0} cleanedMessages=${result.messageCount ?? 0}`
+    logger.debug?.(
+      `[agenr] before_prompt_build: read-time continuity summary generation skipped for ${sessionContext}: predecessor=${sessionFile} transcriptChars=${result.transcriptChars ?? 0} cleanedMessages=${result.messageCount ?? 0}`
     );
-    if (result.reason === "already_exists" && result.content && result.summaryPath) {
-      logger.info(`[agenr] session-start predecessor summary found for ${sessionContext} path=${result.summaryPath}`);
+    if (result.reason === "already_exists" && result.content && result.continuitySummaryPath) {
+      logger.info(`[agenr] session-start predecessor continuity summary found for ${sessionContext} path=${result.continuitySummaryPath}`);
       return result.content;
     }
     return "";
   }
   logger.info(
-    `[agenr] session-start read-time summary generation failed for ${sessionContext} predecessor=${sessionFile} reason=${result.reason ?? "unknown"} elapsedMs=${elapsedMs2} model=${result.model ?? "unknown"}`
+    `[agenr] session-start read-time continuity summary generation failed for ${sessionContext} predecessor=${sessionFile} reason=${result.reason ?? "unknown"} elapsedMs=${elapsedMs2} model=${result.model ?? "unknown"}`
   );
-  debugLog5(
-    logger,
-    "before_prompt_build",
-    `read-time summary generation failed for ${sessionContext}: predecessor=${sessionFile} durationMs=${result.durationMs ?? 0} transcriptChars=${result.transcriptChars ?? 0}`
+  logger.debug?.(
+    `[agenr] before_prompt_build: read-time continuity summary generation failed for ${sessionContext}: predecessor=${sessionFile} durationMs=${result.durationMs ?? 0} transcriptChars=${result.transcriptChars ?? 0}`
   );
   return "";
 }
-async function renderRecentSessionSection(sessionFile, logger) {
-  try {
-    const transcript = await openClawTranscriptParser.parseFile(sessionFile);
-    const tail = transcript.messages.slice(-RECENT_SESSION_MESSAGE_LIMIT);
-    const body = capRecentSession(tail.map((message) => `${message.role === "user" ? "U" : "A"}: ${message.text}`).join("\n"), RECENT_SESSION_MAX_CHARS);
-    debugLog5(logger, "before_prompt_build", `recent session tail for file=${sessionFile}: messages=${tail.length} chars=${body.length}`);
-    return body;
-  } catch (error) {
-    debugLog5(logger, "before_prompt_build", `failed to build recent session tail for file=${sessionFile}: ${formatErrorMessage4(error)}`);
-    return "";
-  }
-}
-async function awaitWithTimeout(promise, timeoutMs) {
+async function awaitWithTimeout2(promise, timeoutMs) {
   return new Promise((resolve, reject) => {
     const timeout = setTimeout(() => {
-      resolve(READ_TIME_SUMMARY_TIMEOUT);
+      resolve(READ_TIME_CONTINUITY_SUMMARY_TIMEOUT);
     }, timeoutMs);
     promise.then(
       (value) => {
@@ -3641,121 +5122,66 @@ async function awaitWithTimeout(promise, timeoutMs) {
     );
   });
 }
-function debugLog5(logger, subsystem, message) {
-  logger.debug?.(`[agenr] ${subsystem}: ${message}`);
-}
-function formatSessionContext2(sessionId, sessionKey) {
-  const normalizedSessionId = sessionId?.trim();
-  const normalizedSessionKey = sessionKey?.trim();
-  if (normalizedSessionId && normalizedSessionKey) {
-    return `session=${normalizedSessionId} key=${normalizedSessionKey}`;
-  }
-  if (normalizedSessionId) {
-    return `session=${normalizedSessionId}`;
-  }
-  if (normalizedSessionKey) {
-    return `key=${normalizedSessionKey}`;
-  }
-  return "session=unknown";
-}
-function formatEntryRefs(entries) {
-  if (entries.length === 0) {
-    return "none";
-  }
-  return entries.map((entry) => `${entry.subject} [${entry.id}]`).join(", ");
-}
-function formatErrorMessage4(error) {
-  if (error instanceof Error) {
-    return error.message;
-  }
-  return String(error);
-}
-function capRecentSession(value, maxChars) {
-  if (value.length <= maxChars) {
-    return value;
-  }
-  const marker = "[...truncated earlier recent session...]\n";
-  return `${marker}${value.slice(-(maxChars - marker.length)).trimStart()}`;
-}
 
-// ../../src/adapters/openclaw/hooks/before-reset.ts
-async function handleAgenrBeforeReset(event, ctx, params) {
-  const sessionContext = formatSessionContext3(ctx.sessionId, ctx.sessionKey);
-  const sessionFile = event.sessionFile?.trim();
-  const rawMessageCount = Array.isArray(event.messages) ? event.messages.length : 0;
-  if (!sessionFile) {
-    params.logger.info(`[agenr] before_reset: summary generation skipped for ${sessionContext} reason=no_session_file rawMessages=${rawMessageCount}`);
-    debugLog6(params.logger, "before_reset", `skipping summary for ${sessionContext} because no session file was provided`);
-    return;
+// ../../src/adapters/openclaw/hooks/before-prompt-build.ts
+var CORE_ENTRY_LIMIT = 4;
+var INTERNAL_AGENR_SESSION_PREFIX = "temp:agenr-";
+async function handleAgenrBeforePromptBuild(_event, ctx, params) {
+  const sessionContext = formatSessionContext(ctx.sessionId, ctx.sessionKey);
+  const trackerState = params.tracker.consume(ctx.sessionId, ctx.sessionKey);
+  if (!trackerState.isFirst) {
+    params.logger.debug?.(`[agenr] before_prompt_build: session tracker duplicate blocked for ${sessionContext}`);
+    params.logger.debug?.(`[agenr] before_prompt_build: session tracker active count=${trackerState.activeCount}`);
+    params.logger.info(`[agenr] session-start recall skipped (already ran) for ${sessionContext}`);
+    return void 0;
   }
-  params.tracker.rememberReset(ctx.sessionKey, {
-    sessionFile,
-    recordedAt: (/* @__PURE__ */ new Date()).toISOString(),
-    ...ctx.sessionId?.trim() ? { sessionId: ctx.sessionId.trim() } : {}
-  });
-  params.logger.info(
-    `[agenr] before_reset: summary generation started for ${sessionContext} reason=${event.reason ?? "unknown"} rawMessages=${rawMessageCount}`
-  );
-  debugLog6(
-    params.logger,
-    "before_reset",
-    `summary request details for ${sessionContext}: file=${sessionFile} workspace=${ctx.workspaceDir ?? "unknown"} reason=${event.reason ?? "unknown"}`
-  );
+  if (isInternalAgenrSession(ctx.sessionKey)) {
+    params.logger.debug?.(`[agenr] before_prompt_build: skipping pipeline for internal session ${sessionContext}`);
+    return void 0;
+  }
+  params.logger.debug?.(`[agenr] before_prompt_build: session tracker first start for ${sessionContext}`);
+  params.logger.debug?.(`[agenr] before_prompt_build: session tracker active count=${trackerState.activeCount}`);
+  params.logger.info(`[agenr] session-start recall for ${sessionContext}`);
   try {
     const services = await params.servicesPromise;
-    const result = await writeOpenClawSessionSummary({
-      sessionFile,
-      agentId: ctx.agentId,
-      openClaw: services.openClaw,
+    const continuity = await resolvePredecessorContinuity(ctx, params.tracker, services, params.logger);
+    void writeOpenClawPredecessorEpisode({
+      ctx,
+      predecessor: continuity.predecessor,
+      services,
       logger: params.logger
     });
-    if (result.status === "written") {
-      params.logger.info(`[agenr] before_reset: summary file written for ${sessionContext} path=${result.summaryPath} bytes=${result.bytesWritten ?? 0}`);
-      return;
-    }
-    if (result.status === "skipped") {
-      params.logger.info(
-        `[agenr] before_reset: summary generation skipped for ${sessionContext} reason=${result.reason ?? "unknown"} cleanedMessages=${result.messageCount ?? 0}`
-      );
-      debugLog6(
-        params.logger,
-        "before_reset",
-        `skip details for ${sessionContext}: summaryPath=${result.summaryPath ?? "n/a"} transcriptChars=${result.transcriptChars ?? 0}`
-      );
-      return;
+    const sessionStartRecall = await runAgenrSessionStartRecall(services);
+    const memoryContext = formatAgenrSessionStartRecall(sessionStartRecall);
+    const sections = [
+      continuity.continuitySummaryContent && `## Previous session summary
+${continuity.continuitySummaryContent}`,
+      continuity.recentSessionContent && `## Recent session
+${continuity.recentSessionContent}`,
+      memoryContext
+    ].filter((value) => Boolean(value && value.trim().length > 0));
+    const prependContext = sections.join("\n\n");
+    params.logger.info(`[agenr] session-start recall: ${sessionStartRecall.core.length} core entries for ${sessionContext}`);
+    params.logger.debug?.(`[agenr] before_prompt_build: session-start core entries for ${sessionContext}: ${formatEntryRefs(sessionStartRecall.core)}`);
+    params.logger.debug?.(`[agenr] before_prompt_build: session-start prependContext length for ${sessionContext}: ${prependContext.length} chars`);
+    if (prependContext.length === 0) {
+      params.logger.info(`[agenr] session-start recall: nothing to inject for ${sessionContext}`);
+      return void 0;
     }
-    params.logger.info(
-      `[agenr] before_reset: summary generation failed for ${sessionContext} reason=${result.reason ?? "unknown"} model=${result.model ?? "unknown"}`
-    );
-    debugLog6(
-      params.logger,
-      "before_reset",
-      `failure details for ${sessionContext}: summaryPath=${result.summaryPath ?? "n/a"} durationMs=${result.durationMs ?? 0} transcriptChars=${result.transcriptChars ?? 0}`
-    );
-  } catch (error) {
-    params.logger.info(`[agenr] before_reset: summary generation failed for ${sessionContext} reason=${formatErrorMessage5(error)} model=unknown`);
-    debugLog6(params.logger, "before_reset", `unexpected failure for ${sessionContext}: ${formatErrorMessage5(error)}`);
-  }
-}
-function debugLog6(logger, subsystem, message) {
-  logger.debug?.(`[agenr] ${subsystem}: ${message}`);
-}
-function formatErrorMessage5(error) {
-  return error instanceof Error ? error.message : String(error);
-}
-function formatSessionContext3(sessionId, sessionKey) {
-  const normalizedSessionId = sessionId?.trim();
-  const normalizedSessionKey = sessionKey?.trim();
-  if (normalizedSessionId && normalizedSessionKey) {
-    return `session=${normalizedSessionId} key=${normalizedSessionKey}`;
-  }
-  if (normalizedSessionId) {
-    return `session=${normalizedSessionId}`;
-  }
-  if (normalizedSessionKey) {
-    return `key=${normalizedSessionKey}`;
+    return { prependContext };
+  } catch (error) {
+    params.logger.warn(`[agenr] session-start recall failed for ${sessionContext}: ${formatErrorMessage2(error)}`);
+    return void 0;
   }
-  return "session=unknown";
+}
+async function runAgenrSessionStartRecall(services) {
+  return { core: await listOpenClawCoreEntries(services.database, CORE_ENTRY_LIMIT) };
+}
+function formatEntryRefs(entries) {
+  return entries.length === 0 ? "none" : entries.map((entry) => `${entry.subject} [${entry.id}]`).join(", ");
+}
+function isInternalAgenrSession(sessionKey) {
+  return Boolean(sessionKey?.startsWith(INTERNAL_AGENR_SESSION_PREFIX));
 }
 
 // ../../src/adapters/openclaw/memory/flush-plan.ts
@@ -3946,8 +5372,9 @@ async function sleep(durationMs) {
 }
 
 // ../../src/adapters/db/schema.ts
-var SCHEMA_VERSION = "2";
+var SCHEMA_VERSION = "4";
 var VECTOR_INDEX_NAME = "idx_entries_embedding";
+var EPISODE_VECTOR_INDEX_NAME = "idx_episodes_embedding";
 var BULK_WRITE_STATE_META_KEY = "bulk_write_state";
 var CREATE_ENTRIES_TABLE_SQL = `
   CREATE TABLE IF NOT EXISTS entries (
@@ -3969,6 +5396,8 @@ var CREATE_ENTRIES_TABLE_SQL = `
     last_recalled_at TEXT,
     superseded_by TEXT REFERENCES entries(id),
     cluster_id TEXT,
+    user_id TEXT,
+    project TEXT,
     retired INTEGER NOT NULL DEFAULT 0,
     retired_at TEXT,
     retired_reason TEXT,
@@ -4017,6 +5446,51 @@ var CREATE_INGEST_LOG_TABLE_SQL = `
     entry_count INTEGER DEFAULT 0
   )
 `;
+var CREATE_EPISODES_TABLE_SQL = `
+  CREATE TABLE IF NOT EXISTS episodes (
+    id TEXT PRIMARY KEY,
+    source TEXT NOT NULL,
+    source_id TEXT,
+    source_ref TEXT,
+    transcript_hash TEXT,
+    summary_hash TEXT,
+    agent_id TEXT,
+    surface TEXT,
+    started_at TEXT NOT NULL,
+    ended_at TEXT,
+    summary TEXT NOT NULL,
+    tags TEXT,
+    activity_level TEXT,
+    user_id TEXT,
+    project TEXT,
+    gen_model TEXT,
+    gen_version TEXT,
+    message_count INTEGER,
+    embedding F32_BLOB(1024),
+    retired INTEGER NOT NULL DEFAULT 0,
+    retired_at TEXT,
+    retired_reason TEXT,
+    superseded_by TEXT REFERENCES episodes(id),
+    created_at TEXT NOT NULL,
+    updated_at TEXT NOT NULL
+  )
+`;
+var CREATE_TASKS_TABLE_SQL = `
+  CREATE TABLE IF NOT EXISTS tasks (
+    id TEXT PRIMARY KEY,
+    subject TEXT NOT NULL,
+    content TEXT NOT NULL,
+    status TEXT NOT NULL DEFAULT 'open',
+    priority INTEGER NOT NULL DEFAULT 5,
+    tags TEXT,
+    source_context TEXT,
+    project TEXT,
+    created_at TEXT NOT NULL,
+    updated_at TEXT NOT NULL,
+    completed_at TEXT,
+    due_at TEXT
+  )
+`;
 var CREATE_RECALL_EVENTS_TABLE_SQL = `
   CREATE TABLE IF NOT EXISTS recall_events (
     id TEXT PRIMARY KEY,
@@ -4102,6 +5576,43 @@ var CREATE_ENTRIES_CREATED_AT_INDEX_SQL = `
   CREATE INDEX IF NOT EXISTS idx_entries_created_at
   ON entries(created_at)
 `;
+var CREATE_EPISODES_STARTED_AT_INDEX_SQL = `
+  CREATE INDEX IF NOT EXISTS idx_episodes_started_at
+  ON episodes(started_at)
+`;
+var CREATE_EPISODES_ENDED_AT_INDEX_SQL = `
+  CREATE INDEX IF NOT EXISTS idx_episodes_ended_at
+  ON episodes(ended_at)
+`;
+var CREATE_EPISODES_SOURCE_INDEX_SQL = `
+  CREATE INDEX IF NOT EXISTS idx_episodes_source
+  ON episodes(source)
+`;
+var CREATE_EPISODES_SOURCE_ID_INDEX_SQL = `
+  CREATE INDEX IF NOT EXISTS idx_episodes_source_id
+  ON episodes(source_id)
+`;
+var CREATE_EPISODES_RETIRED_INDEX_SQL = `
+  CREATE INDEX IF NOT EXISTS idx_episodes_retired
+  ON episodes(retired)
+`;
+var CREATE_EPISODES_SOURCE_SOURCE_ID_UNIQUE_INDEX_SQL = `
+  CREATE UNIQUE INDEX IF NOT EXISTS idx_episodes_source_source_id
+  ON episodes(source, source_id)
+  WHERE source_id IS NOT NULL
+`;
+var CREATE_TASKS_STATUS_INDEX_SQL = `
+  CREATE INDEX IF NOT EXISTS idx_tasks_status
+  ON tasks(status)
+`;
+var CREATE_TASKS_CREATED_AT_INDEX_SQL = `
+  CREATE INDEX IF NOT EXISTS idx_tasks_created_at
+  ON tasks(created_at)
+`;
+var CREATE_TASKS_PROJECT_INDEX_SQL = `
+  CREATE INDEX IF NOT EXISTS idx_tasks_project
+  ON tasks(project)
+`;
 var CREATE_RECALL_EVENTS_ENTRY_ID_INDEX_SQL = `
   CREATE INDEX IF NOT EXISTS idx_recall_events_entry_id
   ON recall_events(entry_id)
@@ -4123,6 +5634,19 @@ var CREATE_ENTRIES_EMBEDDING_INDEX_SQL = `
     AND retired = 0
     AND superseded_by IS NULL
 `;
+var CREATE_EPISODES_EMBEDDING_INDEX_SQL = `
+  CREATE INDEX IF NOT EXISTS idx_episodes_embedding ON episodes (
+    libsql_vector_idx(
+      embedding,
+      'metric=cosine',
+      'compress_neighbors=float8',
+      'max_neighbors=50'
+    )
+  )
+  WHERE embedding IS NOT NULL
+    AND retired = 0
+    AND superseded_by IS NULL
+`;
 var SCHEMA_STATEMENTS = [
   CREATE_ENTRIES_TABLE_SQL,
   CREATE_ENTRIES_FTS_TABLE_SQL,
@@ -4130,6 +5654,8 @@ var SCHEMA_STATEMENTS = [
   CREATE_ENTRIES_FTS_DELETE_TRIGGER_SQL,
   CREATE_ENTRIES_FTS_UPDATE_TRIGGER_SQL,
   CREATE_INGEST_LOG_TABLE_SQL,
+  CREATE_EPISODES_TABLE_SQL,
+  CREATE_TASKS_TABLE_SQL,
   CREATE_RECALL_EVENTS_TABLE_SQL,
   CREATE_SURGEON_RUNS_TABLE_SQL,
   CREATE_META_TABLE_SQL,
@@ -4139,6 +5665,15 @@ var SCHEMA_STATEMENTS = [
   CREATE_ENTRIES_EXPIRY_INDEX_SQL,
   CREATE_ENTRIES_RETIRED_INDEX_SQL,
   CREATE_ENTRIES_CREATED_AT_INDEX_SQL,
+  CREATE_EPISODES_STARTED_AT_INDEX_SQL,
+  CREATE_EPISODES_ENDED_AT_INDEX_SQL,
+  CREATE_EPISODES_SOURCE_INDEX_SQL,
+  CREATE_EPISODES_SOURCE_ID_INDEX_SQL,
+  CREATE_EPISODES_RETIRED_INDEX_SQL,
+  CREATE_EPISODES_SOURCE_SOURCE_ID_UNIQUE_INDEX_SQL,
+  CREATE_TASKS_STATUS_INDEX_SQL,
+  CREATE_TASKS_CREATED_AT_INDEX_SQL,
+  CREATE_TASKS_PROJECT_INDEX_SQL,
   CREATE_RECALL_EVENTS_ENTRY_ID_INDEX_SQL,
   CREATE_RECALL_EVENTS_RECALLED_AT_INDEX_SQL
 ];
@@ -4150,6 +5685,12 @@ async function initSchema(db) {
     await db.execute(statement);
   }
   await ensureSurgeonSchema(db);
+  if (currentVersion === "2") {
+    await migrateSchemaV2ToV3(db);
+  }
+  if (currentVersion === "3") {
+    await migrateSchemaV3ToV4(db);
+  }
   await db.execute({
     sql: `
       INSERT INTO _meta (key, value)
@@ -4165,7 +5706,7 @@ async function initSchema(db) {
   if (currentVersion !== SCHEMA_VERSION || !hadEntriesFts) {
     await rebuildFts(db);
   }
-  await ensureVectorIndex(db);
+  await ensureVectorIndexes(db);
 }
 async function ensureSurgeonSchema(db) {
   const columns = await db.execute("PRAGMA table_info('surgeon_runs')");
@@ -4206,6 +5747,44 @@ async function ensureSurgeonSchema(db) {
   await db.execute(CREATE_SURGEON_RUN_ACTIONS_ENTRY_ID_INDEX_SQL);
   await db.execute(CREATE_SURGEON_RUN_ACTIONS_CREATED_AT_INDEX_SQL);
 }
+async function migrateSchemaV2ToV3(db) {
+  await runImmediateTransaction(db, async () => {
+    await db.execute("DROP TRIGGER IF EXISTS entries_ai");
+    await db.execute("DROP TRIGGER IF EXISTS entries_ad");
+    await db.execute("DROP TRIGGER IF EXISTS entries_au");
+    await db.execute("UPDATE entries SET type = 'milestone' WHERE type = 'event'");
+    await db.execute(`
+      INSERT INTO tasks (id, subject, content, status, priority, tags, source_context, created_at, updated_at)
+      SELECT id, subject, content, 'open', importance, tags, source_context, created_at, updated_at
+      FROM entries
+      WHERE type = 'todo' AND retired = 0
+    `);
+    await db.execute("DELETE FROM entries WHERE type = 'todo'");
+    await db.execute("DELETE FROM entries WHERE type = 'reflection'");
+    if (!await columnExists(db, "entries", "user_id")) {
+      await db.execute("ALTER TABLE entries ADD COLUMN user_id TEXT");
+    }
+    if (!await columnExists(db, "entries", "project")) {
+      await db.execute("ALTER TABLE entries ADD COLUMN project TEXT");
+    }
+    await db.execute(CREATE_ENTRIES_FTS_INSERT_TRIGGER_SQL);
+    await db.execute(CREATE_ENTRIES_FTS_DELETE_TRIGGER_SQL);
+    await db.execute(CREATE_ENTRIES_FTS_UPDATE_TRIGGER_SQL);
+  });
+}
+async function migrateSchemaV3ToV4(db) {
+  for (const statement of [
+    CREATE_EPISODES_TABLE_SQL,
+    CREATE_EPISODES_STARTED_AT_INDEX_SQL,
+    CREATE_EPISODES_ENDED_AT_INDEX_SQL,
+    CREATE_EPISODES_SOURCE_INDEX_SQL,
+    CREATE_EPISODES_SOURCE_ID_INDEX_SQL,
+    CREATE_EPISODES_RETIRED_INDEX_SQL,
+    CREATE_EPISODES_SOURCE_SOURCE_ID_UNIQUE_INDEX_SQL
+  ]) {
+    await db.execute(statement);
+  }
+}
 async function rebuildFts(db) {
   await db.execute("INSERT INTO entries_fts(entries_fts) VALUES ('rebuild')");
 }
@@ -4222,7 +5801,7 @@ async function prepareBulkWrites(db) {
     await db.execute("DROP TRIGGER IF EXISTS entries_ai");
     await db.execute("DROP TRIGGER IF EXISTS entries_ad");
     await db.execute("DROP TRIGGER IF EXISTS entries_au");
-    await dropVectorIndex(db);
+    await dropVectorIndexes(db);
   });
 }
 async function finalizeBulkWrites(db) {
@@ -4231,7 +5810,7 @@ async function finalizeBulkWrites(db) {
     await db.execute(CREATE_ENTRIES_FTS_DELETE_TRIGGER_SQL);
     await db.execute(CREATE_ENTRIES_FTS_UPDATE_TRIGGER_SQL);
     await rebuildFts(db);
-    await ensureVectorIndex(db);
+    await ensureVectorIndexes(db);
     await db.execute({
       sql: "DELETE FROM _meta WHERE key = ?",
       args: [BULK_WRITE_STATE_META_KEY]
@@ -4264,6 +5843,13 @@ async function tableExists(db, tableName) {
   });
   return result.rows.length > 0;
 }
+async function columnExists(db, tableName, columnName) {
+  const result = await db.execute(`PRAGMA table_info('${tableName.replaceAll("'", "''")}')`);
+  return result.rows.some((row) => {
+    const name = row.name;
+    return name === columnName;
+  });
+}
 async function hasActiveBulkWriteState(db) {
   try {
     const result = await db.execute({
@@ -4276,18 +5862,20 @@ async function hasActiveBulkWriteState(db) {
     return false;
   }
 }
-async function ensureVectorIndex(db) {
+async function ensureVectorIndexes(db) {
   try {
     await db.execute(CREATE_ENTRIES_EMBEDDING_INDEX_SQL);
+    await db.execute(CREATE_EPISODES_EMBEDDING_INDEX_SQL);
   } catch (error) {
     if (!isVectorUnavailableError(error)) {
       throw error;
     }
   }
 }
-async function dropVectorIndex(db) {
+async function dropVectorIndexes(db) {
   try {
     await db.execute(`DROP INDEX IF EXISTS ${VECTOR_INDEX_NAME}`);
+    await db.execute(`DROP INDEX IF EXISTS ${EPISODE_VECTOR_INDEX_NAME}`);
   } catch (error) {
     if (!isVectorUnavailableError(error)) {
       throw error;
@@ -4383,9 +5971,9 @@ async function probeVectorAvailability(services) {
 }
 
 // ../../src/config.ts
-import fs6 from "fs";
-import os2 from "os";
-import path5 from "path";
+import fs7 from "fs";
+import os3 from "os";
+import path7 from "path";
 import { fileURLToPath } from "url";
 var AUTH_METHOD_DEFINITIONS = [
   {
@@ -4425,7 +6013,7 @@ var AUTH_METHOD_DEFINITIONS = [
   }
 ];
 var AUTH_METHOD_SET = new Set(AUTH_METHOD_DEFINITIONS.map((definition) => definition.id));
-var DEFAULT_CONFIG_DIR = path5.join(os2.homedir(), ".agenr");
+var DEFAULT_CONFIG_DIR = path7.join(os3.homedir(), ".agenr");
 var DEFAULT_DB_NAME = "knowledge.db";
 function resolveConfigDir() {
   return process.env.AGENR_CONFIG_DIR ?? DEFAULT_CONFIG_DIR;
@@ -4443,18 +6031,18 @@ function resolveConfigPath(options = {}) {
   if (adjacentConfigPath) {
     return adjacentConfigPath;
   }
-  return path5.join(resolveConfigDir(), "config.json");
+  return path7.join(resolveConfigDir(), "config.json");
 }
 function resolveDbPath(config) {
-  return process.env.AGENR_DB_PATH ?? config?.dbPath ?? path5.join(resolveConfigDir(), DEFAULT_DB_NAME);
+  return process.env.AGENR_DB_PATH ?? config?.dbPath ?? path7.join(resolveConfigDir(), DEFAULT_DB_NAME);
 }
 function readConfig(options = {}) {
   const configPath = resolveFilesystemPath(resolveConfigPath(options));
-  if (!fs6.existsSync(configPath)) {
+  if (!fs7.existsSync(configPath)) {
     return {};
   }
   try {
-    const raw = fs6.readFileSync(configPath, "utf-8");
+    const raw = fs7.readFileSync(configPath, "utf-8");
     return JSON.parse(raw);
   } catch {
     return {};
@@ -4467,12 +6055,12 @@ function resolveAdjacentConfigPath(dbPath) {
   }
   if (normalizedDbPath.startsWith("file:")) {
     try {
-      return path5.join(path5.dirname(fileURLToPath(normalizedDbPath)), "config.json");
+      return path7.join(path7.dirname(fileURLToPath(normalizedDbPath)), "config.json");
     } catch {
       return void 0;
     }
   }
-  return path5.join(path5.dirname(normalizedDbPath), "config.json");
+  return path7.join(path7.dirname(normalizedDbPath), "config.json");
 }
 function normalizeOptionalString2(value) {
   const normalized = value?.trim();
@@ -4520,6 +6108,8 @@ async function insertEntry(executor, entry, embedding, contentHash) {
         last_recalled_at,
         superseded_by,
         cluster_id,
+        user_id,
+        project,
         retired,
         retired_at,
         retired_reason,
@@ -4529,7 +6119,7 @@ async function insertEntry(executor, entry, embedding, contentHash) {
       VALUES (
         ?, ?, ?, ?, ?, ?, ?, ?, ?,
         CASE WHEN ? IS NULL THEN NULL ELSE vector32(?) END,
-        ?, ?, ?, ?, ?, ?, ?, ?, ?, ?, ?, ?, ?
+        ?, ?, ?, ?, ?, ?, ?, ?, ?, ?, ?, ?, ?, ?, ?
       )
     `,
     args: [
@@ -4552,6 +6142,8 @@ async function insertEntry(executor, entry, embedding, contentHash) {
       normalizeOptionalString3(entry.last_recalled_at),
       normalizeOptionalString3(entry.superseded_by),
       normalizeOptionalString3(entry.cluster_id),
+      normalizeOptionalString3(entry.user_id),
+      normalizeOptionalString3(entry.project),
       entry.retired ? 1 : 0,
       normalizeOptionalString3(entry.retired_at),
       normalizeOptionalString3(entry.retired_reason),
@@ -4589,6 +6181,8 @@ async function getEntries(executor, ids) {
           last_recalled_at,
           superseded_by,
           cluster_id,
+          user_id,
+          project,
           retired,
           retired_at,
           retired_reason,
@@ -4815,6 +6409,8 @@ var ENTRY_SELECT_COLUMNS2 = `
   e.last_recalled_at,
   e.superseded_by,
   e.cluster_id,
+  e.user_id,
+  e.project,
   e.retired,
   e.retired_at,
   e.retired_reason,
@@ -5043,9 +6639,470 @@ function wrapVectorError(error) {
 }
 
 // ../../src/adapters/db/client.ts
-import fs7 from "fs/promises";
-import path6 from "path";
+import fs8 from "fs/promises";
+import path8 from "path";
 import { createClient } from "@libsql/client";
+
+// ../../src/adapters/db/episode-queries.ts
+import { createHash as createHash3, randomUUID as randomUUID3 } from "crypto";
+var EPISODE_SELECT_COLUMNS = `
+  id,
+  source,
+  source_id,
+  source_ref,
+  transcript_hash,
+  summary_hash,
+  agent_id,
+  surface,
+  started_at,
+  ended_at,
+  summary,
+  tags,
+  activity_level,
+  user_id,
+  project,
+  gen_model,
+  gen_version,
+  message_count,
+  embedding,
+  retired,
+  retired_at,
+  retired_reason,
+  superseded_by,
+  created_at,
+  updated_at
+`;
+async function getEpisodeBySourceId(executor, source, sourceId) {
+  const normalizedSourceId = normalizeOptionalString4(sourceId);
+  if (!normalizedSourceId) {
+    return null;
+  }
+  const result = await executor.execute({
+    sql: `
+      SELECT ${EPISODE_SELECT_COLUMNS}
+      FROM episodes
+      WHERE source = ?
+        AND source_id = ?
+      LIMIT 1
+    `,
+    args: [source, normalizedSourceId]
+  });
+  const row = result.rows[0];
+  return row ? mapEpisodeRow(row) : null;
+}
+async function getEpisodeByTranscriptHash(executor, source, transcriptHash) {
+  const normalizedTranscriptHash = normalizeOptionalString4(transcriptHash);
+  if (!normalizedTranscriptHash) {
+    return null;
+  }
+  const result = await executor.execute({
+    sql: `
+      SELECT ${EPISODE_SELECT_COLUMNS}
+      FROM episodes
+      WHERE source = ?
+        AND transcript_hash = ?
+      LIMIT 1
+    `,
+    args: [source, normalizedTranscriptHash]
+  });
+  const row = result.rows[0];
+  return row ? mapEpisodeRow(row) : null;
+}
+async function upsertEpisode(executor, input) {
+  const payload = normalizeEpisodePayload(input);
+  const summaryHash = createEpisodePayloadHash(payload);
+  const existing = payload.sourceId !== void 0 ? await getEpisodeBySourceId(executor, payload.source, payload.sourceId) : await getEpisodeByTranscriptHash(executor, payload.source, readRequiredIdentityHash(payload));
+  if (!existing) {
+    const id = randomUUID3();
+    const now2 = (/* @__PURE__ */ new Date()).toISOString();
+    const vectorJson2 = serializeEmbeddingForVector(payload.embedding ?? []);
+    await executor.execute({
+      sql: `
+        INSERT INTO episodes (
+          id,
+          source,
+          source_id,
+          source_ref,
+          transcript_hash,
+          summary_hash,
+          agent_id,
+          surface,
+          started_at,
+          ended_at,
+          summary,
+          tags,
+          activity_level,
+          user_id,
+          project,
+          gen_model,
+          gen_version,
+          message_count,
+          embedding,
+          retired,
+          retired_at,
+          retired_reason,
+          superseded_by,
+          created_at,
+          updated_at
+        )
+        VALUES (
+          ?, ?, ?, ?, ?, ?, ?, ?, ?, ?, ?, ?, ?, ?, ?, ?, ?, ?,
+          CASE WHEN ? IS NULL THEN NULL ELSE vector32(?) END,
+          0, NULL, NULL, NULL, ?, ?
+        )
+      `,
+      args: [
+        id,
+        payload.source,
+        toNullableString(payload.sourceId),
+        toNullableString(payload.sourceRef),
+        toNullableString(payload.transcriptHash),
+        summaryHash,
+        toNullableString(payload.agentId),
+        toNullableString(payload.surface),
+        payload.startedAt,
+        toNullableString(payload.endedAt),
+        payload.summary,
+        serializeTags(payload.tags),
+        toNullableString(payload.activityLevel),
+        toNullableString(payload.userId),
+        toNullableString(payload.project),
+        toNullableString(payload.genModel),
+        toNullableString(payload.genVersion),
+        toNullableInteger(payload.messageCount),
+        vectorJson2,
+        vectorJson2,
+        now2,
+        now2
+      ]
+    });
+    return {
+      episode: await getEpisodeById(executor, id),
+      action: "inserted"
+    };
+  }
+  const existingSummaryHash = existing.summaryHash ?? createEpisodePayloadHash(normalizeEpisodePayload(fromStoredEpisode(existing)));
+  if (existingSummaryHash === summaryHash) {
+    return {
+      episode: existing,
+      action: "unchanged"
+    };
+  }
+  const now = (/* @__PURE__ */ new Date()).toISOString();
+  const vectorJson = serializeEmbeddingForVector(payload.embedding ?? []);
+  await executor.execute({
+    sql: `
+      UPDATE episodes
+      SET source_ref = ?,
+          transcript_hash = ?,
+          summary_hash = ?,
+          agent_id = ?,
+          surface = ?,
+          started_at = ?,
+          ended_at = ?,
+          summary = ?,
+          tags = ?,
+          activity_level = ?,
+          user_id = ?,
+          project = ?,
+          gen_model = ?,
+          gen_version = ?,
+          message_count = ?,
+          embedding = CASE WHEN ? IS NULL THEN NULL ELSE vector32(?) END,
+          updated_at = ?
+      WHERE id = ?
+    `,
+    args: [
+      toNullableString(payload.sourceRef),
+      toNullableString(payload.transcriptHash),
+      summaryHash,
+      toNullableString(payload.agentId),
+      toNullableString(payload.surface),
+      payload.startedAt,
+      toNullableString(payload.endedAt),
+      payload.summary,
+      serializeTags(payload.tags),
+      toNullableString(payload.activityLevel),
+      toNullableString(payload.userId),
+      toNullableString(payload.project),
+      toNullableString(payload.genModel),
+      toNullableString(payload.genVersion),
+      toNullableInteger(payload.messageCount),
+      vectorJson,
+      vectorJson,
+      now,
+      existing.id
+    ]
+  });
+  return {
+    episode: await getEpisodeById(executor, existing.id),
+    action: "updated"
+  };
+}
+async function listEpisodesByTimeWindow(executor, window, limit) {
+  const bounds = resolveWindowBounds(window);
+  if (!bounds) {
+    return [];
+  }
+  const whereClauses = [buildActiveEpisodeClause()];
+  const args = [];
+  if (bounds.start && bounds.end) {
+    whereClauses.push("started_at <= ?");
+    whereClauses.push("COALESCE(ended_at, started_at) >= ?");
+    args.push(bounds.end, bounds.start);
+  } else if (bounds.start) {
+    whereClauses.push("COALESCE(ended_at, started_at) >= ?");
+    args.push(bounds.start);
+  } else if (bounds.end) {
+    whereClauses.push("started_at <= ?");
+    args.push(bounds.end);
+  } else {
+    return [];
+  }
+  const normalizedLimit = normalizePositiveInteger(limit);
+  const result = await executor.execute({
+    sql: `
+      SELECT ${EPISODE_SELECT_COLUMNS}
+      FROM episodes
+      WHERE ${whereClauses.join(" AND ")}
+      ORDER BY started_at DESC, id ASC
+      ${normalizedLimit ? "LIMIT ?" : ""}
+    `,
+    args: normalizedLimit ? [...args, normalizedLimit] : args
+  });
+  return result.rows.map((row) => mapEpisodeRow(row));
+}
+async function episodeVectorSearch(executor, params) {
+  if (params.limit <= 0 || params.embedding.length === 0) {
+    return [];
+  }
+  const serializedEmbedding = serializeEmbeddingForVector(params.embedding);
+  if (!serializedEmbedding) {
+    return [];
+  }
+  let result;
+  try {
+    result = await executor.execute({
+      sql: `
+        SELECT ${prefixColumns(EPISODE_SELECT_COLUMNS, "e")}
+        FROM vector_top_k('idx_episodes_embedding', vector32(?), ?) AS v
+        JOIN episodes AS e ON e.rowid = v.id
+        WHERE ${buildActiveEpisodeClause("e")}
+        LIMIT ?
+      `,
+      args: [serializedEmbedding, params.limit, params.limit]
+    });
+  } catch (error) {
+    throw wrapEpisodeVectorError(error);
+  }
+  return result.rows.map((row) => {
+    const episode = mapEpisodeRow(row);
+    return {
+      episode,
+      vectorSim: cosineSimilarity(params.embedding, episode.embedding ?? [])
+    };
+  }).filter((candidate) => candidate.vectorSim > 0).sort((left, right) => right.vectorSim - left.vectorSim).slice(0, params.limit);
+}
+async function listEpisodesWithoutEmbeddings(executor, limit) {
+  const normalizedLimit = normalizePositiveInteger(limit);
+  const result = await executor.execute({
+    sql: `
+      SELECT ${EPISODE_SELECT_COLUMNS}
+      FROM episodes
+      WHERE ${buildActiveEpisodeClause()}
+        AND embedding IS NULL
+      ORDER BY started_at DESC, id ASC
+      ${normalizedLimit ? "LIMIT ?" : ""}
+    `,
+    args: normalizedLimit ? [normalizedLimit] : []
+  });
+  return result.rows.map((row) => mapEpisodeRow(row));
+}
+async function updateEpisodeEmbedding(executor, id, embedding) {
+  const now = (/* @__PURE__ */ new Date()).toISOString();
+  const vectorJson = serializeEmbeddingForVector(embedding);
+  await executor.execute({
+    sql: `
+      UPDATE episodes
+      SET embedding = CASE WHEN ? IS NULL THEN NULL ELSE vector32(?) END,
+          updated_at = ?
+      WHERE id = ?
+    `,
+    args: [vectorJson, vectorJson, now, id]
+  });
+}
+function createEpisodePayloadHash(payload) {
+  return createHash3("sha256").update(JSON.stringify(payload)).digest("hex");
+}
+function fromStoredEpisode(episode) {
+  return {
+    source: episode.source,
+    sourceId: episode.sourceId,
+    sourceRef: episode.sourceRef,
+    transcriptHash: episode.transcriptHash,
+    agentId: episode.agentId,
+    surface: episode.surface,
+    startedAt: episode.startedAt,
+    endedAt: episode.endedAt,
+    summary: episode.summary,
+    tags: episode.tags,
+    activityLevel: episode.activityLevel,
+    userId: episode.userId,
+    project: episode.project,
+    genModel: episode.genModel,
+    genVersion: episode.genVersion,
+    messageCount: episode.messageCount,
+    embedding: episode.embedding
+  };
+}
+async function getEpisodeById(executor, id) {
+  const result = await executor.execute({
+    sql: `
+      SELECT ${EPISODE_SELECT_COLUMNS}
+      FROM episodes
+      WHERE id = ?
+      LIMIT 1
+    `,
+    args: [id]
+  });
+  const row = result.rows[0];
+  if (!row) {
+    throw new Error(`Episode ${id} was not found after persistence.`);
+  }
+  return mapEpisodeRow(row);
+}
+function normalizeEpisodePayload(input) {
+  const sourceId = normalizeOptionalString4(input.sourceId);
+  const transcriptHash = normalizeOptionalString4(input.transcriptHash);
+  if (!sourceId && !transcriptHash) {
+    throw new Error("Episode writes require either sourceId or transcriptHash.");
+  }
+  const startedAt = normalizeRequiredString(input.startedAt, "startedAt");
+  const endedAt = normalizeOptionalString4(input.endedAt);
+  const summary = normalizeSummary2(input.summary);
+  return {
+    source: input.source,
+    ...sourceId ? { sourceId } : {},
+    ...normalizeOptionalString4(input.sourceRef) ? { sourceRef: normalizeOptionalString4(input.sourceRef) ?? void 0 } : {},
+    ...transcriptHash ? { transcriptHash } : {},
+    ...normalizeOptionalString4(input.agentId) ? { agentId: normalizeOptionalString4(input.agentId) ?? void 0 } : {},
+    ...normalizeOptionalString4(input.surface) ? { surface: normalizeOptionalString4(input.surface) ?? void 0 } : {},
+    startedAt,
+    ...endedAt ? { endedAt } : {},
+    summary,
+    tags: normalizeTags3(input.tags),
+    ...normalizeActivityLevel2(input.activityLevel) ? { activityLevel: normalizeActivityLevel2(input.activityLevel) } : {},
+    ...normalizeOptionalString4(input.userId) ? { userId: normalizeOptionalString4(input.userId) ?? void 0 } : {},
+    ...normalizeOptionalText(input.project) ? { project: normalizeOptionalText(input.project) ?? void 0 } : {},
+    ...normalizeOptionalString4(input.genModel) ? { genModel: normalizeOptionalString4(input.genModel) ?? void 0 } : {},
+    ...normalizeOptionalString4(input.genVersion) ? { genVersion: normalizeOptionalString4(input.genVersion) ?? void 0 } : {},
+    ...normalizeOptionalInteger(input.messageCount) !== void 0 ? { messageCount: normalizeOptionalInteger(input.messageCount) } : {},
+    ...normalizeEmbedding2(input.embedding) ? { embedding: normalizeEmbedding2(input.embedding) } : {}
+  };
+}
+function resolveWindowBounds(window) {
+  switch (window.kind) {
+    case "interval": {
+      if (!window.start || !window.end) {
+        return null;
+      }
+      return { start: window.start.toISOString(), end: window.end.toISOString() };
+    }
+    case "anchor": {
+      if (!window.anchor || window.radiusDays === void 0 || window.radiusDays < 0) {
+        return null;
+      }
+      const radiusMs = Math.trunc(window.radiusDays) * 24 * 60 * 60 * 1e3;
+      return {
+        start: new Date(window.anchor.getTime() - radiusMs).toISOString(),
+        end: new Date(window.anchor.getTime() + radiusMs).toISOString()
+      };
+    }
+    case "open_end":
+      return window.start ? { start: window.start.toISOString() } : null;
+    case "open_start":
+      return window.end ? { end: window.end.toISOString() } : null;
+    default:
+      return null;
+  }
+}
+function readRequiredIdentityHash(payload) {
+  if (!payload.transcriptHash) {
+    throw new Error("Episode writes without sourceId require transcriptHash.");
+  }
+  return payload.transcriptHash;
+}
+function normalizeActivityLevel2(value) {
+  if (!value) {
+    return void 0;
+  }
+  return value;
+}
+function normalizeOptionalString4(value) {
+  const trimmed = value?.trim();
+  return trimmed ? trimmed : void 0;
+}
+function normalizeOptionalText(value) {
+  const normalized = value?.replace(/\s+/gu, " ").trim();
+  return normalized ? normalized : void 0;
+}
+function normalizeSummary2(value) {
+  const normalized = value.replace(/\s+/gu, " ").trim();
+  if (!normalized) {
+    throw new Error("Episode summary must not be empty.");
+  }
+  return normalized;
+}
+function normalizeTags3(tags) {
+  if (!tags || tags.length === 0) {
+    return [];
+  }
+  return Array.from(new Set(tags.map((tag) => tag.trim().toLowerCase()).filter((tag) => tag.length > 0))).sort((left, right) => left.localeCompare(right)).slice(0, 8);
+}
+function normalizeOptionalInteger(value) {
+  if (value === void 0 || !Number.isFinite(value)) {
+    return void 0;
+  }
+  return Math.trunc(value);
+}
+function normalizeEmbedding2(embedding) {
+  if (!embedding || embedding.length === 0) {
+    return void 0;
+  }
+  return embedding.map((value) => Number.isFinite(value) ? value : 0);
+}
+function normalizeRequiredString(value, fieldName) {
+  const normalized = value.trim();
+  if (!normalized) {
+    throw new Error(`Episode field "${fieldName}" must not be empty.`);
+  }
+  return normalized;
+}
+function normalizePositiveInteger(value) {
+  const normalized = normalizeOptionalInteger(value);
+  if (normalized === void 0 || normalized <= 0) {
+    return void 0;
+  }
+  return normalized;
+}
+function prefixColumns(columns, alias) {
+  return columns.split(",").map((col) => {
+    const trimmed = col.trim();
+    return trimmed ? `${alias}.${trimmed}` : "";
+  }).filter(Boolean).join(", ");
+}
+function wrapEpisodeVectorError(error) {
+  const message = error instanceof Error ? error.message : String(error);
+  return new Error(`Episode vector search is unavailable: ${message}`);
+}
+function toNullableString(value) {
+  return value ?? null;
+}
+function toNullableInteger(value) {
+  return value ?? null;
+}
+
+// ../../src/adapters/db/client.ts
 var DEFAULT_BUSY_TIMEOUT_MS = 3e3;
 async function createDatabase(dbPath) {
   const client = await openClient(dbPath);
@@ -5083,6 +7140,34 @@ var LibsqlDatabase = class _LibsqlDatabase {
   async findExistingHashes(hashes) {
     return findExistingHashes(this.executor, hashes);
   }
+  /** Loads one episode by stable `(source, sourceId)` identity. */
+  async getEpisodeBySourceId(source, sourceId) {
+    return getEpisodeBySourceId(this.executor, source, sourceId);
+  }
+  /** Loads one episode by fallback `(source, transcriptHash)` identity. */
+  async getEpisodeByTranscriptHash(source, transcriptHash) {
+    return getEpisodeByTranscriptHash(this.executor, source, transcriptHash);
+  }
+  /** Inserts or updates an episodic-memory row using normalized change detection. */
+  async upsertEpisode(input) {
+    return upsertEpisode(this.executor, input);
+  }
+  /** Lists active episodes whose time range overlaps the requested window. */
+  async listEpisodesByTimeWindow(window, limit) {
+    return listEpisodesByTimeWindow(this.executor, window, limit);
+  }
+  /** Finds active episodes by vector similarity. */
+  async episodeVectorSearch(params) {
+    return episodeVectorSearch(this.executor, params);
+  }
+  /** Lists active episodes that are still missing embeddings. */
+  async listEpisodesWithoutEmbeddings(limit) {
+    return listEpisodesWithoutEmbeddings(this.executor, limit);
+  }
+  /** Updates only the embedding payload for one episode row. */
+  async updateEpisodeEmbedding(id, embedding) {
+    await updateEpisodeEmbedding(this.executor, id, embedding);
+  }
   /** Finds which normalized content hashes already exist in storage. */
   async findExistingNormHashes(hashes) {
     return findExistingNormHashes(this.executor, hashes);
@@ -5143,8 +7228,8 @@ async function openClient(dbPath) {
     throw new Error("Database path must not be empty.");
   }
   if (trimmedPath !== ":memory:" && !trimmedPath.startsWith("file:")) {
-    const resolvedPath = path6.resolve(trimmedPath);
-    await fs7.mkdir(path6.dirname(resolvedPath), { recursive: true });
+    const resolvedPath = path8.resolve(trimmedPath);
+    await fs8.mkdir(path8.dirname(resolvedPath), { recursive: true });
   }
   const client = createClient({ url: resolveClientUrl(trimmedPath) });
   await client.execute("PRAGMA foreign_keys = ON");
@@ -5161,7 +7246,7 @@ function resolveClientUrl(dbPath) {
   if (dbPath.startsWith("file:")) {
     return dbPath;
   }
-  return `file:${path6.resolve(dbPath)}`;
+  return `file:${path8.resolve(dbPath)}`;
 }
 async function rollbackTransaction(transaction) {
   if (transaction.closed) {
@@ -5274,7 +7359,6 @@ function requireApiKey(status) {
 function createSessionStartTracker() {
   const seenSessionIds = /* @__PURE__ */ new Set();
   const seenSessionKeys = /* @__PURE__ */ new Set();
-  const latestResetBySessionKey = /* @__PURE__ */ new Map();
   const resumedFromBySessionId = /* @__PURE__ */ new Map();
   const countActiveSessions = () => seenSessionIds.size + seenSessionKeys.size;
   return {
@@ -5312,18 +7396,6 @@ function createSessionStartTracker() {
         activeCount: countActiveSessions()
       };
     },
-    rememberReset(sessionKey, record) {
-      const normalizedSessionKey = sessionKey?.trim();
-      const normalizedSessionFile = record.sessionFile.trim();
-      if (!normalizedSessionKey || normalizedSessionFile.length === 0) {
-        return;
-      }
-      latestResetBySessionKey.set(normalizedSessionKey, {
-        sessionFile: normalizedSessionFile,
-        recordedAt: record.recordedAt,
-        ...record.sessionId?.trim() ? { sessionId: record.sessionId.trim() } : {}
-      });
-    },
     rememberSessionStart(sessionId, _sessionKey, resumedFrom) {
       const normalizedSessionId = sessionId?.trim();
       const normalizedResumedFrom = resumedFrom?.trim();
@@ -5332,10 +7404,6 @@ function createSessionStartTracker() {
       }
       resumedFromBySessionId.set(normalizedSessionId, normalizedResumedFrom);
     },
-    getLatestReset(sessionKey) {
-      const normalizedSessionKey = sessionKey?.trim();
-      return normalizedSessionKey ? latestResetBySessionKey.get(normalizedSessionKey) : void 0;
-    },
     getResumedFrom(sessionId) {
       const normalizedSessionId = sessionId?.trim();
       return normalizedSessionId ? resumedFromBySessionId.get(normalizedSessionId) : void 0;
@@ -5372,14 +7440,6 @@ var openclaw_default = definePluginEntry({
         tracker
       })
     );
-    api.on(
-      "before_reset",
-      (event, ctx) => handleAgenrBeforeReset(event, ctx, {
-        logger: api.logger,
-        servicesPromise,
-        tracker
-      })
-    );
     api.on("session_start", (event) => {
       tracker.rememberSessionStart(event.sessionId, event.sessionKey, event.resumedFrom);
     });