@mastra/server 1.76.0 → 1.77.0-alpha.0

package/dist/{dist-C8tgsOw_.cjs → dist-BOW7V2e6.cjs}

@@ -4637,7 +4637,7 @@ function splitLines(text) {
 	return result;
 }
 //#endregion
-//#region ../memory/dist/src-B9qhQmNI.js
+//#region ../memory/dist/src-ThciS3vu.js
 var __defProp$3 = Object.defineProperty;
 var __exportAll = (all, no_symbols) => {
 	let target = {};
@@ -25063,7 +25063,7 @@ Group related observations (like tool sequences) by indenting:
   * -> applied fix, tests now pass
   * ✅ Tests passing, auth issue resolved
 
-Group observations by date, then list each with 24-hour time.
+Group observations by date. Within a date, list observations in the order the events happened (not by importance), each with 24-hour time.
 
 <observations>
 Date: Dec 4, 2025
@@ -25436,8 +25436,8 @@ function extractToolResultAttachments(result, counter, attachmentFilter) {
 		attachments
 	};
 }
-function formatObserverPartLine(title, body, time, previousTime) {
-	const timeLabel = time && time !== previousTime ? `(${time})` : "";
+function formatObserverPartLine(title, body, time, previousTime, alwaysShowTime) {
+	const timeLabel = time && (alwaysShowTime || time !== previousTime) ? `(${time})` : "";
 	if (!title) return timeLabel ? `${timeLabel}: ${body}` : body;
 	return `${title}${timeLabel ? ` ${timeLabel}` : ""}: ${body}`;
 }
@@ -25462,7 +25462,7 @@ function formatObserverLines(lines, context = {}) {
 			previousDate = line.date;
 			previousTime = void 0;
 		}
-		output.push(formatObserverPartLine(line.title, line.body, line.time, previousTime));
+		output.push(formatObserverPartLine(line.title, line.body, line.time, previousTime, line.alwaysShowTime));
 		previousTime = line.time || previousTime;
 	}
 	return {
@@ -25563,14 +25563,15 @@ function formatObserverMessage(msg, counter, toolFormatting, options) {
 	const unavailableUrls = getUnavailableAttachmentUrls(msg);
 	let lines = [];
 	const temporalGapText = isTemporalGapMarker(msg) ? getTemporalGapMarkerText(msg) : void 0;
-	const pushLine = (title, body, createdAt) => {
+	const pushLine = (title, body, createdAt, opts) => {
 		if (!body) return;
 		const normalizedCreatedAt = normalizeObserverCreatedAt(createdAt) ?? messageCreatedAt;
 		lines.push({
 			date: formatObserverDate(normalizedCreatedAt, timeZone),
 			time: formatObserverTime(normalizedCreatedAt, timeZone),
 			title,
-			body
+			body,
+			alwaysShowTime: opts?.tool === true
 		});
 	};
 	if (temporalGapText) pushLine("", temporalGapText, messageCreatedAt);
@@ -25587,7 +25588,7 @@ function formatObserverMessage(msg, counter, toolFormatting, options) {
 			const exchange = toolFormatting.exchanges.get(inv.toolCallId);
 			if (exchange && occurrence === exchange.firstOccurrence && exchange.signature && !toolFormatting.emittedCalls.has(inv.toolCallId)) {
 				toolFormatting.emittedCalls.add(inv.toolCallId);
-				pushLine(`Tool Call ${exchange.signature.toolName}`, formatObserverToolArguments(exchange.signature.args, maxLen), partCreatedAt);
+				pushLine(`Tool Call ${exchange.signature.toolName}`, formatObserverToolArguments(exchange.signature.args, maxLen), partCreatedAt, { tool: true });
 			}
 			if (inv.state === "result") {
 				const { value: resultForObserver } = resolveToolResultValue(part, inv.result);
@@ -25597,17 +25598,17 @@ function formatObserverMessage(msg, counter, toolFormatting, options) {
 					toolFormatting.emittedOutcomes.add(inv.toolCallId);
 					const hasResult = resultWithoutAttachments !== void 0 && (typeof resultWithoutAttachments !== "string" || resultWithoutAttachments.trim().length > 0);
 					const body = inv.isError ? hasResult ? formatToolResultForObserver(resultWithoutAttachments, { maxTokens: maxToolResultTokens }) : inv.errorText?.trim() ? inv.errorText : "Tool execution failed" : hasResult ? formatToolResultForObserver(resultWithoutAttachments, { maxTokens: maxToolResultTokens }) : "[empty result]";
-					pushLine(`${inv.isError ? "Tool Error" : "Tool Result"} ${inv.toolName}`, maybeTruncate(body, maxLen), partCreatedAt);
+					pushLine(`${inv.isError ? "Tool Error" : "Tool Result"} ${inv.toolName}`, maybeTruncate(body, maxLen), partCreatedAt, { tool: true });
 				}
 				return;
 			}
 			if (exchange?.terminal?.occurrence === occurrence && !toolFormatting.emittedOutcomes.has(inv.toolCallId)) {
 				toolFormatting.emittedOutcomes.add(inv.toolCallId);
-				if (inv.state === "output-error") pushLine(`Tool Error ${inv.toolName}`, maybeTruncate(inv.errorText?.trim() ? inv.errorText : "Tool execution failed", maxLen), partCreatedAt);
-				else if (inv.state === "output-denied") pushLine(`Tool Denied ${inv.toolName}`, maybeTruncate(inv.approval?.reason?.trim() ? inv.approval.reason : "Tool call was not approved by the user", maxLen), partCreatedAt);
+				if (inv.state === "output-error") pushLine(`Tool Error ${inv.toolName}`, maybeTruncate(inv.errorText?.trim() ? inv.errorText : "Tool execution failed", maxLen), partCreatedAt, { tool: true });
+				else if (inv.state === "output-denied") pushLine(`Tool Denied ${inv.toolName}`, maybeTruncate(inv.approval?.reason?.trim() ? inv.approval.reason : "Tool call was not approved by the user", maxLen), partCreatedAt, { tool: true });
 				return;
 			}
-			if (!exchange) pushLine(`Tool Call ${inv.toolName}`, formatObserverToolArguments(inv.args, maxLen), partCreatedAt);
+			if (!exchange) pushLine(`Tool Call ${inv.toolName}`, formatObserverToolArguments(inv.args, maxLen), partCreatedAt, { tool: true });
 			return;
 		}
 		const partType = part.type;
@@ -25762,13 +25763,17 @@ function surroundObserverHistory(history, contextPrompt, taskInstructions) {
 function buildMultiThreadObserverTaskInstructions(includeThreadTitle) {
 	return `## Your Task\n\nExtract new observations from each thread. Output your observations grouped by thread using <thread id="..."> tags inside your <observations> block. Each thread block should contain that thread's observations, current-task, suggested-response${includeThreadTitle ? ", and thread-title" : ""}, in the format specified in your instructions.`;
 }
+function buildTruncationNotice(wasTruncated) {
+	if (!wasTruncated) return "";
+	return "Previous observations were truncated for context budget reasons.\nThe main agent still has full memory context outside this observer window.\n\n";
+}
 function buildMultiThreadObserverContextPrompt(existingObservations, threadOrder, priorMetadataByThread, wasTruncated, includeThreadTitle, extractors = []) {
 	let prompt = "";
 	if (existingObservations) {
 		prompt += `## Previous Observations\n\n${existingObservations}\n\n---\n\n`;
 		prompt += "Do not repeat these existing observations. Your new observations will be appended to the existing observations.\n\n";
 	}
-	const hasTruncatedObservations = wasTruncated ?? false;
+	prompt += buildTruncationNotice(wasTruncated);
 	const threadMetadataLines = threadOrder?.map((threadId) => {
 		const metadata = priorMetadataByThread?.get(threadId);
 		const extractorPriorLines = buildExtractorPriorLines(extractors, metadata?.extracted);
@@ -25782,10 +25787,6 @@ function buildMultiThreadObserverContextPrompt(existingObservations, threadOrder
 	}).filter(Boolean).join("\n");
 	if (threadMetadataLines) {
 		prompt += `## Prior Thread Metadata\n\n${threadMetadataLines}\n\n`;
-		if (hasTruncatedObservations) {
-			prompt += `Previous observations were truncated for context budget reasons.\n`;
-			prompt += `The main agent still has full memory context outside this observer window.\n`;
-		}
 		prompt += `Use each thread's prior current-task, suggested-response${includeThreadTitle ? ", and thread-title" : ""} as continuity hints, then update them based on that thread's new messages.\n\n---\n\n`;
 	}
 	return prompt;
@@ -25828,7 +25829,7 @@ function parseMultiThreadObserverOutput(output, extractors = []) {
 			threadTitle = threadTitleMatch[1].trim();
 			observations = observations.replace(/<thread-title>[\s\S]*?<\/thread-title>/i, "");
 		}
-		observations = sanitizeObservationLines(observations.trim());
+		observations = sortObservationsByTime(sanitizeObservationLines(observations.trim()));
 		threads.set(threadId, {
 			observations,
 			currentTask: currentTask || getStringExtractedValue$1(parsedExtractedValues.values, "current-task"),
@@ -25868,7 +25869,7 @@ function buildObserverContextPrompt(existingObservations, options) {
 		prompt += `## Previous Observations\n\n${existingObservations}\n\n---\n\n`;
 		prompt += "Do not repeat these existing observations. Your new observations will be appended to the existing observations.\n\n";
 	}
-	const hasTruncatedObservations = options?.wasTruncated ?? false;
+	prompt += buildTruncationNotice(options?.wasTruncated);
 	const priorMetadataLines = [];
 	if (options?.priorCurrentTask) priorMetadataLines.push(`- prior current-task: ${options.priorCurrentTask}`);
 	if (options?.priorSuggestedResponse) priorMetadataLines.push(`- prior suggested-response: ${options.priorSuggestedResponse}`);
@@ -25876,10 +25877,6 @@ function buildObserverContextPrompt(existingObservations, options) {
 	priorMetadataLines.push(...buildExtractorPriorLines(options?.extractors ?? [], options?.priorExtractedValues));
 	if (priorMetadataLines.length > 0) {
 		prompt += `## Prior Thread Metadata\n\n${priorMetadataLines.join("\n")}\n\n`;
-		if (hasTruncatedObservations) {
-			prompt += `Previous observations were truncated for context budget reasons.\n`;
-			prompt += `The main agent still has full memory context outside this observer window.\n`;
-		}
 		const titleHint = options?.includeThreadTitle ? ", and thread-title" : "";
 		prompt += `Use the prior current-task, suggested-response${titleHint} as continuity hints, then update them based on the new messages.\n\n---\n\n`;
 	}
@@ -25910,7 +25907,7 @@ function parseObserverOutput(output, extractors = []) {
 	const parsedExtractedValues = parseExtractedValues(output, inlineExtractors);
 	const parsed = parseMemorySectionXml(stripExtractorSections(output, inlineExtractors));
 	return {
-		observations: sanitizeObservationLines(parsed.observations || ""),
+		observations: sortObservationsByTime(sanitizeObservationLines(parsed.observations || "")),
 		currentTask: parsed.currentTask || getStringExtractedValue$1(parsedExtractedValues.values, "current-task"),
 		suggestedContinuation: parsed.suggestedResponse || getStringExtractedValue$1(parsedExtractedValues.values, "suggested-response"),
 		threadTitle: parsed.threadTitle || getStringExtractedValue$1(parsedExtractedValues.values, "thread-title"),
@@ -26004,6 +26001,68 @@ function sanitizeObservationLines(observations) {
 	}
 	return changed ? lines.join("\n") : observations;
 }
+const OBSERVATION_TIME = /^[*-]\s+(?:\S+\s+)?\((\d{1,2}):(\d{2})\s*([AaPp])?\.?(?:[Mm]\.?)?\)/;
+/** Minutes since midnight for each item, or undefined when the group's times can't be ordered safely. */
+function observationMinutes(items) {
+	const times = items.map((item) => OBSERVATION_TIME.exec(item[0]));
+	if (times.some((t) => !t)) return void 0;
+	const matches = times;
+	const marked = matches.filter((m) => m[3]).length;
+	if (marked > 0 && marked < matches.length) return void 0;
+	if (marked === matches.length) return matches.map((m) => Number(m[1]) % 12 * 60 + (/p/i.test(m[3]) ? 720 : 0) + Number(m[2]));
+	const hours = matches.map((m) => m[1]);
+	const twelveHour = hours.some((h) => /^[1-9]$/.test(h));
+	const twentyFourHour = hours.some((h) => /^(0\d|1[3-9]|2\d)$/.test(h));
+	if (twelveHour && (twentyFourHour || new Set(hours).size > 1)) return void 0;
+	return matches.map((m) => Number(m[1]) * 60 + Number(m[2]));
+}
+/**
+* Put the top-level observations of each "Date:" group in time order, keeping indented
+* sub-items with their parent. The Observer writes a time on every observation but tends
+* to list a user's message ahead of the earlier events it follows, which can make a
+* superseded state read as the latest one. Groups are left as written when any
+* observation has no time or the times are ambiguous.
+*/
+function sortObservationsByTime(observations) {
+	if (!observations) return observations;
+	const output = [];
+	let group;
+	const flush = () => {
+		if (!group) return;
+		const minutes = group.sortable && group.items.length > 1 ? observationMinutes(group.items) : void 0;
+		const items = minutes ? group.items.map((item, i) => ({
+			item,
+			minute: minutes[i]
+		})).sort((a, b) => a.minute - b.minute).map((x) => x.item) : group.items;
+		output.push(...group.header, ...items.flat(), ...group.trailing);
+		group = void 0;
+	};
+	for (const line of observations.split("\n")) if (/^\s*Date:\s/.test(line)) {
+		flush();
+		group = {
+			header: [line],
+			items: [],
+			trailing: [],
+			sortable: true
+		};
+	} else if (!group) output.push(line);
+	else if (/^[*-]\s/.test(line)) {
+		group.items.at(-1)?.push(...group.trailing);
+		group.trailing = [];
+		group.items.push([line]);
+	} else if (group.items.length === 0) group.header.push(line);
+	else if (line.trim() === "") group.trailing.push(line);
+	else if (/^\s/.test(line)) {
+		group.items.at(-1).push(...group.trailing, line);
+		group.trailing = [];
+	} else {
+		group.sortable = false;
+		group.items.at(-1).push(...group.trailing, line);
+		group.trailing = [];
+	}
+	flush();
+	return output.join("\n");
+}
 function analyzeDegenerateRepetition(text) {
 	const lines = collapseBoundedLineRuns(text.split("\n"));
 	const windowText = lines.filter((line) => line.trim().length >= MIN_DUPLICATE_LINE_CHARS && line.length <= MAX_OBSERVATION_LINE_CHARS).join("\n");
@@ -26538,7 +26597,7 @@ var ObserverRunner = class {
 	/**
 	* Call the Observer agent for multiple threads in a single batched request.
 	*/
-	async callMultiThread(existingObservations, allMessagesByThread, allThreadOrder, abortSignal, requestContext, priorMetadataByThread, observabilityContext, model, hookContext, timeZone, mainAgent, currentModel) {
+	async callMultiThread(existingObservations, allMessagesByThread, allThreadOrder, abortSignal, requestContext, priorMetadataByThread, observabilityContext, model, hookContext, timeZone, mainAgent, currentModel, wasTruncated) {
 		const contextFor = (threadId) => ({
 			threadId,
 			...hookContext
@@ -26549,7 +26608,7 @@ var ObserverRunner = class {
 			if (filtered.length > 0) messagesByThread.set(threadId, filtered);
 		}
 		const threadOrder = allThreadOrder.filter((threadId) => messagesByThread.has(threadId));
-		const output = await this.callMultiThreadObserver(existingObservations, messagesByThread, threadOrder, abortSignal, requestContext, priorMetadataByThread, observabilityContext, model, timeZone, mainAgent, currentModel);
+		const output = await this.callMultiThreadObserver(existingObservations, messagesByThread, threadOrder, abortSignal, requestContext, priorMetadataByThread, observabilityContext, model, timeZone, mainAgent, currentModel, wasTruncated);
 		for (const threadId of allThreadOrder) {
 			const threadResult = output.results.get(threadId);
 			if (!threadResult) {
@@ -26560,7 +26619,7 @@ var ObserverRunner = class {
 		}
 		return output;
 	}
-	async callMultiThreadObserver(existingObservations, messagesByThread, threadOrder, abortSignal, requestContext, priorMetadataByThread, observabilityContext, model, timeZone, mainAgent, currentModel) {
+	async callMultiThreadObserver(existingObservations, messagesByThread, threadOrder, abortSignal, requestContext, priorMetadataByThread, observabilityContext, model, timeZone, mainAgent, currentModel, wasTruncated) {
 		if (threadOrder.length === 0) return { results: /* @__PURE__ */ new Map() };
 		const inputTokens = Array.from(messagesByThread.values()).reduce((total, messages) => total + this.tokenCounter.countMessages(messages), 0);
 		let resolvedModel;
@@ -26606,7 +26665,8 @@ var ObserverRunner = class {
 					priorThreadTitle: priorMetadataByThread?.get(threadId)?.threadTitle,
 					priorExtractedValues: priorMetadataByThread?.get(threadId)?.extracted,
 					model: resolvedModel.model,
-					timeZone
+					timeZone,
+					wasTruncated
 				});
 				results.set(threadId, {
 					observations: threadResult.observations,
@@ -26632,7 +26692,7 @@ var ObserverRunner = class {
 		const agent = this.createAgent(resolvedModel.model, true, void 0, activeExtractors);
 		const internalRequestContext = withOmInternalThreadId(requestContext, agent.id);
 		const multiThreadAttachmentFilter = this.resolveAttachmentFilter(resolvedModel.model, requestContext);
-		const observerMessages = [buildMultiThreadObserverRequestMessage(existingObservations, messagesByThread, threadOrder, priorMetadataByThread, void 0, this.observationConfig.threadTitle, activeExtractors, {
+		const observerMessages = [buildMultiThreadObserverRequestMessage(existingObservations, messagesByThread, threadOrder, priorMetadataByThread, wasTruncated, this.observationConfig.threadTitle, activeExtractors, {
 			attachmentFilter: multiThreadAttachmentFilter,
 			timeZone
 		})];
@@ -26646,6 +26706,7 @@ var ObserverRunner = class {
 				metadata: {
 					omThreadCount: threadOrder.length,
 					omPreviousObserverTokens: this.observationConfig.previousObserverTokens,
+					omWasTruncated: wasTruncated ?? false,
 					omThreadTitleEnabled: this.observationConfig.threadTitle,
 					...resolvedModel.selectedThreshold !== void 0 ? { omSelectedThreshold: resolvedModel.selectedThreshold } : {},
 					...resolvedModel.routingStrategy ? { omRoutingStrategy: resolvedModel.routingStrategy } : {},
@@ -30887,6 +30948,80 @@ function resolveAutoModelId(mainModelId, options) {
 	const pick = provider ? models[provider] : void 0;
 	return pick ? `${prefix}${pick}` : mainModelId;
 }
+/** How long an op may hold its key before later ops on that key stop waiting for it. */
+const OM_COMMIT_STALL_MS = 6e4;
+/** The per-thread / per-resource key shared by the commit queue and `BufferingCoordinator`. */
+function getOMLockKey(scope, threadId, resourceId) {
+	if (scope === "resource" && resourceId) return `resource:${resourceId}`;
+	return `thread:${threadId ?? "unknown"}`;
+}
+const REGISTRY = Symbol.for("@mastra/memory/om-commit-queue");
+const { queues, heldKeys } = globalThis[REGISTRY] ??= {
+	queues: /* @__PURE__ */ new Map(),
+	heldKeys: new async_hooks.AsyncLocalStorage()
+};
+function holdsKey(key) {
+	const token = heldKeys.getStore()?.get(key);
+	return token !== void 0 && queues.get(key)?.running === token;
+}
+function runNext(key, queue) {
+	const next = queue.reflection.shift() ?? queue.normal.shift();
+	if (!next) {
+		queue.running = null;
+		queues.delete(key);
+		return;
+	}
+	next();
+}
+/**
+* Runs `op` once every earlier op on `key` has settled (reflection-priority ops first among those
+* still waiting) and resolves or rejects with its result. A rejection reaches only this caller.
+*
+* Enqueueing on a key from inside an op that holds the same key, directly or through nested ops
+* on other keys, would deadlock, so it rejects.
+*/
+function runOMCommit(key, op, { priority = "normal" } = {}) {
+	if (holdsKey(key)) return Promise.reject(/* @__PURE__ */ new Error(`Re-entrant observational memory commit on "${key}": an op cannot enqueue on the key it holds.`));
+	return new Promise((resolve, reject) => {
+		let queue = queues.get(key);
+		if (!queue) {
+			queue = {
+				running: null,
+				reflection: [],
+				normal: []
+			};
+			queues.set(key, queue);
+		}
+		const owner = queue;
+		const start = async_hooks.AsyncResource.bind(() => {
+			const token = Symbol(key);
+			owner.running = token;
+			const held = new Map(heldKeys.getStore());
+			held.set(key, token);
+			let released = false;
+			const release = () => {
+				if (released) return;
+				released = true;
+				clearTimeout(stallTimer);
+				runNext(key, owner);
+			};
+			const stallTimer = setTimeout(() => {
+				console.warn(`[observational-memory] Commit on "${key}" has not settled after ${OM_COMMIT_STALL_MS}ms; releasing the key so later commits can run. The stalled storage call is still pending.`);
+				release();
+			}, OM_COMMIT_STALL_MS);
+			stallTimer.unref?.();
+			heldKeys.run(held, () => Promise.resolve().then(op)).then((value) => {
+				release();
+				resolve(value);
+			}, (error) => {
+				release();
+				reject(error);
+			});
+		});
+		(priority === "reflection" ? owner.reflection : owner.normal).push(start);
+		if (owner.running === null) runNext(key, owner);
+	});
+}
 const activeOps = /* @__PURE__ */ new Map();
 function opKey(recordId, op) {
 	return `${recordId}:${op}`;
@@ -30923,11 +31058,37 @@ var BufferingCoordinator = class BufferingCoordinator {
 	*/
 	static asyncBufferingOps = /* @__PURE__ */ new Map();
 	/**
+	* Observation buffer ops that may still append a buffered chunk.
+	* Key format: "obs:{lockKey}"
+	* Value: Promise that resolves once the op has persisted its chunk (or ended without one)
+	*
+	* Above the threshold→blockAfter band, activation waits (bounded) on this phase so the chunk
+	* activates instead of being re-observed by the sync pass. It is not needed for safety: storage
+	* keeps a chunk appended during activation. An op stays in asyncBufferingOps through its
+	* post-persist work (indexing, thread title), which activation never waits for.
+	*/
+	static pendingChunkWrites = /* @__PURE__ */ new Map();
+	/**
 	* Track the last token boundary at which we started buffering.
 	* Key format: "obs:{lockKey}" or "refl:{lockKey}"
 	*/
 	static lastBufferedBoundary = /* @__PURE__ */ new Map();
 	/**
+	* The buffer op that set the observation boundary, if one did. Any other write (an activation
+	* reset, another op) replaces or clears it, so an op that outlived it never writes its boundary
+	* back. Key format: "obs:{lockKey}"
+	*/
+	static observationBoundaryOwners = /* @__PURE__ */ new Map();
+	/** Set the observation boundary; `owner` is the buffer op setting it, if any. */
+	static setObservationBoundary(bufferKey, tokens, owner) {
+		BufferingCoordinator.lastBufferedBoundary.set(bufferKey, tokens);
+		if (owner) BufferingCoordinator.observationBoundaryOwners.set(bufferKey, owner);
+		else BufferingCoordinator.observationBoundaryOwners.delete(bufferKey);
+	}
+	static ownsObservationBoundary(bufferKey, owner) {
+		return BufferingCoordinator.observationBoundaryOwners.get(bufferKey) === owner;
+	}
+	/**
 	* Track the timestamp cursor for buffered messages.
 	* Key format: "obs:{lockKey}"
 	*/
@@ -30943,8 +31104,7 @@ var BufferingCoordinator = class BufferingCoordinator {
 		this.scope = opts.scope;
 	}
 	getLockKey(threadId, resourceId) {
-		if (this.scope === "resource" && resourceId) return `resource:${resourceId}`;
-		return `thread:${threadId ?? "unknown"}`;
+		return getOMLockKey(this.scope, threadId, resourceId);
 	}
 	isAsyncObservationEnabled() {
 		return this.observationConfig.bufferTokens !== void 0 && this.observationConfig.bufferTokens > 0;
@@ -30962,6 +31122,19 @@ var BufferingCoordinator = class BufferingCoordinator {
 		return BufferingCoordinator.asyncBufferingOps.has(bufferKey);
 	}
 	/**
+	* Mark an observation buffer op as able to append a chunk. Call the returned release
+	* function once it no longer can; releasing more than once is a no-op.
+	*/
+	static trackChunkWrite(bufferKey) {
+		let resolve;
+		const pending = new Promise((r) => resolve = r);
+		BufferingCoordinator.pendingChunkWrites.set(bufferKey, pending);
+		return () => {
+			if (BufferingCoordinator.pendingChunkWrites.get(bufferKey) === pending) BufferingCoordinator.pendingChunkWrites.delete(bufferKey);
+			resolve();
+		};
+	}
+	/**
 	* Clean up static maps for a thread/resource to prevent memory leaks.
 	*/
 	cleanupStaticMaps(threadId, resourceId, activatedMessageIds) {
@@ -30970,10 +31143,12 @@ var BufferingCoordinator = class BufferingCoordinator {
 		const reflBufKey = this.getReflectionBufferKey(lockKey);
 		if (activatedMessageIds) {
 			BufferingCoordinator.lastBufferedBoundary.delete(obsBufKey);
+			BufferingCoordinator.observationBoundaryOwners.delete(obsBufKey);
 			BufferingCoordinator.lastBufferedAtTime.delete(obsBufKey);
 		} else {
 			BufferingCoordinator.lastBufferedAtTime.delete(obsBufKey);
 			BufferingCoordinator.lastBufferedBoundary.delete(obsBufKey);
+			BufferingCoordinator.observationBoundaryOwners.delete(obsBufKey);
 			BufferingCoordinator.lastBufferedBoundary.delete(reflBufKey);
 			BufferingCoordinator.asyncBufferingOps.delete(obsBufKey);
 			BufferingCoordinator.asyncBufferingOps.delete(reflBufKey);
@@ -30988,7 +31163,7 @@ var BufferingCoordinator = class BufferingCoordinator {
 		if (record.isBufferingObservation) {
 			if (isOpActiveInProcess(record.id, "bufferingObservation")) return false;
 			omDebug(`[OM:shouldTriggerAsyncObs] isBufferingObservation=true but stale, clearing`);
-			storage?.setBufferingObservationFlag(record.id, false)?.catch(() => {});
+			if (storage) runOMCommit(lockKey, () => storage.setBufferingObservationFlag(record.id, false)).catch(() => {});
 		}
 		const bufferKey = this.getObservationBufferKey(lockKey);
 		if (this.isAsyncBufferingInProgress(bufferKey)) return false;
@@ -31008,7 +31183,7 @@ var BufferingCoordinator = class BufferingCoordinator {
 	* Await any in-flight async buffering operations for a given thread/resource.
 	*/
 	static async awaitBuffering(threadId, resourceId, scope, timeoutMs = 3e4) {
-		const lockKey = scope === "resource" && resourceId ? `resource:${resourceId}` : `thread:${threadId ?? "unknown"}`;
+		const lockKey = getOMLockKey(scope, threadId, resourceId);
 		const obsKey = `obs:${lockKey}`;
 		const reflKey = `refl:${lockKey}`;
 		const promises = [];
@@ -31300,6 +31475,34 @@ function createThreadUpdateMarker(params) {
 		}
 	};
 }
+/**
+* The current head of `origin`'s lineage (the generations reflections have created from it),
+* or `null` when that lineage is gone.
+*
+* Use this instead of reading the head by thread/resource when committing work that started
+* from `origin`. Clearing a record (`om.clear`, `Memory.deleteThread`) deletes every generation
+* of the thread/resource, and the thread can then get a new, unrelated record. Work produced
+* from the cleared messages must never be committed to it.
+*
+* Generation ids are never reused and clearing deletes all of them, so the head belongs to
+* `origin`'s lineage iff `origin` still exists.
+*/
+async function getLineageHead(storage, origin) {
+	const head = await storage.getObservationalMemory(origin.threadId, origin.resourceId);
+	if (!head || head.id === origin.id) return head;
+	if (head.generationCount <= origin.generationCount) return null;
+	return (await storage.getObservationalMemoryHistory(origin.threadId, origin.resourceId, head.generationCount - origin.generationCount + 3)).some((record) => record.id === origin.id) ? head : null;
+}
+/**
+* The generation `id` of `origin`'s lineage, or `null` when that lineage is gone or `id` is not
+* part of it. Unlike {@link getLineageHead}, this keeps naming `id` after later reflections have
+* superseded it, e.g. to report which generation a write landed on.
+*/
+async function getLineageRecord(storage, origin, id) {
+	const head = await getLineageHead(storage, origin);
+	if (!head || head.id === id) return head;
+	return (await storage.getObservationalMemoryHistory(origin.threadId, origin.resourceId, head.generationCount - origin.generationCount + 3)).find((record) => record.id === id) ?? null;
+}
 function isRecord$1(value) {
 	return !!value && typeof value === "object" && !Array.isArray(value);
 }
@@ -31442,6 +31645,39 @@ function calculateProjectedMessageRemoval(chunks, bufferActivation, messageToken
 }
 /** Module-level xxhash singleton — loaded once, shared across all strategy instances. */
 const hasherPromise = e();
+/** Recompose-and-retry rounds for an observation commit that hit a retired or changed head. */
+const MAX_HEAD_COMMIT_RETRIES = 3;
+const OBSERVATION_LIFECYCLE_MARKERS = /* @__PURE__ */ new Set([
+	"data-om-observation-start",
+	"data-om-observation-end",
+	"data-om-observation-failed"
+]);
+function isOmPart(part) {
+	return String(part?.type ?? "").startsWith("data-om-");
+}
+/**
+* Index in `message` right after this cycle's start marker (and any OM parts directly after it),
+* or -1 when the message doesn't carry it.
+*/
+function afterOwnStartMarker(message, marker) {
+	const cycleId = marker.data?.cycleId;
+	const startType = marker.type.startsWith("data-om-buffering-") ? "data-om-buffering-start" : "data-om-observation-start";
+	if (!cycleId || marker.type === startType) return -1;
+	const parts = message.content?.parts ?? [];
+	const start = parts.findIndex((part) => part?.type === startType && part?.data?.cycleId === cycleId);
+	if (start === -1) return -1;
+	let index = start + 1;
+	while (index < parts.length && isOmPart(parts[index])) index++;
+	return index;
+}
+/** True when the message has parts no completed observation boundary covers (OM markers aside). */
+function hasUnobservedContent(message) {
+	return getUnobservedParts(message).some((part) => !isOmPart(part));
+}
+function isObservationLifecycleMarker(marker) {
+	const operationType = marker.data?.operationType;
+	return OBSERVATION_LIFECYCLE_MARKERS.has(marker.type) && operationType !== "reflection";
+}
 /**
 * Abstract base class for observation strategies.
 *
@@ -31491,17 +31727,35 @@ var ObservationStrategy = class ObservationStrategy {
 				const fresh = await this.storage.getObservationalMemory(record.threadId, record.resourceId);
 				if (fresh?.lastObservedAt && record.lastObservedAt && fresh.lastObservedAt > record.lastObservedAt) return { observed: false };
 			}
-			const { messages, existingObservations } = await this.prepare();
+			const { messages, existingObservations, contextRecord } = await this.prepare();
+			if (messages.length === 0) return { observed: false };
 			const observationMessages = stripSubconsciousSignals(messages);
 			await this.emitStartMarkers(cycleId);
-			const output = await this.observe(existingObservations, observationMessages);
-			const processed = await this.process(output, existingObservations);
-			this.settleObservationCommit(await this.persist(processed));
+			const observerContext = this.deps.prepareObserverContext(existingObservations, contextRecord ?? record);
+			const output = await this.observe(observerContext.context ?? "", observationMessages, observerContext.wasTruncated);
+			let processed = await this.process(output, existingObservations);
+			let committedRecord = record;
+			const outcome = await this.persist(processed);
+			this.settleObservationCommit(outcome?.status === "committed" && !outcome.alreadyCovered);
+			if (outcome?.status === "not-committed") {
+				omDebug(`[OM:observe] cycle ${cycleId} not committed: ${outcome.reason}`);
+				await this.emitFailedMarkers(cycleId, /* @__PURE__ */ new Error(`Observation not committed: ${outcome.reason}`));
+				return {
+					observed: false,
+					usage: output.usage,
+					providerMetadata: output.providerMetadata
+				};
+			}
+			if (outcome?.status === "committed") {
+				processed = outcome.processed;
+				committedRecord = outcome.record;
+			}
 			await this.emitEndMarkers(cycleId, processed);
 			if (this.needsReflection) await this.deps.reflector.maybeReflect({
 				record: {
-					...record,
-					activeObservations: processed.observations
+					...committedRecord,
+					activeObservations: processed.observations,
+					observationTokenCount: processed.observationTokens
 				},
 				observationTokens: processed.observationTokens,
 				threadId,
@@ -31537,7 +31791,8 @@ var ObservationStrategy = class ObservationStrategy {
 						threadId
 					}
 				};
-				await this.persistMarkerToStorage(failedMarkerForStorage, threadId, this.opts.resourceId).catch(() => {});
+				const observed = this.getObservedMessagesForThread(threadId);
+				await (observed?.length ? this.persistMarkerToObservedMessage(failedMarkerForStorage, observed, threadId, this.opts.resourceId) : this.persistMarkerToStorage(failedMarkerForStorage, threadId, this.opts.resourceId)).catch(() => {});
 				if (abortSignal?.aborted) throw error;
 				omError("[OM] Observation failed", error);
 				return {
@@ -31564,6 +31819,11 @@ var ObservationStrategy = class ObservationStrategy {
 			transient: true
 		}).catch(() => {});
 		const markerThreadId = marker.data?.threadId ?? this.opts.threadId;
+		const observed = isObservationLifecycleMarker(marker) ? this.getObservedMessagesForThread(markerThreadId) : void 0;
+		if (observed?.length) {
+			await this.persistMarkerToObservedMessage(marker, observed, markerThreadId, this.opts.resourceId);
+			return;
+		}
 		if (!await this.persistMarkerToMessage(marker, this.opts.messageList, markerThreadId, this.opts.resourceId)) await this.persistMarkerToStorage(marker, markerThreadId, this.opts.resourceId);
 	}
 	getObservationMarkerConfig() {
@@ -31647,6 +31907,76 @@ var ObservationStrategy = class ObservationStrategy {
 		}
 		return `${existingObservations}${lastObservedAt ? ObservationStrategy.createMessageBoundary(lastObservedAt) : "\n\n"}${newThreadSection}`;
 	}
+	/**
+	* Commit composed observations to the current head generation.
+	*
+	* The write is conditional on the head text the observations were composed from. When the
+	* target generation was retired by a reflection, or another writer changed the text, the
+	* observations are recomposed against the fresh head and the commit is retried (bounded).
+	* When the fresh head's `observedMessageIds` already include every message this cycle observed
+	* (another instance observed them first), nothing is written and `alreadyCovered` is set, so
+	* callers advance cursors and markers without adding a second copy of the same observations.
+	* The cursor alone is not proof: an activation can move it past a message it never covered.
+	* Returns null when no commit landed — callers must then leave cursors, markers, and the live
+	* context untouched.
+	*/
+	async commitActiveObservationsToHead(opts) {
+		let { processed, composedFrom, target } = opts;
+		for (let attempt = 0; attempt <= MAX_HEAD_COMMIT_RETRIES; attempt++) {
+			const result = await this.runCommit(async () => {
+				const head = await getLineageHead(this.storage, target);
+				if (!head) return null;
+				if (head.id !== target.id || (head.activeObservations ?? "") !== composedFrom) {
+					if (this.headCoversCycle(head, opts.cycleMessageIds)) {
+						omDebug(`[OM:observe] head ${head.id} already covers this cycle's messages; skipping the duplicate commit`);
+						target = head;
+						return {
+							applied: true,
+							alreadyCovered: true
+						};
+					}
+					target = head;
+					composedFrom = head.activeObservations ?? "";
+					processed = await opts.recompose(head);
+				}
+				const input = {
+					id: target.id,
+					observations: processed.observations,
+					tokenCount: processed.observationTokens,
+					lastObservedAt: processed.lastObservedAt,
+					observedMessageIds: processed.observedMessageIds,
+					expectedActiveObservations: composedFrom
+				};
+				return typeof this.storage.commitActiveObservations === "function" ? await this.storage.commitActiveObservations(input) : (await this.storage.updateActiveObservations(input), { applied: true });
+			});
+			if (!result) return null;
+			if ("alreadyCovered" in result) return {
+				processed: {
+					...processed,
+					observations: target.activeObservations ?? "",
+					observationTokens: target.observationTokenCount
+				},
+				record: target,
+				alreadyCovered: true
+			};
+			if (result.applied) return {
+				processed,
+				record: target
+			};
+			omDebug(`[OM:observe] commit to ${target.id} not applied (${result.reason}); retrying against the head`);
+		}
+		return null;
+	}
+	headCoversCycle(head, cycleMessageIds) {
+		if (cycleMessageIds.length === 0) return false;
+		const headIds = new Set(Array.isArray(head.observedMessageIds) ? head.observedMessageIds : []);
+		return cycleMessageIds.every((id) => headIds.has(id));
+	}
+	/** Runs one storage commit in this thread's (or resource's) slot of the process-wide commit queue. */
+	runCommit(op) {
+		const { threadId, resourceId, record } = this.opts;
+		return runOMCommit(getOMLockKey(this.scope, record.threadId ?? threadId, record.resourceId ?? resourceId), op);
+	}
 	async indexObservationGroups(observations, threadId, resourceId, observedAt, recordId) {
 		if (!resourceId || !this.deps.onIndexObservations) return;
 		const groups = parseObservationGroups(observations);
@@ -31665,30 +31995,133 @@ var ObservationStrategy = class ObservationStrategy {
 		})));
 	}
 	/**
+	* Messages this cycle observed for `threadId`, or undefined when the strategy does not
+	* place observation lifecycle markers.
+	*/
+	getObservedMessagesForThread(_threadId) {}
+	/**
+	* Persist an observation start/end/failed marker without hiding unobserved content. A completed
+	* end marker tells `getUnobservedMessages` that everything before it in that message is observed
+	* (whatever thread the marker names), so it must only follow content this cycle observed.
+	* Placement, in order:
+	* 1. the live MessageList's newest assistant message (this turn's response or its seed), when the
+	*    list belongs to the marker's thread and the cycle observed that message or it has no
+	*    unobserved content;
+	* 2. the newest observed assistant message; a stored copy (no live list, or another instance's
+	*    message) gets the marker right after the parts this cycle observed (end/failed markers right
+	*    after this cycle's start marker), so parts added while the Observer ran stay unobserved;
+	* 3. the newest stored assistant message that is not newer than the observed range, only when it
+	*    has nothing unobserved (or already carries this cycle's start marker); otherwise no marker,
+	*    and the thread cursor alone records the cycle.
+	* Lifecycle markers never go on user messages.
+	*/
+	async persistMarkerToObservedMessage(marker, observed, threadId, resourceId) {
+		const observedIds = new Set(observed.map((m) => m.id));
+		const list = threadId === this.opts.threadId ? this.opts.messageList : void 0;
+		const listMessages = list ? getObservableMessages(list) : [];
+		const live = [...listMessages].reverse().find((m) => m.role === "assistant");
+		if (live && (observedIds.has(live.id) || !hasUnobservedContent(live))) {
+			await this.attachMarker(marker, live, live.content.parts.length, threadId, resourceId);
+			return;
+		}
+		const target = [...observed].reverse().find((m) => m.role === "assistant");
+		if (target) {
+			const fromList = listMessages.find((m) => m.id === target.id);
+			if (fromList) {
+				await this.attachMarker(marker, fromList, fromList.content.parts.length, threadId, resourceId);
+				return;
+			}
+			try {
+				const stored = (await this.storage.listMessagesById({ messageIds: [target.id] })).messages[0];
+				if (stored?.content?.parts && Array.isArray(stored.content.parts)) {
+					const afterStart = afterOwnStartMarker(stored, marker);
+					const index = afterStart !== -1 ? afterStart : this.insertionAfterObserved(stored, target);
+					await this.attachMarker(marker, stored, index, threadId, resourceId);
+				}
+			} catch (e) {
+				omDebug(`[OM:persistMarkerToObservedMessage] failed to load marker target: ${e}`);
+			}
+			return;
+		}
+		const observedTimes = observed.filter((m) => m.createdAt).map((m) => new Date(m.createdAt).getTime());
+		if (observedTimes.length === 0) return;
+		await this.persistMarkerToStorage(marker, threadId, resourceId, {
+			notAfter: new Date(Math.max(...observedTimes)),
+			onlyIfObserved: true
+		});
+	}
+	/** What the cycle observed of each message, captured when it placed its first marker there. */
+	observedParts = /* @__PURE__ */ new Map();
+	/**
+	* Index in `stored` right after the parts the cycle observed in `observed` (and any OM markers
+	* directly after them). Parts are only ever appended, so the observed message's non-marker part
+	* count locates them, counted from the start of the message or, when `observed` is the trimmed
+	* copy `getUnobservedMessages` returns for an already marked message, from just after the stored
+	* copy's last completed boundary. Captured at the cycle's first marker, before the Observer runs,
+	* because `observed` may be a live reference that grows meanwhile. Falls back to the end when the
+	* stored copy has fewer parts than were observed.
+	*/
+	insertionAfterObserved(stored, observed) {
+		if (!this.observedParts.has(observed.id)) this.observedParts.set(observed.id, {
+			count: (observed.content?.parts ?? []).filter((part) => !isOmPart(part)).length,
+			observedIsTrimmed: findLastCompletedObservationBoundary(observed) === -1
+		});
+		const { count, observedIsTrimmed } = this.observedParts.get(observed.id);
+		const parts = stored.content.parts;
+		let index = observedIsTrimmed ? findLastCompletedObservationBoundary(stored) + 1 : 0;
+		let seen = 0;
+		while (index < parts.length && seen < count) {
+			if (!isOmPart(parts[index])) seen++;
+			index++;
+		}
+		if (seen < count) return parts.length;
+		while (index < parts.length && isOmPart(parts[index])) index++;
+		return index;
+	}
+	async attachMarker(marker, msg, index, threadId, resourceId) {
+		const parts = msg.content?.parts;
+		if (!parts || !Array.isArray(parts)) return;
+		const markerData = marker.data;
+		if (!(markerData?.cycleId && parts.some((p) => p?.type === marker.type && p?.data?.cycleId === markerData.cycleId))) parts.splice(index, 0, marker);
+		try {
+			await this.messageHistory.persistMessages({
+				messages: [msg],
+				threadId,
+				resourceId
+			});
+		} catch (e) {
+			omDebug(`[OM:persistMarkerToObservedMessage] failed to save marker to DB: ${e}`);
+		}
+	}
+	/**
 	* Persist a marker to the last assistant message in storage.
 	* Fetches messages directly from the DB so it works even when
 	* no MessageList is available (e.g. async buffering ops).
 	*/
-	async persistMarkerToStorage(marker, threadId, resourceId) {
+	async persistMarkerToStorage(marker, threadId, resourceId, opts) {
 		try {
-			const messages = (await this.storage.listMessages({
+			const assistants = ((await this.storage.listMessages({
 				threadId,
 				perPage: 20,
 				orderBy: {
 					field: "createdAt",
 					direction: "DESC"
-				}
-			}))?.messages ?? [];
-			for (const msg of messages) if (msg?.role === "assistant" && msg.content?.parts && Array.isArray(msg.content.parts)) {
-				const markerData = marker.data;
-				if (!(markerData?.cycleId && msg.content.parts.some((p) => p?.type === marker.type && p?.data?.cycleId === markerData.cycleId))) msg.content.parts.push(marker);
-				await this.messageHistory.persistMessages({
-					messages: [msg],
-					threadId,
-					resourceId
-				});
-				return;
-			}
+				},
+				...opts?.notAfter ? { filter: { dateRange: { end: opts.notAfter } } } : {}
+			}))?.messages ?? []).filter((msg) => msg?.role === "assistant" && Array.isArray(msg.content?.parts));
+			const startMessage = opts?.onlyIfObserved || opts?.onCycleStartMessage ? assistants.find((m) => afterOwnStartMarker(m, marker) !== -1) : void 0;
+			const msg = opts?.onCycleStartMessage ? startMessage : startMessage ?? assistants[0];
+			if (!msg) return;
+			const markerData = marker.data;
+			const alreadyPresent = markerData?.cycleId && msg.content.parts.some((p) => p?.type === marker.type && p?.data?.cycleId === markerData.cycleId);
+			const afterStart = afterOwnStartMarker(msg, marker);
+			if (opts?.onlyIfObserved && afterStart === -1 && hasUnobservedContent(msg)) return;
+			if (!alreadyPresent) msg.content.parts.splice(afterStart !== -1 ? afterStart : msg.content.parts.length, 0, marker);
+			await this.messageHistory.persistMessages({
+				messages: [msg],
+				threadId,
+				resourceId
+			});
 		} catch (e) {
 			omDebug(`[OM:persistMarkerToStorage] failed to save marker to DB: ${e}`);
 		}
@@ -31746,10 +32179,15 @@ var SyncObservationStrategy = class extends ObservationStrategy {
 	tokensToObserve = 0;
 	observerResult;
 	priorExtractedValues;
+	/** Head text the processed observations were composed from (the commit's expected text). */
+	composedFrom = "";
 	constructor(deps, opts) {
 		super(deps, opts);
 		this.lastMessage = opts.messages[opts.messages.length - 1];
 	}
+	getObservedMessagesForThread(threadId) {
+		return threadId === this.opts.threadId ? this.opts.messages : void 0;
+	}
 	get needsLock() {
 		return true;
 	}
@@ -31784,9 +32222,11 @@ var SyncObservationStrategy = class extends ObservationStrategy {
 			}
 		}
 		this.tokensToObserve = await this.tokenCounter.countMessagesAsync(messages);
+		const freshRecord = await this.storage.getObservationalMemory(record.threadId, record.resourceId);
 		return {
 			messages,
-			existingObservations: (await this.storage.getObservationalMemory(record.threadId, record.resourceId))?.activeObservations ?? record.activeObservations ?? ""
+			existingObservations: freshRecord?.activeObservations ?? record.activeObservations ?? "",
+			contextRecord: freshRecord
 		};
 	}
 	async emitStartMarkers(cycleId) {
@@ -31804,11 +32244,12 @@ var SyncObservationStrategy = class extends ObservationStrategy {
 			await this.streamMarker(startMarker);
 		}
 	}
-	async observe(existingObservations, messages) {
+	async observe(observerContext, messages, wasTruncated) {
 		const thread = await this.storage.getThreadById({ threadId: this.opts.threadId });
 		const omMeta = thread ? (0, _mastra_core_memory.getThreadOMMetadata)(thread.metadata) : void 0;
 		this.priorExtractedValues = getPriorExtractedValues(omMeta, this.observationConfig.extractors);
-		const result = await this.deps.observer.call(existingObservations, messages, this.opts.abortSignal, {
+		const result = await this.deps.observer.call(observerContext, messages, this.opts.abortSignal, {
+			wasTruncated,
 			requestContext: this.opts.requestContext,
 			observabilityContext: this.opts.observabilityContext,
 			priorCurrentTask: omMeta?.currentTask,
@@ -31854,20 +32295,14 @@ var SyncObservationStrategy = class extends ObservationStrategy {
 	}
 	async process(output, existingObservations) {
 		const { record, threadId, messages } = this.opts;
-		const lastObservedAt = this.getMaxMessageTimestamp(messages);
-		const messageRange = this.retrieval ? buildMessageRange(messages) : void 0;
-		const newObservations = await this.wrapObservations(output.observations, existingObservations, threadId, lastObservedAt, messageRange);
-		const observationTokens = this.tokenCounter.countObservations(newObservations);
-		const cycleObservationTokens = this.tokenCounter.countObservations(output.observations);
-		const newMessageIds = messages.map((m) => m.id);
-		const existingIds = record.observedMessageIds ?? [];
-		const observedMessageIds = [.../* @__PURE__ */ new Set([...Array.isArray(existingIds) ? existingIds : [], ...newMessageIds])];
+		this.composedFrom = existingObservations;
+		const processed = await this.compose(output, existingObservations, record);
 		this.deps.emitDebugEvent({
 			type: "observation_complete",
 			timestamp: /* @__PURE__ */ new Date(),
 			threadId,
 			resourceId: record.resourceId ?? "",
-			observations: newObservations,
+			observations: processed.observations,
 			rawObserverOutput: output.observations,
 			previousObservations: record.activeObservations,
 			messages: messages.map((m) => ({
@@ -31876,11 +32311,23 @@ var SyncObservationStrategy = class extends ObservationStrategy {
 			})),
 			usage: output.usage
 		});
+		return processed;
+	}
+	/** Build the observations to commit on top of `existingObservations` (the head text). */
+	async compose(output, existingObservations, baseRecord) {
+		const { threadId, messages } = this.opts;
+		const lastObservedAt = this.getMaxMessageTimestamp(messages);
+		const messageRange = this.retrieval ? buildMessageRange(messages) : void 0;
+		const newObservations = await this.wrapObservations(output.observations, existingObservations, threadId, lastObservedAt, messageRange);
+		const observationTokens = this.tokenCounter.countObservations(newObservations);
+		const cycleObservationTokens = this.tokenCounter.countObservations(output.observations);
+		const newMessageIds = messages.map((m) => m.id);
+		const existingIds = baseRecord.observedMessageIds ?? [];
 		return {
 			observations: newObservations,
 			observationTokens,
 			cycleObservationTokens,
-			observedMessageIds,
+			observedMessageIds: [.../* @__PURE__ */ new Set([...Array.isArray(existingIds) ? existingIds : [], ...newMessageIds])],
 			lastObservedAt,
 			suggestedContinuation: output.suggestedContinuation,
 			currentTask: output.currentTask,
@@ -31892,12 +32339,27 @@ var SyncObservationStrategy = class extends ObservationStrategy {
 	}
 	async persist(processed) {
 		const { record, threadId, resourceId, messages } = this.opts;
-		const thread = await this.storage.getThreadById({ threadId });
-		if (!await this.storage.getObservationalMemory(record.threadId, record.resourceId)) {
+		const liveRecord = await getLineageHead(this.storage, record);
+		if (!liveRecord) {
 			omDebug(`[OM:sync-obs] skipping persist for thread ${threadId}: observational memory record is gone`);
-			return false;
+			return {
+				status: "not-committed",
+				reason: "the observational memory record was cleared"
+			};
 		}
-		let threadUpdateMarker;
+		const committed = await this.commitActiveObservationsToHead({
+			processed,
+			composedFrom: this.composedFrom,
+			target: liveRecord,
+			recompose: (head) => this.compose(this.observerResult, head.activeObservations ?? "", head),
+			cycleMessageIds: messages.map((m) => m.id)
+		});
+		if (!committed) return {
+			status: "not-committed",
+			reason: "the observational memory head kept changing during the commit"
+		};
+		processed = committed.processed;
+		const thread = committed.alreadyCovered ? null : await this.storage.getThreadById({ threadId });
 		if (thread) {
 			const oldTitle = thread.title?.trim();
 			const newTitle = resolveThreadTitleUpdate(thread, processed.threadTitle);
@@ -31919,23 +32381,20 @@ var SyncObservationStrategy = class extends ObservationStrategy {
 				...shouldUpdateThreadTitle ? { title: newTitle } : {},
 				metadata: newMetadata
 			});
-			if (shouldUpdateThreadTitle) threadUpdateMarker = createThreadUpdateMarker({
+			if (shouldUpdateThreadTitle) await this.streamMarker(createThreadUpdateMarker({
 				cycleId: this.cycleId ?? crypto.randomUUID(),
 				threadId,
 				oldTitle,
 				newTitle
-			});
+			}));
 		}
-		if (threadUpdateMarker) await this.streamMarker(threadUpdateMarker);
-		await this.storage.updateActiveObservations({
-			id: record.id,
-			observations: processed.observations,
-			tokenCount: processed.observationTokens,
-			lastObservedAt: processed.lastObservedAt,
-			observedMessageIds: processed.observedMessageIds
-		});
-		await this.indexObservationGroups(processed.observations, threadId, resourceId, processed.lastObservedAt, record.id);
-		return true;
+		if (!committed.alreadyCovered) await this.indexObservationGroups(processed.observations, threadId, resourceId, processed.lastObservedAt, committed.record.id);
+		return {
+			status: "committed",
+			processed,
+			record: committed.record,
+			alreadyCovered: committed.alreadyCovered
+		};
 	}
 	async emitEndMarkers(cycleId, processed) {
 		const actualTokensObserved = await this.tokenCounter.countMessagesAsync(this.opts.messages);
@@ -31977,6 +32436,8 @@ var AsyncBufferObservationStrategy = class extends ObservationStrategy {
 	startedAt;
 	cycleId;
 	priorExtractedValues;
+	/** The generation the chunk was written to (the head when the target was retired). */
+	persistedRecordId;
 	constructor(deps, opts) {
 		super(deps, opts);
 		this.cycleId = opts.cycleId;
@@ -32003,12 +32464,13 @@ var AsyncBufferObservationStrategy = class extends ObservationStrategy {
 		};
 	}
 	async emitStartMarkers(_cycleId) {}
-	async observe(existingObservations, messages) {
+	async observe(observerContext, messages, wasTruncated) {
 		const thread = await this.storage.getThreadById({ threadId: this.opts.threadId });
 		const omMeta = thread ? (0, _mastra_core_memory.getThreadOMMetadata)(thread.metadata) : void 0;
 		this.priorExtractedValues = getPriorExtractedValues(omMeta, this.observationConfig.extractors);
-		const result = await this.deps.observer.call(existingObservations, messages, void 0, {
+		const result = await this.deps.observer.call(observerContext, messages, void 0, {
 			skipContinuationHints: true,
+			wasTruncated,
 			requestContext: this.opts.requestContext,
 			observabilityContext: this.opts.observabilityContext,
 			priorExtractedValues: this.priorExtractedValues,
@@ -32082,71 +32544,124 @@ var AsyncBufferObservationStrategy = class extends ObservationStrategy {
 		};
 	}
 	async persist(processed) {
-		if (!processed.observations) return false;
+		if (!processed.observations) return;
 		const { record, threadId, resourceId, messages } = this.opts;
-		if (!await this.storage.getObservationalMemory(record.threadId, record.resourceId)) {
+		const liveRecord = await getLineageHead(this.storage, record);
+		if (!liveRecord) {
 			omDebug(`[OM:asyncBuffer] skipping persist for thread ${threadId}: observational memory record is gone`);
-			return false;
+			return {
+				status: "not-committed",
+				reason: "the observational memory record was cleared"
+			};
 		}
 		const messageTokens = await this.tokenCounter.countMessagesAsync(messages);
-		await withRetry(() => this.storage.updateBufferedObservations({
-			id: record.id,
-			chunk: {
-				cycleId: this.cycleId,
-				observations: processed.observations,
-				tokenCount: processed.observationTokens,
-				messageIds: processed.observedMessageIds,
-				messageTokens,
-				lastObservedAt: processed.lastObservedAt,
-				suggestedContinuation: processed.suggestedContinuation,
-				currentTask: processed.currentTask,
-				threadTitle: processed.threadTitle,
-				extractedValues: processed.extractedValues,
-				extractionFailures: processed.extractionFailures
-			},
-			lastBufferedAtTime: processed.lastObservedAt
-		}), {
+		let appendAttempts = 0;
+		let targetId = record.id;
+		const appendResult = await withRetry(() => {
+			appendAttempts++;
+			return this.runCommit(async () => {
+				const head = await getLineageHead(this.storage, record);
+				if (!head) return null;
+				targetId = head.id;
+				const input = {
+					id: targetId,
+					chunk: {
+						cycleId: this.cycleId,
+						observations: processed.observations,
+						tokenCount: processed.observationTokens,
+						messageIds: processed.observedMessageIds,
+						messageTokens,
+						lastObservedAt: processed.lastObservedAt,
+						suggestedContinuation: processed.suggestedContinuation,
+						currentTask: processed.currentTask,
+						threadTitle: processed.threadTitle,
+						extractedValues: processed.extractedValues,
+						extractionFailures: processed.extractionFailures
+					},
+					lastBufferedAtTime: processed.lastObservedAt
+				};
+				return typeof this.storage.appendBufferedObservations === "function" ? this.storage.appendBufferedObservations(input) : this.storage.updateBufferedObservations(input).then(() => ({
+					persisted: true,
+					recordId: input.id
+				}));
+			});
+		}, {
 			label: "persist-buffered-observations",
 			abortSignal: this.opts.abortSignal
 		});
-		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) {
-			const thread = await this.storage.getThreadById({ threadId });
-			if (thread) {
-				const oldTitle = thread.title?.trim();
-				const newTitle = resolveThreadTitleUpdate(thread, candidateTitle);
-				const shouldUpdateThreadTitle = newTitle !== void 0;
-				const previousOmMetadata = (0, _mastra_core_memory.getThreadOMMetadata)(thread.metadata);
-				const metadataUpdate = buildThreadMetadataFromExtractedValues(processed.extractors ?? this.observationConfig.extractors, processed.extractedValues);
-				const newMetadata = (0, _mastra_core_memory.setThreadOMMetadata)(thread.metadata, {
-					...hasValidThreadTitle || metadataUpdate.threadTitle ? { threadTitle: metadataUpdate.threadTitle ?? processed.threadTitle } : {},
-					extracted: {
-						...previousOmMetadata?.extracted ?? {},
-						...metadataUpdate.extracted ?? {}
-					}
-				});
-				await this.storage.patchThread({
-					id: threadId,
-					...shouldUpdateThreadTitle ? { title: newTitle } : {},
-					metadata: newMetadata
-				});
-				if (shouldUpdateThreadTitle) {
-					const marker = createThreadUpdateMarker({
-						cycleId: this.cycleId,
-						threadId,
-						oldTitle,
-						newTitle
+		if (appendResult === null) {
+			omDebug(`[OM:asyncBuffer] skipping persist for thread ${threadId}: observational memory record was cleared`);
+			return {
+				status: "not-committed",
+				reason: "the observational memory record was cleared"
+			};
+		}
+		let committedRecord = liveRecord;
+		if (!appendResult.persisted) {
+			const head = appendAttempts > 1 ? await getLineageHead(this.storage, record) : null;
+			if (!(!!head && (getBufferedChunks(head).some((chunk) => chunk.cycleId === this.cycleId) || head.activeObservations.includes(processed.observations)))) return {
+				status: "not-committed",
+				reason: "the buffered chunk was already observed"
+			};
+			this.persistedRecordId = head.id;
+			committedRecord = head;
+		} else this.persistedRecordId = appendResult.recordId;
+		await this.emitBufferingEndMarker(processed);
+		await this.opts.onBufferedChunkPersisted?.();
+		if (committedRecord.id !== this.persistedRecordId) {
+			const landedOn = await getLineageRecord(this.storage, record, this.persistedRecordId);
+			if (!landedOn) return {
+				status: "not-committed",
+				reason: "the observational memory record was cleared"
+			};
+			committedRecord = landedOn;
+		}
+		try {
+			await this.indexObservationGroups(processed.observations, threadId, resourceId, processed.lastObservedAt, this.persistedRecordId);
+			const candidateTitle = processed.threadTitle?.trim();
+			const hasValidThreadTitle = !!candidateTitle && candidateTitle.length >= 3;
+			if (hasValidThreadTitle || processed.extractedValues) {
+				const thread = await this.storage.getThreadById({ threadId });
+				if (thread) {
+					const oldTitle = thread.title?.trim();
+					const newTitle = resolveThreadTitleUpdate(thread, candidateTitle);
+					const shouldUpdateThreadTitle = newTitle !== void 0;
+					const previousOmMetadata = (0, _mastra_core_memory.getThreadOMMetadata)(thread.metadata);
+					const metadataUpdate = buildThreadMetadataFromExtractedValues(processed.extractors ?? this.observationConfig.extractors, processed.extractedValues);
+					const newMetadata = (0, _mastra_core_memory.setThreadOMMetadata)(thread.metadata, {
+						...hasValidThreadTitle || metadataUpdate.threadTitle ? { threadTitle: metadataUpdate.threadTitle ?? processed.threadTitle } : {},
+						extracted: {
+							...previousOmMetadata?.extracted ?? {},
+							...metadataUpdate.extracted ?? {}
+						}
+					});
+					await this.storage.patchThread({
+						id: threadId,
+						...shouldUpdateThreadTitle ? { title: newTitle } : {},
+						metadata: newMetadata
 					});
-					await this.streamMarker(marker);
+					if (shouldUpdateThreadTitle) {
+						const marker = createThreadUpdateMarker({
+							cycleId: this.cycleId,
+							threadId,
+							oldTitle,
+							newTitle
+						});
+						await this.streamMarker(marker);
+					}
 				}
 			}
+		} catch (error) {
+			omError("[OM] Post-buffer indexing or thread update failed; the buffered chunk is kept", error);
 		}
-		return true;
+		return {
+			status: "committed",
+			processed,
+			record: committedRecord
+		};
 	}
-	async emitEndMarkers(_cycleId, processed) {
-		if (!processed.observations) return;
+	async emitEndMarkers() {}
+	async emitBufferingEndMarker(processed) {
 		const { record, threadId, messages } = this.opts;
 		const tokensBuffered = await this.tokenCounter.countMessagesAsync(messages);
 		const totalBufferedTokens = getBufferedChunks(await this.storage.getObservationalMemory(record.threadId, record.resourceId)).reduce((sum, c) => sum + (c.tokenCount ?? 0), 0) || processed.observationTokens;
@@ -32156,7 +32671,7 @@ var AsyncBufferObservationStrategy = class extends ObservationStrategy {
 			startedAt: this.startedAt,
 			tokensBuffered,
 			bufferedTokens: totalBufferedTokens,
-			recordId: record.id,
+			recordId: this.persistedRecordId ?? record.id,
 			threadId,
 			observations: processed.observations,
 			extractedValues: processed.extractedValues,
@@ -32166,7 +32681,10 @@ var AsyncBufferObservationStrategy = class extends ObservationStrategy {
 			...endMarker,
 			transient: true
 		}).catch(() => {});
-		await this.persistMarkerToStorage(endMarker, threadId, record.resourceId ?? void 0);
+		await this.persistMarkerToStorage(endMarker, threadId, record.resourceId ?? void 0, {
+			notAfter: new Date(this.startedAt),
+			onCycleStartMessage: true
+		});
 	}
 	async emitFailedMarkers(_cycleId, error) {
 		const { record, threadId, messages } = this.opts;
@@ -32185,7 +32703,10 @@ var AsyncBufferObservationStrategy = class extends ObservationStrategy {
 			...failedMarker,
 			transient: true
 		}).catch(() => {});
-		await this.persistMarkerToStorage(failedMarker, threadId, record.resourceId ?? void 0);
+		await this.persistMarkerToStorage(failedMarker, threadId, record.resourceId ?? void 0, {
+			notAfter: new Date(this.startedAt),
+			onCycleStartMessage: true
+		});
 	}
 };
 var ResourceScopedObservationStrategy = class extends ObservationStrategy {
@@ -32206,10 +32727,17 @@ var ResourceScopedObservationStrategy = class extends ObservationStrategy {
 	lastBatchProviderMetadata;
 	observationResults = [];
 	priorMetadataByThread = /* @__PURE__ */ new Map();
+	/** Each observed thread's wrapped section from the last composition. */
+	threadSections = /* @__PURE__ */ new Map();
+	/** Head text the processed observations were composed from (the commit's expected text). */
+	composedFrom = "";
 	constructor(deps, opts) {
 		super(deps, opts);
 		this.resourceId = opts.resourceId;
 	}
+	getObservedMessagesForThread(threadId) {
+		return this.threadsWithMessages.get(threadId);
+	}
 	get needsLock() {
 		return true;
 	}
@@ -32296,10 +32824,12 @@ var ResourceScopedObservationStrategy = class extends ObservationStrategy {
 				content: typeof m.content === "string" ? m.content : JSON.stringify(m.content)
 			}))
 		});
-		const existingObservations = (await this.storage.getObservationalMemory(null, this.resourceId))?.activeObservations ?? record.activeObservations ?? "";
+		const freshRecord = await this.storage.getObservationalMemory(null, this.resourceId);
+		const existingObservations = freshRecord?.activeObservations ?? record.activeObservations ?? "";
 		return {
 			messages: Array.from(this.threadsWithMessages.values()).flat(),
-			existingObservations
+			existingObservations,
+			contextRecord: freshRecord
 		};
 	}
 	async emitStartMarkers(cycleId) {
@@ -32323,7 +32853,7 @@ var ResourceScopedObservationStrategy = class extends ObservationStrategy {
 			}
 		}
 	}
-	async observe(_existingObservations, _messages) {
+	async observe(observerContext, _messages, wasTruncated) {
 		const maxTokensPerBatch = this.observationConfig.maxTokensPerBatch ?? OBSERVATIONAL_MEMORY_DEFAULTS.observation.maxTokensPerBatch;
 		const orderedThreadIds = this.threadOrder.filter((tid) => this.threadsWithMessages.has(tid));
 		const batches = [];
@@ -32349,10 +32879,10 @@ var ResourceScopedObservationStrategy = class extends ObservationStrategy {
 		}
 		if (currentBatch.threadIds.length > 0) batches.push(currentBatch);
 		const batchResults = await Promise.all(batches.map(async (batch) => {
-			return this.deps.observer.callMultiThread(_existingObservations, batch.threadMap, batch.threadIds, this.opts.abortSignal, this.opts.requestContext, this.priorMetadataByThread, this.opts.observabilityContext, void 0, {
+			return this.deps.observer.callMultiThread(observerContext, batch.threadMap, batch.threadIds, this.opts.abortSignal, this.opts.requestContext, this.priorMetadataByThread, this.opts.observabilityContext, void 0, {
 				resourceId: this.opts.resourceId,
 				trigger: this.opts.trigger
-			}, this.opts.record.observedTimezone, this.opts.agent, this.opts.currentModel);
+			}, this.opts.record.observedTimezone, this.opts.agent, this.opts.currentModel, wasTruncated);
 		}));
 		for (const batchResult of batchResults) {
 			for (const [threadId, result] of batchResult.results) this.multiThreadResults.set(threadId, result);
@@ -32419,14 +32949,38 @@ var ResourceScopedObservationStrategy = class extends ObservationStrategy {
 				}
 			});
 		}
+		this.composedFrom = existingObservations;
+		const processed = await this.compose(existingObservations, record);
+		for (const [index, { threadId, threadMessages, result }] of this.observationResults.entries()) this.deps.emitDebugEvent({
+			type: "observation_complete",
+			timestamp: /* @__PURE__ */ new Date(),
+			threadId,
+			resourceId: this.resourceId,
+			observations: this.threadSections.get(threadId) ?? "",
+			rawObserverOutput: result.observations,
+			previousObservations: record.activeObservations,
+			messages: threadMessages.map((m) => ({
+				role: m.role,
+				content: typeof m.content === "string" ? m.content : JSON.stringify(m.content)
+			})),
+			usage: index === 0 && this.totalBatchUsage.totalTokens > 0 ? this.totalBatchUsage : void 0
+		});
+		return processed;
+	}
+	/**
+	* Merge every observed thread's section into `existingObservations` (the head text). Resource
+	* scope rewrites an existing same-day `<thread>` section in place, so the result is not an
+	* append of the head text.
+	*/
+	async compose(existingObservations, baseRecord) {
 		let currentObservations = existingObservations;
 		let cycleObservationTokens = 0;
 		const threadMetadataUpdates = [];
-		for (const obsResult of this.observationResults) {
-			const { threadId, threadMessages, result } = obsResult;
+		for (const { threadId, threadMessages, result } of this.observationResults) {
 			cycleObservationTokens += this.tokenCounter.countObservations(result.observations);
 			const messageRange = this.retrieval ? buildMessageRange(threadMessages) : void 0;
 			const threadSection = await this.wrapWithThreadTag(threadId, result.observations, messageRange);
+			this.threadSections.set(threadId, threadSection);
 			const threadLastObservedAt = this.getMaxMessageTimestamp(threadMessages);
 			currentObservations = this.replaceOrAppendThreadSection(currentObservations, threadId, threadSection, threadLastObservedAt);
 			threadMetadataUpdates.push({
@@ -32440,26 +32994,11 @@ var ResourceScopedObservationStrategy = class extends ObservationStrategy {
 				extractors: result.extractors,
 				lastObservedMessageCursor: getLastObservedMessageCursor(threadMessages)
 			});
-			const isFirstThread = this.observationResults.indexOf(obsResult) === 0;
-			this.deps.emitDebugEvent({
-				type: "observation_complete",
-				timestamp: /* @__PURE__ */ new Date(),
-				threadId,
-				resourceId: this.resourceId,
-				observations: threadSection,
-				rawObserverOutput: result.observations,
-				previousObservations: record.activeObservations,
-				messages: threadMessages.map((m) => ({
-					role: m.role,
-					content: typeof m.content === "string" ? m.content : JSON.stringify(m.content)
-				})),
-				usage: isFirstThread && this.totalBatchUsage.totalTokens > 0 ? this.totalBatchUsage : void 0
-			});
 		}
 		const observedMessages = this.observationResults.flatMap((r) => r.threadMessages);
 		const lastObservedAt = this.getMaxMessageTimestamp(observedMessages);
 		const newMessageIds = observedMessages.map((m) => m.id);
-		const existingIds = record.observedMessageIds ?? [];
+		const existingIds = baseRecord.observedMessageIds ?? [];
 		const observedMessageIds = [.../* @__PURE__ */ new Set([...existingIds, ...newMessageIds])];
 		const observationTokens = this.tokenCounter.countObservations(currentObservations);
 		return {
@@ -32473,8 +33012,25 @@ var ResourceScopedObservationStrategy = class extends ObservationStrategy {
 	}
 	async persist(processed) {
 		const { record, resourceId } = this.opts;
+		const head = await getLineageHead(this.storage, record);
+		if (!head) return {
+			status: "not-committed",
+			reason: "the observational memory record was cleared"
+		};
+		const committed = await this.commitActiveObservationsToHead({
+			processed,
+			composedFrom: this.composedFrom,
+			target: head,
+			recompose: (fresh) => this.compose(fresh.activeObservations ?? "", fresh),
+			cycleMessageIds: this.observationResults.flatMap((r) => r.threadMessages.map((m) => m.id))
+		});
+		if (!committed) return {
+			status: "not-committed",
+			reason: "the observational memory head kept changing during the commit"
+		};
+		processed = committed.processed;
 		const threadUpdateMarkers = [];
-		if (processed.threadMetadataUpdates) for (const update of processed.threadMetadataUpdates) {
+		if (processed.threadMetadataUpdates && !committed.alreadyCovered) for (const update of processed.threadMetadataUpdates) {
 			const thread = await this.storage.getThreadById({ threadId: update.threadId });
 			if (thread) {
 				const oldTitle = thread.title?.trim();
@@ -32507,15 +33063,13 @@ var ResourceScopedObservationStrategy = class extends ObservationStrategy {
 			}
 		}
 		for (const marker of threadUpdateMarkers) await this.streamMarker(marker);
-		await this.storage.updateActiveObservations({
-			id: record.id,
-			observations: processed.observations,
-			tokenCount: processed.observationTokens,
-			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), record.id)));
-		return true;
+		if (resourceId && !committed.alreadyCovered) await Promise.all(this.observationResults.map(({ threadId, threadMessages, result }) => this.indexObservationGroups(result.observations, threadId, resourceId, this.getMaxMessageTimestamp(threadMessages), committed.record.id)));
+		return {
+			status: "committed",
+			processed,
+			record: committed.record,
+			alreadyCovered: committed.alreadyCovered
+		};
 	}
 	async emitEndMarkers(cycleId, processed) {
 		for (const obsResult of this.observationResults) {
@@ -32572,7 +33126,8 @@ ObservationStrategy.create = ((om, opts) => {
 		observedMessageIds: om.observedMessageIds,
 		obscureThreadIds: om.getObscureThreadIds(),
 		onIndexObservations: om.onIndexObservations,
-		emitDebugEvent: (e) => om.emitDebugEvent(e)
+		emitDebugEvent: (e) => om.emitDebugEvent(e),
+		prepareObserverContext: (observations, record) => om.prepareObserverContext(observations, record)
 	};
 	if (opts.cycleId) return new AsyncBufferObservationStrategy(deps, opts);
 	if (deps.scope === "resource" && opts.resourceId) return new ResourceScopedObservationStrategy(deps, opts);
@@ -32698,8 +33253,8 @@ var ObservationStep = class {
 		let reflected = false;
 		let didThresholdCleanup = false;
 		let observerExchange;
+		const step0Messages = this.stepNumber === 0 ? getObservableMessages(messageList) : [];
 		if (this.stepNumber === 0) {
-			const step0Messages = getObservableMessages(messageList);
 			const activation = await om.activate({
 				threadId,
 				resourceId,
@@ -32756,7 +33311,17 @@ var ObservationStep = class {
 			record: this.turn.record,
 			messages: getObservableMessages(messageList)
 		});
-		if (statusSnapshot.shouldBuffer) {
+		if (statusSnapshot.inAsyncObservationBand && !statusSnapshot.canActivate && !hasIncompleteToolCalls) {
+			await this.turn.refreshRecord();
+			statusSnapshot = await om.getStatus({
+				threadId,
+				resourceId,
+				record: this.turn.record,
+				messages: getObservableMessages(messageList)
+			});
+		}
+		const activateBeforeBuffering = statusSnapshot.inAsyncObservationBand && statusSnapshot.canActivate && !hasIncompleteToolCalls;
+		if (statusSnapshot.shouldBuffer && !activateBeforeBuffering) {
 			const allMessages = getObservableMessages(messageList);
 			const unobservedMessages = om.getUnobservedMessages(allMessages, statusSnapshot.record);
 			const candidates = om.getUnobservedMessages(unobservedMessages, statusSnapshot.record, { excludeBuffered: true });
@@ -32770,8 +33335,10 @@ var ObservationStep = class {
 					omDebug(`[OM:buffer] onBufferChunkSealed hook failed: ${error instanceof Error ? error.message : String(error)}`);
 				}
 				if (this.turn.memory) await this.turn.memory.persistMessages(safeCandidates);
-				messageList.removeByIds(safeCandidates.map((msg) => msg.id));
-				for (const msg of safeCandidates) messageList.add(msg, "memory");
+				const inputIds = new Set(messageList.get.input.db().map((msg) => msg.id));
+				const sealedOutput = safeCandidates.filter((msg) => !inputIds.has(msg.id));
+				messageList.removeByIds(sealedOutput.map((msg) => msg.id));
+				for (const msg of sealedOutput) messageList.add(msg, "memory");
 			}
 			if (!deferred) {
 				om.trackBackgroundWork(om.buffer({
@@ -32793,7 +33360,8 @@ var ObservationStep = class {
 				buffered = true;
 			}
 		}
-		const willObserveNow = statusSnapshot.shouldObserve && !hasIncompleteToolCalls;
+		const bandDefersObservation = statusSnapshot.inAsyncObservationBand && !statusSnapshot.canActivate;
+		const willObserveNow = statusSnapshot.shouldObserve && !hasIncompleteToolCalls && !bandDefersObservation;
 		/** In-flight message ids the step-0 cleanup must never remove from live context. */
 		let step0PreserveIds;
 		if (this.stepNumber > 0 || willObserveNow) {
@@ -32835,7 +33403,7 @@ var ObservationStep = class {
 			}
 			if (willObserveNow) {
 				const preObsGeneration = this.turn.record.generationCount;
-				const obsResult = await this.runThresholdObservation();
+				const obsResult = await this.runThresholdObservation(statusSnapshot.inAsyncObservationBand);
 				observerExchange = obsResult.observerExchange;
 				if (obsResult.succeeded) {
 					observed = true;
@@ -32908,12 +33476,12 @@ var ObservationStep = class {
 	/**
 	* Run the full threshold observation pipeline:
 	* waitForBuffering → re-check → activate buffered chunks → reflect → observe
-	* (sync fallback when pending tokens are still at or above the threshold)
+	* (sync fallback at blockAfter when async buffering is enabled)
 	*/
-	async runThresholdObservation() {
+	async runThresholdObservation(inAsyncObservationBand) {
 		const { threadId, resourceId, messageList } = this.turn;
 		const om = this.turn.om;
-		await om.waitForBuffering(threadId, resourceId);
+		if (!inAsyncObservationBand) await om.waitForBuffering(threadId, resourceId);
 		await this.turn.refreshRecord();
 		const observableMessages = this.seededResponseMessage ? getObservableMessages(messageList).filter((msg) => msg.id !== this.turn.responseMessageId) : getObservableMessages(messageList);
 		let status = await om.getStatus({
@@ -32942,7 +33510,16 @@ var ObservationStep = class {
 				messageList
 			});
 			this.turn.setRecord(activation.record);
-			if (!activation.activated) break;
+			if (!activation.activated) {
+				await this.turn.refreshRecord();
+				status = await om.getStatus({
+					threadId,
+					resourceId,
+					record: this.turn.record,
+					messages: pendingMessages
+				});
+				break;
+			}
 			activated = true;
 			const ids = new Set(activation.activatedMessageIds ?? []);
 			activatedMessageIds.push(...ids);
@@ -32954,11 +33531,17 @@ var ObservationStep = class {
 				messages: pendingMessages
 			});
 		}
+		if (status.shouldObserve && status.canActivate) return {
+			succeeded: activated,
+			record: this.turn.record,
+			activatedMessageIds: activated ? activatedMessageIds : void 0,
+			cleanupMessageIds: activatedMessageIds
+		};
 		if (activated) {
-			const postActivationRecord = this.turn.record;
+			const preReflectionRecord = this.turn.record;
 			await om.reflector.maybeReflect({
-				record: postActivationRecord,
-				observationTokens: postActivationRecord.observationTokenCount ?? 0,
+				record: preReflectionRecord,
+				observationTokens: preReflectionRecord.observationTokenCount ?? 0,
 				threadId,
 				writer: this.turn.writer,
 				messageList,
@@ -32973,6 +33556,14 @@ var ObservationStep = class {
 				}),
 				trigger: "turn-sync"
 			});
+			await this.turn.refreshRecord();
+			const postActivationRecord = this.turn.record;
+			status = await om.getStatus({
+				threadId,
+				resourceId,
+				record: postActivationRecord,
+				messages: pendingMessages
+			});
 			if (!status.shouldObserve) return {
 				succeeded: true,
 				record: postActivationRecord,
@@ -32980,6 +33571,12 @@ var ObservationStep = class {
 				cleanupMessageIds: activatedMessageIds
 			};
 		}
+		if (status.inAsyncObservationBand || status.canActivate) return {
+			succeeded: activated,
+			record: this.turn.record,
+			activatedMessageIds: activated ? activatedMessageIds : void 0,
+			cleanupMessageIds: activatedMessageIds
+		};
 		let obsResult;
 		try {
 			obsResult = await om.observe({
@@ -33327,13 +33924,18 @@ Take the existing observations and rewrite them to make it easier to continue in
 
 IMPORTANT: your reflections are THE ENTIRETY of the assistants memory. Any information you do not add to your reflections will be immediately forgotten. Make sure you do not leave out anything. Your reflections must assume the assistant knows nothing - your reflections are the ENTIRE memory system.
 
+The assistant relies on this memory to answer precise questions about what the user said, when they said it, and how things changed over time.
+
 When consolidating observations:
-- Preserve and include dates/times when present (temporal context is critical)
-- Retain the most relevant timestamps (start times, completion times, significant events)
+- Keep every concrete fact: names, places, dates, numbers, amounts, durations, titles, versions, and who said what. Merge duplicates, but never drop specifics
+- Keep every dated statement with its date, and retain the timestamps that matter (start times, completion times, significant events)
+- When the user changed their mind or a fact was updated, keep both the old and new values with their dates and say which is current
+- Keep what the user explicitly said they have never done, do not know, or refused, and keep every stated preference, rule, and instruction with its meaning intact
+- Prefer many short factual lines over prose summaries. Do not replace facts with generalities like "discussed travel plans"
 - Combine related items where it makes sense (e.g., "agent called view tool 5 times on file x")
 - Preserve ✅ completion markers — they are memory signals that tell the assistant what is already resolved and help prevent repeated work
 - Preserve the concrete resolved outcome captured by ✅ markers so the assistant knows what exactly is done
-- Condense older observations more aggressively, retain more detail for recent ones
+- Condense the wording of older observations more than recent ones, but keep their facts
 
 CRITICAL: USER ASSERTIONS vs QUESTIONS
 - "User stated: X" = authoritative assertion (user told us something about themselves)
@@ -33613,6 +34215,25 @@ async function withAbortCheck(fn, abortSignal) {
 * size while still letting them fire sooner than a threshold activation.
 */
 const EARLY_ACTIVATION_SIZE_FLOOR_RATIO = .75;
+/** A reflection commit that created nothing because the reflected record is no longer the head. */
+var ReflectionNotAppliedError = class extends Error {
+	constructor(recordId, headId) {
+		super(`Reflection not applied: record ${recordId} is no longer the current generation (head is ${headId})`);
+		this.name = "ReflectionNotAppliedError";
+	}
+};
+/**
+* Whether a reflection commit created the generation the caller asked for. Storage creates
+* nothing (and returns the current head or the stored record) when the reflected record was
+* already retired or its observations were rewritten since the reflection read them.
+*
+* Adapters that predate `newRecordId` ignore it and do not report `supersededBy`; for those a
+* returned record other than the reflected one means a new generation was created.
+*/
+function isReflectionApplied(returned, newRecordId, reflectedRecordId) {
+	if (returned.id === newRecordId) return true;
+	return returned.supersededBy === void 0 && returned.id !== reflectedRecordId;
+}
 /**
 * Runs the Reflector agent for compressing observations.
 * Handles synchronous reflection, async buffered reflection, and activation.
@@ -33976,14 +34597,14 @@ var ReflectorRunner = class {
 	* Perform async buffered reflection — reflects observations and stores to bufferedReflection.
 	* Does NOT create a new generation or update activeObservations.
 	*/
-	async doAsyncBufferedReflection(record, _bufferKey, writer, requestContext, observabilityContext, priorExtractedValues, mainAgent, sendSignal, trigger, currentModel) {
+	async doAsyncBufferedReflection(record, bufferKey, writer, requestContext, observabilityContext, priorExtractedValues, mainAgent, sendSignal, trigger, currentModel) {
 		const currentRecord = await this.storage.getObservationalMemory(record.threadId, record.resourceId) ?? record;
 		const observationTokens = currentRecord.observationTokenCount ?? 0;
 		const reflectThreshold = getMaxThreshold(this.getEffectiveReflectionTokens(currentRecord));
 		const bufferActivation = this.reflectionConfig.bufferActivation ?? .5;
 		const startedAt = (/* @__PURE__ */ new Date()).toISOString();
 		const cycleId = `reflect-buf-${Date.now()}-${Math.random().toString(36).slice(2, 11)}`;
-		BufferingCoordinator.reflectionBufferCycleIds.set(_bufferKey, cycleId);
+		BufferingCoordinator.reflectionBufferCycleIds.set(bufferKey, cycleId);
 		const allLines = (currentRecord.activeObservations ?? "").split("\n");
 		const totalLines = allLines.length;
 		const avgTokensPerLine = totalLines > 0 ? observationTokens / totalLines : 0;
@@ -34022,13 +34643,24 @@ var ReflectorRunner = class {
 		await persistThreadExtractedValues(this.storage, this.reflectionConfig.extractors, currentRecord.threadId ?? void 0, reflectResult.extractedValues);
 		const reflectionTokenCount = this.tokenCounter.countObservations(reflectResult.observations);
 		omDebug(`[OM:reflect] doAsyncBufferedReflection: reflector returned ${reflectionTokenCount} tokens (${reflectResult.observations?.length} chars), saving to recordId=${currentRecord.id}`);
-		await this.storage.updateBufferedReflection({
-			id: currentRecord.id,
-			reflection: reflectResult.observations,
-			tokenCount: reflectionTokenCount,
-			inputTokenCount: sliceTokenEstimate,
-			reflectedObservationLineCount
-		});
+		if (!await runOMCommit(this.buffering.getLockKey(currentRecord.threadId, currentRecord.resourceId), async () => {
+			if ((await this.storage.getObservationalMemory(currentRecord.threadId, currentRecord.resourceId))?.id !== currentRecord.id) return false;
+			await this.storage.updateBufferedReflection({
+				id: currentRecord.id,
+				reflection: reflectResult.observations,
+				tokenCount: reflectionTokenCount,
+				inputTokenCount: sliceTokenEstimate,
+				reflectedObservationLineCount
+			});
+			return true;
+		})) {
+			omDebug(`[OM:reflect] doAsyncBufferedReflection: record ${currentRecord.id} is no longer the head; discarding the buffered reflection`);
+			BufferingCoordinator.lastBufferedBoundary.delete(bufferKey);
+			return {
+				usage: reflectResult.usage,
+				providerMetadata: reflectResult.providerMetadata
+			};
+		}
 		omDebug(`[OM:reflect] doAsyncBufferedReflection: bufferedReflection saved with lineCount=${reflectedObservationLineCount}`);
 		if (writer) {
 			const endMarker = createBufferingEndMarker({
@@ -34107,10 +34739,16 @@ var ReflectorRunner = class {
 			}
 		}
 		omDebug(`[OM:reflect] tryActivateBufferedReflection: activating, beforeTokens=${beforeTokens}, combinedTokenCount=${combinedTokenCount}, reflectedLineCount=${reflectedLineCount}, unreflectedLines=${unreflectedLines.length}`);
-		await this.storage.swapBufferedReflectionToActive({
+		const newRecordId = crypto.randomUUID();
+		const swapped = await runOMCommit(lockKey, () => this.storage.swapBufferedReflectionToActive({
 			currentRecord: freshRecord,
-			tokenCount: combinedTokenCount
-		});
+			tokenCount: combinedTokenCount,
+			newRecordId
+		}), { priority: "reflection" });
+		if (!isReflectionApplied(swapped, newRecordId, freshRecord.id)) {
+			omDebug(`[OM:reflect] tryActivateBufferedReflection: buffered reflection on ${freshRecord.id} not applied (head is ${swapped.id})`);
+			return { status: "not-applied" };
+		}
 		if (committedContext) await this.notifyReflectionCommitted({
 			...committedContext,
 			observations: allLines.slice(0, reflectedLineCount).join("\n").trim(),
@@ -34165,7 +34803,8 @@ var ReflectorRunner = class {
 	* @internal Used by observation strategies. Do not call directly.
 	*/
 	async maybeReflect(opts) {
-		const { record, observationTokens, writer, abortSignal, mainAgent, sendSignal, sendStateSignal, messageList, currentModel, reflectionHooks, trigger, requestContext, observabilityContext, lastActivityAt, threadId: requestedThreadId } = opts;
+		const { record: callerRecord, observationTokens, writer, abortSignal, mainAgent, sendSignal, sendStateSignal, messageList, currentModel, reflectionHooks, trigger, requestContext, observabilityContext, lastActivityAt, threadId: requestedThreadId } = opts;
+		const record = { ...callerRecord };
 		const lockKey = this.buffering.getLockKey(record.threadId, record.resourceId);
 		const reflectThreshold = getMaxThreshold(this.getEffectiveReflectionTokens(record));
 		const priorExtractedValues = await getThreadExtractedValues(this.storage, this.reflectionConfig.extractors, requestedThreadId ?? record.threadId);
@@ -34219,7 +34858,7 @@ var ReflectorRunner = class {
 				abortSignal,
 				observabilityContext
 			});
-			if (activationResult.status === "activated") return;
+			if (activationResult.status === "activated" || activationResult.status === "not-applied") return;
 			if (activationResult.status === "suppressed") {
 				omDebug(`[OM:reflect] skipping sync fallback / re-buffer after suppressed early ${activationMetadata.triggeredBy} activation (reason=${activationResult.reason})`);
 				return;
@@ -34302,13 +34941,19 @@ var ReflectorRunner = class {
 			reflectResult.observations = await applyTextTransform(this.hooks, "afterReflection", reflectResult.observations, hookContext);
 			reflectionUsage = reflectResult.usage;
 			reflectionProviderMetadata = reflectResult.providerMetadata;
-			await persistThreadExtractedValues(this.storage, this.reflectionConfig.extractors, record.threadId ?? void 0, reflectResult.extractedValues);
 			const reflectionTokenCount = this.tokenCounter.countObservations(reflectResult.observations);
-			await this.storage.createReflectionGeneration({
+			const newRecordId = crypto.randomUUID();
+			const committedRecord = await runOMCommit(this.buffering.getLockKey(record.threadId, record.resourceId), () => this.storage.createReflectionGeneration({
 				currentRecord: record,
 				reflection: reflectResult.observations,
-				tokenCount: reflectionTokenCount
-			});
+				tokenCount: reflectionTokenCount,
+				newRecordId
+			}), { priority: "reflection" });
+			if (!isReflectionApplied(committedRecord, newRecordId, record.id)) {
+				omDebug(`[OM:reflect] reflection of ${record.id} not applied (head is ${committedRecord.id})`);
+				throw new ReflectionNotAppliedError(record.id, committedRecord.id);
+			}
+			await persistThreadExtractedValues(this.storage, this.reflectionConfig.extractors, record.threadId ?? void 0, reflectResult.extractedValues);
 			if (reflectionTokenCount >= reflectThreshold) this.syncReflectionSuppression.set(lockKey, reflectionTokenCount);
 			else this.syncReflectionSuppression.delete(lockKey);
 			await this.notifyReflectionCommitted({
@@ -34388,6 +35033,7 @@ var ReflectorRunner = class {
 				failureKind: failedMarker.data.failureKind,
 				error: reflectionError.message
 			});
+			if (error instanceof ReflectionNotAppliedError) return;
 			if (lifecycleError !== void 0 || abortSignal?.aborted || this.reflectionConfig.failurePolicy !== "continue" || !isOmModelExecutionError(error) || error.failureKind !== "reflector-model") throw error;
 			this.syncReflectionSuppression.set(lockKey, observationTokens);
 			omError("[OM] Reflection failed", error);
@@ -34727,6 +35373,8 @@ function writeProcessInputStepReproCapture(params) {
 * Returns the parts from the latest step of a message (after the last step-start marker).
 * If no step-start marker exists, returns all parts.
 */
+/** Re-reads of the head after an activation swap hit a generation retired by a reflection. */
+const MAX_ACTIVATION_RETIRED_RETRIES = 3;
 function getLatestStepParts(parts) {
 	for (let i = parts.length - 1; i >= 0; i--) if (parts[i]?.type === "step-start") return parts.slice(i + 1);
 	return parts;
@@ -34920,6 +35568,8 @@ var ObservationalMemory = class ObservationalMemory {
 	reflector;
 	/** Buffering state coordinator — manages static maps and buffering lifecycle. */
 	buffering;
+	/** Unresolved observation blockAfter (multiplier or absolute); resolved per record. */
+	observationBlockAfterSetting;
 	shouldObscureThreadIds = false;
 	hasher = e();
 	mastra;
@@ -35055,6 +35705,7 @@ var ObservationalMemory = class ObservationalMemory {
 		else throw new Error("shareTokenBudget requires async buffering to be disabled (this is a temporary limitation). Add observation: { bufferTokens: false } to your config:\n\n  observationalMemory: {\n    shareTokenBudget: true,\n    observation: { bufferTokens: false },\n  }\n\nAsync buffering is enabled by default — this opt-out is only needed when using shareTokenBudget.");
 		const observationActivateAfterIdle = config.observation?.activateAfterIdle ?? config.activateAfterIdle;
 		const observationActivateAfterIdlePath = config.observation?.activateAfterIdle !== void 0 ? "observation.activateAfterIdle" : "activateAfterIdle";
+		this.observationBlockAfterSetting = asyncBufferingDisabled ? void 0 : config.observation?.blockAfter ?? (config.observation?.bufferTokens ?? OBSERVATIONAL_MEMORY_DEFAULTS.observation.bufferTokens ? 1.2 : void 0);
 		this.observationConfig = {
 			model: observationModel,
 			maxRetries: config.observation?.maxRetries ?? RETRY_CONFIG.maxRetries,
@@ -35075,8 +35726,8 @@ var ObservationalMemory = class ObservationalMemory {
 			bufferActivation: asyncBufferingDisabled ? void 0 : config.observation?.bufferActivation ?? OBSERVATIONAL_MEMORY_DEFAULTS.observation.bufferActivation,
 			activateAfterIdle: parseActivationTTLConfig(observationActivateAfterIdle, observationActivateAfterIdlePath),
 			activateOnProviderChange: config.observation?.activateOnProviderChange ?? config.activateOnProviderChange ?? false,
-			blockAfter: asyncBufferingDisabled ? void 0 : resolveBlockAfter(config.observation?.blockAfter ?? (config.observation?.bufferTokens ?? OBSERVATIONAL_MEMORY_DEFAULTS.observation.bufferTokens ? 1.2 : void 0), config.observation?.messageTokens ?? OBSERVATIONAL_MEMORY_DEFAULTS.observation.messageTokens),
-			previousObserverTokens: config.observation?.previousObserverTokens ?? 2e3,
+			blockAfter: resolveBlockAfter(this.observationBlockAfterSetting, config.observation?.messageTokens ?? OBSERVATIONAL_MEMORY_DEFAULTS.observation.messageTokens),
+			previousObserverTokens: config.observation?.previousObserverTokens ?? false,
 			instruction: config.observation?.instruction,
 			threadTitle: config.observation?.threadTitle ?? false,
 			observeAttachments: config.observation?.observeAttachments ?? [...OBSERVATIONAL_MEMORY_DEFAULTS.observation.observeAttachments],
@@ -35385,6 +36036,13 @@ var ObservationalMemory = class ObservationalMemory {
 		return this.observationConfig.messageTokens;
 	}
 	/**
+	* Resolve the observation blockAfter for a record. A multiplier scales the record's
+	* effective messageTokens (per-record overrides included); an absolute value is used as-is.
+	*/
+	getEffectiveObservationBlockAfter(record) {
+		return resolveBlockAfter(this.observationBlockAfterSetting, this.getEffectiveMessageTokens(record));
+	}
+	/**
 	* Resolve the effective reflection observationTokens for a record.
 	* Only explicit per-record overrides (stored under `_overrides`) win;
 	* the initial config snapshot is ignored so instance-level changes
@@ -35498,18 +36156,21 @@ var ObservationalMemory = class ObservationalMemory {
 	* the latest user input that triggered it.
 	* @internal Used by observation strategies and the reflector. Do not call directly.
 	*/
-	async persistMarkerToStorage(marker, threadId, resourceId) {
+	async persistMarkerToStorage(marker, threadId, resourceId, opts) {
 		try {
-			const messages = (await this.storage.listMessages({
+			const markerData = marker.data;
+			const targetRole = markerData?.operationType === "reflection" ? "user" : "assistant";
+			const preferred = [...opts?.preferMessages ?? []].reverse().find((m) => m.role === targetRole && (!m.threadId || m.threadId === threadId));
+			const preferredStored = preferred ? (await this.storage.listMessagesById({ messageIds: [preferred.id] })).messages : [];
+			const messages = (preferredStored.length ? { messages: preferredStored } : await this.storage.listMessages({
 				threadId,
 				perPage: 20,
 				orderBy: {
 					field: "createdAt",
 					direction: "DESC"
-				}
+				},
+				...opts?.notAfter ? { filter: { dateRange: { end: opts.notAfter } } } : {}
 			}))?.messages ?? [];
-			const markerData = marker.data;
-			const targetRole = markerData?.operationType === "reflection" ? "user" : "assistant";
 			for (const msg of messages) if (msg?.role === targetRole && msg.content?.parts && Array.isArray(msg.content.parts)) {
 				if (!(markerData?.cycleId && msg.content.parts.some((p) => p?.type === marker.type && p?.data?.cycleId === markerData.cycleId))) msg.content.parts.push(marker);
 				await this.messageHistory.persistMessages({
@@ -35596,7 +36257,7 @@ var ObservationalMemory = class ObservationalMemory {
 	*/
 	createUnobservedMessage(message) {
 		const unobservedParts = getUnobservedParts(message);
-		if (unobservedParts.length === 0) return null;
+		if (unobservedParts.every((part) => part?.type?.startsWith("data-om-"))) return null;
 		return {
 			...message,
 			content: {
@@ -35968,17 +36629,17 @@ ${formattedMessages}
 	async startAsyncBufferedObservation(record, threadId, unobservedMessages, lockKey, writer, contextWindowTokens, requestContext, observabilityContext) {
 		const bufferKey = this.buffering.getObservationBufferKey(lockKey);
 		const currentTokens = contextWindowTokens ?? await this.tokenCounter.countMessagesAsync(unobservedMessages) + (record.pendingMessageTokens ?? 0);
-		BufferingCoordinator.lastBufferedBoundary.set(bufferKey, currentTokens);
+		BufferingCoordinator.setObservationBoundary(bufferKey, currentTokens);
 		registerOp(record.id, "bufferingObservation");
-		this.storage.setBufferingObservationFlag(record.id, true, currentTokens).catch((err) => {
+		runOMCommit(lockKey, () => this.storage.setBufferingObservationFlag(record.id, true, currentTokens)).catch((err) => {
 			omError("[OM] Failed to set buffering observation flag", err);
 		});
 		const asyncOp = this.runAsyncBufferedObservation(record, threadId, unobservedMessages, bufferKey, writer, requestContext, observabilityContext).catch((err) => {
 			omError("[OM] async buffering observation failed", err);
 		}).finally(() => {
-			BufferingCoordinator.asyncBufferingOps.delete(bufferKey);
+			if (BufferingCoordinator.asyncBufferingOps.get(bufferKey) === asyncOp) BufferingCoordinator.asyncBufferingOps.delete(bufferKey);
 			unregisterOp(record.id, "bufferingObservation");
-			this.storage.setBufferingObservationFlag(record.id, false).catch((err) => {
+			runOMCommit(lockKey, () => this.storage.setBufferingObservationFlag(record.id, false)).catch((err) => {
 				omError("[OM] Failed to clear buffering observation flag", err);
 			});
 		});
@@ -35993,6 +36654,14 @@ ${formattedMessages}
 		if (existingOp) try {
 			await existingOp;
 		} catch {}
+		const releaseChunkWrite = BufferingCoordinator.trackChunkWrite(bufferKey);
+		try {
+			await this.bufferObservationChunk(record, threadId, unobservedMessages, bufferKey, releaseChunkWrite, writer, requestContext, observabilityContext);
+		} finally {
+			releaseChunkWrite();
+		}
+	}
+	async bufferObservationChunk(record, threadId, unobservedMessages, bufferKey, releaseChunkWrite, writer, requestContext, observabilityContext) {
 		const freshRecord = await this.storage.getObservationalMemory(record.threadId, record.resourceId);
 		if (!freshRecord) return;
 		let bufferCursor = BufferingCoordinator.lastBufferedAtTime.get(bufferKey) ?? freshRecord.lastBufferedAtTime ?? null;
@@ -36033,13 +36702,16 @@ ${formattedMessages}
 			threadIds: [threadId],
 			config: this.getObservationMarkerConfig()
 		});
-		await this.persistMarkerToStorage(startMarker, threadId, freshRecord.resourceId ?? void 0);
+		await this.persistMarkerToStorage(startMarker, threadId, freshRecord.resourceId ?? void 0, {
+			notAfter: new Date(startedAt),
+			preferMessages: messagesToBuffer
+		});
 		if (writer) writer.custom({
 			...startMarker,
 			transient: true
 		}).catch(() => {});
 		omDebug(`[OM:bufferInput] cycleId=${cycleId}, msgCount=${messagesToBuffer.length}, msgTokens=${tokensToBuffer}, ids=${messagesToBuffer.map((m) => `${m.id?.slice(0, 8)}@${m.createdAt ? new Date(m.createdAt).toISOString() : "none"}`).join(",")}`);
-		if ((await this.runBufferedObservationCycle({
+		await this.runBufferedObservationCycle({
 			threadId,
 			resourceId: freshRecord.resourceId ?? void 0,
 			trigger: "async-buffer"
@@ -36053,12 +36725,13 @@ ${formattedMessages}
 			writer,
 			requestContext,
 			observabilityContext,
-			trigger: "async-buffer"
-		}).run()))?.observed) {
-			const maxTs = this.getMaxMessageTimestamp(messagesToBuffer);
-			const cursor = new Date(maxTs.getTime() + 1);
-			BufferingCoordinator.lastBufferedAtTime.set(bufferKey, cursor);
-		}
+			trigger: "async-buffer",
+			onBufferedChunkPersisted: async () => {
+				const maxTs = this.getMaxMessageTimestamp(messagesToBuffer);
+				BufferingCoordinator.lastBufferedAtTime.set(bufferKey, new Date(maxTs.getTime() + 1));
+				releaseChunkWrite();
+			}
+		}).run());
 	}
 	/**
 	* Trigger async buffered observation if the token count has crossed a new interval.
@@ -36243,8 +36916,8 @@ ${formattedMessages}
 		const { threadId, resourceId, recordId, activatedMessageIds } = opts;
 		const lockKey = this.buffering.getLockKey(threadId, resourceId);
 		const bufKey = this.buffering.getObservationBufferKey(lockKey);
-		BufferingCoordinator.lastBufferedBoundary.set(bufKey, 0);
-		await this.storage.setBufferingObservationFlag(recordId, false, 0).catch(() => {});
+		BufferingCoordinator.setObservationBoundary(bufKey, 0);
+		await runOMCommit(lockKey, () => this.storage.setBufferingObservationFlag(recordId, false, 0)).catch(() => {});
 		if (activatedMessageIds && activatedMessageIds.length > 0) this.buffering.cleanupStaticMaps(threadId, resourceId, activatedMessageIds);
 	}
 	/**
@@ -36403,9 +37076,13 @@ ${formattedMessages}
 	* @example
 	* ```ts
 	* const status = await om.getStatus({ threadId });
-	* if (status.shouldObserve) {
+	* if (status.shouldObserve && status.canActivate) {
+	*   await om.activate({ threadId });
+	* } else if (status.shouldObserve && !status.inAsyncObservationBand) {
+	*   // At/above blockAfter (or async buffering disabled): observe synchronously
 	*   await om.observe({ threadId });
 	* } else if (status.shouldBuffer) {
+	*   // Below the threshold, or in the threshold→blockAfter band: buffer in the background
 	*   await om.buffer({ threadId });
 	* }
 	* if (status.shouldReflect) {
@@ -36435,8 +37112,10 @@ ${formattedMessages}
 		const bufferedChunkCount = bufferedChunks.length;
 		const bufferedChunkTokens = bufferedChunks.reduce((sum, chunk) => sum + (chunk.messageTokens ?? 0), 0);
 		const asyncObservationEnabled = this.buffering.isAsyncObservationEnabled();
+		const observationBlockAfter = asyncObservationEnabled ? this.getEffectiveObservationBlockAfter(record) : void 0;
+		const inAsyncObservationBand = observationBlockAfter !== void 0 && pendingTokens >= threshold && pendingTokens < observationBlockAfter;
 		let shouldBuffer = false;
-		if (asyncObservationEnabled && pendingTokens < threshold) {
+		if (asyncObservationEnabled && (pendingTokens < threshold || inAsyncObservationBand)) {
 			const lockKey = this.buffering.getLockKey(threadId, resourceId);
 			shouldBuffer = this.buffering.shouldTriggerAsyncObservation(pendingTokens, lockKey, record, this.storage, threshold);
 		}
@@ -36461,6 +37140,8 @@ ${formattedMessages}
 			canActivate,
 			asyncObservationEnabled,
 			asyncReflectionEnabled: this.buffering.isAsyncReflectionEnabled(),
+			observationBlockAfter,
+			inAsyncObservationBand,
 			scope: this.scope
 		};
 	}
@@ -36587,24 +37268,27 @@ ${formattedMessages}
 		const currentTokens = opts.pendingTokens ?? record.pendingMessageTokens ?? 0;
 		const lockKey = this.buffering.getLockKey(threadId, resourceId);
 		const bufferKey = this.buffering.getObservationBufferKey(lockKey);
-		BufferingCoordinator.lastBufferedBoundary.set(bufferKey, currentTokens);
-		if (record.isBufferingObservation) await this.storage.setBufferingObservationFlag(record.id, false).catch(() => {});
+		const boundaryOwner = Symbol("observation-boundary");
+		BufferingCoordinator.setObservationBoundary(bufferKey, currentTokens, boundaryOwner);
 		const existingOp = BufferingCoordinator.asyncBufferingOps.get(bufferKey);
+		let resolveOp;
+		const opPromise = new Promise((resolve) => {
+			resolveOp = resolve;
+		});
+		BufferingCoordinator.asyncBufferingOps.set(bufferKey, opPromise);
+		if (record.isBufferingObservation) await runOMCommit(lockKey, () => this.storage.setBufferingObservationFlag(record.id, false)).catch(() => {});
 		if (existingOp) try {
 			await existingOp;
 		} catch {}
-		registerOp(record.id, "bufferingObservation");
+		const opRecordId = record.id;
+		registerOp(opRecordId, "bufferingObservation");
+		const releaseChunkWrite = BufferingCoordinator.trackChunkWrite(bufferKey);
+		const ownsStartBoundary = BufferingCoordinator.ownsObservationBoundary(bufferKey, boundaryOwner);
 		inMemoryRecord.isBufferingObservation = true;
-		inMemoryRecord.lastBufferedAtTokens = currentTokens;
-		this.storage.setBufferingObservationFlag(record.id, true, currentTokens).catch((err) => {
+		if (ownsStartBoundary) inMemoryRecord.lastBufferedAtTokens = currentTokens;
+		runOMCommit(lockKey, () => this.storage.setBufferingObservationFlag(record.id, true, ownsStartBoundary ? currentTokens : void 0)).catch((err) => {
 			omError("[OM] Failed to set buffering observation flag", err);
 		});
-		let resolveOp;
-		const opPromise = new Promise((resolve) => {
-			resolveOp = resolve;
-		});
-		BufferingCoordinator.asyncBufferingOps.set(bufferKey, opPromise);
-		record = await this.storage.getObservationalMemory(record.threadId, record.resourceId) ?? record;
 		const setBufferingState = (isBufferingObservation, lastBufferedAtTokens) => {
 			inMemoryRecord.isBufferingObservation = isBufferingObservation;
 			record.isBufferingObservation = isBufferingObservation;
@@ -36615,6 +37299,7 @@ ${formattedMessages}
 		};
 		let flagCleared = false;
 		try {
+			record = await this.storage.getObservationalMemory(record.threadId, record.resourceId) ?? record;
 			let candidateMessages;
 			if (opts.messages) candidateMessages = this.getUnobservedMessages(opts.messages, record, { excludeBuffered: true });
 			else {
@@ -36654,12 +37339,29 @@ ${formattedMessages}
 				threadIds: [threadId],
 				config: this.getObservationMarkerConfig()
 			});
-			await this.persistMarkerToStorage(startMarker, threadId, record.resourceId ?? void 0);
+			await this.persistMarkerToStorage(startMarker, threadId, record.resourceId ?? void 0, {
+				notAfter: new Date(startedAt),
+				preferMessages: candidateMessages
+			});
 			const writer = opts.writer;
 			if (writer) writer.custom({
 				...startMarker,
 				transient: true
 			}).catch(() => {});
+			let chunkRecorded = false;
+			const recordBufferedChunk = async () => {
+				if (chunkRecorded) return;
+				chunkRecorded = true;
+				const ownsBoundary = BufferingCoordinator.ownsObservationBoundary(bufferKey, boundaryOwner);
+				if (ownsBoundary) BufferingCoordinator.setObservationBoundary(bufferKey, newTokens, boundaryOwner);
+				await runOMCommit(lockKey, () => this.storage.setBufferingObservationFlag(record.id, false, ownsBoundary ? newTokens : void 0)).catch(() => {});
+				flagCleared = true;
+				const stillOwnsBoundary = ownsBoundary && BufferingCoordinator.ownsObservationBoundary(bufferKey, boundaryOwner);
+				setBufferingState(false, stillOwnsBoundary ? newTokens : void 0);
+				const maxTimestamp = this.getMaxMessageTimestamp(candidateMessages);
+				BufferingCoordinator.lastBufferedAtTime.set(bufferKey, new Date(maxTimestamp.getTime() + 1));
+				releaseChunkWrite();
+			};
 			if (!(await this.runBufferedObservationCycle({
 				threadId,
 				resourceId: record.resourceId ?? resourceId,
@@ -36678,7 +37380,8 @@ ${formattedMessages}
 				requestContext,
 				currentModel: opts.currentModel,
 				observabilityContext,
-				trigger: "async-buffer"
+				trigger: "async-buffer",
+				onBufferedChunkPersisted: recordBufferedChunk
 			}).run()))?.observed) return {
 				buffered: false,
 				record
@@ -36698,13 +37401,7 @@ ${formattedMessages}
 					newTokens
 				}
 			});
-			await this.storage.setBufferingObservationFlag(record.id, false, newTokens).catch(() => {});
-			flagCleared = true;
-			setBufferingState(false, newTokens);
-			BufferingCoordinator.lastBufferedBoundary.set(bufferKey, newTokens);
-			const maxTimestamp = this.getMaxMessageTimestamp(candidateMessages);
-			const cursor = new Date(maxTimestamp.getTime() + 1);
-			BufferingCoordinator.lastBufferedAtTime.set(bufferKey, cursor);
+			await recordBufferedChunk();
 			return {
 				buffered: true,
 				record: await this.storage.getObservationalMemory(record.threadId, record.resourceId) ?? record
@@ -36716,12 +37413,13 @@ ${formattedMessages}
 				record
 			};
 		} finally {
-			unregisterOp(record.id, "bufferingObservation");
-			BufferingCoordinator.asyncBufferingOps.delete(bufferKey);
+			releaseChunkWrite();
+			unregisterOp(opRecordId, "bufferingObservation");
+			if (BufferingCoordinator.asyncBufferingOps.get(bufferKey) === opPromise) BufferingCoordinator.asyncBufferingOps.delete(bufferKey);
 			resolveOp();
 			if (!flagCleared) {
 				setBufferingState(false);
-				await this.storage.setBufferingObservationFlag(record.id, false).catch(() => {});
+				await runOMCommit(lockKey, () => this.storage.setBufferingObservationFlag(record.id, false)).catch(() => {});
 			}
 		}
 	}
@@ -36758,8 +37456,8 @@ ${formattedMessages}
 				const currentContextTokens = this.tokenCounter.countMessages(unobserved);
 				if (currentContextTokens < dbBoundary * .5) {
 					omDebug(`[OM:activate] resetting stale lastBufferedBoundary: dbBoundary=${dbBoundary}, currentContextTokens=${currentContextTokens}`);
-					BufferingCoordinator.lastBufferedBoundary.set(bufKey, 0);
-					await this.storage.setBufferingObservationFlag(record.id, false, 0).catch(() => {});
+					BufferingCoordinator.setObservationBoundary(bufKey, 0);
+					await runOMCommit(lockKey, () => this.storage.setBufferingObservationFlag(record.id, false, 0)).catch(() => {});
 				}
 			}
 		}
@@ -36805,39 +37503,63 @@ ${formattedMessages}
 				livePendingTokens ??= status.pendingTokens;
 			}
 		}
-		if (record.isBufferingObservation) {
-			const lockKey = this.buffering.getLockKey(threadId, resourceId);
-			const bufferKey = this.buffering.getObservationBufferKey(lockKey);
-			const asyncOp = BufferingCoordinator.asyncBufferingOps.get(bufferKey);
-			if (asyncOp) try {
-				await Promise.race([asyncOp, new Promise((_, reject) => setTimeout(() => reject(/* @__PURE__ */ new Error("Timeout")), 6e4))]);
-			} catch {}
+		const obsBufferKey = this.buffering.getObservationBufferKey(this.buffering.getLockKey(threadId, resourceId));
+		const pendingChunkWrite = BufferingCoordinator.pendingChunkWrites.get(obsBufferKey);
+		if (pendingChunkWrite) {
+			const blockAfter = this.buffering.isAsyncObservationEnabled() ? this.getEffectiveObservationBlockAfter(record) : void 0;
+			const threshold = calculateDynamicThreshold(this.getEffectiveMessageTokens(record), record.observationTokenCount ?? 0);
+			if (activationTriggeredBy === "threshold" && !(livePendingTokens !== void 0 && blockAfter !== void 0 && livePendingTokens >= threshold && livePendingTokens < blockAfter)) {
+				let timeoutId;
+				await Promise.race([pendingChunkWrite, new Promise((resolve) => timeoutId = setTimeout(resolve, 6e4))]);
+				clearTimeout(timeoutId);
+			}
+		}
+		const commitKey = this.buffering.getLockKey(threadId, resourceId);
+		let freshRecord = null;
+		let freshChunks = [];
+		let activationResult;
+		for (let attempt = 0; attempt <= MAX_ACTIVATION_RETIRED_RETRIES; attempt++) {
+			const swapped = await runOMCommit(commitKey, async () => {
+				const head = await this.storage.getObservationalMemory(record.threadId, record.resourceId);
+				if (!head) return null;
+				const chunks = getBufferedChunks(head);
+				if (!chunks.length) return null;
+				const messageTokensThreshold = getMaxThreshold(this.getEffectiveMessageTokens(head));
+				const activationRatio = resolveActivationRatio(this.observationConfig.bufferActivation ?? .7, messageTokensThreshold);
+				const totalChunkMessageTokens = chunks.reduce((sum, c) => sum + (c.messageTokens ?? 0), 0);
+				const currentPendingTokens = livePendingTokens ?? (head.pendingMessageTokens || totalChunkMessageTokens);
+				const blockAfter = this.getEffectiveObservationBlockAfter(head);
+				const forceMaxActivation = !!(blockAfter && currentPendingTokens >= blockAfter);
+				if (head.pendingMessageTokens !== currentPendingTokens) await this.storage.setPendingMessageTokens(head.id, currentPendingTokens);
+				return {
+					head,
+					chunks,
+					result: await this.storage.swapBufferedToActive({
+						id: head.id,
+						activationRatio,
+						messageTokensThreshold,
+						currentPendingTokens,
+						forceMaxActivation,
+						bufferedChunks: chunks
+					})
+				};
+			});
+			if (!swapped) return {
+				activated: false,
+				record
+			};
+			freshRecord = swapped.head;
+			freshChunks = swapped.chunks;
+			activationResult = swapped.result;
+			if (!activationResult.retired) break;
+			omDebug(`[OM:activate] record ${freshRecord.id} was retired by a reflection; retrying on the head`);
 		}
-		const freshRecord = await this.storage.getObservationalMemory(record.threadId, record.resourceId);
-		if (!freshRecord) return {
+		if (!freshRecord || !activationResult || activationResult.retired) return {
 			activated: false,
-			record
+			record: await this.getRecord(threadId, resourceId) ?? record
 		};
-		const freshChunks = getBufferedChunks(freshRecord);
-		if (!freshChunks.length) return {
-			activated: false,
-			record
-		};
-		const messageTokensThreshold = getMaxThreshold(this.getEffectiveMessageTokens(freshRecord));
-		const activationRatio = resolveActivationRatio(this.observationConfig.bufferActivation ?? .7, messageTokensThreshold);
-		const totalChunkMessageTokens = freshChunks.reduce((sum, c) => sum + (c.messageTokens ?? 0), 0);
-		const currentPendingTokens = livePendingTokens ?? (freshRecord.pendingMessageTokens || totalChunkMessageTokens);
-		const forceMaxActivation = !!(this.observationConfig.blockAfter && currentPendingTokens >= this.observationConfig.blockAfter);
-		if (freshRecord.pendingMessageTokens !== currentPendingTokens) await this.storage.setPendingMessageTokens(freshRecord.id, currentPendingTokens);
-		const activationResult = await this.storage.swapBufferedToActive({
-			id: freshRecord.id,
-			activationRatio,
-			messageTokensThreshold,
-			currentPendingTokens,
-			forceMaxActivation,
-			bufferedChunks: freshChunks
-		});
-		await this.storage.setBufferingObservationFlag(freshRecord.id, false).catch(() => {});
+		const swappedRecordId = freshRecord.id;
+		await runOMCommit(commitKey, () => this.storage.setBufferingObservationFlag(swappedRecordId, false)).catch(() => {});
 		unregisterOp(freshRecord.id, "bufferingObservation");
 		const postSwapRecord = await this.storage.getObservationalMemory(record.threadId, record.resourceId);
 		if (opts.writer && postSwapRecord && activationResult.activatedCycleIds.length > 0) {
@@ -37082,7 +37804,7 @@ ${formattedMessages}
 	* ```
 	*/
 	async reflect(threadId, resourceId, prompt, requestContext, observabilityContext) {
-		const record = await this.getOrCreateRecord(threadId, resourceId);
+		const record = { ...await this.getOrCreateRecord(threadId, resourceId) };
 		if (!record.activeObservations) return {
 			reflected: false,
 			record,
@@ -37127,11 +37849,23 @@ ${formattedMessages}
 			const reflectResult = await this.reflector.call(await applyTextTransform(this.hooks, "beforeReflection", record.activeObservations, hookContext), prompt, void 0, reflectThreshold, void 0, void 0, void 0, requestContext, priorExtractedValues, observabilityContext, void 0);
 			reflectResult.observations = await applyTextTransform(this.hooks, "afterReflection", reflectResult.observations, hookContext);
 			const reflectionTokenCount = this.tokenCounter.countObservations(reflectResult.observations);
-			await this.storage.createReflectionGeneration({
+			const newRecordId = crypto.randomUUID();
+			const committedRecord = await runOMCommit(this.buffering.getLockKey(threadId, resourceId), () => this.storage.createReflectionGeneration({
 				currentRecord: record,
 				reflection: reflectResult.observations,
-				tokenCount: reflectionTokenCount
-			});
+				tokenCount: reflectionTokenCount,
+				newRecordId
+			}), { priority: "reflection" });
+			reflectionUsage = reflectResult.usage;
+			reflectionProviderMetadata = reflectResult.providerMetadata;
+			if (!isReflectionApplied(committedRecord, newRecordId, record.id)) {
+				omDebug(`[OM:reflect] manual reflection of ${record.id} not applied (head is ${committedRecord.id})`);
+				return {
+					reflected: false,
+					record: await this.getOrCreateRecord(threadId, resourceId),
+					usage: reflectResult.usage
+				};
+			}
 			if (thread && reflectResult.extractedValues) {
 				const metadataUpdate = buildThreadMetadataFromExtractedValues(this.reflectionConfig.extractors, reflectResult.extractedValues);
 				const newMetadata = (0, _mastra_core_memory.setThreadOMMetadata)(thread.metadata, {
@@ -37220,11 +37954,13 @@ ${formattedMessages}
 	*/
 	async updateRecordConfig(threadId, resourceId, config) {
 		const ids = this.getStorageIds(threadId, resourceId);
-		const record = await this.storage.getObservationalMemory(ids.threadId, ids.resourceId);
-		if (!record) throw new Error(`No observational memory record found for thread ${ids.threadId}`);
-		await this.storage.updateObservationalMemoryConfig({
-			id: record.id,
-			config: { _overrides: config }
+		await runOMCommit(this.buffering.getLockKey(threadId, resourceId), async () => {
+			const record = await this.storage.getObservationalMemory(ids.threadId, ids.resourceId);
+			if (!record) throw new Error(`No observational memory record found for thread ${ids.threadId}`);
+			await this.storage.updateObservationalMemoryConfig({
+				id: record.id,
+				config: { _overrides: config }
+			});
 		});
 	}
 	/**
@@ -37614,7 +38350,7 @@ var ObservationalMemoryProcessor = class {
 				});
 				const finalTotalPending = ctx.status.pendingTokens;
 				try {
-					await this.engine.getStorage().setPendingMessageTokens(turnRecord.id, finalTotalPending);
+					await runOMCommit(this.engine.buffering.getLockKey(threadId, resourceId), () => this.engine.getStorage().setPendingMessageTokens(turnRecord.id, finalTotalPending));
 					this.turn.patchRecord({ pendingMessageTokens: finalTotalPending });
 				} catch {}
 				if (reproCaptureEnabled) writeProcessInputStepReproCapture({
@@ -39928,6 +40664,7 @@ Notes:
 		cloned.id = crypto.randomUUID();
 		cloned.createdAt = now;
 		cloned.updatedAt = now;
+		cloned.supersededBy = null;
 		await memoryStore.insertObservationalMemoryRecord(cloned);
 	}
 	/**
@@ -51002,4 +51739,4 @@ const agentBuilderWorkflows = {
 //#endregion
 exports.agentBuilderWorkflows = agentBuilderWorkflows;
 
-//# sourceMappingURL=dist-C8tgsOw_.cjs.map
+//# sourceMappingURL=dist-BOW7V2e6.cjs.map