@mastra/server 1.73.1-alpha.0 → 1.74.0

package/dist/{dist-CxDKuckB.cjs → dist-BACW0Que.cjs}

@@ -4637,7 +4637,7 @@ function splitLines(text) {
 	return result;
 }
 //#endregion
-//#region ../memory/dist/src-C9z_nVe-.js
+//#region ../memory/dist/src-CPCWMt3d.js
 var __defProp$3 = Object.defineProperty;
 var __exportAll = (all, no_symbols) => {
 	let target = {};
@@ -22961,6 +22961,8 @@ const OBSERVATION_CONTEXT_INSTRUCTIONS = `IMPORTANT: When responding, reference
 
 KNOWLEDGE UPDATES: When asked about current state (e.g., "where do I currently...", "what is my current..."), always prefer the MOST RECENT information. Observations include dates - if you see conflicting information, the newer observation supersedes the older one. Look for phrases like "will start", "is switching", "changed to", "moved to" as indicators that previous information has been updated.
 
+USER STATEMENTS VS ASSISTANT SUGGESTIONS: Treat what the user said about their own life, plans, decisions, and dates as authoritative, unless data or their own later messages say otherwise. Treat what the assistant said, such as proposed schedules, example dates, and recommendations, as suggestions rather than facts about what happened, unless the user adopted or confirmed them. What the assistant did, such as editing a file, running a command, or calling a tool, is a record of what happened.
+
 PLANNED ACTIONS: If the user stated they planned to do something (e.g., "I'm going to...", "I'm looking forward to...", "I will...") and the date they planned to do it is now in the past (check the relative time like "3 weeks ago"), assume they completed the action unless there's evidence they didn't. For example, if someone said "I'll start my new diet on Monday" and that was 2 weeks ago, assume they started the diet.
 
 MOST RECENT USER INPUT: Treat the most recent user message as the highest-priority signal for what to do next. Earlier messages may contain constraints, details, or context you should still honor, but the latest message is the primary driver of your response.
@@ -22981,30 +22983,19 @@ SYSTEM REMINDERS: Messages wrapped in <system-reminder>...</system-reminder> con
 * @param searchEnabled - Whether semantic search (`retrieval: { vector: true }`) is
 *   available. When false, the guidance only covers \`threads\`/\`messages\` browsing so
 *   the agent is not steered toward a mode that cannot work.
+* @param observationPagingEnabled - Whether the storage adapter supports original
+*   observation-group paging. Only used when search is enabled.
 */
-function getRetrievalInstructions(scope = "resource", customInstructions, searchEnabled = true) {
+function getRetrievalInstructions(scope = "resource", customInstructions, searchEnabled = true, observationPagingEnabled = searchEnabled) {
 	const isResource = scope === "resource";
-	const base = `## Recall — looking up source messages
-
-Your memory is comprised of observations which are sometimes wrapped in <observation-group> xml tags containing ranges like <observation-group range="startId:endId">. These ranges point back to the raw messages that each observation group was derived from. The original messages are still available — use the **recall** tool to retrieve them.
-
-### When to use recall
-- The user asks you to **repeat, show, or reproduce** something from a past conversation
-- The user asks for **exact content** — code, text, quotes, error messages, URLs, file paths, specific numbers
-- Your observations mention something but your memory lacks the detail needed to fully answer (e.g. you know a blog post was shared but only have a summary of it)
-- You want to **verify or expand on** an observation before responding${isResource ? `
-- The user references another conversation that your observations don't cover — even if you have no observations yet, their other threads may contain it` : ""}
-
-**Default to using recall when the user references specific past content.** Your observations capture the gist, not the details. If there's any doubt whether your memory is complete enough, use recall.
-
-${isResource ? searchEnabled ? `### Choosing a mode
+	const modeSection = isResource ? searchEnabled ? `### Choosing a mode
 The recall tool works across ALL of this user's conversation threads, not just the current one.
 
-- Use \`mode: "search"\` with a \`query\` when you don't know which thread contains the answer. Each result includes its thread ID and the raw message IDs it came from, which you can use as a \`cursor\`.
-- Use \`mode: "messages"\` when you already know the thread — pass \`threadId\` to read another thread, or a \`cursor\` from an observation-group range or a search result.
+- Use \`mode: "search"\` with a \`query\` to find relevant history, even when you already know the thread. Each result includes its thread ID, observation group ID, and source message range.
+- Use \`mode: "messages"\` for original wording or details behind an observation — pass \`threadId\` to read another thread and a \`cursor\` from the source message range.
 - Use \`mode: "threads"\` to list the user's threads (IDs, titles, dates) when you need to discover where something was discussed. Use \`before\`/\`after\` to narrow by date.
 
-**If search results look irrelevant, do not give up.** Search only covers content that has been indexed — a short or recent conversation may exist in raw message history before any observation of it was created. When search returns nothing suitable but the user is clearly referring to a past conversation, call \`mode: "threads"\` to find candidate threads (titles and dates are strong clues), then read them with \`mode: "messages"\`. If a search result already gives you a thread ID, go straight to \`mode: "messages"\`.` : `### Choosing a mode
+**If search results look irrelevant, do not give up.** Search only covers content that has been indexed — a short or recent conversation may exist in raw message history before any observation of it was created. When search returns nothing suitable but the user is clearly referring to a past conversation, call \`mode: "threads"\` to find candidate threads (titles and dates are strong clues), then read them with \`mode: "messages"\`. Use a useful hit as an entry point to the surrounding history rather than treating it as the whole answer.` : `### Choosing a mode
 The recall tool works across ALL of this user's conversation threads, not just the current one.
 
 - Use \`mode: "threads"\` to list the user's threads (IDs, titles, dates) when you need to discover where something was discussed. Use \`before\`/\`after\` to narrow by date.
@@ -23015,7 +23006,62 @@ The recall tool is limited to the current conversation thread.
 
 - Use \`mode: "messages"\` (default) to page through this thread's message history near a cursor.${searchEnabled ? `
 - Use \`mode: "search"\` with a \`query\` to find messages by content within this thread.` : ""}
-- Use \`mode: "threads"\` to get the current thread's ID, title, and dates.`}
+- Use \`mode: "threads"\` to get the current thread's ID, title, and dates.`;
+	const pagingEnabled = searchEnabled && observationPagingEnabled;
+	const lookupSteps = [
+		`**Search to locate.** Run a few differently worded queries rather than relying on one. When you roughly know when something happened, or need events from different periods, repeat the search with \`after\`/\`before\` date windows. Date filters apply to when an observation was recorded, not necessarily to dates mentioned inside it, so widen or remove them when nothing fits. If nothing useful comes up, try the user's message verbatim as the search query.`,
+		...pagingEnabled ? [`**Page observations for context.** Open a relevant hit with \`mode: "observations"\` and its \`groupId\` to read the full group and the dated conclusions and decisions around it, without loading every tool call or diff. Do this for truncated excerpts, for dates you need to pin down, and for events that unfolded over several turns. To understand what led to an event and what followed, page both before and after the anchor.`] : [],
+		`**Read source messages to confirm.** When exact wording, numbers, code, who said what, or conflicting accounts matter, read the raw messages from the hit's source range. The range connects the summary view to the raw-message view.`
+	];
+	const searchSection = searchEnabled ? `### Finding evidence
+Search matches are entry points, not a complete timeline. Similarity selects the matches; they are displayed by observation date. A missing search hit is not evidence that an event did not happen.
+
+${pagingEnabled ? "Observations and messages are two views of the same conversation history, not separate archives. Use search to find an entry point, observations for breadth, and messages for depth:" : "Use search to find an entry point and messages for depth:"}
+${lookupSteps.map((step, i) => `${i + 1}. ${step}`).join("\n")}
+
+When searches keep returning the same groups, often as already-in-context references, stop rephrasing: ${pagingEnabled ? "page from those groups or read their source messages" : "read their source messages"} instead.
+
+"Excerpt already in current context" marks a hit whose text an earlier search result already shows. "Group already in current context" marks a group that is already in your observations or whose source messages are still in the conversation. "Source range overlaps current context" marks a group whose source messages are still in the conversation. Search keeps these references and tries lower-ranked matches to fill the requested number of excerpts. This backfill is bounded: fewer excerpts do not mean history is exhausted. Use the evidence already present rather than repeating the same lookup. You can still ${pagingEnabled ? "page a referenced group" : "read a referenced group's source messages"} when you need all of it, or search again if that context is no longer available.
+
+If search still finds nothing useful, browse raw messages${isResource ? " or discover other threads" : " in this thread"} before concluding the information is unavailable. Raw history may exist for threads that have no observations yet.` : "";
+	const base = `## Recall — looking up source messages
+
+Your memory contains observation groups with IDs and source message ranges, shown as \`## Group\` headings with \`_range: startId:endId\` or as \`<observation-group>\` tags. Use the **recall** tool to recover retained original observations and source messages.
+
+Historical notes may describe older versions of tools. Use the currently provided tool schema and these instructions for available modes and arguments; treat recalled tool descriptions as evidence about past behavior, not the current tool contract.
+
+### Reflections are lossy
+Groups marked \`kind="reflection"\` (rendered as \`_kind: reflection_\`) are lossy summaries. Use them for a broad understanding of what happened, not as an exhaustive record. If something is absent from a reflection, that does not mean it did not happen. Use recall to check the original evidence before drawing that conclusion. Original observations can omit details too; read the source messages when precise wording or evidence matters.
+
+### When to use recall
+- The user asks you to **repeat, show, or reproduce** something from a past conversation
+- The user asks for **exact content** — code, text, quotes, error messages, URLs, file paths, specific numbers
+- Your observations mention something but your memory lacks the detail needed to fully answer (e.g. you know a blog post was shared but only have a summary of it)
+- You want to **verify or expand on** an observation before responding
+- The answer depends on historical dates, order, or duration: verify both event dates and that they refer to the events the user means. Distinguish a plan, an actual start, a later update, and a repeated mention instead of choosing a nearby date from a summary
+- An observation records something the assistant proposed, such as a schedule, date, or plan, and your observations don't show what the user decided. Read the raw messages around it to find the user's decision before treating the proposal as what happened
+- Relevant details are missing, ambiguous, or conflicting in the current observations${isResource ? `
+- The user references another conversation that your observations don't cover — even if you have no observations yet, their other threads may contain it` : ""}
+
+**Default to using recall when the user references specific past content.** Your observations capture the gist, not the details. If there's any doubt whether your memory is complete enough, use recall.
+
+For questions about what was discussed or decided and why, start with recall when the original evidence is not already visible. Current source code or general documentation can establish what happens now, but not necessarily the past discussion or rationale. Retrieve the recorded decisions first; inspect current code separately if the answer also depends on today's implementation. Distinguish recorded reasons from your own inference, and use source messages when observation summaries omit the rationale.
+
+${[
+		modeSection,
+		searchSection,
+		pagingEnabled ? `### Paging original observations
+Use \`mode: "observations"\` around a relevant search hit to fill in missing details, check earlier or later events, and recover context omitted from a reflection or search result.
+
+- Copy the hit's \`groupId\`${isResource ? " and `threadId`" : ""} exactly as shown. Omit \`direction\` to read the full anchor group and following groups, including text truncated in search.
+- Use \`direction: "before"\` or \`direction: "after"\` to read groups strictly before or after that anchor. Pages contain 5 groups by default; \`limit\` allows up to 20. Dense groups can be large; use \`limit: 1\` or \`limit: 2\` for a quick skim.
+- Follow the returned continuation calls, using the first or last group ID on each page as the next anchor. \`groupId\` is an observation cursor; \`cursor\` is a raw message ID. Do not interchange them.
+- \`hasMore\` reports whether more groups exist in the requested direction (after when direction is omitted). A full page can still have \`hasMore: false\`; stop in that direction without making an empty follow-up call. Explicit start/end markers describe retained observation history, not whether older raw messages exist. When newer messages have not been observed yet, the end marker says how many and gives the \`mode: "messages"\` call that reads them.
+- Search results mark where other observation groups may sit between two hits from the same thread. Page from those hits instead of repeatedly searching for the same isolated hit.
+- These pages contain original observations, not reflections. For exact wording or details absent from the observations, use \`mode: "messages"\` with a message ID from the group's \`_range\`.
+
+Stop once the relevant evidence is sufficient. If retained history is incomplete, say what is unknown rather than guessing.` : ""
+	].filter(Boolean).join("\n\n")}
 
 ### How to use recall with a cursor
 Each range has the format \`startId:endId\` where both are message IDs separated by a colon.
@@ -23026,8 +23072,8 @@ Each range has the format \`startId:endId\` where both are message IDs separated
 4. If the first page doesn't have what you need, increment the page number to keep paginating.
 5. Check \`hasNextPage\`/\`hasPrevPage\` in the result to know if more pages exist in each direction.
 
-### Detail levels
-By default recall returns **low** detail: truncated text and tool names only. Each message shows its ID and each part has a positional index like \`[p0]\`, \`[p1]\`, etc.
+### Raw-message detail levels
+In \`mode: "messages"\`, recall returns **low** detail by default: truncated text and tool names only. Each message shows its ID and each part has a positional index like \`[p0]\`, \`[p1]\`, etc.
 
 - Use \`detail: "high"\` to get full message content including tool arguments and results. This will only return the high detail version of a single message part at a time.
 - Use \`partIndex\` with a cursor to fetch a single part at full detail — for example, to read one specific tool result or code block without loading every part.
@@ -23044,8 +23090,8 @@ If a single part is larger than the token budget, the \`partIndex\` result is \`
 
 ### When recall is NOT needed
 - The user is asking for a high-level summary and your observations already cover it
-- The question is about general preferences or facts that don't require source text
-${isResource ? `- No relevant observation range exists AND ${searchEnabled ? "`search`/`threads`" : "`threads`"} turned up nothing — but remember that raw history may exist for threads that have no observations yet, so check before concluding the information is unavailable` : `- There is no relevant range in your observations for the topic`}
+- The question is general knowledge that doesn't depend on this user's history
+- The necessary original evidence is already visible, unambiguous, and not contradicted by other observations; do not repeat a lookup just to call the tool
 
 Observation groups with range IDs and your recall tool allows you to think back and remember details you're fuzzy on.`;
 	const custom = customInstructions?.trim();
@@ -23688,6 +23734,10 @@ function calendarDayIn(instant, timeZone) {
 	const part = (type) => Number(parts.find((p) => p.type === type)?.value);
 	return Date.UTC(part("year"), part("month") - 1, part("day")) / DAY_MS;
 }
+/** Format an instant relative to today, using the record's calendar time zone. */
+function formatRelativeTime(date, currentDate, timeZone) {
+	return formatRelativeDays(calendarDayIn(currentDate, timeZone) - calendarDayIn(date, timeZone));
+}
 function formatRelativeDays(diffDays) {
 	if (diffDays < 0) {
 		const futureDays = Math.abs(diffDays);
@@ -28263,6 +28313,676 @@ var WorkingMemoryExtractor = class extends Extractor {
 		});
 	}
 };
+/**
+* Find the index of the last completed observation boundary (end marker) in a message's parts.
+* Returns -1 if no completed observation is found.
+*/
+function findLastCompletedObservationBoundary(message) {
+	const parts = message.content?.parts;
+	if (!parts || !Array.isArray(parts)) return -1;
+	for (let i = parts.length - 1; i >= 0; i--) {
+		const part = parts[i];
+		if (part?.type === "data-om-observation-end" && part.data?.operationType !== "reflection") return i;
+	}
+	return -1;
+}
+/**
+* Get unobserved parts from a message.
+* If the message has a completed observation (start + end), only return parts after the end.
+* If observation is in progress (start without end), include parts before the start.
+* Otherwise, return all parts.
+*/
+function getUnobservedParts(message) {
+	const parts = message.content?.parts;
+	if (!parts || !Array.isArray(parts)) return [];
+	const endMarkerIndex = findLastCompletedObservationBoundary(message);
+	if (endMarkerIndex === -1) return parts.filter((p) => {
+		return p?.type !== "data-om-observation-start";
+	});
+	return parts.slice(endMarkerIndex + 1).filter((p) => {
+		return !p?.type?.startsWith("data-om-observation-");
+	});
+}
+/**
+* Compute a cursor pointing at the latest message by createdAt.
+* Used to derive a stable observation boundary for replay pruning.
+*/
+function getLastObservedMessageCursor(messages) {
+	let latest;
+	for (const msg of messages) {
+		if (!msg?.id || !msg.createdAt) continue;
+		if (!latest || new Date(msg.createdAt).getTime() > new Date(latest.createdAt).getTime()) latest = msg;
+	}
+	return latest ? {
+		createdAt: new Date(latest.createdAt).toISOString(),
+		id: latest.id
+	} : void 0;
+}
+/**
+* Check if a message is at or before a cursor (by createdAt then id).
+*/
+function isMessageAtOrBeforeCursor(msg, cursor) {
+	if (!msg.createdAt) return false;
+	const msgIso = new Date(msg.createdAt).toISOString();
+	if (msgIso < cursor.createdAt) return true;
+	if (msgIso === cursor.createdAt && msg.id === cursor.id) return true;
+	return false;
+}
+/**
+* Return the toolCallId of a tool-invocation part in the given state, or undefined.
+*/
+function getToolInvocationId(part, state) {
+	if (part?.type !== "tool-invocation") return void 0;
+	if (part.toolInvocation.state !== state) return void 0;
+	return part.toolInvocation.toolCallId || void 0;
+}
+function collectPendingToolResultIds(allMessages, observedIds) {
+	const pendingToolResultIds = /* @__PURE__ */ new Set();
+	for (const msg of allMessages) {
+		if (!msg?.id) continue;
+		if (observedIds?.has(msg.id)) continue;
+		const parts = msg.content?.parts;
+		if (!parts || !Array.isArray(parts)) continue;
+		for (const part of parts) {
+			const id = getToolInvocationId(part, "result");
+			if (id) pendingToolResultIds.add(id);
+		}
+	}
+	return pendingToolResultIds;
+}
+function hasPendingToolResultPair(message, pendingToolResultIds) {
+	if (pendingToolResultIds.size === 0) return false;
+	const parts = message.content?.parts;
+	if (!parts || !Array.isArray(parts)) return false;
+	return parts.some((part) => {
+		const id = getToolInvocationId(part, "call");
+		return id !== void 0 && pendingToolResultIds.has(id);
+	});
+}
+function collectPendingToolResultIdsAfterMarker(allMessages, markerMessageIndex, markerMessage) {
+	const pendingToolResultIds = /* @__PURE__ */ new Set();
+	const unobservedMarkerParts = getUnobservedParts(markerMessage);
+	if (unobservedMarkerParts.length > 0) collectPendingToolResultIds([{
+		...markerMessage,
+		content: {
+			...markerMessage.content,
+			parts: unobservedMarkerParts
+		}
+	}], void 0).forEach((id) => pendingToolResultIds.add(id));
+	collectPendingToolResultIds(allMessages.slice(markerMessageIndex + 1), void 0).forEach((id) => pendingToolResultIds.add(id));
+	return pendingToolResultIds;
+}
+function getUnobservedPartsPreservingToolCallPairs(message) {
+	const parts = message.content?.parts;
+	if (!parts || !Array.isArray(parts)) return [];
+	const endMarkerIndex = findLastCompletedObservationBoundary(message);
+	if (endMarkerIndex === -1) return getUnobservedParts(message);
+	const unobservedParts = getUnobservedParts(message);
+	const unobservedResultIds = /* @__PURE__ */ new Set();
+	for (const part of unobservedParts) {
+		const id = getToolInvocationId(part, "result");
+		if (id) unobservedResultIds.add(id);
+	}
+	if (unobservedResultIds.size === 0) return unobservedParts;
+	const preservedCalls = parts.slice(0, endMarkerIndex).filter((part) => {
+		const id = getToolInvocationId(part, "call");
+		return id !== void 0 && unobservedResultIds.has(id);
+	});
+	return preservedCalls.length > 0 ? [...preservedCalls, ...unobservedParts] : unobservedParts;
+}
+/**
+* Get the messages Observational Memory is allowed to work with.
+*
+* Messages supplied through the `context` option and the synthetic `om-continuation`
+* message are prompt-only input. Core's persistence contract already treats context as
+* never-persist, while the continuation remains memory-sourced so it can stay in the live
+* actor prompt.
+*
+* OM builds its windows from `get.all.db()`, which includes both categories, and then seals
+* and persists candidates directly. Excluding them here keeps OM's observation, buffering,
+* persistence, and token accounting consistent with their ephemeral contract.
+*/
+function getObservableMessages(messageList) {
+	const contextMessageIds = messageList.makeMessageSourceChecker().context;
+	return messageList.get.all.db().filter((message) => {
+		return message.id !== "om-continuation" && !contextMessageIds.has(message.id);
+	});
+}
+/**
+* Safely extract buffered observation chunks from a record.
+* Handles both array and JSON-string formats, returning empty array if malformed.
+*/
+/**
+* Filter out already-observed messages from the in-memory context.
+* Uses marker-boundary pruning (preferred) or record-based fallback.
+*
+* The `fallbackCursor` is optional — callers that need it should resolve it
+* from thread metadata before calling this function.
+*/
+function filterObservedMessages(opts) {
+	const { messageList, record } = opts;
+	const allMessages = getObservableMessages(messageList);
+	const useMarkerBoundaryPruning = opts.useMarkerBoundaryPruning ?? true;
+	const preserveMessageIds = opts.preserveMessageIds ?? /* @__PURE__ */ new Set();
+	const observedIds = new Set(Array.isArray(record?.observedMessageIds) ? record.observedMessageIds : []);
+	let markerMessageIndex = -1;
+	let markerMessage = null;
+	for (let i = allMessages.length - 1; i >= 0; i--) {
+		const msg = allMessages[i];
+		if (!msg) continue;
+		if (findLastCompletedObservationBoundary(msg) !== -1) {
+			markerMessageIndex = i;
+			markerMessage = msg;
+			break;
+		}
+	}
+	if (useMarkerBoundaryPruning && markerMessage && markerMessageIndex !== -1) {
+		const pendingToolResultIds = collectPendingToolResultIdsAfterMarker(allMessages, markerMessageIndex, markerMessage);
+		const messagesToRemove = [];
+		for (let i = 0; i < markerMessageIndex; i++) {
+			const msg = allMessages[i];
+			if (msg?.id && msg.id !== "om-continuation" && !preserveMessageIds.has(msg.id) && !hasPendingToolResultPair(msg, pendingToolResultIds)) messagesToRemove.push(msg.id);
+		}
+		if (messagesToRemove.length > 0) messageList.removeByIds(messagesToRemove);
+		const unobserved = getUnobservedPartsPreservingToolCallPairs(markerMessage);
+		if (unobserved.length === 0) {
+			if (markerMessage.id) messageList.removeByIds([markerMessage.id]);
+		} else if (unobserved.length < (markerMessage.content?.parts?.length ?? 0)) markerMessage.content.parts = unobserved;
+	} else if (record) {
+		const pendingToolResultIds = collectPendingToolResultIds(allMessages, observedIds);
+		const derivedCursor = opts.fallbackCursor ?? getLastObservedMessageCursor(allMessages.filter((msg) => !!msg?.id && observedIds.has(msg.id) && !!msg.createdAt));
+		const lastObservedAt = record.lastObservedAt;
+		const messagesToRemove = [];
+		for (const msg of allMessages) {
+			if (!msg?.id || msg.id === "om-continuation" || preserveMessageIds.has(msg.id)) continue;
+			const hasPendingPair = hasPendingToolResultPair(msg, pendingToolResultIds);
+			if (observedIds.has(msg.id)) {
+				if (hasPendingPair) continue;
+				messagesToRemove.push(msg.id);
+				continue;
+			}
+			if (derivedCursor && isMessageAtOrBeforeCursor(msg, derivedCursor)) {
+				if (hasPendingPair) continue;
+				messagesToRemove.push(msg.id);
+				continue;
+			}
+			if (lastObservedAt && msg.createdAt) {
+				if (new Date(msg.createdAt) <= lastObservedAt) {
+					if (hasPendingPair) continue;
+					messagesToRemove.push(msg.id);
+				}
+			}
+		}
+		if (messagesToRemove.length > 0) messageList.removeByIds(messagesToRemove);
+	}
+}
+function getBufferedChunks(record) {
+	if (!record?.bufferedObservationChunks) return [];
+	if (Array.isArray(record.bufferedObservationChunks)) return record.bufferedObservationChunks;
+	if (typeof record.bufferedObservationChunks === "string") try {
+		const parsed = JSON.parse(record.bufferedObservationChunks);
+		return Array.isArray(parsed) ? parsed : [];
+	} catch {
+		return [];
+	}
+	return [];
+}
+/**
+* Sort threads by their oldest unobserved message.
+* Returns thread IDs in order from oldest to most recent.
+*/
+/**
+* Combine active and buffered observations for the buffering observer context.
+*/
+function combineObservationsForBuffering(activeObservations, bufferedObservations) {
+	if (!activeObservations && !bufferedObservations) return void 0;
+	if (!activeObservations) return bufferedObservations;
+	if (!bufferedObservations) return activeObservations;
+	return `${activeObservations}\n\n--- BUFFERED (pending activation) ---\n\n${bufferedObservations}`;
+}
+function sortThreadsByOldestMessage(messagesByThread) {
+	return Array.from(messagesByThread.entries()).map(([threadId, messages]) => ({
+		threadId,
+		oldestTimestamp: Math.min(...messages.map((m) => m.createdAt ? new Date(m.createdAt).getTime() : Date.now()))
+	})).sort((a, b) => a.oldestTimestamp - b.oldestTimestamp).map((t) => t.threadId);
+}
+/**
+* Strip any thread tags that the Observer might have added.
+* Thread attribution is handled externally by the system, not by the Observer.
+*/
+function stripThreadTags(observations) {
+	return observations.replace(/<\/?thread\b[^>]{0,1024}>/gi, "").trim();
+}
+const OBSERVATION_GROUP_OPEN = "<observation-group";
+const OBSERVATION_GROUP_CLOSE = "</observation-group>";
+const ATTRIBUTE_PATTERN = /([\w][\w-]*)="([^"]*)"/g;
+const REFLECTION_GROUP_SPLIT_PATTERN = /^##\s+Group\s+/m;
+function parseObservationGroupAttributes(attributeString) {
+	const attributes = {};
+	for (const match of attributeString.matchAll(ATTRIBUTE_PATTERN)) {
+		const [, key, value] = match;
+		if (key && value !== void 0) attributes[key] = value;
+	}
+	return attributes;
+}
+function isLineStart(observations, index) {
+	return index === 0 || observations[index - 1] === "\n";
+}
+function scanObservationGroupTags(observations) {
+	const tags = [];
+	const incompleteOpenings = [];
+	let cursor = 0;
+	let closeFloor = 0;
+	let nestedFloor = -1;
+	while (cursor < observations.length) {
+		const start = observations.indexOf(OBSERVATION_GROUP_OPEN, cursor);
+		if (start === -1) break;
+		const attributesStart = start + 18;
+		if (!/\s/.test(observations[attributesStart] ?? "")) {
+			cursor = attributesStart;
+			continue;
+		}
+		const openEnd = observations.indexOf(">", attributesStart);
+		if (openEnd === -1) break;
+		const closeStart = observations.indexOf(OBSERVATION_GROUP_CLOSE, Math.max(openEnd + 1, closeFloor));
+		if (closeStart === -1) {
+			if (isLineStart(observations, start)) incompleteOpenings.push({
+				start,
+				end: openEnd + 1
+			});
+			closeFloor = observations.length;
+			cursor = openEnd + 1;
+			continue;
+		}
+		if (nestedFloor <= openEnd) {
+			const lineOpen = observations.indexOf(`\n${OBSERVATION_GROUP_OPEN}`, openEnd);
+			nestedFloor = lineOpen === -1 ? observations.length : lineOpen + 1;
+		}
+		const nestedStart = nestedFloor;
+		if (nestedStart < closeStart) {
+			incompleteOpenings.push({
+				start,
+				end: openEnd + 1
+			});
+			closeFloor = closeStart;
+			cursor = nestedStart;
+			continue;
+		}
+		tags.push({
+			start,
+			end: closeStart + 20,
+			attributeString: observations.slice(attributesStart, openEnd),
+			content: observations.slice(openEnd + 1, closeStart)
+		});
+		closeFloor = closeStart;
+		cursor = closeStart + 20;
+	}
+	return {
+		tags,
+		incompleteOpenings
+	};
+}
+function replaceObservationGroupTags(observations, replace) {
+	const { tags, incompleteOpenings } = scanObservationGroupTags(observations);
+	const parts = [];
+	let cursor = 0;
+	let openingIndex = 0;
+	const skipIncompleteOpeningsBefore = (limit) => {
+		while (openingIndex < incompleteOpenings.length && incompleteOpenings[openingIndex].start < limit) {
+			const opening = incompleteOpenings[openingIndex];
+			openingIndex++;
+			if (opening.start < cursor) continue;
+			parts.push(observations.slice(cursor, opening.start));
+			cursor = opening.end;
+		}
+	};
+	for (const tag of tags) {
+		skipIncompleteOpeningsBefore(tag.start);
+		parts.push(observations.slice(cursor, tag.start), replace(tag));
+		cursor = tag.end;
+	}
+	skipIncompleteOpeningsBefore(Number.POSITIVE_INFINITY);
+	parts.push(observations.slice(cursor));
+	return parts.join("");
+}
+function parseReflectionObservationGroupSections(content) {
+	const normalizedContent = content.trim();
+	if (!normalizedContent || !REFLECTION_GROUP_SPLIT_PATTERN.test(normalizedContent)) return [];
+	return normalizedContent.split(REFLECTION_GROUP_SPLIT_PATTERN).map((section) => section.trim()).filter(Boolean).map((section) => {
+		const newlineIndex = section.indexOf("\n");
+		return {
+			heading: (newlineIndex >= 0 ? section.slice(0, newlineIndex) : section).trim(),
+			body: stripReflectionGroupMetadata((newlineIndex >= 0 ? section.slice(newlineIndex + 1) : "").trim())
+		};
+	});
+}
+function stripReflectionGroupMetadata(body) {
+	return body.replace(/^_range:\s*`[^`]*`_\s*\n?/m, "").trim();
+}
+function generateAnchorId() {
+	return Buffer.from(globalThis.crypto.getRandomValues(/* @__PURE__ */ new Uint8Array(8))).toString("hex");
+}
+function wrapInObservationGroup(observations, range, id = generateAnchorId(), _sourceGroupIds, kind) {
+	const content = observations.trim();
+	return `<observation-group id="${id}" range="${range}"${kind ? ` kind="${kind}"` : ""}>\n${content}\n</observation-group>`;
+}
+function parseObservationGroups(observations) {
+	if (!observations) return [];
+	const groups = [];
+	for (const tag of scanObservationGroupTags(observations).tags) {
+		const attributes = parseObservationGroupAttributes(tag.attributeString);
+		const id = attributes.id;
+		const range = attributes.range;
+		if (!id || !range) continue;
+		groups.push({
+			id,
+			range,
+			kind: attributes.kind,
+			content: tag.content.trim()
+		});
+	}
+	return groups;
+}
+function stripObservationGroups(observations) {
+	if (!observations) return observations;
+	return replaceObservationGroupTags(observations, (tag) => tag.content.trim()).replace(/\n{3,}/g, "\n\n").trim();
+}
+function getRangeSegments(range) {
+	return range.split(",").map((segment) => segment.trim()).filter(Boolean);
+}
+function getRangeEndpoints(segment) {
+	const parts = segment.split(":").map((part) => part.trim());
+	if (parts.length !== 2 || !parts[0] || !parts[1]) return null;
+	return {
+		start: parts[0],
+		end: parts[1]
+	};
+}
+/**
+* `buildMessageRange` produces opaque UUID endpoints, so those segments cannot be ordered by value.
+* Spanning from the first start to the last end keeps reflected metadata bounded — the full segment
+* list is deliberately not preserved (#14791). Segments that are not `start:end` pairs are left as
+* they are rather than being joined into a fabricated span.
+*/
+function spanRangeSegments(segments) {
+	const endpoints = segments.map(getRangeEndpoints);
+	if (endpoints.some((endpoint) => endpoint === null)) return segments.join(",");
+	const first = endpoints[0];
+	const last = endpoints.at(-1);
+	return `${first.start}:${last.end}`;
+}
+function combineObservationGroupRanges(groups) {
+	const segments = Array.from(new Set(groups.flatMap((group) => getRangeSegments(group.range))));
+	if (segments.length === 0) return "";
+	const numericEndpoints = [];
+	if (!segments.every((segment) => {
+		const endpoints = getRangeEndpoints(segment);
+		if (!endpoints || !/^\d+$/.test(endpoints.start) || !/^\d+$/.test(endpoints.end)) return false;
+		const start = {
+			label: endpoints.start,
+			value: Number(endpoints.start)
+		};
+		const end = {
+			label: endpoints.end,
+			value: Number(endpoints.end)
+		};
+		if (!Number.isSafeInteger(start.value) || !Number.isSafeInteger(end.value)) return false;
+		numericEndpoints.push(start.value <= end.value ? {
+			start,
+			end
+		} : {
+			start: end,
+			end: start
+		});
+		return true;
+	})) return spanRangeSegments(segments);
+	const first = numericEndpoints.reduce((lowest, pair) => pair.start.value < lowest.start.value ? pair : lowest);
+	const last = numericEndpoints.reduce((highest, pair) => pair.end.value > highest.end.value ? pair : highest);
+	return `${first.start.label}:${last.end.label}`;
+}
+function renderObservationGroupsForReflection(observations, options) {
+	if (parseObservationGroups(observations).length === 0) return null;
+	return replaceObservationGroupTags(observations, (tag) => {
+		const attributes = parseObservationGroupAttributes(tag.attributeString);
+		if (!attributes.id || !attributes.range) return tag.content.trim();
+		const kind = options?.includeReflectionKind && attributes.kind === "reflection" ? "\n_kind: reflection_" : "";
+		return `## Group \`${attributes.id}\`${kind}\n_range: \`${attributes.range}\`_\n\n${tag.content.trim()}`;
+	}).replace(/\n{3,}/g, "\n\n").trim();
+}
+function getCanonicalGroupId(sectionHeading, fallbackIndex) {
+	return sectionHeading.match(/`([^`]+)`/)?.[1]?.trim() || `derived-group-${fallbackIndex + 1}`;
+}
+function getContentLines(content) {
+	return content.split("\n").map((line) => line.trim()).filter(Boolean);
+}
+function deriveObservationGroupProvenance(content, groups) {
+	const sections = parseReflectionObservationGroupSections(content);
+	if (sections.length === 0 || groups.length === 0) return [];
+	return sections.map((section, index) => {
+		const canonicalGroupId = getCanonicalGroupId(section.heading, index);
+		const identifiedGroup = groups.find((group) => group.id === canonicalGroupId);
+		const bodyLines = new Set(getContentLines(section.body));
+		const matchingGroups = groups.filter((group) => getContentLines(group.content).some((line) => bodyLines.has(line)));
+		const fallbackGroup = groups[Math.min(index, groups.length - 1)];
+		const identifiedLines = new Set(getContentLines(identifiedGroup?.content ?? ""));
+		const contributingGroups = identifiedGroup ? matchingGroups.filter((group) => group.id !== identifiedGroup.id && getContentLines(group.content).some((line) => bodyLines.has(line) && !identifiedLines.has(line))) : [];
+		return {
+			id: canonicalGroupId,
+			range: combineObservationGroupRanges(identifiedGroup ? groups.filter((group) => group === identifiedGroup || contributingGroups.includes(group)) : matchingGroups.length > 0 ? matchingGroups : fallbackGroup ? [fallbackGroup] : []),
+			kind: "reflection",
+			content: section.body
+		};
+	});
+}
+function reconcileObservationGroupsFromReflection(content, sourceObservations) {
+	const sourceGroups = parseObservationGroups(sourceObservations);
+	if (sourceGroups.length === 0) return null;
+	const normalizedContent = content.trim();
+	if (!normalizedContent) return "";
+	const derivedGroups = deriveObservationGroupProvenance(normalizedContent, sourceGroups);
+	if (derivedGroups.length > 0) return derivedGroups.map((group) => wrapInObservationGroup(group.content, group.range, group.id, void 0, group.kind)).join("\n\n");
+	return wrapInObservationGroup(normalizedContent, combineObservationGroupRanges(sourceGroups), generateAnchorId(), void 0, "reflection");
+}
+const hasher = e();
+/** Thrown when storage returns history records without applying the requested filters. */
+var HistoryFiltersIgnoredError = class extends Error {};
+const HISTORY_FILTERS_IGNORED = "Observation paging is unavailable: the storage adapter returned observation history without applying the history filters (group, record, and generation). If you use Convex, redeploy the Mastra server functions; otherwise upgrade the storage adapter together with @mastra/memory. Use mode=\"messages\" with a message ID from the search hit's source range instead.";
+function rawText(record) {
+	return [record.activeObservations, ...getBufferedChunks(record).map((chunk) => chunk.observations)].join("\n");
+}
+async function buildTimeline(record, threadId) {
+	let text = rawText(record);
+	if (record.threadId === null) {
+		const obscuredId = (await hasher).h32ToString(threadId);
+		text = [...text.matchAll(/<thread id="([^"]+)">([\s\S]*?)<\/thread>/g)].filter((match) => match[1] === threadId || match[1] === obscuredId).map((match) => match[2]).join("\n");
+	}
+	const groups = parseObservationGroups(text).filter((group) => group.kind !== "reflection");
+	const indexById = /* @__PURE__ */ new Map();
+	return {
+		record,
+		groups: groups.filter((group) => {
+			if (indexById.has(group.id)) return false;
+			indexById.set(group.id, indexById.size);
+			return true;
+		}),
+		indexById
+	};
+}
+async function findGroupTimeline(om, threadId, resourceId, groupId, recordId) {
+	const resolve = async (options) => {
+		const [record] = await om.getHistory(threadId, resourceId, 1, {
+			...options,
+			groupId
+		});
+		if (!record || record.threadId !== null && record.threadId !== threadId) return null;
+		if (!rawText(record).includes(`<observation-group id="${groupId}"`)) throw new HistoryFiltersIgnoredError();
+		const timeline = await buildTimeline(record, threadId);
+		return timeline.indexById.has(groupId) ? timeline : null;
+	};
+	return recordId !== void 0 && await resolve({ recordId }) || await resolve({ sortDirection: "ASC" });
+}
+/** Group IDs shown to the agent carry the record holding the group, so paging can read it by ID. */
+function groupCursor(groupId, recordId) {
+	return recordId ? `${groupId}@${recordId}` : groupId;
+}
+function parseGroupCursor(cursor) {
+	const at = cursor.indexOf("@");
+	return at === -1 ? { groupId: cursor } : {
+		groupId: cursor.slice(0, at),
+		recordId: cursor.slice(at + 1) || void 0
+	};
+}
+function pagingCall(groupId, direction, threadId, recordId) {
+	return `recall(${JSON.stringify({
+		mode: "observations",
+		threadId,
+		groupId: groupCursor(groupId, recordId),
+		direction
+	})})`;
+}
+/** Messages after the last observed range are raw history only; say so instead of implying the thread ends. */
+async function newerMessagesNote(group, countNewerMessages, threadId) {
+	const endpoints = group?.range.split(",").at(-1)?.split(":");
+	const cursor = endpoints?.length === 2 ? endpoints[1] : void 0;
+	if (!cursor || !countNewerMessages) return null;
+	const count = await countNewerMessages(cursor);
+	if (count <= 0) return null;
+	const call = `recall(${JSON.stringify({
+		mode: "messages",
+		threadId,
+		cursor
+	})})`;
+	return count === 1 ? `1 newer message has not been observed yet; read it with ${call}` : `${count} newer messages have not been observed yet; read them with ${call}`;
+}
+async function pageObservationGroups(options) {
+	try {
+		return await pageGroups(options);
+	} catch (error) {
+		if (error instanceof HistoryFiltersIgnoredError) return {
+			results: HISTORY_FILTERS_IGNORED,
+			count: 0
+		};
+		throw error;
+	}
+}
+async function pageGroups({ om, threadId, resourceId, groupId, recordId, direction: requestedDirection, limit, threadTitle, includeThreadId = true, countNewerMessages }) {
+	const home = await findGroupTimeline(om, threadId, resourceId, groupId, recordId);
+	if (!home) return {
+		results: `No original observation group ${JSON.stringify(groupId)} was found in the active or buffered observations of thread ${JSON.stringify(threadId)} across its retained history. Check the threadId and groupId from the search hit, or use mode="messages" with a message ID from its source range.`,
+		count: 0
+	};
+	const direction = requestedDirection ?? "after";
+	let current = home;
+	let position = home.indexById.get(groupId) - (requestedDirection === void 0 ? 1 : 0);
+	const seen = new Set((direction === "after" ? home.groups.slice(0, position + 1) : home.groups.slice(position)).map((group) => group.id));
+	const entries = [];
+	while (entries.length <= limit) {
+		position += direction === "after" ? 1 : -1;
+		const group = current.groups[position];
+		if (group) {
+			if (!seen.has(group.id)) {
+				seen.add(group.id);
+				entries.push({
+					group,
+					record: current.record
+				});
+			}
+			continue;
+		}
+		const generation = current.record.generationCount;
+		const [record] = await om.getHistory(threadId, resourceId, 1, direction === "after" ? {
+			afterGeneration: generation,
+			sortDirection: "ASC"
+		} : {
+			beforeGeneration: generation,
+			sortDirection: "DESC"
+		});
+		if (!record) break;
+		if ((direction === "after" ? record.generationCount <= generation : record.generationCount >= generation) || record.threadId !== null && record.threadId !== threadId) throw new HistoryFiltersIgnoredError();
+		current = await buildTimeline(record, threadId);
+		position = direction === "after" ? -1 : current.groups.length;
+	}
+	const hasMore = entries.length > limit;
+	const page = entries.slice(0, limit);
+	if (direction === "before") page.reverse();
+	const pagingThreadId = includeThreadId ? threadId : void 0;
+	if (!page.length) {
+		const note = direction === "after" ? await newerMessagesNote(home.groups[home.indexById.get(groupId)], countNewerMessages, pagingThreadId) : null;
+		return {
+			results: `No ${direction === "before" ? "earlier" : "later"} original observation groups in this thread's retained history.${note ? ` ${note}.` : ""}`,
+			count: 0,
+			hasMore: false
+		};
+	}
+	const now = /* @__PURE__ */ new Date();
+	const text = page.map(({ group, record }) => [
+		`## Group \`${group.id}\``,
+		`_range: \`${group.range}\`_`,
+		addRelativeTimeToObservations(group.content, now, record.observedTimezone ?? void 0)
+	].join("\n"));
+	const hasEarlier = direction === "before" ? hasMore : requestedDirection !== void 0 || home.indexById.get(groupId) > 0 || home.record.generationCount > 0 && (await pageGroups({
+		om,
+		threadId,
+		resourceId,
+		groupId,
+		recordId: home.record.id,
+		direction: "before",
+		limit: 1
+	})).count > 0;
+	const hasLater = direction === "before" || hasMore;
+	const newer = hasLater ? null : await newerMessagesNote(page.at(-1).group, countNewerMessages, pagingThreadId);
+	text.unshift(hasEarlier ? `— Browse earlier: ${pagingCall(page[0].group.id, "before", pagingThreadId, page[0].record.id)} —` : "— Start of retained observation history for this thread. —");
+	text.push(hasLater ? `— Browse later: ${pagingCall(page.at(-1).group.id, "after", pagingThreadId, page.at(-1).record.id)} —` : newer ? `— End of observation history for this thread. ${newer} —` : "— End of retained observation history for this thread. —");
+	text.unshift(`### Observation page\nThread: ${threadTitle || "(untitled)"}\nShowing ${page.length} groups ${requestedDirection === void 0 ? "starting at" : `strictly ${direction}`} \`${groupId}\` (oldest first).`);
+	return {
+		results: text.join("\n\n"),
+		count: page.length,
+		hasMore
+	};
+}
+function searchContextKey(match) {
+	return JSON.stringify([match.threadId, match.groupId]);
+}
+/** Read only real recall results, not quoted tool output in user or assistant text. */
+function getVisibleSearchExcerpts(messages) {
+	const excerpts = /* @__PURE__ */ new Map();
+	for (const message of messages) {
+		if (message.role !== "assistant") continue;
+		for (const part of message.content.parts) {
+			if (part.type !== "tool-invocation") continue;
+			const invocation = part.toolInvocation;
+			if (invocation.toolName !== "recall" || invocation.state !== "result" || invocation.args?.mode !== "search") continue;
+			const resolved = resolveToolResultValue(part, invocation.result);
+			let value = resolved.value;
+			if (resolved.usingStoredModelOutput) {
+				if (!value || typeof value !== "object" || !("type" in value) || value.type !== "json" || !("value" in value)) continue;
+				value = value.value;
+			}
+			if (!value || typeof value !== "object" || !("results" in value) || typeof value.results !== "string") continue;
+			for (const section of value.results.split(/^### (?:Current thread memory|Memory from another thread)\s*$/m)) {
+				const threadId = /^- thread: (\S+)/m.exec(section)?.[1];
+				const groupId = (/^- observation group: ([^\n]+)$/m.exec(section)?.[1])?.split("@")[0];
+				const excerpt = /\n```text\n([\s\S]*?)\n```/.exec(section)?.[1];
+				if (!threadId || !groupId || !excerpt) continue;
+				const key = searchContextKey({
+					threadId,
+					groupId
+				});
+				const previous = excerpts.get(key) ?? [];
+				previous.push(excerpt);
+				excerpts.set(key, previous);
+			}
+		}
+	}
+	return excerpts;
+}
+function sourceRangeOverlapsContext({ match, messages }) {
+	if (!match.groupId || !match.range) return false;
+	const endpoints = /^([^:,]+):([^:,]+)$/.exec(match.range);
+	if (!endpoints) return false;
+	const visible = new Set(messages.filter((message) => message.threadId === match.threadId).map((message) => message.id));
+	return visible.has(endpoints[1]) && visible.has(endpoints[2]);
+}
 function getMessageParts(msg) {
 	if (typeof msg.content === "string") return [];
 	if (Array.isArray(msg.content)) return msg.content;
@@ -28389,7 +29109,7 @@ async function listThreadsForResource({ memory, resourceId, currentThreadId, pag
 	};
 }
 const SEARCH_NOT_CONFIGURED_MESSAGE = "Search is not configured. Enable it with `retrieval: { vector: true }` and configure a vector store and embedder on your Memory instance.";
-async function searchMessagesForResource({ memory, resourceId, currentThreadId, query, topK = 10, maxTokens = DEFAULT_MAX_RESULT_TOKENS, before, after, threadScope }) {
+async function searchMessagesForResource({ memory, om, resourceId, currentThreadId, query, topK = 10, maxTokens = DEFAULT_MAX_RESULT_TOKENS, before, after, threadScope, includeThreadId = true, currentMessages = [] }) {
 	if (!memory.searchMessages) return {
 		results: SEARCH_NOT_CONFIGURED_MESSAGE,
 		count: 0
@@ -28400,15 +29120,16 @@ async function searchMessagesForResource({ memory, resourceId, currentThreadId,
 	const searchTopK = Math.min(MAX_TOPK, effectiveTopK);
 	const beforeDate = before ? new Date(before) : void 0;
 	const afterDate = after ? new Date(after) : void 0;
+	const filter = {
+		...threadScope ? { threadId: threadScope } : {},
+		...afterDate ? { observedAfter: afterDate } : {},
+		...beforeDate ? { observedBefore: beforeDate } : {}
+	};
 	const { results } = await memory.searchMessages({
 		query,
 		resourceId,
 		topK: searchTopK,
-		filter: {
-			...threadScope ? { threadId: threadScope } : {},
-			...afterDate ? { observedAfter: afterDate } : {},
-			...beforeDate ? { observedBefore: beforeDate } : {}
-		}
+		filter
 	});
 	if (results.length === 0) return {
 		results: "No matching messages found.",
@@ -28420,47 +29141,169 @@ async function searchMessagesForResource({ memory, resourceId, currentThreadId,
 		const thread = await memory.getThreadById({ threadId: id });
 		if (thread) threadMap.set(id, thread);
 	}));
-	const filteredMatches = results.filter((match) => {
+	const matchesFilter = (match) => {
 		if (threadScope && match.threadId !== threadScope) return false;
 		if (beforeDate && match.observedAt && match.observedAt >= beforeDate) return false;
 		if (afterDate && match.observedAt && match.observedAt <= afterDate) return false;
 		return true;
-	});
+	};
+	const filteredMatches = results.filter(matchesFilter);
 	if (filteredMatches.length === 0) return {
 		results: "No matching messages found.",
 		count: 0
 	};
 	const limitedMatches = filteredMatches.slice(0, clampedTopK);
-	const { text: limited } = truncateByTokens(limitedMatches.map((match) => {
+	const contentBudget = Math.max(0, Math.floor(maxTokens));
+	const perGroupBudget = Math.floor(contentBudget / limitedMatches.length);
+	const now = /* @__PURE__ */ new Date();
+	const terms = excerptQueryTerms(query);
+	const setExcerpt = (entry, budget) => {
+		const selected = selectSearchExcerpt(entry.body, terms, budget);
+		entry.excerpt = selected.text;
+		entry.excerptContent = selected.content;
+	};
+	const [currentRecord] = om && currentThreadId ? await om.getHistory(currentThreadId, resourceId, 1) : [];
+	const timeZone = resolveTimeZone(currentRecord?.observedTimezone ?? void 0);
+	const prepareEntry = (match, index, budget) => {
+		const rawBody = (match.text || "").trim() || "_Observation text unavailable._";
+		const entry = {
+			match,
+			index,
+			body: match.groupId ? addRelativeTimeToObservations(rawBody, now, timeZone) : rawBody,
+			excerpt: "",
+			excerptContent: "",
+			suppression: ""
+		};
+		setExcerpt(entry, budget);
+		return entry;
+	};
+	const ordered = limitedMatches.map((match, index) => prepareEntry(match, index, perGroupBudget));
+	let remaining = contentBudget - ordered.reduce((sum, entry) => sum + estimateTokenCount(entry.excerpt), 0);
+	for (const entry of ordered) {
+		if (remaining <= 0) break;
+		if (entry.excerpt === entry.body) continue;
+		const previousTokens = estimateTokenCount(entry.excerpt);
+		setExcerpt(entry, previousTokens + remaining);
+		remaining -= estimateTokenCount(entry.excerpt) - previousTokens;
+	}
+	const visibleExcerpts = getVisibleSearchExcerpts(currentMessages);
+	const contextGroupIds = /* @__PURE__ */ new Set();
+	for (const observations of [currentRecord?.activeObservations ?? "", ...getBufferedChunks(currentRecord).map((chunk) => chunk.observations)]) for (const group of parseObservationGroups(observations)) contextGroupIds.add(group.id);
+	const suppressCoveredEntry = (entry) => {
+		if (!entry.match.groupId) return;
+		if (entry.excerptContent && visibleExcerpts.get(searchContextKey(entry.match))?.some((text) => text.includes(entry.excerptContent))) entry.suppression = "Excerpt already in current context.";
+		else if (contextGroupIds.has(entry.match.groupId)) entry.suppression = "Group already in current context.";
+		else if (sourceRangeOverlapsContext({
+			match: entry.match,
+			messages: currentMessages
+		})) entry.suppression = "Source range overlaps current context.";
+		if (entry.suppression) {
+			entry.excerpt = "";
+			entry.excerptContent = "";
+		}
+	};
+	ordered.forEach(suppressCoveredEntry);
+	let freshCount = ordered.filter((entry) => !entry.suppression).length;
+	if (freshCount < ordered.length && contentBudget > 0) {
+		const backfillBudget = Math.floor(contentBudget / clampedTopK);
+		for (const entry of ordered) {
+			if (entry.suppression) continue;
+			setExcerpt(entry, backfillBudget);
+			suppressCoveredEntry(entry);
+		}
+		freshCount = ordered.filter((entry) => !entry.suppression).length;
+		const candidateLimit = Math.max(searchTopK, Math.min(100, clampedTopK * 5));
+		const candidateKey = (match) => match.groupId ? searchContextKey(match) : JSON.stringify([
+			match.threadId,
+			match.range,
+			match.text
+		]);
+		const seen = new Set(ordered.map((entry) => candidateKey(entry.match)));
+		const addCandidates = async (candidates) => {
+			for (const match of candidates.slice(0, candidateLimit)) {
+				if (freshCount >= clampedTopK || seen.size >= candidateLimit) break;
+				if (!matchesFilter(match)) continue;
+				const key = candidateKey(match);
+				if (seen.has(key)) continue;
+				seen.add(key);
+				if (!threadMap.has(match.threadId) && memory.getThreadById) {
+					const thread = await memory.getThreadById({ threadId: match.threadId });
+					if (thread) threadMap.set(match.threadId, thread);
+				}
+				const entry = prepareEntry(match, ordered.length, backfillBudget);
+				suppressCoveredEntry(entry);
+				ordered.push(entry);
+				if (!entry.suppression) freshCount++;
+			}
+		};
+		await addCandidates(filteredMatches.slice(limitedMatches.length));
+		if (freshCount < clampedTopK && seen.size < candidateLimit && searchTopK < candidateLimit) await addCandidates((await memory.searchMessages({
+			query,
+			resourceId,
+			topK: candidateLimit,
+			filter
+		})).results);
+	}
+	remaining = contentBudget - ordered.reduce((sum, entry) => sum + estimateTokenCount(entry.excerpt), 0);
+	for (const entry of ordered) {
+		if (remaining <= 0) break;
+		if (entry.suppression || entry.excerpt === entry.body) continue;
+		const previousTokens = estimateTokenCount(entry.excerpt);
+		setExcerpt(entry, previousTokens + remaining);
+		remaining -= estimateTokenCount(entry.excerpt) - previousTokens;
+	}
+	ordered.sort((a, b) => {
+		const at = a.match.observedAt?.getTime() ?? Number.POSITIVE_INFINITY;
+		const bt = b.match.observedAt?.getTime() ?? Number.POSITIVE_INFINITY;
+		if (at !== bt) return at < bt ? -1 : 1;
+		if (a.match.threadId !== b.match.threadId) return a.match.threadId.localeCompare(b.match.threadId);
+		return a.index - b.index;
+	});
+	const sections = [];
+	const compactCount = ordered.length - freshCount;
+	if (compactCount > 0) sections.push(`Showing ${freshCount} excerpts and ${compactCount} already-in-context references.` + (freshCount < clampedTopK ? " Backfill is bounded; fewer excerpts do not mean history is exhausted." : ""));
+	for (let i = 0; i < ordered.length; i++) {
+		const { match, body, excerpt, suppression } = ordered[i];
 		const thread = threadMap.get(match.threadId);
 		const title = thread?.title || "(untitled)";
 		const isCurrentThread = match.threadId === currentThreadId;
-		const generationLabel = isCurrentThread ? "Current thread memory" : "Older memory from another thread";
-		const generationDetail = isCurrentThread ? "This result came from the current thread." : "This result came from an older memory generation in another thread.";
+		const generationLabel = isCurrentThread ? "Current thread memory" : "Memory from another thread";
+		const generationDetail = isCurrentThread ? "This result came from the current thread." : "This result came from another thread.";
 		const threadLine = `- thread: ${match.threadId}${thread ? ` (${title})` : ""}`;
+		const observedLine = match.observedAt ? `- observed: ${formatTimestamp(match.observedAt)} (${formatRelativeTime(match.observedAt, now, timeZone)})` : void 0;
 		const sourceLine = match.range ? `- source: raw messages from ID ${match.range.split(":")[0] ?? "(unknown)"} through ID ${match.range.split(":")[1] ?? "(unknown)"}` : "- source: raw message range unavailable";
-		const updatedLine = thread ? `- thread updated: ${formatTimestamp(thread.updatedAt)}` : void 0;
-		const groupLine = match.groupId ? `- observation group: ${match.groupId}` : void 0;
+		const groupLine = match.groupId ? `- observation group: ${groupCursor(match.groupId, match.recordId)}` : void 0;
 		const scoreLine = `- score: ${match.score.toFixed(2)}`;
-		const body = (match.text || "").trim() || "_Observation text unavailable._";
-		return [
+		const prev = i > 0 ? ordered[i - 1].match : void 0;
+		if (om && prev?.groupId && match.groupId && prev.threadId === match.threadId) sections.push(`— Observation groups may be hidden between these results; continue with ${pagingCall(prev.groupId, "after", includeThreadId ? prev.threadId : void 0, prev.recordId)} —`);
+		if (suppression) {
+			sections.push(`${groupLine}\n  thread: ${match.threadId}; ${suppression}`);
+			continue;
+		}
+		sections.push([
 			`### ${generationLabel}`,
 			"",
 			generationDetail,
 			threadLine,
+			observedLine,
 			sourceLine,
-			updatedLine,
 			groupLine,
 			scoreLine,
 			"",
 			"```text",
-			body,
-			"```"
-		].filter(Boolean).join("\n");
-	}).join("\n\n"), maxTokens);
+			excerpt,
+			"```",
+			excerpt !== body ? "[Excerpt truncated]" : void 0
+		].filter(Boolean).join("\n"));
+	}
+	if (ordered.some((entry) => !entry.suppression && entry.excerpt !== entry.body)) sections.push([
+		`All ${ordered.length} selected matching groups are shown; some excerpts are truncated.`,
+		om ? "To read a full group, use mode=\"observations\" with its threadId and groupId, omitting direction." : void 0,
+		"Use mode=\"messages\" with a source-range cursor for original messages."
+	].filter(Boolean).join(" "));
 	return {
-		results: limited,
-		count: limitedMatches.length
+		results: sections.join("\n\n"),
+		count: ordered.length
 	};
 }
 const LOW_DETAIL_PART_TOKENS = 30;
@@ -28511,6 +29354,54 @@ function chunkTextByTokens(text, maxTokens, charOffset = 0) {
 		truncated: nextCharOffset < text.length
 	};
 }
+const EXCERPT_STOP_WORDS = new Set("the and for with that this from have has had what when where which while who whom why how many much did does was were are you your our their them they there been being some also just than then those these its into about any all can could would should not but user agent asked said mention mentioned total".split(" "));
+function excerptQueryTerms(query) {
+	const words = query.toLowerCase().match(/[\p{L}\p{N}]+/gu) ?? [];
+	return [...new Set(words.filter((word) => word.length >= 3 && !EXCERPT_STOP_WORDS.has(word)))];
+}
+const EXCERPT_OMISSION_MARKER = "[earlier lines omitted]";
+/**
+* Fit an observation to a token budget. When it does not fit, start at the observation
+* line matching the most query terms (keeping that line's date header) instead of the head,
+* so repeated searches can reach text a head-only excerpt would never show.
+* `content` is the slice of the body that is shown, used to recognize excerpts already in context.
+*/
+function selectSearchExcerpt(body, terms, maxTokens) {
+	const head = chunkTextByTokens(body, maxTokens);
+	if (!head.truncated || terms.length === 0) return {
+		text: head.text,
+		content: head.text
+	};
+	const starts = [0, ...[...body.matchAll(/(?<=\s)(?:Date: |\* )/g)].map((match) => match.index)];
+	let best;
+	for (let i = 0; i < starts.length; i++) {
+		const start = starts[i];
+		const end = starts[i + 1] ?? body.length;
+		const line = body.slice(start, end).toLowerCase();
+		const score = terms.filter((term) => line.includes(term)).length;
+		if (score > (best?.score ?? 0)) best = {
+			start,
+			end,
+			score
+		};
+	}
+	if (!best || best.end <= head.text.length) return {
+		text: head.text,
+		content: head.text
+	};
+	const dateStart = body.lastIndexOf("Date: ", best.start);
+	const dateHeader = dateStart >= 0 && dateStart < best.start ? body.slice(dateStart, starts.find((start) => start > dateStart) ?? best.start).trim() : "";
+	const prefix = `${dateHeader ? `${dateHeader} ` : ""}${EXCERPT_OMISSION_MARKER} `;
+	const window = chunkTextByTokens(body, maxTokens - estimateTokenCount(prefix), best.start);
+	if (!window.text) return {
+		text: head.text,
+		content: head.text
+	};
+	return {
+		text: prefix + window.text,
+		content: window.text
+	};
+}
 function lowDetailPartLimit(type) {
 	if (type === "text") return AUTO_EXPAND_TEXT_TOKENS;
 	if (type === "tool-result" || type === "tool-call") return AUTO_EXPAND_TOOL_TOKENS;
@@ -29125,11 +30016,13 @@ const recallTool = (_memoryConfig, options) => {
 	const retrievalScope = options?.retrievalScope ?? "thread";
 	const isResourceScope = retrievalScope === "resource";
 	const searchEnabled = options?.searchEnabled ?? true;
-	const description = isResourceScope ? `Browse conversation history. Use mode="threads" to list all threads for the current user. Use mode="messages" (default) to browse messages in the current thread or pass threadId to browse another thread in the active resource. When mode="messages" has no cursor or threadId, it defaults to the current thread and says so at the top of the result. If you pass only a cursor, it must belong to the current thread.${searchEnabled ? " Use mode=\"search\" to find messages by content across all threads." : ""}` : `Browse conversation history in the current thread. Use mode="messages" (default) to page through messages near a cursor.${searchEnabled ? " Use mode=\"search\" to find messages by content in this thread." : ""} Use mode="threads" to get the current thread's ID and title.`;
+	const getOMEngine = options?.getOMEngine;
+	const description = isResourceScope ? `Browse conversation history. Use mode="threads" to list all threads for the current user. Use mode="messages" (default) to browse messages in the current thread or pass threadId to browse another thread in the active resource. When mode="messages" has no cursor or threadId, it defaults to the current thread and says so at the top of the result. If you pass only a cursor, it must belong to the current thread.${searchEnabled ? " Use mode=\"search\" to find messages by content across all threads; results come back oldest-first with markers where observation groups were skipped. Use mode=\"observations\" with a groupId from a search result to page chronologically through the observation groups around it." : ""}` : `Browse conversation history in the current thread. Use mode="messages" (default) to page through messages near a cursor.${searchEnabled ? " Use mode=\"search\" to find messages by content in this thread; results come back oldest-first with markers where observation groups were skipped. Use mode=\"observations\" with a groupId from a search result to page chronologically through the observation groups around it." : ""} Use mode="threads" to get the current thread's ID and title.`;
 	const modeEnum = searchEnabled ? [
 		"messages",
 		"threads",
-		"search"
+		"search",
+		"observations"
 	] : ["messages", "threads"];
 	return (0, _mastra_core_tools.createTool)({
 		id: "recall",
@@ -29142,7 +30035,7 @@ const recallTool = (_memoryConfig, options) => {
 					mode: {
 						type: "string",
 						enum: modeEnum,
-						description: `What to retrieve. "messages" (default) pages through message history. "threads" lists all threads for the current user.${searchEnabled ? " \"search\" finds messages by semantic similarity across all threads." : ""}`
+						description: `What to retrieve. "messages" (default) pages through message history. "threads" lists all threads for the current user.${searchEnabled ? " \"search\" finds messages by semantic similarity across all threads. \"observations\" pages observation groups chronologically around a groupId from a search result." : ""}`
 					},
 					threadId: {
 						type: "string",
@@ -29151,22 +30044,44 @@ const recallTool = (_memoryConfig, options) => {
 					},
 					before: {
 						type: "string",
-						description: "For mode=\"threads\": only show threads created before this date. ISO 8601 or natural date string (e.g. \"2026-03-15\", \"2026-03-10T00:00:00Z\")."
+						description: "Only show results before this date. Applies to mode=\"threads\" (thread creation date) and mode=\"search\" (observation date). ISO 8601 or natural date string (e.g. \"2026-03-15\", \"2026-03-10T00:00:00Z\")."
 					},
 					after: {
 						type: "string",
-						description: "For mode=\"threads\": only show threads created after this date. ISO 8601 or natural date string (e.g. \"2026-03-01\", \"2026-03-10T00:00:00Z\")."
+						description: "Only show results after this date. Applies to mode=\"threads\" (thread creation date) and mode=\"search\" (observation date). ISO 8601 or natural date string (e.g. \"2026-03-01\", \"2026-03-10T00:00:00Z\")."
 					}
 				} : { mode: {
 					type: "string",
 					enum: modeEnum,
-					description: `What to retrieve. "messages" (default) pages through message history. "threads" returns info about the current thread.${searchEnabled ? " \"search\" finds messages by semantic similarity in this thread." : ""}`
+					description: `What to retrieve. "messages" (default) pages through message history. "threads" returns info about the current thread.${searchEnabled ? " \"search\" finds messages by semantic similarity in this thread. \"observations\" pages observation groups chronologically around a groupId from a search result." : ""}`
 				} },
-				...searchEnabled ? { query: {
-					type: "string",
-					minLength: 1,
-					description: "Search query for mode=\"search\". Finds messages semantically similar to this text."
-				} } : {},
+				...searchEnabled ? {
+					...!isResourceScope ? {
+						before: {
+							type: "string",
+							description: "For mode=\"search\": only show observations dated before this ISO 8601 date."
+						},
+						after: {
+							type: "string",
+							description: "For mode=\"search\": only show observations dated after this ISO 8601 date."
+						}
+					} : {},
+					query: {
+						type: "string",
+						minLength: 1,
+						description: "Search query for mode=\"search\". Finds messages semantically similar to this text."
+					},
+					groupId: {
+						type: "string",
+						minLength: 1,
+						description: "Observation group ID to page around, for mode=\"observations\". Copy it exactly from the \"observation group:\" line of a search result or a continuation call."
+					},
+					direction: {
+						type: "string",
+						enum: ["before", "after"],
+						description: "For mode=\"observations\": page strictly before or after the groupId. Omit to read the full anchor group and following groups."
+					}
+				} : {},
 				cursor: {
 					type: "string",
 					minLength: 1,
@@ -29187,7 +30102,7 @@ const recallTool = (_memoryConfig, options) => {
 					type: "integer",
 					minimum: 1,
 					maximum: 20,
-					description: "Maximum number of items to return per page. Defaults to 20."
+					description: "Maximum items per page: defaults to 20 for messages, 5 for observations. For search, target number of excerpts (default 10), plus compact references for evidence already in context; bounded backfill may return fewer excerpts."
 				},
 				detail: {
 					type: "string",
@@ -29228,13 +30143,59 @@ const recallTool = (_memoryConfig, options) => {
 			}
 		},
 		execute: async (inputData, context) => {
-			const { mode, query, cursor, threadId: explicitThreadId, anchor, page, limit, detail, partType, toolName, partIndex, charOffset, before, after, viewAttachment } = inputData;
+			const { mode, query, groupId, direction, cursor, threadId: explicitThreadId, anchor, page, limit, detail, partType, toolName, partIndex, charOffset, before, after, viewAttachment } = inputData;
 			const memory = context?.memory;
 			const currentThreadId = context?.agent?.threadId;
 			const resourceId = context?.agent?.resourceId;
 			const resolvedExplicitThreadId = explicitThreadId === "current" ? currentThreadId : explicitThreadId;
 			if (!memory) throw new Error("Memory instance is required for recall");
 			if (explicitThreadId === "current" && !currentThreadId) throw new Error("Could not resolve current thread.");
+			if (mode === "observations") {
+				if (!searchEnabled) return {
+					results: SEARCH_NOT_CONFIGURED_MESSAGE,
+					count: 0
+				};
+				if (!groupId) throw new Error("groupId is required for mode=\"observations\"");
+				if (!resourceId) throw new Error("Resource ID is required for recall");
+				const om = await getOMEngine?.() ?? null;
+				if (!om) return {
+					results: "Observation group paging requires observational memory and a storage adapter supporting observation history search.",
+					count: 0
+				};
+				const pagingThreadId = !isResourceScope ? currentThreadId : resolvedExplicitThreadId || currentThreadId;
+				if (!pagingThreadId) throw new Error("Could not resolve current thread.");
+				const thread = await memory.getThreadById?.({ threadId: pagingThreadId });
+				if (!thread || thread.resourceId !== resourceId) throw new Error("Thread not found");
+				return pageObservationGroups({
+					om,
+					threadId: pagingThreadId,
+					resourceId,
+					...parseGroupCursor(groupId),
+					direction,
+					limit: Math.min(Math.max(limit ?? 5, 1), 20),
+					threadTitle: thread.title,
+					includeThreadId: isResourceScope,
+					countNewerMessages: async (cursor) => {
+						const end = (await (await memory.getMemoryStore()).listMessagesById({ messageIds: [cursor] })).messages.find((m) => m.id === cursor);
+						if (!end || end.threadId !== pagingThreadId) return 0;
+						const { total } = await memory.recall({
+							threadId: pagingThreadId,
+							resourceId,
+							page: 0,
+							perPage: 1,
+							orderBy: {
+								field: "createdAt",
+								direction: "ASC"
+							},
+							filter: { dateRange: {
+								start: end.createdAt,
+								startExclusive: true
+							} }
+						});
+						return total;
+					}
+				});
+			}
 			if (mode === "search") {
 				if (!searchEnabled) return {
 					results: SEARCH_NOT_CONFIGURED_MESSAGE,
@@ -29244,13 +30205,16 @@ const recallTool = (_memoryConfig, options) => {
 				if (!resourceId) throw new Error("Resource ID is required for recall");
 				return searchMessagesForResource({
 					memory,
+					om: await getOMEngine?.() ?? null,
 					resourceId,
 					currentThreadId: currentThreadId || void 0,
+					currentMessages: context?.agent?.getMessages?.(),
 					query,
 					topK: limit ?? 10,
 					before,
 					after,
-					threadScope: !isResourceScope ? currentThreadId || void 0 : resolvedExplicitThreadId || void 0
+					threadScope: !isResourceScope ? currentThreadId || void 0 : resolvedExplicitThreadId || void 0,
+					includeThreadId: isResourceScope
 				});
 			}
 			if (mode === "threads") {
@@ -29967,475 +30931,6 @@ function createThreadUpdateMarker(params) {
 		}
 	};
 }
-/**
-* Find the index of the last completed observation boundary (end marker) in a message's parts.
-* Returns -1 if no completed observation is found.
-*/
-function findLastCompletedObservationBoundary(message) {
-	const parts = message.content?.parts;
-	if (!parts || !Array.isArray(parts)) return -1;
-	for (let i = parts.length - 1; i >= 0; i--) {
-		const part = parts[i];
-		if (part?.type === "data-om-observation-end" && part.data?.operationType !== "reflection") return i;
-	}
-	return -1;
-}
-/**
-* Get unobserved parts from a message.
-* If the message has a completed observation (start + end), only return parts after the end.
-* If observation is in progress (start without end), include parts before the start.
-* Otherwise, return all parts.
-*/
-function getUnobservedParts(message) {
-	const parts = message.content?.parts;
-	if (!parts || !Array.isArray(parts)) return [];
-	const endMarkerIndex = findLastCompletedObservationBoundary(message);
-	if (endMarkerIndex === -1) return parts.filter((p) => {
-		return p?.type !== "data-om-observation-start";
-	});
-	return parts.slice(endMarkerIndex + 1).filter((p) => {
-		return !p?.type?.startsWith("data-om-observation-");
-	});
-}
-/**
-* Compute a cursor pointing at the latest message by createdAt.
-* Used to derive a stable observation boundary for replay pruning.
-*/
-function getLastObservedMessageCursor(messages) {
-	let latest;
-	for (const msg of messages) {
-		if (!msg?.id || !msg.createdAt) continue;
-		if (!latest || new Date(msg.createdAt).getTime() > new Date(latest.createdAt).getTime()) latest = msg;
-	}
-	return latest ? {
-		createdAt: new Date(latest.createdAt).toISOString(),
-		id: latest.id
-	} : void 0;
-}
-/**
-* Check if a message is at or before a cursor (by createdAt then id).
-*/
-function isMessageAtOrBeforeCursor(msg, cursor) {
-	if (!msg.createdAt) return false;
-	const msgIso = new Date(msg.createdAt).toISOString();
-	if (msgIso < cursor.createdAt) return true;
-	if (msgIso === cursor.createdAt && msg.id === cursor.id) return true;
-	return false;
-}
-/**
-* Return the toolCallId of a tool-invocation part in the given state, or undefined.
-*/
-function getToolInvocationId(part, state) {
-	if (part?.type !== "tool-invocation") return void 0;
-	if (part.toolInvocation.state !== state) return void 0;
-	return part.toolInvocation.toolCallId || void 0;
-}
-function collectPendingToolResultIds(allMessages, observedIds) {
-	const pendingToolResultIds = /* @__PURE__ */ new Set();
-	for (const msg of allMessages) {
-		if (!msg?.id) continue;
-		if (observedIds?.has(msg.id)) continue;
-		const parts = msg.content?.parts;
-		if (!parts || !Array.isArray(parts)) continue;
-		for (const part of parts) {
-			const id = getToolInvocationId(part, "result");
-			if (id) pendingToolResultIds.add(id);
-		}
-	}
-	return pendingToolResultIds;
-}
-function hasPendingToolResultPair(message, pendingToolResultIds) {
-	if (pendingToolResultIds.size === 0) return false;
-	const parts = message.content?.parts;
-	if (!parts || !Array.isArray(parts)) return false;
-	return parts.some((part) => {
-		const id = getToolInvocationId(part, "call");
-		return id !== void 0 && pendingToolResultIds.has(id);
-	});
-}
-function collectPendingToolResultIdsAfterMarker(allMessages, markerMessageIndex, markerMessage) {
-	const pendingToolResultIds = /* @__PURE__ */ new Set();
-	const unobservedMarkerParts = getUnobservedParts(markerMessage);
-	if (unobservedMarkerParts.length > 0) collectPendingToolResultIds([{
-		...markerMessage,
-		content: {
-			...markerMessage.content,
-			parts: unobservedMarkerParts
-		}
-	}], void 0).forEach((id) => pendingToolResultIds.add(id));
-	collectPendingToolResultIds(allMessages.slice(markerMessageIndex + 1), void 0).forEach((id) => pendingToolResultIds.add(id));
-	return pendingToolResultIds;
-}
-function getUnobservedPartsPreservingToolCallPairs(message) {
-	const parts = message.content?.parts;
-	if (!parts || !Array.isArray(parts)) return [];
-	const endMarkerIndex = findLastCompletedObservationBoundary(message);
-	if (endMarkerIndex === -1) return getUnobservedParts(message);
-	const unobservedParts = getUnobservedParts(message);
-	const unobservedResultIds = /* @__PURE__ */ new Set();
-	for (const part of unobservedParts) {
-		const id = getToolInvocationId(part, "result");
-		if (id) unobservedResultIds.add(id);
-	}
-	if (unobservedResultIds.size === 0) return unobservedParts;
-	const preservedCalls = parts.slice(0, endMarkerIndex).filter((part) => {
-		const id = getToolInvocationId(part, "call");
-		return id !== void 0 && unobservedResultIds.has(id);
-	});
-	return preservedCalls.length > 0 ? [...preservedCalls, ...unobservedParts] : unobservedParts;
-}
-/**
-* Get the messages Observational Memory is allowed to work with.
-*
-* Messages supplied through the `context` option and the synthetic `om-continuation`
-* message are prompt-only input. Core's persistence contract already treats context as
-* never-persist, while the continuation remains memory-sourced so it can stay in the live
-* actor prompt.
-*
-* OM builds its windows from `get.all.db()`, which includes both categories, and then seals
-* and persists candidates directly. Excluding them here keeps OM's observation, buffering,
-* persistence, and token accounting consistent with their ephemeral contract.
-*/
-function getObservableMessages(messageList) {
-	const contextMessageIds = messageList.makeMessageSourceChecker().context;
-	return messageList.get.all.db().filter((message) => {
-		return message.id !== "om-continuation" && !contextMessageIds.has(message.id);
-	});
-}
-/**
-* Safely extract buffered observation chunks from a record.
-* Handles both array and JSON-string formats, returning empty array if malformed.
-*/
-/**
-* Filter out already-observed messages from the in-memory context.
-* Uses marker-boundary pruning (preferred) or record-based fallback.
-*
-* The `fallbackCursor` is optional — callers that need it should resolve it
-* from thread metadata before calling this function.
-*/
-function filterObservedMessages(opts) {
-	const { messageList, record } = opts;
-	const allMessages = getObservableMessages(messageList);
-	const useMarkerBoundaryPruning = opts.useMarkerBoundaryPruning ?? true;
-	const preserveMessageIds = opts.preserveMessageIds ?? /* @__PURE__ */ new Set();
-	const observedIds = new Set(Array.isArray(record?.observedMessageIds) ? record.observedMessageIds : []);
-	let markerMessageIndex = -1;
-	let markerMessage = null;
-	for (let i = allMessages.length - 1; i >= 0; i--) {
-		const msg = allMessages[i];
-		if (!msg) continue;
-		if (findLastCompletedObservationBoundary(msg) !== -1) {
-			markerMessageIndex = i;
-			markerMessage = msg;
-			break;
-		}
-	}
-	if (useMarkerBoundaryPruning && markerMessage && markerMessageIndex !== -1) {
-		const pendingToolResultIds = collectPendingToolResultIdsAfterMarker(allMessages, markerMessageIndex, markerMessage);
-		const messagesToRemove = [];
-		for (let i = 0; i < markerMessageIndex; i++) {
-			const msg = allMessages[i];
-			if (msg?.id && msg.id !== "om-continuation" && !preserveMessageIds.has(msg.id) && !hasPendingToolResultPair(msg, pendingToolResultIds)) messagesToRemove.push(msg.id);
-		}
-		if (messagesToRemove.length > 0) messageList.removeByIds(messagesToRemove);
-		const unobserved = getUnobservedPartsPreservingToolCallPairs(markerMessage);
-		if (unobserved.length === 0) {
-			if (markerMessage.id) messageList.removeByIds([markerMessage.id]);
-		} else if (unobserved.length < (markerMessage.content?.parts?.length ?? 0)) markerMessage.content.parts = unobserved;
-	} else if (record) {
-		const pendingToolResultIds = collectPendingToolResultIds(allMessages, observedIds);
-		const derivedCursor = opts.fallbackCursor ?? getLastObservedMessageCursor(allMessages.filter((msg) => !!msg?.id && observedIds.has(msg.id) && !!msg.createdAt));
-		const lastObservedAt = record.lastObservedAt;
-		const messagesToRemove = [];
-		for (const msg of allMessages) {
-			if (!msg?.id || msg.id === "om-continuation" || preserveMessageIds.has(msg.id)) continue;
-			const hasPendingPair = hasPendingToolResultPair(msg, pendingToolResultIds);
-			if (observedIds.has(msg.id)) {
-				if (hasPendingPair) continue;
-				messagesToRemove.push(msg.id);
-				continue;
-			}
-			if (derivedCursor && isMessageAtOrBeforeCursor(msg, derivedCursor)) {
-				if (hasPendingPair) continue;
-				messagesToRemove.push(msg.id);
-				continue;
-			}
-			if (lastObservedAt && msg.createdAt) {
-				if (new Date(msg.createdAt) <= lastObservedAt) {
-					if (hasPendingPair) continue;
-					messagesToRemove.push(msg.id);
-				}
-			}
-		}
-		if (messagesToRemove.length > 0) messageList.removeByIds(messagesToRemove);
-	}
-}
-function getBufferedChunks(record) {
-	if (!record?.bufferedObservationChunks) return [];
-	if (Array.isArray(record.bufferedObservationChunks)) return record.bufferedObservationChunks;
-	if (typeof record.bufferedObservationChunks === "string") try {
-		const parsed = JSON.parse(record.bufferedObservationChunks);
-		return Array.isArray(parsed) ? parsed : [];
-	} catch {
-		return [];
-	}
-	return [];
-}
-/**
-* Sort threads by their oldest unobserved message.
-* Returns thread IDs in order from oldest to most recent.
-*/
-/**
-* Combine active and buffered observations for the buffering observer context.
-*/
-function combineObservationsForBuffering(activeObservations, bufferedObservations) {
-	if (!activeObservations && !bufferedObservations) return void 0;
-	if (!activeObservations) return bufferedObservations;
-	if (!bufferedObservations) return activeObservations;
-	return `${activeObservations}\n\n--- BUFFERED (pending activation) ---\n\n${bufferedObservations}`;
-}
-function sortThreadsByOldestMessage(messagesByThread) {
-	return Array.from(messagesByThread.entries()).map(([threadId, messages]) => ({
-		threadId,
-		oldestTimestamp: Math.min(...messages.map((m) => m.createdAt ? new Date(m.createdAt).getTime() : Date.now()))
-	})).sort((a, b) => a.oldestTimestamp - b.oldestTimestamp).map((t) => t.threadId);
-}
-/**
-* Strip any thread tags that the Observer might have added.
-* Thread attribution is handled externally by the system, not by the Observer.
-*/
-function stripThreadTags(observations) {
-	return observations.replace(/<\/?thread\b[^>]{0,1024}>/gi, "").trim();
-}
-const OBSERVATION_GROUP_OPEN = "<observation-group";
-const OBSERVATION_GROUP_CLOSE = "</observation-group>";
-const ATTRIBUTE_PATTERN = /([\w][\w-]*)="([^"]*)"/g;
-const REFLECTION_GROUP_SPLIT_PATTERN = /^##\s+Group\s+/m;
-function parseObservationGroupAttributes(attributeString) {
-	const attributes = {};
-	for (const match of attributeString.matchAll(ATTRIBUTE_PATTERN)) {
-		const [, key, value] = match;
-		if (key && value !== void 0) attributes[key] = value;
-	}
-	return attributes;
-}
-function isLineStart(observations, index) {
-	return index === 0 || observations[index - 1] === "\n";
-}
-function scanObservationGroupTags(observations) {
-	const tags = [];
-	const incompleteOpenings = [];
-	let cursor = 0;
-	let closeFloor = 0;
-	let nestedFloor = -1;
-	while (cursor < observations.length) {
-		const start = observations.indexOf(OBSERVATION_GROUP_OPEN, cursor);
-		if (start === -1) break;
-		const attributesStart = start + 18;
-		if (!/\s/.test(observations[attributesStart] ?? "")) {
-			cursor = attributesStart;
-			continue;
-		}
-		const openEnd = observations.indexOf(">", attributesStart);
-		if (openEnd === -1) break;
-		const closeStart = observations.indexOf(OBSERVATION_GROUP_CLOSE, Math.max(openEnd + 1, closeFloor));
-		if (closeStart === -1) {
-			if (isLineStart(observations, start)) incompleteOpenings.push({
-				start,
-				end: openEnd + 1
-			});
-			closeFloor = observations.length;
-			cursor = openEnd + 1;
-			continue;
-		}
-		if (nestedFloor <= openEnd) {
-			const lineOpen = observations.indexOf(`\n${OBSERVATION_GROUP_OPEN}`, openEnd);
-			nestedFloor = lineOpen === -1 ? observations.length : lineOpen + 1;
-		}
-		const nestedStart = nestedFloor;
-		if (nestedStart < closeStart) {
-			incompleteOpenings.push({
-				start,
-				end: openEnd + 1
-			});
-			closeFloor = closeStart;
-			cursor = nestedStart;
-			continue;
-		}
-		tags.push({
-			start,
-			end: closeStart + 20,
-			attributeString: observations.slice(attributesStart, openEnd),
-			content: observations.slice(openEnd + 1, closeStart)
-		});
-		closeFloor = closeStart;
-		cursor = closeStart + 20;
-	}
-	return {
-		tags,
-		incompleteOpenings
-	};
-}
-function replaceObservationGroupTags(observations, replace) {
-	const { tags, incompleteOpenings } = scanObservationGroupTags(observations);
-	const parts = [];
-	let cursor = 0;
-	let openingIndex = 0;
-	const skipIncompleteOpeningsBefore = (limit) => {
-		while (openingIndex < incompleteOpenings.length && incompleteOpenings[openingIndex].start < limit) {
-			const opening = incompleteOpenings[openingIndex];
-			openingIndex++;
-			if (opening.start < cursor) continue;
-			parts.push(observations.slice(cursor, opening.start));
-			cursor = opening.end;
-		}
-	};
-	for (const tag of tags) {
-		skipIncompleteOpeningsBefore(tag.start);
-		parts.push(observations.slice(cursor, tag.start), replace(tag));
-		cursor = tag.end;
-	}
-	skipIncompleteOpeningsBefore(Number.POSITIVE_INFINITY);
-	parts.push(observations.slice(cursor));
-	return parts.join("");
-}
-function parseReflectionObservationGroupSections(content) {
-	const normalizedContent = content.trim();
-	if (!normalizedContent || !REFLECTION_GROUP_SPLIT_PATTERN.test(normalizedContent)) return [];
-	return normalizedContent.split(REFLECTION_GROUP_SPLIT_PATTERN).map((section) => section.trim()).filter(Boolean).map((section) => {
-		const newlineIndex = section.indexOf("\n");
-		return {
-			heading: (newlineIndex >= 0 ? section.slice(0, newlineIndex) : section).trim(),
-			body: stripReflectionGroupMetadata((newlineIndex >= 0 ? section.slice(newlineIndex + 1) : "").trim())
-		};
-	});
-}
-function stripReflectionGroupMetadata(body) {
-	return body.replace(/^_range:\s*`[^`]*`_\s*\n?/m, "").trim();
-}
-function generateAnchorId() {
-	return Buffer.from(globalThis.crypto.getRandomValues(/* @__PURE__ */ new Uint8Array(8))).toString("hex");
-}
-function wrapInObservationGroup(observations, range, id = generateAnchorId(), _sourceGroupIds, kind) {
-	const content = observations.trim();
-	return `<observation-group id="${id}" range="${range}"${kind ? ` kind="${kind}"` : ""}>\n${content}\n</observation-group>`;
-}
-function parseObservationGroups(observations) {
-	if (!observations) return [];
-	const groups = [];
-	for (const tag of scanObservationGroupTags(observations).tags) {
-		const attributes = parseObservationGroupAttributes(tag.attributeString);
-		const id = attributes.id;
-		const range = attributes.range;
-		if (!id || !range) continue;
-		groups.push({
-			id,
-			range,
-			kind: attributes.kind,
-			content: tag.content.trim()
-		});
-	}
-	return groups;
-}
-function stripObservationGroups(observations) {
-	if (!observations) return observations;
-	return replaceObservationGroupTags(observations, (tag) => tag.content.trim()).replace(/\n{3,}/g, "\n\n").trim();
-}
-function getRangeSegments(range) {
-	return range.split(",").map((segment) => segment.trim()).filter(Boolean);
-}
-function getRangeEndpoints(segment) {
-	const parts = segment.split(":").map((part) => part.trim());
-	if (parts.length !== 2 || !parts[0] || !parts[1]) return null;
-	return {
-		start: parts[0],
-		end: parts[1]
-	};
-}
-/**
-* `buildMessageRange` produces opaque UUID endpoints, so those segments cannot be ordered by value.
-* Spanning from the first start to the last end keeps reflected metadata bounded — the full segment
-* list is deliberately not preserved (#14791). Segments that are not `start:end` pairs are left as
-* they are rather than being joined into a fabricated span.
-*/
-function spanRangeSegments(segments) {
-	const endpoints = segments.map(getRangeEndpoints);
-	if (endpoints.some((endpoint) => endpoint === null)) return segments.join(",");
-	const first = endpoints[0];
-	const last = endpoints.at(-1);
-	return `${first.start}:${last.end}`;
-}
-function combineObservationGroupRanges(groups) {
-	const segments = Array.from(new Set(groups.flatMap((group) => getRangeSegments(group.range))));
-	if (segments.length === 0) return "";
-	const numericEndpoints = [];
-	if (!segments.every((segment) => {
-		const endpoints = getRangeEndpoints(segment);
-		if (!endpoints || !/^\d+$/.test(endpoints.start) || !/^\d+$/.test(endpoints.end)) return false;
-		const start = {
-			label: endpoints.start,
-			value: Number(endpoints.start)
-		};
-		const end = {
-			label: endpoints.end,
-			value: Number(endpoints.end)
-		};
-		if (!Number.isSafeInteger(start.value) || !Number.isSafeInteger(end.value)) return false;
-		numericEndpoints.push(start.value <= end.value ? {
-			start,
-			end
-		} : {
-			start: end,
-			end: start
-		});
-		return true;
-	})) return spanRangeSegments(segments);
-	const first = numericEndpoints.reduce((lowest, pair) => pair.start.value < lowest.start.value ? pair : lowest);
-	const last = numericEndpoints.reduce((highest, pair) => pair.end.value > highest.end.value ? pair : highest);
-	return `${first.start.label}:${last.end.label}`;
-}
-function renderObservationGroupsForReflection(observations) {
-	if (parseObservationGroups(observations).length === 0) return null;
-	return replaceObservationGroupTags(observations, (tag) => {
-		const attributes = parseObservationGroupAttributes(tag.attributeString);
-		if (!attributes.id || !attributes.range) return tag.content.trim();
-		return `## Group \`${attributes.id}\`\n_range: \`${attributes.range}\`_\n\n${tag.content.trim()}`;
-	}).replace(/\n{3,}/g, "\n\n").trim();
-}
-function getCanonicalGroupId(sectionHeading, fallbackIndex) {
-	return sectionHeading.match(/`([^`]+)`/)?.[1]?.trim() || `derived-group-${fallbackIndex + 1}`;
-}
-function getContentLines(content) {
-	return content.split("\n").map((line) => line.trim()).filter(Boolean);
-}
-function deriveObservationGroupProvenance(content, groups) {
-	const sections = parseReflectionObservationGroupSections(content);
-	if (sections.length === 0 || groups.length === 0) return [];
-	return sections.map((section, index) => {
-		const canonicalGroupId = getCanonicalGroupId(section.heading, index);
-		const identifiedGroup = groups.find((group) => group.id === canonicalGroupId);
-		const bodyLines = new Set(getContentLines(section.body));
-		const matchingGroups = groups.filter((group) => getContentLines(group.content).some((line) => bodyLines.has(line)));
-		const fallbackGroup = groups[Math.min(index, groups.length - 1)];
-		const identifiedLines = new Set(getContentLines(identifiedGroup?.content ?? ""));
-		const contributingGroups = identifiedGroup ? matchingGroups.filter((group) => group.id !== identifiedGroup.id && getContentLines(group.content).some((line) => bodyLines.has(line) && !identifiedLines.has(line))) : [];
-		return {
-			id: canonicalGroupId,
-			range: combineObservationGroupRanges(identifiedGroup ? groups.filter((group) => group === identifiedGroup || contributingGroups.includes(group)) : matchingGroups.length > 0 ? matchingGroups : fallbackGroup ? [fallbackGroup] : []),
-			kind: "reflection",
-			content: section.body
-		};
-	});
-}
-function reconcileObservationGroupsFromReflection(content, sourceObservations) {
-	const sourceGroups = parseObservationGroups(sourceObservations);
-	if (sourceGroups.length === 0) return null;
-	const normalizedContent = content.trim();
-	if (!normalizedContent) return "";
-	const derivedGroups = deriveObservationGroupProvenance(normalizedContent, sourceGroups);
-	if (derivedGroups.length > 0) return derivedGroups.map((group) => wrapInObservationGroup(group.content, group.range, group.id, void 0, group.kind)).join("\n\n");
-	return wrapInObservationGroup(normalizedContent, combineObservationGroupRanges(sourceGroups), generateAnchorId(), void 0, "reflection");
-}
 function isRecord$1(value) {
 	return !!value && typeof value === "object" && !Array.isArray(value);
 }
@@ -30774,7 +31269,7 @@ var ObservationStrategy = class ObservationStrategy {
 		}
 		return `${existingObservations}${lastObservedAt ? ObservationStrategy.createMessageBoundary(lastObservedAt) : "\n\n"}${newThreadSection}`;
 	}
-	async indexObservationGroups(observations, threadId, resourceId, observedAt) {
+	async indexObservationGroups(observations, threadId, resourceId, observedAt, recordId) {
 		if (!resourceId || !this.deps.onIndexObservations) return;
 		const groups = parseObservationGroups(observations);
 		if (groups.length === 0) return;
@@ -30784,7 +31279,8 @@ var ObservationStrategy = class ObservationStrategy {
 			range: group.range,
 			threadId,
 			resourceId,
-			observedAt
+			observedAt,
+			recordId
 		}), {
 			label: "index-observations",
 			abortSignal: this.opts.abortSignal
@@ -31058,7 +31554,7 @@ var SyncObservationStrategy = class extends ObservationStrategy {
 			lastObservedAt: processed.lastObservedAt,
 			observedMessageIds: processed.observedMessageIds
 		});
-		await this.indexObservationGroups(processed.observations, threadId, resourceId, processed.lastObservedAt);
+		await this.indexObservationGroups(processed.observations, threadId, resourceId, processed.lastObservedAt, record.id);
 	}
 	async emitEndMarkers(cycleId, processed) {
 		const actualTokensObserved = await this.tokenCounter.countMessagesAsync(this.opts.messages);
@@ -31230,7 +31726,7 @@ var AsyncBufferObservationStrategy = class extends ObservationStrategy {
 			label: "persist-buffered-observations",
 			abortSignal: this.opts.abortSignal
 		});
-		await this.indexObservationGroups(processed.observations, threadId, resourceId, processed.lastObservedAt);
+		await this.indexObservationGroups(processed.observations, threadId, resourceId, processed.lastObservedAt, record.id);
 		const candidateTitle = processed.threadTitle?.trim();
 		const hasValidThreadTitle = !!candidateTitle && candidateTitle.length >= 3;
 		if (hasValidThreadTitle || processed.extractedValues) {
@@ -31633,7 +32129,7 @@ var ResourceScopedObservationStrategy = class extends ObservationStrategy {
 			lastObservedAt: processed.lastObservedAt,
 			observedMessageIds: processed.observedMessageIds
 		});
-		if (resourceId) await Promise.all(this.observationResults.map(({ threadId, threadMessages, result }) => this.indexObservationGroups(result.observations, threadId, resourceId, this.getMaxMessageTimestamp(threadMessages))));
+		if (resourceId) await Promise.all(this.observationResults.map(({ threadId, threadMessages, result }) => this.indexObservationGroups(result.observations, threadId, resourceId, this.getMaxMessageTimestamp(threadMessages), record.id)));
 	}
 	async emitEndMarkers(cycleId, processed) {
 		for (const obsResult of this.observationResults) {
@@ -34753,9 +35249,9 @@ var ObservationalMemory = class ObservationalMemory {
 	* the message for the current thread.
 	*/
 	formatObservationsForContext(observations, currentTask, suggestedResponse, extractedValues, unobservedContextBlocks, currentDate, retrieval = false, timeZone) {
-		let optimized = retrieval ? renderObservationGroupsForReflection(observations) ?? optimizeObservationsForContext(observations) : optimizeObservationsForContext(observations);
+		let optimized = retrieval ? renderObservationGroupsForReflection(observations, { includeReflectionKind: true }) ?? optimizeObservationsForContext(observations) : optimizeObservationsForContext(observations);
 		if (currentDate) optimized = addRelativeTimeToObservations(optimized, currentDate, timeZone);
-		const messages = [`${getObservationContextPrompt(this.scope)}\n\n${OBSERVATION_CONTEXT_INSTRUCTIONS}${retrieval ? `\n\n${getRetrievalInstructions(this.retrievalScope, this.retrievalInstructions, this.retrievalSearch)}` : ""}`];
+		const messages = [`${getObservationContextPrompt(this.scope)}\n\n${OBSERVATION_CONTEXT_INSTRUCTIONS}${retrieval ? `\n\n${getRetrievalInstructions(this.retrievalScope, this.retrievalInstructions, this.retrievalSearch, this.storage.supportsObservationalMemoryHistorySearch === true)}` : ""}`];
 		if (unobservedContextBlocks) messages.push(`The following content is from OTHER conversations different from the current conversation, they're here for reference,  but they're not necessarily your focus:\nSTART_OTHER_CONVERSATIONS_BLOCK\n${unobservedContextBlocks}\nEND_OTHER_CONVERSATIONS_BLOCK`);
 		const observationChunks = this.splitObservationContextChunks(optimized);
 		if (observationChunks.length > 0) messages.push("<observations>", ...observationChunks);
@@ -35252,7 +35748,8 @@ ${formattedMessages}
 	*
 	* Loads thread metadata (currentTask, suggestedResponse), formats observations
 	* with context prompts and instructions, and returns the fully-formed string.
-	* Returns undefined if no observations exist.
+	* Returns recall guidance even without observations when retrieval is enabled;
+	* otherwise returns undefined when no observations exist.
 	*
 	* This is the public entry point for context formatting — used by both
 	* Memory.getContext() (standalone) and the processor (via injectObservationsIntoMessages).
@@ -35276,9 +35773,9 @@ ${formattedMessages}
 	*/
 	async buildContextSystemMessages(opts) {
 		const { threadId, resourceId, unobservedContextBlocks } = opts;
-		const record = opts.record ?? await this.getOrCreateRecord(threadId, resourceId);
-		if (!record.activeObservations) {
-			if (this.retrieval && this.retrievalScope === "resource") return [getRetrievalInstructions(this.retrievalScope, this.retrievalInstructions, this.retrievalSearch)];
+		const record = opts.record === void 0 ? await this.getOrCreateRecord(threadId, resourceId) : opts.record;
+		if (!record?.activeObservations) {
+			if (this.retrieval) return [getRetrievalInstructions(this.retrievalScope, this.retrievalInstructions, this.retrievalSearch, this.storage.supportsObservationalMemoryHistorySearch === true)];
 			return;
 		}
 		const omMetadata = (0, _mastra_core_memory.getThreadOMMetadata)((await this.storage.getThreadById({ threadId }))?.metadata);
@@ -36514,12 +37011,12 @@ var ObservationalMemoryProcessor = class {
 					resourceId,
 					runState
 				});
-				const systemMessages = ctx.omRecord ? await this.engine.buildContextSystemMessages({
+				const systemMessages = await this.engine.buildContextSystemMessages({
 					threadId,
 					resourceId,
 					record: ctx.omRecord,
 					unobservedContextBlocks: ctx.otherThreadsContext
-				}) : void 0;
+				});
 				injectObservationContextMessages({
 					messageList,
 					systemMessages,
@@ -38141,6 +38638,7 @@ Notes:
 					threadId: r.metadata.thread_id,
 					score: r.score,
 					groupId,
+					recordId: typeof r.metadata.record_id === "string" ? r.metadata.record_id : void 0,
 					range: typeof r.metadata.range === "string" ? r.metadata.range : void 0,
 					text: typeof r.metadata.text === "string" ? r.metadata.text : void 0,
 					observedAt: typeof r.metadata.observed_at === "string" || r.metadata.observed_at instanceof Date ? new Date(r.metadata.observed_at) : void 0
@@ -38158,7 +38656,7 @@ Notes:
 	/**
 	* Index a single observation group into the observation vector store.
 	*/
-	async indexObservation({ text, groupId, range, threadId, resourceId, observedAt }) {
+	async indexObservation({ text, groupId, range, threadId, resourceId, observedAt, recordId }) {
 		if (!this.vector || !this.embedder) return;
 		const embedResult = await this.embedMessageContent(text);
 		if (embedResult.embeddings.length === 0 || embedResult.dimension === void 0) return;
@@ -38186,6 +38684,7 @@ Notes:
 				thread_id: threadId,
 				resource_id: resourceId,
 				observed_at: observedAt?.toISOString(),
+				...recordId ? { record_id: recordId } : {},
 				text: chunk
 			}))
 		});
@@ -38362,7 +38861,11 @@ Notes:
 		const omConfig = normalizeObservationalMemoryConfig(mergedConfig.observationalMemory);
 		if (omConfig?.retrieval) tools.recall = recallTool(mergedConfig, {
 			retrievalScope: typeof omConfig.retrieval === "object" ? omConfig.retrieval.scope ?? "resource" : "resource",
-			searchEnabled: this.hasRetrievalSearch(omConfig.retrieval)
+			searchEnabled: this.hasRetrievalSearch(omConfig.retrieval),
+			getOMEngine: async () => {
+				const om = await this.omEngine;
+				return om?.getStorage().supportsObservationalMemoryHistorySearch ? om : null;
+			}
 		});
 		if (omConfig?.experimental_subconscious instanceof Subconscious && omConfig.experimental_subconscious.resolved.tools) {
 			Object.assign(tools, createKnowledgeTools(this));
@@ -49830,4 +50333,4 @@ const agentBuilderWorkflows = {
 //#endregion
 exports.agentBuilderWorkflows = agentBuilderWorkflows;
 
-//# sourceMappingURL=dist-CxDKuckB.cjs.map
+//# sourceMappingURL=dist-BACW0Que.cjs.map