@mastra/memory 0.0.0-studio-deploy-20260404182525 → 0.0.0-studio-cli-20260504022012

package/dist/{chunk-4FMHSWZD.cjs → chunk-6ODYOMHN.cjs}

@@ -12,9 +12,9 @@ var crypto$1 = require('crypto');
 var tokenx = require('tokenx');
 var agent = require('@mastra/core/agent');
 var observability = require('@mastra/core/observability');
+var util = require('util');
 var async_hooks = require('async_hooks');
 var imageSize = require('image-size');
-var util = require('util');
 
 function _interopDefault (e) { return e && e.__esModule ? e : { default: e }; }
 
@@ -208,6 +208,19 @@ var BufferingCoordinator = class _BufferingCoordinator {
   }
 };
 
+// src/processors/observational-memory/model-context.ts
+function didProviderChange(actorModel, lastModel) {
+  if (actorModel === void 0 || lastModel === void 0) return false;
+  const actorHasSlash = actorModel.includes("/");
+  const lastHasSlash = lastModel.includes("/");
+  if (actorHasSlash && lastHasSlash) {
+    return actorModel !== lastModel;
+  }
+  const actorModelId = actorHasSlash ? actorModel.slice(actorModel.indexOf("/") + 1) : actorModel;
+  const lastModelId = lastHasSlash ? lastModel.slice(lastModel.indexOf("/") + 1) : lastModel;
+  return actorModelId !== lastModelId;
+}
+
 // src/processors/observational-memory/date-utils.ts
 function formatRelativeTime(date, currentDate) {
   const diffMs = currentDate.getTime() - date.getTime();
@@ -372,6 +385,67 @@ ${gap}
   result += withInlineDates.slice(lastIndex);
   return result;
 }
+var MIN_TEMPORAL_GAP_MS = 10 * 60 * 1e3;
+function formatTemporalGap(diffMs) {
+  if (diffMs < MIN_TEMPORAL_GAP_MS) return null;
+  const minute = 60 * 1e3;
+  const hour = 60 * minute;
+  const day = 24 * hour;
+  const week = 7 * day;
+  const month = 30 * day;
+  const year = 365 * day;
+  const formatUnit = (value, unit) => `${value} ${unit}${value === 1 ? "" : "s"}`;
+  if (diffMs < hour) {
+    const minutes = Math.max(1, Math.round(diffMs / minute));
+    return `${formatUnit(minutes, "minute")} later`;
+  }
+  const formatTwoUnits = (primaryMs, primaryUnit, secondaryMs, secondaryUnit) => {
+    const primary = Math.floor(diffMs / primaryMs);
+    const remainder = diffMs - primary * primaryMs;
+    const secondary = Math.floor(remainder / secondaryMs);
+    const parts = [formatUnit(primary, primaryUnit)];
+    if (secondary > 0) {
+      parts.push(formatUnit(secondary, secondaryUnit));
+    }
+    return `${parts.join(" ")} later`;
+  };
+  if (diffMs < day) {
+    return formatTwoUnits(hour, "hour", minute, "minute");
+  }
+  if (diffMs < week) {
+    return formatTwoUnits(day, "day", hour, "hour");
+  }
+  if (diffMs < month) {
+    return formatTwoUnits(week, "week", day, "day");
+  }
+  if (diffMs < year) {
+    return formatTwoUnits(month, "month", week, "week");
+  }
+  return formatTwoUnits(year, "year", month, "month");
+}
+function formatTemporalTimestamp(date) {
+  return date.toLocaleString("en-US", {
+    year: "numeric",
+    month: "2-digit",
+    day: "2-digit",
+    hour: "numeric",
+    minute: "2-digit",
+    hour12: true,
+    timeZoneName: "short"
+  });
+}
+function getMessagePartTimestamp(msg, position) {
+  const timestamps = msg.content?.parts?.map((part) => "createdAt" in part ? part.createdAt : void 0).filter((timestamp) => typeof timestamp === "number");
+  if (timestamps && timestamps.length > 0) {
+    const index = position === "first" ? 0 : timestamps.length - 1;
+    const timestamp = timestamps[index];
+    if (timestamp !== void 0) return timestamp;
+  }
+  return new Date(msg.createdAt).getTime();
+}
+function isTemporalGapMarker(msg) {
+  return msg.id.startsWith("__temporal_");
+}
 
 // src/processors/observational-memory/markers.ts
 function createObservationStartMarker(params) {
@@ -491,7 +565,12 @@ function createActivationMarker(params) {
       threadId: params.threadId,
       generationCount: params.generationCount,
       config: params.config,
-      observations: params.observations
+      observations: params.observations,
+      triggeredBy: params.triggeredBy,
+      lastActivityAt: params.lastActivityAt,
+      ttlExpiredMs: params.ttlExpiredMs,
+      previousModel: params.previousModel,
+      currentModel: params.currentModel
     }
   };
 }
@@ -641,7 +720,7 @@ function sortThreadsByOldestMessage(messagesByThread) {
   })).sort((a, b) => a.oldestTimestamp - b.oldestTimestamp).map((t) => t.threadId);
 }
 function stripThreadTags(observations) {
-  return observations.replace(/<thread[^>]*>|<\/thread>/gi, "").trim();
+  return observations.replace(/<\/?thread\b[^>]{0,1024}>/gi, "").trim();
 }
 
 // src/processors/observational-memory/model-by-input-tokens.ts
@@ -941,6 +1020,8 @@ var ObservationStrategy = class _ObservationStrategy {
     this.scope = deps.scope;
     this.retrieval = deps.retrieval;
   }
+  deps;
+  opts;
   storage;
   messageHistory;
   tokenCounter;
@@ -952,7 +1033,7 @@ var ObservationStrategy = class _ObservationStrategy {
   static create;
   /**
    * Run the full observation lifecycle.
-   * @returns `true` if a full observation cycle completed; `false` if skipped (stale lock) or async-buffer failure was swallowed.
+   * @returns Result with `observed` flag and optional `usage` from the observer LLM call.
    * @throws On sync/resource-scoped observer failure after failed markers (same as pre–Option-A contract).
    */
   async run() {
@@ -962,7 +1043,7 @@ var ObservationStrategy = class _ObservationStrategy {
       if (this.needsLock) {
         const fresh = await this.storage.getObservationalMemory(record.threadId, record.resourceId);
         if (fresh?.lastObservedAt && record.lastObservedAt && fresh.lastObservedAt > record.lastObservedAt) {
-          return false;
+          return { observed: false };
         }
       }
       const { messages, existingObservations } = await this.prepare();
@@ -983,7 +1064,7 @@ var ObservationStrategy = class _ObservationStrategy {
           observabilityContext: this.opts.observabilityContext
         });
       }
-      return true;
+      return { observed: true, usage: output.usage };
     } catch (error) {
       await this.emitFailedMarkers(cycleId, error);
       if (!this.rethrowOnFailure) {
@@ -1002,7 +1083,7 @@ var ObservationStrategy = class _ObservationStrategy {
         });
         if (abortSignal?.aborted) throw error;
         omError("[OM] Observation failed", error);
-        return false;
+        return { observed: false };
       }
       omError("[OM] Observation failed", error);
       throw error;
@@ -1014,9 +1095,11 @@ var ObservationStrategy = class _ObservationStrategy {
   }
   async streamMarker(marker) {
     if (this.opts.writer) {
-      await this.opts.writer.custom(marker).catch(() => {
+      await this.opts.writer.custom({ ...marker, transient: true }).catch(() => {
       });
     }
+    const markerThreadId = marker.data?.threadId ?? this.opts.threadId;
+    await this.persistMarkerToStorage(marker, markerThreadId, this.opts.resourceId);
   }
   getObservationMarkerConfig() {
     return {
@@ -1522,7 +1605,7 @@ var AsyncBufferObservationStrategy = class extends ObservationStrategy {
     }
   }
   async emitEndMarkers(_cycleId, processed) {
-    if (!processed.observations || !this.opts.writer) return;
+    if (!processed.observations) return;
     const { record, threadId, messages } = this.opts;
     const tokensBuffered = await this.tokenCounter.countMessagesAsync(messages);
     const updatedRecord = await this.storage.getObservationalMemory(record.threadId, record.resourceId);
@@ -1538,12 +1621,13 @@ var AsyncBufferObservationStrategy = class extends ObservationStrategy {
       threadId,
       observations: processed.observations
     });
-    void this.opts.writer.custom(endMarker).catch(() => {
-    });
+    if (this.opts.writer) {
+      void this.opts.writer.custom({ ...endMarker, transient: true }).catch(() => {
+      });
+    }
     await this.persistMarkerToStorage(endMarker, threadId, record.resourceId ?? void 0);
   }
   async emitFailedMarkers(_cycleId, error) {
-    if (!this.opts.writer) return;
     const { record, threadId, messages } = this.opts;
     const tokensAttempted = await this.tokenCounter.countMessagesAsync(messages);
     const failedMarker = createBufferingFailedMarker({
@@ -1555,8 +1639,10 @@ var AsyncBufferObservationStrategy = class extends ObservationStrategy {
       recordId: record.id,
       threadId
     });
-    void this.opts.writer.custom(failedMarker).catch(() => {
-    });
+    if (this.opts.writer) {
+      void this.opts.writer.custom({ ...failedMarker, transient: true }).catch(() => {
+      });
+    }
     await this.persistMarkerToStorage(failedMarker, threadId, record.resourceId ?? void 0);
   }
 };
@@ -1947,6 +2033,8 @@ var ObservationStep = class {
     this.turn = turn;
     this.stepNumber = stepNumber;
   }
+  turn;
+  stepNumber;
   _prepared = false;
   _context;
   /** Whether this step has been prepared. */
@@ -1982,6 +2070,7 @@ var ObservationStep = class {
         resourceId,
         checkThreshold: true,
         messages: step0Messages,
+        currentModel: this.turn.actorModelContext,
         writer: this.turn.writer,
         messageList
       });
@@ -2005,8 +2094,11 @@ var ObservationStep = class {
         observationTokens: obsTokens,
         threadId,
         writer: this.turn.writer,
+        messageList,
+        currentModel: this.turn.actorModelContext,
         requestContext: this.turn.requestContext,
-        observabilityContext: this.turn.observabilityContext
+        observabilityContext: this.turn.observabilityContext,
+        lastActivityAt: getLastActivityFromMessages(messageList.get.all.db())
       });
       await this.turn.refreshRecord();
       if (this.turn.record.generationCount > preReflectGeneration) {
@@ -2015,7 +2107,11 @@ var ObservationStep = class {
     }
     const allMsgsForToolCheck = messageList.get.all.db();
     const lastMessage = allMsgsForToolCheck[allMsgsForToolCheck.length - 1];
-    const latestStepParts = getLatestStepParts(lastMessage?.content?.parts ?? []);
+    const pendingStepMessages = [...messageList.get.input.db(), ...messageList.get.response.db()];
+    const latestStepParts = [
+      ...getLatestStepParts(lastMessage?.content?.parts ?? []),
+      ...pendingStepMessages.flatMap((msg) => getLatestStepParts(msg.content?.parts ?? []))
+    ];
     const hasIncompleteToolCalls = latestStepParts.some(
       (part) => part?.type === "tool-invocation" && part.toolInvocation?.state === "call"
     );
@@ -2170,6 +2266,7 @@ var ObservationStep = class {
         threadId,
         resourceId,
         messages: messageList.get.all.db(),
+        currentModel: this.turn.actorModelContext,
         writer: this.turn.writer,
         messageList
       });
@@ -2181,8 +2278,10 @@ var ObservationStep = class {
           threadId,
           writer: this.turn.writer,
           messageList,
+          currentModel: this.turn.actorModelContext,
           requestContext: this.turn.requestContext,
-          observabilityContext: this.turn.observabilityContext
+          observabilityContext: this.turn.observabilityContext,
+          lastActivityAt: getLastActivityFromMessages(messageList.get.all.db())
         });
         return {
           succeeded: true,
@@ -2199,6 +2298,31 @@ var ObservationStep = class {
       writer: this.turn.writer,
       observabilityContext: this.turn.observabilityContext
     });
+    if (obsResult.observed) {
+      const observedMessageIds = new Set(obsResult.record.observedMessageIds ?? []);
+      const liveMessages = messageList.get.all.db();
+      let latestObservedIndex = -1;
+      for (let i = liveMessages.length - 1; i >= 0; i--) {
+        const message = liveMessages[i];
+        if (message && observedMessageIds.has(message.id)) {
+          latestObservedIndex = i;
+          break;
+        }
+      }
+      const messageToSeal = latestObservedIndex >= 0 ? liveMessages[latestObservedIndex] : void 0;
+      const messagesToSeal = messageToSeal ? [messageToSeal] : [];
+      om.sealMessagesForBuffering(messagesToSeal);
+      try {
+        await this.turn.hooks?.onSyncObservationComplete?.();
+      } catch (error) {
+        omDebug(
+          `[OM:observe] onSyncObservationComplete hook failed: ${error instanceof Error ? error.message : String(error)}`
+        );
+      }
+      if (messagesToSeal.length > 0) {
+        await om.persistMessages(messagesToSeal, threadId, resourceId);
+      }
+    }
     return {
       succeeded: obsResult.observed,
       record: obsResult.record,
@@ -2224,7 +2348,9 @@ var ObservationTurn = class {
   requestContext;
   /** Optional observability context for nested OM spans. */
   observabilityContext;
-  /** Optional processor-provided hooks for turn/step lifecycle integration. */
+  /** Current actor model for this step. Updated by the processor before prepare(). */
+  actorModelContext;
+  /** Processor-provided hooks for turn/step lifecycle integration. */
   hooks;
   constructor(opts) {
     this.om = opts.om;
@@ -2232,7 +2358,7 @@ var ObservationTurn = class {
     this.resourceId = opts.resourceId;
     this.messageList = opts.messageList;
     this.observabilityContext = opts.observabilityContext;
-    this.hooks = opts.hooks;
+    this.hooks = opts.hooks ?? {};
   }
   om;
   threadId;
@@ -2252,6 +2378,10 @@ var ObservationTurn = class {
   get currentStep() {
     return this._currentStep;
   }
+  addHooks(hooks) {
+    if (!hooks) return;
+    Object.assign(this.hooks, hooks);
+  }
   /**
    * Load context and cache the record. Call once at the start of the turn.
    *
@@ -2408,6 +2538,15 @@ function stripEphemeralAnchorIds(observations) {
   }
   return observations.replace(/(^|\n)([^\S\n]*)\[(O\d+(?:-N\d+)?)\][^\S\n]*/g, "$1$2");
 }
+
+// src/processors/observational-memory/string-utils.ts
+function safeSlice(str, end) {
+  if (end <= 0) return "";
+  if (end >= str.length) return str;
+  const code = str.charCodeAt(end - 1);
+  const safeEnd = code >= 55296 && code <= 56319 ? end - 1 : end;
+  return str.slice(0, safeEnd);
+}
 var ENCRYPTED_CONTENT_KEY = "encryptedContent";
 var ENCRYPTED_CONTENT_REDACTION_THRESHOLD = 256;
 var DEFAULT_OBSERVER_TOOL_RESULT_MAX_TOKENS = 1e4;
@@ -2473,7 +2612,7 @@ function truncateStringByTokens(text, maxTokens) {
     return text;
   }
   const buildCandidate = (sliceEnd) => {
-    const visible = text.slice(0, sliceEnd);
+    const visible = safeSlice(text, sliceEnd);
     return `${visible}
 ... [truncated ~${totalTokens - tokenx.estimateTokenCount(visible)} tokens]`;
   };
@@ -2929,11 +3068,13 @@ var OBSERVER_IMAGE_FILE_EXTENSIONS = /* @__PURE__ */ new Set([
   "heif",
   "avif"
 ]);
-function formatObserverTimestamp(createdAt) {
-  return createdAt ? new Date(createdAt).toLocaleString("en-US", {
-    year: "numeric",
-    month: "short",
-    day: "numeric",
+function formatObserverDate(createdAt) {
+  return createdAt ? `${createdAt.toLocaleDateString("en-US", {
+    month: "short"
+  })} ${createdAt.getDate()} ${createdAt.getFullYear()}` : "";
+}
+function formatObserverTime(createdAt) {
+  return createdAt ? createdAt.toLocaleTimeString("en-US", {
     hour: "numeric",
     minute: "2-digit",
     hour12: true
@@ -3024,19 +3165,88 @@ function formatObserverAttachmentPlaceholder(part, counter) {
   const label = resolveObserverAttachmentLabel(part);
   return label ? `[${attachmentType} #${attachmentId}: ${label}]` : `[${attachmentType} #${attachmentId}]`;
 }
+function formatObserverPartLine(title, body, time, previousTime) {
+  const timeLabel = time && time !== previousTime ? `(${time})` : "";
+  if (!title) {
+    return timeLabel ? `${timeLabel}: ${body}` : body;
+  }
+  return `${title}${timeLabel ? ` ${timeLabel}` : ""}: ${body}`;
+}
+function normalizeObserverCreatedAt(createdAt) {
+  if (createdAt instanceof Date) {
+    if (Number.isNaN(createdAt.getTime())) {
+      return void 0;
+    }
+    return createdAt;
+  }
+  if (typeof createdAt === "number" || typeof createdAt === "string") {
+    const date = new Date(createdAt);
+    if (Number.isNaN(date.getTime())) {
+      return void 0;
+    }
+    return date;
+  }
+  return void 0;
+}
+function formatObserverLines(lines, context = {}) {
+  const output = [];
+  let previousDate = context.previousDate;
+  let previousTime = context.previousTime;
+  for (const line of lines) {
+    if (line.date && line.date !== previousDate) {
+      output.push(`${line.date}:`);
+      previousDate = line.date;
+      previousTime = void 0;
+    }
+    output.push(formatObserverPartLine(line.title, line.body, line.time, previousTime));
+    previousTime = line.time || previousTime;
+  }
+  return {
+    text: output.join("\n"),
+    context: { previousDate, previousTime }
+  };
+}
+function getTemporalGapMarkerText(msg) {
+  const metadata = typeof msg.content === "object" && msg.content && "metadata" in msg.content ? msg.content.metadata : void 0;
+  if (metadata?.reminderType === "temporal-gap" && typeof metadata.gapText === "string") {
+    return metadata.gapText;
+  }
+  if (typeof metadata?.systemReminder === "object" && metadata.systemReminder && "type" in metadata.systemReminder && metadata.systemReminder.type === "temporal-gap" && "gapText" in metadata.systemReminder && typeof metadata.systemReminder.gapText === "string") {
+    return metadata.systemReminder.gapText;
+  }
+  return void 0;
+}
 function formatObserverMessage(msg, counter, options) {
   const maxLen = options?.maxPartLength;
   const maxToolResultTokens = options?.maxToolResultTokens ?? DEFAULT_OBSERVER_TOOL_RESULT_MAX_TOKENS;
-  const timestamp = formatObserverTimestamp(msg.createdAt);
   const role = msg.role.charAt(0).toUpperCase() + msg.role.slice(1);
-  const timestampStr = timestamp ? ` (${timestamp})` : "";
   const attachments = [];
-  let content = "";
-  if (typeof msg.content === "string") {
-    content = maybeTruncate(msg.content, maxLen);
+  const messageCreatedAt = normalizeObserverCreatedAt(msg.createdAt);
+  let lines = [];
+  const temporalGapText = isTemporalGapMarker(msg) ? getTemporalGapMarkerText(msg) : void 0;
+  const pushLine = (title, body, createdAt) => {
+    if (!body) {
+      return;
+    }
+    const normalizedCreatedAt = normalizeObserverCreatedAt(createdAt) ?? messageCreatedAt;
+    lines.push({
+      date: formatObserverDate(normalizedCreatedAt),
+      time: formatObserverTime(normalizedCreatedAt),
+      title,
+      body
+    });
+  };
+  if (temporalGapText) {
+    pushLine("", temporalGapText, messageCreatedAt);
+  } else if (typeof msg.content === "string") {
+    pushLine(role, maybeTruncate(msg.content, maxLen), messageCreatedAt);
   } else if (msg.content?.parts && Array.isArray(msg.content.parts) && msg.content.parts.length > 0) {
-    content = msg.content.parts.map((part) => {
-      if (part.type === "text") return maybeTruncate(part.text, maxLen);
+    msg.content.parts.forEach((part) => {
+      const partCreatedAt = normalizeObserverCreatedAt(part.createdAt) ?? messageCreatedAt;
+      if (part.type === "text") {
+        pushLine(role, maybeTruncate(part.text, maxLen), partCreatedAt);
+        return;
+      }
       if (part.type === "tool-invocation") {
         const inv = part.toolInvocation;
         if (inv.state === "result") {
@@ -3044,19 +3254,24 @@ function formatObserverMessage(msg, counter, options) {
             part,
             inv.result
           );
-          const resultStr = formatToolResultForObserver(resultForObserver, { maxTokens: maxToolResultTokens });
-          return `[Tool Result: ${inv.toolName}]
-${maybeTruncate(resultStr, maxLen)}`;
+          pushLine(
+            `Tool Result ${inv.toolName}`,
+            maybeTruncate(formatToolResultForObserver(resultForObserver, { maxTokens: maxToolResultTokens }), maxLen),
+            partCreatedAt
+          );
+          return;
         }
-        const argsStr = JSON.stringify(inv.args, null, 2);
-        return `[Tool Call: ${inv.toolName}]
-${maybeTruncate(argsStr, maxLen)}`;
+        pushLine(`Tool Call ${inv.toolName}`, maybeTruncate(JSON.stringify(inv.args, null, 2), maxLen), partCreatedAt);
+        return;
       }
       const partType = part.type;
       if (partType === "reasoning") {
         const reasoning = part.reasoning;
-        if (reasoning) return maybeTruncate(reasoning, maxLen);
-        return "";
+        if (!reasoning) {
+          return;
+        }
+        pushLine("Reasoning", maybeTruncate(reasoning, maxLen), partCreatedAt);
+        return;
       }
       if (partType === "image" || partType === "file") {
         const attachment = part;
@@ -3064,40 +3279,58 @@ ${maybeTruncate(argsStr, maxLen)}`;
         if (inputAttachment) {
           attachments.push(inputAttachment);
         }
-        return formatObserverAttachmentPlaceholder(attachment, counter);
+        pushLine(
+          partType === "image" ? "Image" : "File",
+          formatObserverAttachmentPlaceholder(attachment, counter),
+          partCreatedAt
+        );
       }
-      if (partType?.startsWith("data-")) return "";
-      return "";
-    }).filter(Boolean).join("\n");
+    });
   } else if (msg.content?.content) {
-    content = maybeTruncate(msg.content.content, maxLen);
+    pushLine(role, maybeTruncate(msg.content.content, maxLen), messageCreatedAt);
   }
-  if (!content && attachments.length === 0) {
-    return { text: "", attachments };
+  if (lines.length === 0 && attachments.length === 0) {
+    return { lines: [], attachments };
   }
   return {
-    text: `**${role}${timestampStr}:**
-${content}`,
+    lines,
     attachments
   };
 }
 function formatMessagesForObserver(messages, options) {
   const counter = { nextImageId: 1, nextFileId: 1 };
-  return messages.map((msg) => formatObserverMessage(msg, counter, options).text).filter(Boolean).join("\n\n---\n\n");
+  const sections = [];
+  let context = {};
+  for (const message of messages) {
+    const formatted = formatObserverMessage(message, counter, options);
+    if (formatted.lines.length === 0) {
+      continue;
+    }
+    const rendered = formatObserverLines(formatted.lines, context);
+    if (!rendered.text) {
+      continue;
+    }
+    sections.push(rendered.text);
+    context = rendered.context;
+  }
+  return sections.join("\n");
+}
+function appendFormattedObserverMessage(content, formatted, context) {
+  const rendered = formatObserverLines(formatted.lines, context);
+  if (rendered.text) {
+    content.push({ type: "text", text: rendered.text });
+  }
+  content.push(...formatted.attachments);
+  return rendered.context;
 }
 function buildObserverHistoryMessage(messages, options) {
   const counter = { nextImageId: 1, nextFileId: 1 };
   const content = [{ type: "text", text: "## New Message History to Observe\n\n" }];
-  let visibleCount = 0;
+  let context = {};
   messages.forEach((message) => {
     const formatted = formatObserverMessage(message, counter, options);
-    if (!formatted.text && formatted.attachments.length === 0) return;
-    if (visibleCount > 0) {
-      content.push({ type: "text", text: "\n\n---\n\n" });
-    }
-    content.push({ type: "text", text: formatted.text });
-    content.push(...formatted.attachments);
-    visibleCount++;
+    if (formatted.lines.length === 0 && formatted.attachments.length === 0) return;
+    context = appendFormattedObserverMessage(content, formatted, context);
   });
   return {
     role: "user",
@@ -3106,8 +3339,8 @@ function buildObserverHistoryMessage(messages, options) {
 }
 function maybeTruncate(str, maxLen) {
   if (!maxLen || str.length <= maxLen) return str;
-  const truncated = str.slice(0, maxLen);
-  const remaining = str.length - maxLen;
+  const truncated = safeSlice(str, maxLen);
+  const remaining = str.length - truncated.length;
   return `${truncated}
 ... [truncated ${remaining} characters]`;
 }
@@ -3127,18 +3360,15 @@ The following messages are from ${threadOrder.length} different conversation thr
     const messages = messagesByThread.get(threadId);
     if (!messages || messages.length === 0) return;
     const threadContent = [];
-    let visibleCount = 0;
+    let context = {};
+    let hasVisibleContent = false;
     messages.forEach((message) => {
       const formatted = formatObserverMessage(message, counter, options);
-      if (!formatted.text && formatted.attachments.length === 0) return;
-      if (visibleCount > 0) {
-        threadContent.push({ type: "text", text: "\n\n---\n\n" });
-      }
-      threadContent.push({ type: "text", text: formatted.text });
-      threadContent.push(...formatted.attachments);
-      visibleCount++;
+      if (formatted.lines.length === 0 && formatted.attachments.length === 0) return;
+      context = appendFormattedObserverMessage(threadContent, formatted, context);
+      hasVisibleContent = true;
     });
-    if (visibleCount === 0) return;
+    if (!hasVisibleContent) return;
     content.push({ type: "text", text: `<thread id="${threadId}">
 ` });
     content.push(...threadContent);
@@ -3414,7 +3644,7 @@ function sanitizeObservationLines(observations) {
   let changed = false;
   for (let i = 0; i < lines.length; i++) {
     if (lines[i].length > MAX_OBSERVATION_LINE_CHARS) {
-      lines[i] = lines[i].slice(0, MAX_OBSERVATION_LINE_CHARS) + " \u2026 [truncated]";
+      lines[i] = safeSlice(lines[i], MAX_OBSERVATION_LINE_CHARS) + " \u2026 [truncated]";
       changed = true;
     }
   }
@@ -4017,12 +4247,44 @@ function validateCompression(reflectedTokens, targetThreshold) {
 }
 
 // src/processors/observational-memory/reflector-runner.ts
+function formatModelContext(provider, modelId) {
+  if (provider && modelId) {
+    return `${provider}/${modelId}`;
+  }
+  return modelId;
+}
+function getCurrentModel(model) {
+  return formatModelContext(model?.provider, model?.modelId);
+}
+function getLastModelFromMessageList(messageList) {
+  const messages = messageList?.get.all.db();
+  if (!messages) return void 0;
+  for (let i = messages.length - 1; i >= 0; i--) {
+    const message = messages[i];
+    if (!message || message.role !== "assistant" || !message.content || typeof message.content === "string") {
+      continue;
+    }
+    for (let j = message.content.parts.length - 1; j >= 0; j--) {
+      const part = message.content.parts[j];
+      if (part?.type === "step-start" && typeof part.model === "string" && part.model.length > 0) {
+        return part.model;
+      }
+    }
+    const metadata = message.content.metadata;
+    const model = formatModelContext(metadata?.provider, metadata?.modelId);
+    if (model) {
+      return model;
+    }
+  }
+  return void 0;
+}
 async function withAbortCheck(fn, abortSignal) {
   if (abortSignal?.aborted) throw new Error("The operation was aborted.");
   const result = await fn();
   if (abortSignal?.aborted) throw new Error("The operation was aborted.");
   return result;
 }
+var EARLY_ACTIVATION_SIZE_FLOOR_RATIO = 0.75;
 var ReflectorRunner = class {
   reflectionConfig;
   observationConfig;
@@ -4056,13 +4318,30 @@ var ReflectorRunner = class {
       model
     });
   }
-  getObservationMarkerConfig() {
+  getObservationMarkerConfig(record) {
     return {
       messageTokens: getMaxThreshold(this.observationConfig.messageTokens),
-      observationTokens: getMaxThreshold(this.reflectionConfig.observationTokens),
-      scope: this.scope
+      observationTokens: getMaxThreshold(
+        record ? this.getEffectiveReflectionTokens(record) : this.reflectionConfig.observationTokens
+      ),
+      scope: this.scope,
+      activateAfterIdle: this.reflectionConfig.activateAfterIdle
     };
   }
+  /**
+   * 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
+   * still take effect for existing records.
+   */
+  getEffectiveReflectionTokens(record) {
+    const overrides = record.config?._overrides;
+    const recordTokens = overrides?.reflection?.observationTokens;
+    if (recordTokens) {
+      return recordTokens;
+    }
+    return this.reflectionConfig.observationTokens;
+  }
   /**
    * Call the Reflector agent with escalating compression levels.
    */
@@ -4172,8 +4451,9 @@ var ReflectorRunner = class {
           recordId: streamContext.recordId,
           threadId: streamContext.threadId
         });
-        await streamContext.writer.custom(failedMarker).catch(() => {
+        await streamContext.writer.custom({ ...failedMarker, transient: true }).catch(() => {
         });
+        await this.persistMarkerToStorage(failedMarker, streamContext.threadId, streamContext.resourceId);
         const retryCycleId = crypto.randomUUID();
         streamContext.cycleId = retryCycleId;
         const startMarker = createObservationStartMarker({
@@ -4186,8 +4466,9 @@ var ReflectorRunner = class {
           config: this.getObservationMarkerConfig()
         });
         streamContext.startedAt = startMarker.data.startedAt;
-        await streamContext.writer.custom(startMarker).catch(() => {
+        await streamContext.writer.custom({ ...startMarker, transient: true }).catch(() => {
         });
+        await this.persistMarkerToStorage(startMarker, streamContext.threadId, streamContext.resourceId);
       }
       currentLevel = Math.min(currentLevel + 1, maxLevel);
     }
@@ -4200,7 +4481,7 @@ var ReflectorRunner = class {
   /**
    * Start an async buffered reflection in the background.
    */
-  startAsyncBufferedReflection(record, observationTokens, lockKey, writer, requestContext, observabilityContext) {
+  startAsyncBufferedReflection(record, observationTokens, lockKey, writer, requestContext, observabilityContext, reflectionHooks) {
     const bufferKey = this.buffering.getReflectionBufferKey(lockKey);
     if (this.buffering.isAsyncBufferingInProgress(bufferKey)) {
       return;
@@ -4210,7 +4491,10 @@ var ReflectorRunner = class {
     this.storage.setBufferingReflectionFlag(record.id, true).catch((err) => {
       omError("[OM] Failed to set buffering reflection flag", err);
     });
-    const asyncOp = this.doAsyncBufferedReflection(record, bufferKey, writer, requestContext, observabilityContext).catch(async (error) => {
+    reflectionHooks?.onReflectionStart?.();
+    const asyncOp = this.doAsyncBufferedReflection(record, bufferKey, writer, requestContext, observabilityContext).then((usage) => {
+      reflectionHooks?.onReflectionEnd?.({ usage });
+    }).catch(async (error) => {
       if (writer) {
         const failedMarker = createBufferingFailedMarker({
           cycleId: `reflect-buf-${Date.now()}-${Math.random().toString(36).slice(2, 11)}`,
@@ -4221,11 +4505,15 @@ var ReflectorRunner = class {
           recordId: record.id,
           threadId: record.threadId ?? ""
         });
-        void writer.custom(failedMarker).catch(() => {
+        void writer.custom({ ...failedMarker, transient: true }).catch(() => {
         });
         await this.persistMarkerToStorage(failedMarker, record.threadId ?? "", record.resourceId ?? void 0);
       }
       omError("[OM] Async buffered reflection failed", error);
+      reflectionHooks?.onReflectionEnd?.({
+        usage: void 0,
+        error: error instanceof Error ? error : new Error(String(error))
+      });
       BufferingCoordinator.lastBufferedBoundary.delete(bufferKey);
     }).finally(() => {
       BufferingCoordinator.asyncBufferingOps.delete(bufferKey);
@@ -4244,7 +4532,7 @@ var ReflectorRunner = class {
     const freshRecord = await this.storage.getObservationalMemory(record.threadId, record.resourceId);
     const currentRecord = freshRecord ?? record;
     const observationTokens = currentRecord.observationTokenCount ?? 0;
-    const reflectThreshold = getMaxThreshold(this.reflectionConfig.observationTokens);
+    const reflectThreshold = getMaxThreshold(this.getEffectiveReflectionTokens(currentRecord));
     const bufferActivation = this.reflectionConfig.bufferActivation ?? 0.5;
     const startedAt = (/* @__PURE__ */ new Date()).toISOString();
     const cycleId = `reflect-buf-${Date.now()}-${Math.random().toString(36).slice(2, 11)}`;
@@ -4273,10 +4561,15 @@ var ReflectorRunner = class {
         recordId: record.id,
         threadId: record.threadId ?? "",
         threadIds: record.threadId ? [record.threadId] : [],
-        config: this.getObservationMarkerConfig()
+        config: this.getObservationMarkerConfig(currentRecord)
       });
-      void writer.custom(startMarker).catch(() => {
+      void writer.custom({ ...startMarker, transient: true }).catch(() => {
       });
+      await this.persistMarkerToStorage(
+        startMarker,
+        currentRecord.threadId ?? "",
+        currentRecord.resourceId ?? void 0
+      );
     }
     const compressionStartLevel = await this.getCompressionStartLevel(requestContext);
     const reflectResult = await this.call(
@@ -4315,26 +4608,35 @@ var ReflectorRunner = class {
         threadId: currentRecord.threadId ?? "",
         observations: reflectResult.observations
       });
-      void writer.custom(endMarker).catch(() => {
+      void writer.custom({ ...endMarker, transient: true }).catch(() => {
       });
       await this.persistMarkerToStorage(endMarker, currentRecord.threadId ?? "", currentRecord.resourceId ?? void 0);
     }
+    return reflectResult.usage;
   }
   /**
    * Try to activate buffered reflection when threshold is reached.
-   * Returns true if activation succeeded.
+   * Returns a discriminated result so the caller can distinguish between
+   * "activated", "no buffer present", and "suppressed by overshoot guard"
+   * without re-deriving that state.
    */
-  async tryActivateBufferedReflection(record, lockKey, writer, messageList) {
+  async tryActivateBufferedReflection(record, lockKey, writer, messageList, activationMetadata) {
     const bufferKey = this.buffering.getReflectionBufferKey(lockKey);
     const asyncOp = BufferingCoordinator.asyncBufferingOps.get(bufferKey);
     if (asyncOp) {
-      omDebug(`[OM:reflect] tryActivateBufferedReflection: waiting for in-progress op...`);
-      try {
-        await Promise.race([
-          asyncOp,
-          new Promise((_, reject) => setTimeout(() => reject(new Error("Timeout")), 6e4))
-        ]);
-      } catch {
+      if (activationMetadata?.triggeredBy === "ttl" || activationMetadata?.triggeredBy === "provider_change") {
+        omDebug(
+          `[OM:reflect] tryActivateBufferedReflection: async op in progress, not blocking for ${activationMetadata.triggeredBy} trigger`
+        );
+      } else {
+        omDebug(`[OM:reflect] tryActivateBufferedReflection: waiting for in-progress op...`);
+        try {
+          await Promise.race([
+            asyncOp,
+            new Promise((_, reject) => setTimeout(() => reject(new Error("Timeout")), 5e3))
+          ]);
+        } catch {
+        }
       }
     }
     const freshRecord = await this.storage.getObservationalMemory(record.threadId, record.resourceId);
@@ -4345,8 +4647,8 @@ var ReflectorRunner = class {
       `[OM:reflect] tryActivateBufferedReflection: freshRecord.id=${freshRecord?.id}, freshBufferedReflection=${freshRecord?.bufferedReflection ? "present (" + freshRecord.bufferedReflection.length + " chars)" : "empty"}, freshObsTokens=${freshRecord?.observationTokenCount}`
     );
     if (!freshRecord?.bufferedReflection) {
-      omDebug(`[OM:reflect] tryActivateBufferedReflection: no buffered reflection after re-fetch, returning false`);
-      return false;
+      omDebug(`[OM:reflect] tryActivateBufferedReflection: no buffered reflection after re-fetch`);
+      return { status: "no-buffer" };
     }
     const beforeTokens = freshRecord.observationTokenCount ?? 0;
     const reflectedLineCount = freshRecord.reflectedObservationLineCount ?? 0;
@@ -4358,6 +4660,26 @@ var ReflectorRunner = class {
 
 ${unreflectedContent}` : freshRecord.bufferedReflection;
     const combinedTokenCount = this.tokenCounter.countObservations(combinedObservations);
+    if (activationMetadata?.triggeredBy === "ttl" || activationMetadata?.triggeredBy === "provider_change") {
+      const unreflectedTailTokens = unreflectedContent ? this.tokenCounter.countObservations(unreflectedContent) : 0;
+      const bufferedReflectionTokens = freshRecord.bufferedReflectionTokens ?? 0;
+      if (unreflectedTailTokens < bufferedReflectionTokens) {
+        omDebug(
+          `[OM:reflect] tryActivateBufferedReflection: suppressing early ${activationMetadata.triggeredBy} activation \u2014 unreflectedTailTokens=${unreflectedTailTokens} < bufferedReflectionTokens=${bufferedReflectionTokens}; keeping buffer for threshold activation`
+        );
+        return { status: "suppressed", reason: "composition" };
+      }
+      const bufferActivation = this.reflectionConfig.bufferActivation;
+      const reflectThreshold = getMaxThreshold(this.getEffectiveReflectionTokens(freshRecord));
+      const regularActivationTarget = reflectThreshold * (1 - bufferActivation);
+      const minCombinedTokens = Math.round(regularActivationTarget * EARLY_ACTIVATION_SIZE_FLOOR_RATIO);
+      if (combinedTokenCount < minCombinedTokens) {
+        omDebug(
+          `[OM:reflect] tryActivateBufferedReflection: suppressing early ${activationMetadata.triggeredBy} activation \u2014 combinedTokenCount=${combinedTokenCount} < minCombinedTokens=${minCombinedTokens} (${EARLY_ACTIVATION_SIZE_FLOOR_RATIO * 100}% of regular activation target ${Math.round(regularActivationTarget)}, threshold=${reflectThreshold}, bufferActivation=${bufferActivation}); keeping buffer for threshold activation`
+        );
+        return { status: "suppressed", reason: "size" };
+      }
+    }
     omDebug(
       `[OM:reflect] tryActivateBufferedReflection: activating, beforeTokens=${beforeTokens}, combinedTokenCount=${combinedTokenCount}, reflectedLineCount=${reflectedLineCount}, unreflectedLines=${unreflectedLines.length}`
     );
@@ -4384,9 +4706,14 @@ ${unreflectedContent}` : freshRecord.bufferedReflection;
         threadId: freshRecord.threadId ?? "",
         generationCount: afterRecord?.generationCount ?? freshRecord.generationCount ?? 0,
         observations: afterRecord?.activeObservations,
-        config: this.getObservationMarkerConfig()
+        triggeredBy: activationMetadata?.triggeredBy,
+        lastActivityAt: activationMetadata?.lastActivityAt,
+        ttlExpiredMs: activationMetadata?.ttlExpiredMs,
+        previousModel: activationMetadata?.previousModel,
+        currentModel: activationMetadata?.currentModel,
+        config: this.getObservationMarkerConfig(freshRecord)
       });
-      void writer.custom(activationMarker).catch(() => {
+      void writer.custom({ ...activationMarker, transient: true }).catch(() => {
       });
       await this.persistMarkerToMessage(
         activationMarker,
@@ -4396,7 +4723,7 @@ ${unreflectedContent}` : freshRecord.bufferedReflection;
       );
     }
     BufferingCoordinator.reflectionBufferCycleIds.delete(bufferKey);
-    return true;
+    return { status: "activated" };
   }
   /**
    * Check if reflection needed and trigger if so.
@@ -4410,12 +4737,15 @@ ${unreflectedContent}` : freshRecord.bufferedReflection;
       writer,
       abortSignal,
       messageList,
+      currentModel,
       reflectionHooks,
       requestContext,
-      observabilityContext
+      observabilityContext,
+      lastActivityAt,
+      threadId: requestedThreadId
     } = opts;
     const lockKey = this.buffering.getLockKey(record.threadId, record.resourceId);
-    const reflectThreshold = getMaxThreshold(this.reflectionConfig.observationTokens);
+    const reflectThreshold = getMaxThreshold(this.getEffectiveReflectionTokens(record));
     if (this.buffering.isAsyncReflectionEnabled() && observationTokens < reflectThreshold) {
       const shouldTrigger = (() => {
         if (!this.buffering.isAsyncReflectionEnabled()) return false;
@@ -4439,13 +4769,28 @@ ${unreflectedContent}` : freshRecord.bufferedReflection;
           lockKey,
           writer,
           requestContext,
-          observabilityContext
+          observabilityContext,
+          reflectionHooks
         );
       }
     }
-    if (observationTokens < reflectThreshold) {
+    const activateAfterIdle = this.reflectionConfig.activateAfterIdle;
+    const ttlExpiredMs = activateAfterIdle !== void 0 && lastActivityAt !== void 0 ? Date.now() - lastActivityAt : void 0;
+    const ttlExpired = ttlExpiredMs !== void 0 && activateAfterIdle !== void 0 && ttlExpiredMs >= activateAfterIdle;
+    const actorModel = getCurrentModel(currentModel);
+    const lastModel = getLastModelFromMessageList(messageList);
+    const providerChanged = this.reflectionConfig.activateOnProviderChange === true && didProviderChange(actorModel, lastModel);
+    if (observationTokens < reflectThreshold && !ttlExpired && !providerChanged) {
       return;
     }
+    const activationTriggeredBy = observationTokens >= reflectThreshold ? "threshold" : providerChanged ? "provider_change" : "ttl";
+    const activationMetadata = {
+      triggeredBy: activationTriggeredBy,
+      lastActivityAt: activationTriggeredBy === "ttl" ? lastActivityAt : void 0,
+      ttlExpiredMs: activationTriggeredBy === "ttl" ? ttlExpiredMs : void 0,
+      previousModel: activationTriggeredBy === "provider_change" ? lastModel : void 0,
+      currentModel: activationTriggeredBy === "provider_change" ? actorModel : void 0
+    };
     if (record.isReflecting) {
       if (isOpActiveInProcess(record.id, "reflecting")) {
         omDebug(`[OM:reflect] isReflecting=true and active in this process, skipping`);
@@ -4455,8 +4800,20 @@ ${unreflectedContent}` : freshRecord.bufferedReflection;
       await this.storage.setReflectingFlag(record.id, false);
     }
     if (this.buffering.isAsyncReflectionEnabled()) {
-      const activationSuccess = await this.tryActivateBufferedReflection(record, lockKey, writer, messageList);
-      if (activationSuccess) {
+      const activationResult = await this.tryActivateBufferedReflection(
+        record,
+        lockKey,
+        writer,
+        messageList,
+        activationMetadata
+      );
+      if (activationResult.status === "activated") {
+        return;
+      }
+      if (activationResult.status === "suppressed") {
+        omDebug(
+          `[OM:reflect] skipping sync fallback / re-buffer after suppressed early ${activationMetadata.triggeredBy} activation (reason=${activationResult.reason})`
+        );
         return;
       }
       if (this.reflectionConfig.blockAfter && observationTokens >= this.reflectionConfig.blockAfter) {
@@ -4464,6 +4821,13 @@ ${unreflectedContent}` : freshRecord.bufferedReflection;
           `[OM:reflect] blockAfter exceeded (${observationTokens} >= ${this.reflectionConfig.blockAfter}), falling through to sync reflection`
         );
       } else {
+        const activationPoint = reflectThreshold * this.reflectionConfig.bufferActivation;
+        if (observationTokens < activationPoint) {
+          omDebug(
+            `[OM:reflect] skipping async reflection \u2014 observationTokens (${observationTokens}) below activation point (${activationPoint}), triggered by ${activationTriggeredBy}`
+          );
+          return;
+        }
         omDebug(
           `[OM:reflect] async activation failed, no blockAfter or below it (obsTokens=${observationTokens}, blockAfter=${this.reflectionConfig.blockAfter}) \u2014 starting background reflection`
         );
@@ -4473,7 +4837,8 @@ ${unreflectedContent}` : freshRecord.bufferedReflection;
           lockKey,
           writer,
           requestContext,
-          observabilityContext
+          observabilityContext,
+          reflectionHooks
         );
         return;
       }
@@ -4483,7 +4848,7 @@ ${unreflectedContent}` : freshRecord.bufferedReflection;
     registerOp(record.id, "reflecting");
     const cycleId = crypto.randomUUID();
     const startedAt = (/* @__PURE__ */ new Date()).toISOString();
-    const threadId = opts.threadId ?? "unknown";
+    const threadId = requestedThreadId ?? "unknown";
     if (writer) {
       const startMarker = createObservationStartMarker({
         cycleId,
@@ -4492,10 +4857,11 @@ ${unreflectedContent}` : freshRecord.bufferedReflection;
         recordId: record.id,
         threadId,
         threadIds: [threadId],
-        config: this.getObservationMarkerConfig()
+        config: this.getObservationMarkerConfig(record)
       });
-      await writer.custom(startMarker).catch(() => {
+      await writer.custom({ ...startMarker, transient: true }).catch(() => {
       });
+      await this.persistMarkerToStorage(startMarker, threadId, record.resourceId ?? void 0);
     }
     this.emitDebugEvent({
       type: "reflection_triggered",
@@ -4510,8 +4876,11 @@ ${unreflectedContent}` : freshRecord.bufferedReflection;
       cycleId,
       startedAt,
       recordId: record.id,
-      threadId
+      threadId,
+      resourceId: record.resourceId ?? void 0
     } : void 0;
+    let reflectionUsage;
+    let reflectionError;
     try {
       const compressionStartLevel = await this.getCompressionStartLevel(requestContext);
       const reflectResult = await this.call(
@@ -4525,6 +4894,7 @@ ${unreflectedContent}` : freshRecord.bufferedReflection;
         requestContext,
         observabilityContext
       );
+      reflectionUsage = reflectResult.usage;
       const reflectionTokenCount = this.tokenCounter.countObservations(reflectResult.observations);
       await this.storage.createReflectionGeneration({
         currentRecord: record,
@@ -4542,8 +4912,9 @@ ${unreflectedContent}` : freshRecord.bufferedReflection;
           recordId: record.id,
           threadId
         });
-        await writer.custom(endMarker).catch(() => {
+        await writer.custom({ ...endMarker, transient: true }).catch(() => {
         });
+        await this.persistMarkerToStorage(endMarker, threadId, record.resourceId ?? void 0);
       }
       this.emitDebugEvent({
         type: "reflection_complete",
@@ -4566,89 +4937,413 @@ ${unreflectedContent}` : freshRecord.bufferedReflection;
           recordId: record.id,
           threadId
         });
-        await writer.custom(failedMarker).catch(() => {
+        await writer.custom({ ...failedMarker, transient: true }).catch(() => {
         });
+        await this.persistMarkerToStorage(failedMarker, threadId, record.resourceId ?? void 0);
       }
+      reflectionError = error instanceof Error ? error : new Error(String(error));
       if (abortSignal?.aborted) {
         throw error;
       }
       omError("[OM] Reflection failed", error);
     } finally {
       await this.storage.setReflectingFlag(record.id, false);
-      reflectionHooks?.onReflectionEnd?.();
+      reflectionHooks?.onReflectionEnd?.({ usage: reflectionUsage, error: reflectionError });
       unregisterOp(record.id, "reflecting");
     }
   }
 };
-var IMAGE_FILE_EXTENSIONS = /* @__PURE__ */ new Set([
-  "png",
-  "jpg",
-  "jpeg",
-  "webp",
-  "gif",
-  "bmp",
-  "tiff",
-  "tif",
-  "heic",
-  "heif",
-  "avif"
-]);
-var TOKEN_ESTIMATE_CACHE_VERSION = 6;
-var DEFAULT_IMAGE_ESTIMATOR = {
-  baseTokens: 85,
-  tileTokens: 170,
-  fallbackTiles: 4
-};
-var GOOGLE_LEGACY_IMAGE_TOKENS_PER_TILE = 258;
-var GOOGLE_GEMINI_3_IMAGE_TOKENS_BY_RESOLUTION = {
-  low: 280,
-  medium: 560,
-  high: 1120,
-  ultra_high: 2240,
-  unspecified: 1120
-};
-var ANTHROPIC_IMAGE_TOKENS_PER_PIXEL = 1 / 750;
-var ANTHROPIC_IMAGE_MAX_LONG_EDGE = 1568;
-var GOOGLE_MEDIA_RESOLUTION_VALUES = /* @__PURE__ */ new Set([
-  "low",
-  "medium",
-  "high",
-  "ultra_high",
-  "unspecified"
-]);
-var ATTACHMENT_COUNT_TIMEOUT_MS = 2e4;
-var REMOTE_IMAGE_PROBE_TIMEOUT_MS = 2500;
-var PROVIDER_API_KEY_ENV_VARS = {
-  openai: ["OPENAI_API_KEY"],
-  google: ["GOOGLE_GENERATIVE_AI_API_KEY", "GOOGLE_API_KEY"],
-  anthropic: ["ANTHROPIC_API_KEY"]
-};
-function getPartMastraMetadata(part) {
-  return part.providerMetadata?.mastra;
+function getOmReproCaptureDir() {
+  return process.env.OM_REPRO_CAPTURE_DIR ?? ".mastra-om-repro";
 }
-function ensurePartMastraMetadata(part) {
-  const typedPart = part;
-  typedPart.providerMetadata ??= {};
-  typedPart.providerMetadata.mastra ??= {};
-  return typedPart.providerMetadata.mastra;
+function sanitizeCapturePathSegment(value) {
+  const sanitized = value.replace(/[\\/]+/g, "_").replace(/\.{2,}/g, "_").trim();
+  return sanitized.length > 0 ? sanitized : "unknown-thread";
 }
-function getContentMastraMetadata(content) {
-  if (!content || typeof content !== "object") {
-    return void 0;
+function isOmReproCaptureEnabled() {
+  return process.env.OM_REPRO_CAPTURE === "1";
+}
+function safeCaptureJson(value) {
+  return JSON.parse(
+    JSON.stringify(value, (_key, current) => {
+      if (typeof current === "bigint") return current.toString();
+      if (typeof current === "function") return "[function]";
+      if (typeof current === "symbol") return current.toString();
+      if (current instanceof Error) return { name: current.name, message: current.message, stack: current.stack };
+      if (current instanceof Set) return { __type: "Set", values: Array.from(current.values()) };
+      if (current instanceof Map) return { __type: "Map", entries: Array.from(current.entries()) };
+      return current;
+    })
+  );
+}
+function safeCaptureJsonOrError(value) {
+  try {
+    return { ok: true, value: safeCaptureJson(value) };
+  } catch (error) {
+    return {
+      ok: false,
+      error: safeCaptureJson({
+        message: error instanceof Error ? error.message : String(error),
+        stack: error instanceof Error ? error.stack : void 0,
+        inspected: util.inspect(value, { depth: 3, maxArrayLength: 20, breakLength: 120 })
+      })
+    };
   }
-  return content.metadata?.mastra;
 }
-function ensureContentMastraMetadata(content) {
-  if (!content || typeof content !== "object") {
+function formatCaptureDate(value) {
+  if (!value) return void 0;
+  if (value instanceof Date) return value.toISOString();
+  try {
+    return new Date(value).toISOString();
+  } catch {
     return void 0;
   }
-  const typedContent = content;
-  typedContent.metadata ??= {};
-  typedContent.metadata.mastra ??= {};
-  return typedContent.metadata.mastra;
-}
-function getMessageMastraMetadata(message) {
-  return message.metadata?.mastra;
+}
+function summarizeOmTurn(value) {
+  if (!value || typeof value !== "object") {
+    return value;
+  }
+  const turn = value;
+  return {
+    __type: "ObservationTurn",
+    threadId: turn.threadId,
+    resourceId: turn.resourceId,
+    started: turn._started,
+    ended: turn._ended,
+    generationCountAtStart: turn._generationCountAtStart,
+    record: turn._record ? {
+      id: turn._record.id,
+      scope: turn._record.scope,
+      threadId: turn._record.threadId,
+      resourceId: turn._record.resourceId,
+      createdAt: formatCaptureDate(turn._record.createdAt),
+      updatedAt: formatCaptureDate(turn._record.updatedAt),
+      lastObservedAt: formatCaptureDate(turn._record.lastObservedAt),
+      generationCount: turn._record.generationCount,
+      observationTokenCount: turn._record.observationTokenCount,
+      pendingMessageTokens: turn._record.pendingMessageTokens,
+      isBufferingObservation: turn._record.isBufferingObservation,
+      isBufferingReflection: turn._record.isBufferingReflection
+    } : void 0,
+    context: turn._context ? {
+      messageCount: Array.isArray(turn._context.messages) ? turn._context.messages.length : void 0,
+      hasSystemMessage: Array.isArray(turn._context.systemMessage) ? turn._context.systemMessage.length > 0 : Boolean(turn._context.systemMessage),
+      continuationId: turn._context.continuation?.id,
+      hasOtherThreadsContext: Boolean(turn._context.otherThreadsContext),
+      recordId: turn._context.record?.id
+    } : void 0,
+    currentStep: turn._currentStep ? {
+      stepNumber: turn._currentStep.stepNumber,
+      prepared: turn._currentStep._prepared,
+      context: turn._currentStep._context ? {
+        activated: turn._currentStep._context.activated,
+        observed: turn._currentStep._context.observed,
+        buffered: turn._currentStep._context.buffered,
+        reflected: turn._currentStep._context.reflected,
+        didThresholdCleanup: turn._currentStep._context.didThresholdCleanup,
+        messageCount: Array.isArray(turn._currentStep._context.messages) ? turn._currentStep._context.messages.length : void 0,
+        systemMessageCount: Array.isArray(turn._currentStep._context.systemMessage) ? turn._currentStep._context.systemMessage.length : void 0
+      } : void 0
+    } : void 0
+  };
+}
+function sanitizeCaptureState(rawState) {
+  return Object.fromEntries(
+    Object.entries(rawState).map(([key, value]) => {
+      if (key === "__omTurn") {
+        return [key, summarizeOmTurn(value)];
+      }
+      return [key, value];
+    })
+  );
+}
+function buildReproMessageFingerprint(message) {
+  const createdAt = message.createdAt instanceof Date ? message.createdAt.toISOString() : message.createdAt ? new Date(message.createdAt).toISOString() : "";
+  return JSON.stringify({
+    role: message.role,
+    createdAt,
+    content: message.content
+  });
+}
+function inferReproIdRemap(preMessages, postMessages) {
+  const preByFingerprint = /* @__PURE__ */ new Map();
+  const postByFingerprint = /* @__PURE__ */ new Map();
+  for (const message of preMessages) {
+    if (!message.id) continue;
+    const fingerprint = buildReproMessageFingerprint(message);
+    const list = preByFingerprint.get(fingerprint) ?? [];
+    list.push(message.id);
+    preByFingerprint.set(fingerprint, list);
+  }
+  for (const message of postMessages) {
+    if (!message.id) continue;
+    const fingerprint = buildReproMessageFingerprint(message);
+    const list = postByFingerprint.get(fingerprint) ?? [];
+    list.push(message.id);
+    postByFingerprint.set(fingerprint, list);
+  }
+  const remap = [];
+  for (const [fingerprint, preIds] of preByFingerprint.entries()) {
+    const postIds = postByFingerprint.get(fingerprint);
+    if (!postIds || preIds.length !== 1 || postIds.length !== 1) continue;
+    const fromId = preIds[0];
+    const toId = postIds[0];
+    if (!fromId || !toId || fromId === toId) {
+      continue;
+    }
+    remap.push({ fromId, toId, fingerprint });
+  }
+  return remap;
+}
+function createOmReproCaptureDir(threadId, label) {
+  const sanitizedThreadId = sanitizeCapturePathSegment(threadId);
+  const captureDir = path.join(
+    process.cwd(),
+    getOmReproCaptureDir(),
+    sanitizedThreadId,
+    `${Date.now()}-${label}-${crypto$1.randomUUID()}`
+  );
+  fs.mkdirSync(captureDir, { recursive: true });
+  return captureDir;
+}
+function writeObserverExchangeReproCapture(params) {
+  if (!isOmReproCaptureEnabled() || !params.observerExchange) {
+    return;
+  }
+  try {
+    const captureDir = createOmReproCaptureDir(params.threadId, params.label);
+    const payloads = [
+      {
+        fileName: "input.json",
+        data: {
+          threadId: params.threadId,
+          resourceId: params.resourceId,
+          label: params.label
+        }
+      },
+      {
+        fileName: "output.json",
+        data: {
+          details: params.details ?? {}
+        }
+      },
+      {
+        fileName: "observer-exchange.json",
+        data: params.observerExchange
+      }
+    ];
+    const captureErrors = [];
+    for (const payload of payloads) {
+      const serialized = safeCaptureJsonOrError(payload.data);
+      if (serialized.ok) {
+        fs.writeFileSync(path.join(captureDir, payload.fileName), `${JSON.stringify(serialized.value, null, 2)}
+`);
+        continue;
+      }
+      captureErrors.push({ fileName: payload.fileName, error: serialized.error });
+      fs.writeFileSync(
+        path.join(captureDir, payload.fileName),
+        `${JSON.stringify({ __captureError: serialized.error }, null, 2)}
+`
+      );
+    }
+    if (captureErrors.length > 0) {
+      fs.writeFileSync(path.join(captureDir, "capture-error.json"), `${JSON.stringify(captureErrors, null, 2)}
+`);
+      params.debug?.(
+        `[OM:repro-capture] wrote ${params.label} capture with ${captureErrors.length} serialization error(s) to ${captureDir}`
+      );
+      return;
+    }
+    params.debug?.(`[OM:repro-capture] wrote ${params.label} capture to ${captureDir}`);
+  } catch (error) {
+    params.debug?.(`[OM:repro-capture] failed to write ${params.label} capture: ${String(error)}`);
+  }
+}
+function writeProcessInputStepReproCapture(params) {
+  if (!isOmReproCaptureEnabled()) {
+    return;
+  }
+  try {
+    const captureDir = createOmReproCaptureDir(params.threadId, `step-${params.stepNumber}`);
+    const contextMessages = params.messageList.get.all.db();
+    const memoryContext = memory.parseMemoryRequestContext(params.args.requestContext);
+    const preMessageIds = new Set(params.preMessages.map((message) => message.id));
+    const postMessageIds = new Set(contextMessages.map((message) => message.id));
+    const removedMessageIds = params.preMessages.map((message) => message.id).filter((id) => Boolean(id) && !postMessageIds.has(id));
+    const addedMessageIds = contextMessages.map((message) => message.id).filter((id) => Boolean(id) && !preMessageIds.has(id));
+    const idRemap = inferReproIdRemap(params.preMessages, contextMessages);
+    const rawState = params.args.state ?? {};
+    const sanitizedState = sanitizeCaptureState(rawState);
+    const payloads = [
+      {
+        fileName: "input.json",
+        data: {
+          stepNumber: params.stepNumber,
+          threadId: params.threadId,
+          resourceId: params.resourceId,
+          readOnly: memoryContext?.memoryConfig?.readOnly,
+          messageCount: contextMessages.length,
+          messageIds: contextMessages.map((message) => message.id),
+          stateKeys: Object.keys(rawState),
+          state: sanitizedState,
+          args: {
+            messages: params.args.messages,
+            steps: params.args.steps,
+            systemMessages: params.args.systemMessages,
+            retryCount: params.args.retryCount,
+            toolChoice: params.args.toolChoice,
+            activeTools: params.args.activeTools,
+            modelSettings: params.args.modelSettings,
+            structuredOutput: params.args.structuredOutput
+          }
+        }
+      },
+      {
+        fileName: "pre-state.json",
+        data: {
+          record: params.preRecord,
+          bufferedChunks: params.preBufferedChunks,
+          contextTokenCount: params.preContextTokenCount,
+          messages: params.preMessages,
+          messageList: params.preSerializedMessageList
+        }
+      },
+      {
+        fileName: "output.json",
+        data: {
+          details: params.details,
+          messageDiff: {
+            removedMessageIds,
+            addedMessageIds,
+            idRemap
+          }
+        }
+      },
+      {
+        fileName: "post-state.json",
+        data: {
+          record: params.postRecord,
+          bufferedChunks: params.postBufferedChunks,
+          contextTokenCount: params.postContextTokenCount,
+          messageCount: contextMessages.length,
+          messageIds: contextMessages.map((message) => message.id),
+          messages: contextMessages,
+          messageList: params.messageList.serialize()
+        }
+      }
+    ];
+    const captureErrors = [];
+    for (const payload of payloads) {
+      const serialized = safeCaptureJsonOrError(payload.data);
+      if (serialized.ok) {
+        fs.writeFileSync(path.join(captureDir, payload.fileName), `${JSON.stringify(serialized.value, null, 2)}
+`);
+        continue;
+      }
+      captureErrors.push({ fileName: payload.fileName, error: serialized.error });
+      fs.writeFileSync(
+        path.join(captureDir, payload.fileName),
+        `${JSON.stringify({ __captureError: serialized.error }, null, 2)}
+`
+      );
+    }
+    if (params.observerExchange) {
+      const serialized = safeCaptureJsonOrError(params.observerExchange);
+      if (serialized.ok) {
+        fs.writeFileSync(path.join(captureDir, "observer-exchange.json"), `${JSON.stringify(serialized.value, null, 2)}
+`);
+      } else {
+        captureErrors.push({ fileName: "observer-exchange.json", error: serialized.error });
+        fs.writeFileSync(
+          path.join(captureDir, "observer-exchange.json"),
+          `${JSON.stringify({ __captureError: serialized.error }, null, 2)}
+`
+        );
+      }
+    }
+    if (captureErrors.length > 0) {
+      fs.writeFileSync(path.join(captureDir, "capture-error.json"), `${JSON.stringify(captureErrors, null, 2)}
+`);
+      params.debug?.(
+        `[OM:repro-capture] wrote processInputStep capture with ${captureErrors.length} serialization error(s) to ${captureDir}`
+      );
+      return;
+    }
+    params.debug?.(`[OM:repro-capture] wrote processInputStep capture to ${captureDir}`);
+  } catch (error) {
+    params.debug?.(`[OM:repro-capture] failed to write processInputStep capture: ${String(error)}`);
+  }
+}
+var IMAGE_FILE_EXTENSIONS = /* @__PURE__ */ new Set([
+  "png",
+  "jpg",
+  "jpeg",
+  "webp",
+  "gif",
+  "bmp",
+  "tiff",
+  "tif",
+  "heic",
+  "heif",
+  "avif"
+]);
+var TOKEN_ESTIMATE_CACHE_VERSION = 6;
+var DEFAULT_IMAGE_ESTIMATOR = {
+  baseTokens: 85,
+  tileTokens: 170,
+  fallbackTiles: 4
+};
+var GOOGLE_LEGACY_IMAGE_TOKENS_PER_TILE = 258;
+var GOOGLE_GEMINI_3_IMAGE_TOKENS_BY_RESOLUTION = {
+  low: 280,
+  medium: 560,
+  high: 1120,
+  ultra_high: 2240,
+  unspecified: 1120
+};
+var ANTHROPIC_IMAGE_TOKENS_PER_PIXEL = 1 / 750;
+var ANTHROPIC_IMAGE_MAX_LONG_EDGE = 1568;
+var GOOGLE_MEDIA_RESOLUTION_VALUES = /* @__PURE__ */ new Set([
+  "low",
+  "medium",
+  "high",
+  "ultra_high",
+  "unspecified"
+]);
+var ATTACHMENT_COUNT_TIMEOUT_MS = 2e4;
+var REMOTE_IMAGE_PROBE_TIMEOUT_MS = 2500;
+var PROVIDER_API_KEY_ENV_VARS = {
+  openai: ["OPENAI_API_KEY"],
+  google: ["GOOGLE_GENERATIVE_AI_API_KEY", "GOOGLE_API_KEY"],
+  anthropic: ["ANTHROPIC_API_KEY"]
+};
+function getPartMastraMetadata(part) {
+  return part.providerMetadata?.mastra;
+}
+function ensurePartMastraMetadata(part) {
+  const typedPart = part;
+  typedPart.providerMetadata ??= {};
+  typedPart.providerMetadata.mastra ??= {};
+  return typedPart.providerMetadata.mastra;
+}
+function getContentMastraMetadata(content) {
+  if (!content || typeof content !== "object") {
+    return void 0;
+  }
+  return content.metadata?.mastra;
+}
+function ensureContentMastraMetadata(content) {
+  if (!content || typeof content !== "object") {
+    return void 0;
+  }
+  const typedContent = content;
+  typedContent.metadata ??= {};
+  typedContent.metadata.mastra ??= {};
+  return typedContent.metadata.mastra;
+}
+function getMessageMastraMetadata(message) {
+  return message.metadata?.mastra;
 }
 function ensureMessageMastraMetadata(message) {
   const typedMessage = message;
@@ -5807,6 +6502,88 @@ function buildMessageRange(messages) {
   const last = [...messages].reverse().find(messageHasVisibleContent) ?? messages[messages.length - 1];
   return `${first.id}:${last.id}`;
 }
+function getLastActivityFromMessages(messages) {
+  if (!messages) return void 0;
+  for (let i = messages.length - 1; i >= 0; i--) {
+    const message = messages[i];
+    if (!message || message.role !== "assistant") {
+      continue;
+    }
+    if (!message.content || typeof message.content === "string") {
+      return message.createdAt ? new Date(message.createdAt).getTime() : void 0;
+    }
+    for (let j = message.content.parts.length - 1; j >= 0; j--) {
+      const part = message.content.parts[j];
+      if (!part || part.type?.startsWith("data-")) {
+        continue;
+      }
+      if (part.createdAt !== void 0) {
+        return part.createdAt;
+      }
+    }
+    return message.createdAt ? new Date(message.createdAt).getTime() : void 0;
+  }
+  return void 0;
+}
+function formatModelContext2(provider, modelId) {
+  if (provider && modelId) {
+    return `${provider}/${modelId}`;
+  }
+  return modelId;
+}
+function getLastModelFromMessages(messages) {
+  if (!messages) return void 0;
+  for (let i = messages.length - 1; i >= 0; i--) {
+    const message = messages[i];
+    if (!message || message.role !== "assistant" || !message.content || typeof message.content === "string") {
+      continue;
+    }
+    for (let j = message.content.parts.length - 1; j >= 0; j--) {
+      const part = message.content.parts[j];
+      if (part?.type === "step-start" && typeof part.model === "string" && part.model.length > 0) {
+        return part.model;
+      }
+    }
+    const metadata = message.content.metadata;
+    const model = formatModelContext2(metadata?.provider, metadata?.modelId);
+    if (model) {
+      return model;
+    }
+  }
+  return void 0;
+}
+function getCurrentModel2(model) {
+  return formatModelContext2(model?.provider, model?.modelId);
+}
+function parseActivationTTL(value, fieldPath) {
+  if (value === void 0) {
+    return void 0;
+  }
+  if (typeof value === "number") {
+    if (!Number.isFinite(value) || value < 0) {
+      throw new Error(`${fieldPath} must be a non-negative number of milliseconds or a duration string like "5m".`);
+    }
+    return value;
+  }
+  const trimmed = value.trim();
+  const match = trimmed.match(
+    /^(\d+(?:\.\d+)?)\s*(ms|msec|msecs|millisecond|milliseconds|s|sec|secs|second|seconds|m|min|mins|minute|minutes|h|hr|hrs|hour|hours)$/i
+  );
+  if (!match) {
+    throw new Error(
+      `${fieldPath} must be a non-negative number of milliseconds or a duration string like "5m" or "1hr".`
+    );
+  }
+  const rawAmount = match[1];
+  const rawUnit = match[2];
+  const amount = Number(rawAmount);
+  const unit = rawUnit.toLowerCase();
+  if (!Number.isFinite(amount) || amount < 0) {
+    throw new Error(`${fieldPath} must be a non-negative number of milliseconds or a duration string like "5m".`);
+  }
+  const multiplier = unit === "ms" || unit === "msec" || unit === "msecs" || unit === "millisecond" || unit === "milliseconds" ? 1 : unit === "s" || unit === "sec" || unit === "secs" || unit === "second" || unit === "seconds" ? 1e3 : unit === "m" || unit === "min" || unit === "mins" || unit === "minute" || unit === "minutes" ? 6e4 : 36e5;
+  return amount * multiplier;
+}
 var ObservationalMemory = class _ObservationalMemory {
   storage;
   tokenCounter;
@@ -5953,6 +6730,8 @@ Async buffering is enabled by default \u2014 this opt-out is only needed when us
         config.observation?.messageTokens ?? chunkD4J4XPGM_cjs.OBSERVATIONAL_MEMORY_DEFAULTS.observation.messageTokens
       ),
       bufferActivation: asyncBufferingDisabled ? void 0 : config.observation?.bufferActivation ?? chunkD4J4XPGM_cjs.OBSERVATIONAL_MEMORY_DEFAULTS.observation.bufferActivation,
+      activateAfterIdle: parseActivationTTL(config.activateAfterIdle, "activateAfterIdle"),
+      activateOnProviderChange: config.activateOnProviderChange ?? false,
       blockAfter: asyncBufferingDisabled ? void 0 : resolveBlockAfter(
         config.observation?.blockAfter ?? (config.observation?.bufferTokens ?? chunkD4J4XPGM_cjs.OBSERVATIONAL_MEMORY_DEFAULTS.observation.bufferTokens ? 1.2 : void 0),
         config.observation?.messageTokens ?? chunkD4J4XPGM_cjs.OBSERVATIONAL_MEMORY_DEFAULTS.observation.messageTokens
@@ -5971,6 +6750,8 @@ Async buffering is enabled by default \u2014 this opt-out is only needed when us
       },
       providerOptions: config.reflection?.providerOptions ?? chunkD4J4XPGM_cjs.OBSERVATIONAL_MEMORY_DEFAULTS.reflection.providerOptions,
       bufferActivation: asyncBufferingDisabled ? void 0 : config?.reflection?.bufferActivation ?? chunkD4J4XPGM_cjs.OBSERVATIONAL_MEMORY_DEFAULTS.reflection.bufferActivation,
+      activateAfterIdle: parseActivationTTL(config.activateAfterIdle, "activateAfterIdle"),
+      activateOnProviderChange: config.activateOnProviderChange ?? false,
       blockAfter: asyncBufferingDisabled ? void 0 : resolveBlockAfter(
         config.reflection?.blockAfter ?? (config.reflection?.bufferActivation ?? chunkD4J4XPGM_cjs.OBSERVATIONAL_MEMORY_DEFAULTS.reflection.bufferActivation ? 1.2 : void 0),
         config.reflection?.observationTokens ?? chunkD4J4XPGM_cjs.OBSERVATIONAL_MEMORY_DEFAULTS.reflection.observationTokens
@@ -6251,6 +7032,47 @@ Async buffering is enabled by default \u2014 this opt-out is only needed when us
       }
     }
   }
+  /**
+   * Resolve the effective messageTokens for a record.
+   * Only explicit per-record overrides (stored under `_overrides`) win;
+   * the initial config snapshot written by getOrCreateRecord() is ignored
+   * so that later instance-level changes still take effect.
+   *
+   * Overrides that fall below the instance-level buffering floor
+   * (bufferTokens / absolute bufferActivation) are clamped to the
+   * instance threshold to preserve buffering invariants.
+   */
+  getEffectiveMessageTokens(record) {
+    const overrides = record.config?._overrides;
+    const recordTokens = overrides?.observation?.messageTokens;
+    if (recordTokens) {
+      const maxOverride = getMaxThreshold(recordTokens);
+      const bufferTokens = this.observationConfig.bufferTokens;
+      if (bufferTokens && maxOverride <= bufferTokens) {
+        return this.observationConfig.messageTokens;
+      }
+      const bufferActivation = this.observationConfig.bufferActivation;
+      if (bufferActivation && bufferActivation >= 1e3 && maxOverride <= bufferActivation) {
+        return this.observationConfig.messageTokens;
+      }
+      return recordTokens;
+    }
+    return this.observationConfig.messageTokens;
+  }
+  /**
+   * 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
+   * still take effect for existing records.
+   */
+  getEffectiveReflectionTokens(record) {
+    const overrides = record.config?._overrides;
+    const recordTokens = overrides?.reflection?.observationTokens;
+    if (recordTokens) {
+      return recordTokens;
+    }
+    return this.reflectionConfig.observationTokens;
+  }
   /**
    * Check whether the unobserved message tokens meet the observation threshold.
    */
@@ -6258,7 +7080,7 @@ Async buffering is enabled by default \u2014 this opt-out is only needed when us
     const { record, unobservedTokens, extraTokens = 0 } = opts;
     const pendingTokens = (record.pendingMessageTokens ?? 0) + unobservedTokens + extraTokens;
     const currentObservationTokens = record.observationTokenCount ?? 0;
-    const threshold = calculateDynamicThreshold(this.observationConfig.messageTokens, currentObservationTokens);
+    const threshold = calculateDynamicThreshold(this.getEffectiveMessageTokens(record), currentObservationTokens);
     return pendingTokens >= threshold;
   }
   /**
@@ -6324,7 +7146,8 @@ Async buffering is enabled by default \u2014 this opt-out is only needed when us
     return {
       messageTokens: getMaxThreshold(this.observationConfig.messageTokens),
       observationTokens: getMaxThreshold(this.reflectionConfig.observationTokens),
-      scope: this.scope
+      scope: this.scope,
+      activateAfterIdle: this.observationConfig.activateAfterIdle
     };
   }
   /**
@@ -7045,17 +7868,18 @@ ${grouped}` : grouped;
     const cycleId = `buffer-obs-${Date.now()}-${Math.random().toString(36).slice(2, 11)}`;
     const startedAt = (/* @__PURE__ */ new Date()).toISOString();
     const tokensToBuffer = await this.tokenCounter.countMessagesAsync(messagesToBuffer);
+    const startMarker = createBufferingStartMarker({
+      cycleId,
+      operationType: "observation",
+      tokensToBuffer,
+      recordId: freshRecord.id,
+      threadId,
+      threadIds: [threadId],
+      config: this.getObservationMarkerConfig()
+    });
+    await this.persistMarkerToStorage(startMarker, threadId, freshRecord.resourceId ?? void 0);
     if (writer) {
-      const startMarker = createBufferingStartMarker({
-        cycleId,
-        operationType: "observation",
-        tokensToBuffer,
-        recordId: freshRecord.id,
-        threadId,
-        threadIds: [threadId],
-        config: this.getObservationMarkerConfig()
-      });
-      void writer.custom(startMarker).catch(() => {
+      void writer.custom({ ...startMarker, transient: true }).catch(() => {
       });
     }
     omDebug(
@@ -7351,10 +8175,12 @@ ${grouped}` : grouped;
   async getOtherThreadsContext(resourceId, currentThreadId) {
     const { threads: allThreads } = await this.storage.listThreads({ filter: { resourceId } });
     const messagesByThread = /* @__PURE__ */ new Map();
+    const record = await this.getRecord(currentThreadId, resourceId);
+    const recordLastObservedAt = record?.lastObservedAt;
     for (const thread of allThreads) {
       if (thread.id === currentThreadId) continue;
       const omMetadata = memory.getThreadOMMetadata(thread.metadata);
-      const threadLastObservedAt = omMetadata?.lastObservedAt;
+      const threadLastObservedAt = omMetadata?.lastObservedAt ?? recordLastObservedAt;
       const startDate = threadLastObservedAt ? new Date(new Date(threadLastObservedAt).getTime() + 1) : void 0;
       const result = await this.storage.listMessages({
         threadId: thread.id,
@@ -7407,7 +8233,7 @@ ${grouped}` : grouped;
       const projectedMessageRemoval = calculateProjectedMessageRemoval(
         bufferedChunks,
         this.observationConfig.bufferActivation ?? 1,
-        getMaxThreshold(this.observationConfig.messageTokens),
+        getMaxThreshold(this.getEffectiveMessageTokens(record)),
         pendingTokens
       );
       let obsBufferStatus = "idle";
@@ -7496,7 +8322,7 @@ ${grouped}` : grouped;
       otherThreadTokens = otherContext ? this.tokenCounter.countString(otherContext) : 0;
     }
     const pendingTokens = Math.max(0, contextWindowTokens + otherThreadTokens);
-    const threshold = calculateDynamicThreshold(this.observationConfig.messageTokens, currentObservationTokens);
+    const threshold = calculateDynamicThreshold(this.getEffectiveMessageTokens(record), currentObservationTokens);
     const bufferedChunks = getBufferedChunks(record);
     const bufferedChunkCount = bufferedChunks.length;
     const bufferedChunkTokens = bufferedChunks.reduce((sum, chunk) => sum + (chunk.messageTokens ?? 0), 0);
@@ -7513,11 +8339,12 @@ ${grouped}` : grouped;
       );
     }
     const shouldObserve = pendingTokens >= threshold;
-    const reflectThreshold = getMaxThreshold(this.reflectionConfig.observationTokens);
+    const reflectThreshold = getMaxThreshold(this.getEffectiveReflectionTokens(record));
     const shouldReflect = currentObservationTokens >= reflectThreshold;
     const canActivate = bufferedChunkCount > 0;
-    const isSharedBudget = typeof this.observationConfig.messageTokens !== "number";
-    const totalBudget = isSharedBudget ? this.observationConfig.messageTokens.max : 0;
+    const effectiveMessageTokens = this.getEffectiveMessageTokens(record);
+    const isSharedBudget = typeof effectiveMessageTokens !== "number";
+    const totalBudget = isSharedBudget ? effectiveMessageTokens.max : 0;
     const effectiveObservationTokensThreshold = isSharedBudget ? Math.max(totalBudget - threshold, 1e3) : reflectThreshold;
     const unbufferedPendingTokens = Math.max(0, pendingTokens - bufferedChunkTokens);
     return {
@@ -7561,7 +8388,7 @@ ${grouped}` : grouped;
     await BufferingCoordinator.awaitBuffering(threadId, resourceId ?? null, this.scope);
     const preStatus = await this.getStatus({ threadId, resourceId, messages });
     if (preStatus.canActivate) {
-      const actResult = await this.activate({ threadId, resourceId });
+      const actResult = await this.activate({ threadId, resourceId, messages });
       activated = actResult.activated;
     }
     const postStatus = await this.getStatus({ threadId, resourceId, messages });
@@ -7712,18 +8539,19 @@ ${grouped}` : grouped;
       }
       const cycleId = `buffer-obs-${Date.now()}-${Math.random().toString(36).slice(2, 11)}`;
       const startedAt = (/* @__PURE__ */ new Date()).toISOString();
+      const startMarker = createBufferingStartMarker({
+        cycleId,
+        operationType: "observation",
+        tokensToBuffer: newTokens,
+        recordId: record.id,
+        threadId,
+        threadIds: [threadId],
+        config: this.getObservationMarkerConfig()
+      });
+      await this.persistMarkerToStorage(startMarker, threadId, record.resourceId ?? void 0);
       const writer = opts.writer;
       if (writer) {
-        const startMarker = createBufferingStartMarker({
-          cycleId,
-          operationType: "observation",
-          tokensToBuffer: newTokens,
-          recordId: record.id,
-          threadId,
-          threadIds: [threadId],
-          config: this.getObservationMarkerConfig()
-        });
-        void writer.custom(startMarker).catch(() => {
+        void writer.custom({ ...startMarker, transient: true }).catch(() => {
         });
       }
       await ObservationStrategy.create(this, {
@@ -7737,6 +8565,23 @@ ${grouped}` : grouped;
         requestContext,
         observabilityContext
       }).run();
+      if (isOmReproCaptureEnabled()) {
+        writeObserverExchangeReproCapture({
+          threadId,
+          resourceId: record.resourceId ?? void 0,
+          label: `buffer-${cycleId}`,
+          observerExchange: this.observer.lastExchange,
+          details: {
+            cycleId,
+            startedAt,
+            buffered: true,
+            candidateMessageIds: candidateMessages.map((message) => message.id),
+            candidateMessageCount: candidateMessages.length,
+            pendingTokens: currentTokens,
+            newTokens
+          }
+        });
+      }
       await this.storage.setBufferingObservationFlag(record.id, false, newTokens).catch(() => {
       });
       flagCleared = true;
@@ -7804,10 +8649,37 @@ ${grouped}` : grouped;
     if (!chunks.length) {
       return { activated: false, record };
     }
+    let activationTriggeredBy = "threshold";
+    let activationLastActivityAt;
+    let activateAfterIdleExpiredMs;
+    let previousModel;
+    let currentModel;
     if (opts.checkThreshold) {
-      const status = await this.getStatus({ threadId, resourceId, messages: opts.messages });
-      if (status.pendingTokens < status.threshold) {
-        return { activated: false, record };
+      const thresholdMessages = opts.messages ?? await this.loadMessagesFromStorage(
+        threadId,
+        resourceId,
+        record.lastObservedAt ? new Date(record.lastObservedAt) : void 0
+      );
+      const activateAfterIdle = this.observationConfig.activateAfterIdle;
+      const lastActivityAt = getLastActivityFromMessages(thresholdMessages);
+      const ttlExpiredMs = activateAfterIdle !== void 0 && lastActivityAt !== void 0 ? Date.now() - lastActivityAt : void 0;
+      const ttlExpired = ttlExpiredMs !== void 0 && activateAfterIdle !== void 0 && ttlExpiredMs >= activateAfterIdle;
+      const actorModel = getCurrentModel2(opts.currentModel);
+      const lastModel = getLastModelFromMessages(thresholdMessages);
+      const providerChanged = this.observationConfig.activateOnProviderChange === true && didProviderChange(actorModel, lastModel);
+      if (providerChanged) {
+        activationTriggeredBy = "provider_change";
+        previousModel = lastModel;
+        currentModel = actorModel;
+      } else if (ttlExpired) {
+        activationTriggeredBy = "ttl";
+        activationLastActivityAt = lastActivityAt;
+        activateAfterIdleExpiredMs = ttlExpiredMs;
+      } else {
+        const status = await this.getStatus({ threadId, resourceId, messages: thresholdMessages });
+        if (status.pendingTokens < status.threshold) {
+          return { activated: false, record };
+        }
       }
     }
     if (record.isBufferingObservation) {
@@ -7832,7 +8704,7 @@ ${grouped}` : grouped;
     if (!freshChunks.length) {
       return { activated: false, record };
     }
-    const messageTokensThreshold = getMaxThreshold(this.observationConfig.messageTokens);
+    const messageTokensThreshold = getMaxThreshold(this.getEffectiveMessageTokens(freshRecord));
     const bufferActivation = this.observationConfig.bufferActivation ?? 0.7;
     const activationRatio = resolveActivationRatio(bufferActivation, messageTokensThreshold);
     const totalChunkMessageTokens = freshChunks.reduce((sum, c) => sum + (c.messageTokens ?? 0), 0);
@@ -7865,9 +8737,14 @@ ${grouped}` : grouped;
           threadId: postSwapRecord.threadId ?? record.threadId ?? "",
           generationCount: postSwapRecord.generationCount ?? 0,
           observations: chunkData?.observations ?? activationResult.observations,
+          triggeredBy: activationTriggeredBy,
+          lastActivityAt: activationLastActivityAt,
+          ttlExpiredMs: activateAfterIdleExpiredMs,
+          previousModel,
+          currentModel,
           config: this.getObservationMarkerConfig()
         });
-        void opts.writer.custom(activationMarker).catch(() => {
+        void opts.writer.custom({ ...activationMarker, transient: true }).catch(() => {
         });
         await this.persistMarkerToMessage(
           activationMarker,
@@ -7920,6 +8797,7 @@ ${grouped}` : grouped;
     const lockKey = this.buffering.getLockKey(threadId, resourceId);
     const reflectionHooks = hooks ? { onReflectionStart: hooks.onReflectionStart, onReflectionEnd: hooks.onReflectionEnd } : void 0;
     let observed = false;
+    let observationUsage;
     let generationBefore = -1;
     await this.withLock(lockKey, async () => {
       const freshRecord = await this.getOrCreateRecord(threadId, resourceId);
@@ -7936,8 +8814,9 @@ ${grouped}` : grouped;
         return;
       }
       hooks?.onObservationStart?.();
+      let observationError;
       try {
-        observed = await ObservationStrategy.create(this, {
+        const result = await ObservationStrategy.create(this, {
           record: freshRecord,
           threadId,
           resourceId,
@@ -7947,8 +8826,13 @@ ${grouped}` : grouped;
           writer: opts.writer,
           observabilityContext: opts.observabilityContext
         }).run();
+        observed = result.observed;
+        observationUsage = result.usage;
+      } catch (error) {
+        observationError = error instanceof Error ? error : new Error(String(error));
+        throw error;
       } finally {
-        hooks?.onObservationEnd?.();
+        hooks?.onObservationEnd?.({ usage: observationUsage, error: observationError });
       }
     });
     const record = await this.getOrCreateRecord(threadId, resourceId);
@@ -7969,12 +8853,12 @@ ${grouped}` : grouped;
   async reflect(threadId, resourceId, prompt, requestContext, observabilityContext) {
     const record = await this.getOrCreateRecord(threadId, resourceId);
     if (!record.activeObservations) {
-      return { reflected: false, record };
+      return { reflected: false, record, usage: void 0 };
     }
     await this.storage.setReflectingFlag(record.id, true);
     registerOp(record.id, "reflecting");
     try {
-      const reflectThreshold = getMaxThreshold(this.reflectionConfig.observationTokens);
+      const reflectThreshold = getMaxThreshold(this.getEffectiveReflectionTokens(record));
       const reflectResult = await this.reflector.call(
         record.activeObservations,
         prompt,
@@ -7994,11 +8878,11 @@ ${grouped}` : grouped;
         tokenCount: reflectionTokenCount
       });
       const updatedRecord = await this.getOrCreateRecord(threadId, resourceId);
-      return { reflected: true, record: updatedRecord };
+      return { reflected: true, record: updatedRecord, usage: reflectResult.usage };
     } catch (error) {
       omError("[OM] reflect() failed", error);
       const latestRecord = await this.getOrCreateRecord(threadId, resourceId);
-      return { reflected: false, record: latestRecord };
+      return { reflected: false, record: latestRecord, usage: void 0 };
     } finally {
       await this.storage.setReflectingFlag(record.id, false);
       unregisterOp(record.id, "reflecting");
@@ -8019,12 +8903,40 @@ ${grouped}` : grouped;
     const ids = this.getStorageIds(threadId, resourceId);
     return this.storage.getObservationalMemory(ids.threadId, ids.resourceId);
   }
+  /**
+   * Update per-record config overrides for observation and/or reflection thresholds.
+   * The provided config is deep-merged into the record's `_overrides` key,
+   * so you only need to specify the fields you want to change.
+   *
+   * Overrides that violate buffering invariants (e.g. messageTokens below
+   * bufferTokens) are silently ignored at read time — the helpers fall back
+   * to the instance-level config.
+   *
+   * @example
+   * ```ts
+   * await om.updateRecordConfig('thread-1', undefined, {
+   *   observation: { messageTokens: 2000 },
+   *   reflection: { observationTokens: 8000 },
+   * });
+   * ```
+   */
+  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 }
+    });
+  }
   /**
    * Get observation history (previous generations)
    */
-  async getHistory(threadId, resourceId, limit) {
+  async getHistory(threadId, resourceId, limit, options) {
     const ids = this.getStorageIds(threadId, resourceId);
-    return this.storage.getObservationalMemoryHistory(ids.threadId, ids.resourceId, limit);
+    return this.storage.getObservationalMemoryHistory(ids.threadId, ids.resourceId, limit, options);
   }
   /**
    * Clear all memory for a specific thread/resource
@@ -8067,293 +8979,137 @@ ${grouped}` : grouped;
   /**
    * Get whether thread IDs should be obscured in observations.
    */
-  getObscureThreadIds() {
-    return this.shouldObscureThreadIds;
-  }
-  /**
-   * Begin a new observation turn — the high-level API for managing the
-   * observe/buffer/activate/reflect lifecycle across agentic loop steps.
-   *
-   * @example
-   * ```ts
-   * const turn = om.beginTurn({ threadId, resourceId, messageList });
-   * await turn.start(memory);
-   *
-   * const step0 = turn.step(0);
-   * const ctx = await step0.prepare();
-   * // ... agent generates ...
-   *
-   * await turn.end();
-   * ```
-   */
-  beginTurn(opts) {
-    return new ObservationTurn({
-      om: this,
-      threadId: opts.threadId,
-      resourceId: opts.resourceId,
-      messageList: opts.messageList,
-      observabilityContext: opts.observabilityContext,
-      hooks: opts.hooks
-    });
-  }
-};
-var OM_REPRO_CAPTURE_DIR = process.env.OM_REPRO_CAPTURE_DIR ?? ".mastra-om-repro";
-function sanitizeCapturePathSegment(value) {
-  const sanitized = value.replace(/[\\/]+/g, "_").replace(/\.{2,}/g, "_").trim();
-  return sanitized.length > 0 ? sanitized : "unknown-thread";
-}
-function isOmReproCaptureEnabled() {
-  return process.env.OM_REPRO_CAPTURE === "1";
-}
-function safeCaptureJson(value) {
-  return JSON.parse(
-    JSON.stringify(value, (_key, current) => {
-      if (typeof current === "bigint") return current.toString();
-      if (typeof current === "function") return "[function]";
-      if (typeof current === "symbol") return current.toString();
-      if (current instanceof Error) return { name: current.name, message: current.message, stack: current.stack };
-      if (current instanceof Set) return { __type: "Set", values: Array.from(current.values()) };
-      if (current instanceof Map) return { __type: "Map", entries: Array.from(current.entries()) };
-      return current;
-    })
-  );
-}
-function safeCaptureJsonOrError(value) {
-  try {
-    return { ok: true, value: safeCaptureJson(value) };
-  } catch (error) {
-    return {
-      ok: false,
-      error: safeCaptureJson({
-        message: error instanceof Error ? error.message : String(error),
-        stack: error instanceof Error ? error.stack : void 0,
-        inspected: util.inspect(value, { depth: 3, maxArrayLength: 20, breakLength: 120 })
-      })
-    };
-  }
-}
-function formatCaptureDate(value) {
-  if (!value) return void 0;
-  if (value instanceof Date) return value.toISOString();
-  try {
-    return new Date(value).toISOString();
-  } catch {
-    return void 0;
+  getObscureThreadIds() {
+    return this.shouldObscureThreadIds;
   }
-}
-function summarizeOmTurn(value) {
-  if (!value || typeof value !== "object") {
-    return value;
+  /**
+   * Begin a new observation turn — the high-level API for managing the
+   * observe/buffer/activate/reflect lifecycle across agentic loop steps.
+   *
+   * @example
+   * ```ts
+   * const turn = om.beginTurn({ threadId, resourceId, messageList });
+   * await turn.start(memory);
+   *
+   * const step0 = turn.step(0);
+   * const ctx = await step0.prepare();
+   * // ... agent generates ...
+   *
+   * await turn.end();
+   * ```
+   */
+  beginTurn(opts) {
+    return new ObservationTurn({
+      om: this,
+      threadId: opts.threadId,
+      resourceId: opts.resourceId,
+      messageList: opts.messageList,
+      observabilityContext: opts.observabilityContext,
+      hooks: opts.hooks
+    });
   }
-  const turn = value;
+};
+
+// src/processors/observational-memory/temporal-markers.ts
+var TEMPORAL_GAP_REMINDER_TYPE = "temporal-gap";
+function getTemporalGapReminderText(gapText, timestamp) {
+  return `${gapText} \u2014 ${formatTemporalTimestamp(new Date(timestamp))}`;
+}
+function getTemporalGapReminderMetadata(message, gapText, gapMs, timestamp) {
+  const formattedTimestamp = formatTemporalTimestamp(new Date(timestamp));
   return {
-    __type: "ObservationTurn",
-    threadId: turn.threadId,
-    resourceId: turn.resourceId,
-    started: turn._started,
-    ended: turn._ended,
-    generationCountAtStart: turn._generationCountAtStart,
-    record: turn._record ? {
-      id: turn._record.id,
-      scope: turn._record.scope,
-      threadId: turn._record.threadId,
-      resourceId: turn._record.resourceId,
-      createdAt: formatCaptureDate(turn._record.createdAt),
-      updatedAt: formatCaptureDate(turn._record.updatedAt),
-      lastObservedAt: formatCaptureDate(turn._record.lastObservedAt),
-      generationCount: turn._record.generationCount,
-      observationTokenCount: turn._record.observationTokenCount,
-      pendingMessageTokens: turn._record.pendingMessageTokens,
-      isBufferingObservation: turn._record.isBufferingObservation,
-      isBufferingReflection: turn._record.isBufferingReflection
-    } : void 0,
-    context: turn._context ? {
-      messageCount: Array.isArray(turn._context.messages) ? turn._context.messages.length : void 0,
-      hasSystemMessage: Array.isArray(turn._context.systemMessage) ? turn._context.systemMessage.length > 0 : Boolean(turn._context.systemMessage),
-      continuationId: turn._context.continuation?.id,
-      hasOtherThreadsContext: Boolean(turn._context.otherThreadsContext),
-      recordId: turn._context.record?.id
-    } : void 0,
-    currentStep: turn._currentStep ? {
-      stepNumber: turn._currentStep.stepNumber,
-      prepared: turn._currentStep._prepared,
-      context: turn._currentStep._context ? {
-        activated: turn._currentStep._context.activated,
-        observed: turn._currentStep._context.observed,
-        buffered: turn._currentStep._context.buffered,
-        reflected: turn._currentStep._context.reflected,
-        didThresholdCleanup: turn._currentStep._context.didThresholdCleanup,
-        messageCount: Array.isArray(turn._currentStep._context.messages) ? turn._currentStep._context.messages.length : void 0,
-        systemMessageCount: Array.isArray(turn._currentStep._context.systemMessage) ? turn._currentStep._context.systemMessage.length : void 0
-      } : void 0
-    } : void 0
+    reminderType: TEMPORAL_GAP_REMINDER_TYPE,
+    gapText,
+    gapMs,
+    timestamp: formattedTimestamp,
+    timestampMs: timestamp,
+    precedesMessageId: message.id,
+    systemReminder: {
+      type: TEMPORAL_GAP_REMINDER_TYPE,
+      message: getTemporalGapReminderText(gapText, timestamp),
+      gapText,
+      gapMs,
+      timestamp: formattedTimestamp,
+      timestampMs: timestamp,
+      precedesMessageId: message.id
+    }
   };
 }
-function sanitizeCaptureState(rawState) {
-  return Object.fromEntries(
-    Object.entries(rawState).map(([key, value]) => {
-      if (key === "__omTurn") {
-        return [key, summarizeOmTurn(value)];
-      }
-      return [key, value];
-    })
-  );
+function isTemporalGapMarkerForMessage(message, targetMessageId) {
+  if (!isTemporalGapMarker(message)) {
+    return false;
+  }
+  const metadata = message.content.metadata;
+  if (metadata?.precedesMessageId === targetMessageId) {
+    return true;
+  }
+  return metadata?.systemReminder?.type === TEMPORAL_GAP_REMINDER_TYPE && metadata.systemReminder.precedesMessageId === targetMessageId;
 }
-function buildReproMessageFingerprint(message) {
-  const createdAt = message.createdAt instanceof Date ? message.createdAt.toISOString() : message.createdAt ? new Date(message.createdAt).toISOString() : "";
-  return JSON.stringify({
-    role: message.role,
-    createdAt,
-    content: message.content
-  });
+function createTemporalGapMarker(message, gapText, gapMs, timestamp) {
+  const metadata = getTemporalGapReminderMetadata(message, gapText, gapMs, timestamp);
+  return {
+    id: `__temporal_gap_${crypto.randomUUID()}`,
+    role: "user",
+    createdAt: new Date(timestamp - 1),
+    threadId: message.threadId,
+    resourceId: message.resourceId,
+    content: {
+      format: 2,
+      parts: [
+        {
+          type: "text",
+          text: `<system-reminder type="${TEMPORAL_GAP_REMINDER_TYPE}" precedesMessageId="${message.id}">${getTemporalGapReminderText(gapText, timestamp)}</system-reminder>`
+        }
+      ],
+      metadata
+    }
+  };
 }
-function inferReproIdRemap(preMessages, postMessages) {
-  const preByFingerprint = /* @__PURE__ */ new Map();
-  const postByFingerprint = /* @__PURE__ */ new Map();
-  for (const message of preMessages) {
-    if (!message.id) continue;
-    const fingerprint = buildReproMessageFingerprint(message);
-    const list = preByFingerprint.get(fingerprint) ?? [];
-    list.push(message.id);
-    preByFingerprint.set(fingerprint, list);
+async function insertTemporalGapMarkers({
+  messageList,
+  writer
+}) {
+  const inputMessages = messageList.get.input.db().filter((message) => Boolean(message));
+  const latestInputMessage = inputMessages.at(-1);
+  if (!latestInputMessage || isTemporalGapMarker(latestInputMessage)) {
+    return;
   }
-  for (const message of postMessages) {
-    if (!message.id) continue;
-    const fingerprint = buildReproMessageFingerprint(message);
-    const list = postByFingerprint.get(fingerprint) ?? [];
-    list.push(message.id);
-    postByFingerprint.set(fingerprint, list);
+  const allMessages = messageList.get.all.db().filter((message) => Boolean(message));
+  const latestInputIndex = allMessages.findIndex((message) => message.id === latestInputMessage.id);
+  if (latestInputIndex <= 0) {
+    return;
   }
-  const remap = [];
-  for (const [fingerprint, preIds] of preByFingerprint.entries()) {
-    const postIds = postByFingerprint.get(fingerprint);
-    if (!postIds || preIds.length !== 1 || postIds.length !== 1) continue;
-    const fromId = preIds[0];
-    const toId = postIds[0];
-    if (!fromId || !toId || fromId === toId) {
-      continue;
+  if (allMessages.some((message) => isTemporalGapMarkerForMessage(message, latestInputMessage.id))) {
+    return;
+  }
+  let previousNonMarker;
+  for (let index = latestInputIndex - 1; index >= 0; index--) {
+    const candidate = allMessages[index];
+    if (candidate && !isTemporalGapMarker(candidate)) {
+      previousNonMarker = candidate;
+      break;
     }
-    remap.push({ fromId, toId, fingerprint });
   }
-  return remap;
-}
-function writeProcessInputStepReproCapture(params) {
-  if (!isOmReproCaptureEnabled()) {
+  if (!previousNonMarker) {
     return;
   }
-  try {
-    const sanitizedThreadId = sanitizeCapturePathSegment(params.threadId);
-    const runId = `${Date.now()}-step-${params.stepNumber}-${crypto$1.randomUUID()}`;
-    const captureDir = path.join(process.cwd(), OM_REPRO_CAPTURE_DIR, sanitizedThreadId, runId);
-    fs.mkdirSync(captureDir, { recursive: true });
-    const contextMessages = params.messageList.get.all.db();
-    const memoryContext = memory.parseMemoryRequestContext(params.args.requestContext);
-    const preMessageIds = new Set(params.preMessages.map((message) => message.id));
-    const postMessageIds = new Set(contextMessages.map((message) => message.id));
-    const removedMessageIds = params.preMessages.map((message) => message.id).filter((id) => Boolean(id) && !postMessageIds.has(id));
-    const addedMessageIds = contextMessages.map((message) => message.id).filter((id) => Boolean(id) && !preMessageIds.has(id));
-    const idRemap = inferReproIdRemap(params.preMessages, contextMessages);
-    const rawState = params.args.state ?? {};
-    const sanitizedState = sanitizeCaptureState(rawState);
-    const payloads = [
-      {
-        fileName: "input.json",
-        data: {
-          stepNumber: params.stepNumber,
-          threadId: params.threadId,
-          resourceId: params.resourceId,
-          readOnly: memoryContext?.memoryConfig?.readOnly,
-          messageCount: contextMessages.length,
-          messageIds: contextMessages.map((message) => message.id),
-          stateKeys: Object.keys(rawState),
-          state: sanitizedState,
-          args: {
-            messages: params.args.messages,
-            steps: params.args.steps,
-            systemMessages: params.args.systemMessages,
-            retryCount: params.args.retryCount,
-            toolChoice: params.args.toolChoice,
-            activeTools: params.args.activeTools,
-            modelSettings: params.args.modelSettings,
-            structuredOutput: params.args.structuredOutput
-          }
-        }
-      },
-      {
-        fileName: "pre-state.json",
-        data: {
-          record: params.preRecord,
-          bufferedChunks: params.preBufferedChunks,
-          contextTokenCount: params.preContextTokenCount,
-          messages: params.preMessages,
-          messageList: params.preSerializedMessageList
-        }
-      },
-      {
-        fileName: "output.json",
-        data: {
-          details: params.details,
-          messageDiff: {
-            removedMessageIds,
-            addedMessageIds,
-            idRemap
-          }
-        }
-      },
-      {
-        fileName: "post-state.json",
-        data: {
-          record: params.postRecord,
-          bufferedChunks: params.postBufferedChunks,
-          contextTokenCount: params.postContextTokenCount,
-          messageCount: contextMessages.length,
-          messageIds: contextMessages.map((message) => message.id),
-          messages: contextMessages,
-          messageList: params.messageList.serialize()
-        }
-      }
-    ];
-    const captureErrors = [];
-    for (const payload of payloads) {
-      const serialized = safeCaptureJsonOrError(payload.data);
-      if (serialized.ok) {
-        fs.writeFileSync(path.join(captureDir, payload.fileName), `${JSON.stringify(serialized.value, null, 2)}
-`);
-        continue;
-      }
-      captureErrors.push({ fileName: payload.fileName, error: serialized.error });
-      fs.writeFileSync(
-        path.join(captureDir, payload.fileName),
-        `${JSON.stringify({ __captureError: serialized.error }, null, 2)}
-`
-      );
-    }
-    if (params.observerExchange) {
-      const serialized = safeCaptureJsonOrError(params.observerExchange);
-      if (serialized.ok) {
-        fs.writeFileSync(path.join(captureDir, "observer-exchange.json"), `${JSON.stringify(serialized.value, null, 2)}
-`);
-      } else {
-        captureErrors.push({ fileName: "observer-exchange.json", error: serialized.error });
-        fs.writeFileSync(
-          path.join(captureDir, "observer-exchange.json"),
-          `${JSON.stringify({ __captureError: serialized.error }, null, 2)}
-`
-        );
-      }
-    }
-    if (captureErrors.length > 0) {
-      fs.writeFileSync(path.join(captureDir, "capture-error.json"), `${JSON.stringify(captureErrors, null, 2)}
-`);
-      params.debug?.(
-        `[OM:repro-capture] wrote processInputStep capture with ${captureErrors.length} serialization error(s) to ${captureDir}`
-      );
-      return;
-    }
-    params.debug?.(`[OM:repro-capture] wrote processInputStep capture to ${captureDir}`);
-  } catch (error) {
-    params.debug?.(`[OM:repro-capture] failed to write processInputStep capture: ${String(error)}`);
+  const timestamp = getMessagePartTimestamp(latestInputMessage, "first");
+  const gapMs = timestamp - getMessagePartTimestamp(previousNonMarker, "last");
+  const gapText = formatTemporalGap(gapMs);
+  if (!gapText) {
+    return;
   }
+  const reminderMetadata = getTemporalGapReminderMetadata(latestInputMessage, gapText, gapMs, timestamp);
+  await writer?.custom({
+    type: "data-system-reminder",
+    data: {
+      message: getTemporalGapReminderText(gapText, timestamp),
+      ...reminderMetadata
+    },
+    transient: true
+  });
+  const marker = createTemporalGapMarker(latestInputMessage, gapText, gapMs, timestamp);
+  messageList.add(marker, "input");
 }
 
 // src/processors/observational-memory/processor.ts
@@ -8368,6 +9124,10 @@ function getOmObservabilityContext(args) {
     metrics: args.metrics
   };
 }
+var GATEWAY_STATE_KEY = "__isGatewayModel";
+function isMastraGatewayModel(model) {
+  return typeof model === "object" && model !== null && "gatewayId" in model && model.gatewayId === "mastra";
+}
 var ObservationalMemoryProcessor = class {
   id = "observational-memory";
   name = "Observational Memory";
@@ -8375,11 +9135,14 @@ var ObservationalMemoryProcessor = class {
   engine;
   /** Memory instance for loading context. */
   memory;
+  /** Whether temporal-gap reminder markers should be inserted. */
+  temporalMarkers;
   /** Active turn — created on first processInputStep, ended on processOutputResult. */
   turn;
-  constructor(engine, memory) {
+  constructor(engine, memory, options) {
     this.engine = engine;
     this.memory = memory;
+    this.temporalMarkers = options?.temporalMarkers ?? false;
   }
   // ─── Processor lifecycle hooks ──────────────────────────────────────────
   async processInputStep(args) {
@@ -8403,6 +9166,11 @@ var ObservationalMemoryProcessor = class {
       omDebug(`[OM:processInputStep:NO-CONTEXT] getThreadContext returned null \u2014 returning early`);
       return messageList;
     }
+    if (isMastraGatewayModel(model)) {
+      state[GATEWAY_STATE_KEY] = true;
+      omDebug(`[OM:processInputStep:GATEWAY] gateway handles OM \u2014 skipping local processing`);
+      return messageList;
+    }
     const { threadId, resourceId } = context;
     const memoryContext = memory.parseMemoryRequestContext(requestContext);
     const readOnly = memoryContext?.memoryConfig?.readOnly;
@@ -8416,6 +9184,15 @@ var ObservationalMemoryProcessor = class {
       if (readOnly) {
         return messageList;
       }
+      const activeTurn = state.__omTurn ?? this.turn;
+      if (activeTurn && activeTurn.messageList !== messageList) {
+        await activeTurn.end().catch(() => {
+        });
+        if (this.turn === activeTurn) {
+          this.turn = void 0;
+        }
+        state.__omTurn = void 0;
+      }
       if (!this.turn || !state.__omTurn) {
         if (this.turn && !state.__omTurn) {
           await this.turn.end().catch(() => {
@@ -8427,17 +9204,26 @@ var ObservationalMemoryProcessor = class {
           messageList,
           observabilityContext: getOmObservabilityContext(args),
           hooks: {
-            onBufferChunkSealed: rotateResponseMessageId
+            onBufferChunkSealed: rotateResponseMessageId,
+            onSyncObservationComplete: rotateResponseMessageId
           }
         });
         this.turn.writer = writer;
         this.turn.requestContext = requestContext;
         await this.turn.start(this.memory);
+        if (stepNumber === 0 && this.temporalMarkers) {
+          await insertTemporalGapMarkers({ messageList, writer });
+        }
         state.__omTurn = this.turn;
       }
+      this.turn.addHooks({
+        onBufferChunkSealed: rotateResponseMessageId,
+        onSyncObservationComplete: rotateResponseMessageId
+      });
       const observabilityContext = getOmObservabilityContext(args);
       state.__omObservabilityContext = observabilityContext;
       this.turn.observabilityContext = observabilityContext;
+      this.turn.actorModelContext = actorModelContext;
       {
         const step = this.turn.step(stepNumber);
         let ctx;
@@ -8519,6 +9305,7 @@ var ObservationalMemoryProcessor = class {
     const state = _state ?? {};
     const context = this.engine.getThreadContext(requestContext, messageList);
     if (!context) return messageList;
+    if (state[GATEWAY_STATE_KEY]) return messageList;
     const observabilityContext = getOmObservabilityContext(args);
     state.__omObservabilityContext = observabilityContext;
     return this.engine.getTokenCounter().runWithModelContext(state.__omActorModelContext, async () => {
@@ -8595,5 +9382,5 @@ exports.stripEphemeralAnchorIds = stripEphemeralAnchorIds;
 exports.stripObservationGroups = stripObservationGroups;
 exports.truncateStringByTokens = truncateStringByTokens;
 exports.wrapInObservationGroup = wrapInObservationGroup;
-//# sourceMappingURL=chunk-4FMHSWZD.cjs.map
-//# sourceMappingURL=chunk-4FMHSWZD.cjs.map
+//# sourceMappingURL=chunk-6ODYOMHN.cjs.map
+//# sourceMappingURL=chunk-6ODYOMHN.cjs.map