@mastra/memory 1.6.0 → 1.6.1-alpha.0

package/dist/{chunk-5UYAHJVJ.cjs → chunk-D6II7EP4.cjs}

@@ -7,6 +7,7 @@ var llm = require('@mastra/core/llm');
 var memory = require('@mastra/core/memory');
 var processors = require('@mastra/core/processors');
 var xxhash = require('xxhash-wasm');
+var crypto$1 = require('crypto');
 var lite = require('js-tiktoken/lite');
 var o200k_base = require('js-tiktoken/ranks/o200k_base');
 
@@ -17,6 +18,294 @@ var o200k_base__default = /*#__PURE__*/_interopDefault(o200k_base);
 
 // src/processors/observational-memory/observational-memory.ts
 
+// src/processors/observational-memory/date-utils.ts
+function formatRelativeTime(date, currentDate) {
+  const diffMs = currentDate.getTime() - date.getTime();
+  const diffDays = Math.floor(diffMs / (1e3 * 60 * 60 * 24));
+  if (diffDays < 0) {
+    const futureDays = Math.abs(diffDays);
+    if (futureDays === 1) return "tomorrow";
+    if (futureDays < 7) return `in ${futureDays} days`;
+    if (futureDays < 14) return "in 1 week";
+    if (futureDays < 30) return `in ${Math.floor(futureDays / 7)} weeks`;
+    if (futureDays < 60) return "in 1 month";
+    if (futureDays < 365) return `in ${Math.floor(futureDays / 30)} months`;
+    const years = Math.floor(futureDays / 365);
+    return `in ${years} year${years > 1 ? "s" : ""}`;
+  }
+  if (diffDays === 0) return "today";
+  if (diffDays === 1) return "yesterday";
+  if (diffDays < 7) return `${diffDays} days ago`;
+  if (diffDays < 14) return "1 week ago";
+  if (diffDays < 30) return `${Math.floor(diffDays / 7)} weeks ago`;
+  if (diffDays < 60) return "1 month ago";
+  if (diffDays < 365) return `${Math.floor(diffDays / 30)} months ago`;
+  return `${Math.floor(diffDays / 365)} year${Math.floor(diffDays / 365) > 1 ? "s" : ""} ago`;
+}
+function formatGapBetweenDates(prevDate, currDate) {
+  const diffMs = currDate.getTime() - prevDate.getTime();
+  const diffDays = Math.floor(diffMs / (1e3 * 60 * 60 * 24));
+  if (diffDays <= 1) {
+    return null;
+  } else if (diffDays < 7) {
+    return `[${diffDays} days later]`;
+  } else if (diffDays < 14) {
+    return `[1 week later]`;
+  } else if (diffDays < 30) {
+    const weeks = Math.floor(diffDays / 7);
+    return `[${weeks} weeks later]`;
+  } else if (diffDays < 60) {
+    return `[1 month later]`;
+  } else {
+    const months = Math.floor(diffDays / 30);
+    return `[${months} months later]`;
+  }
+}
+function parseDateFromContent(dateContent) {
+  let targetDate = null;
+  const simpleDateMatch = dateContent.match(/([A-Z][a-z]+)\s+(\d{1,2}),?\s+(\d{4})/);
+  if (simpleDateMatch) {
+    const parsed = /* @__PURE__ */ new Date(`${simpleDateMatch[1]} ${simpleDateMatch[2]}, ${simpleDateMatch[3]}`);
+    if (!isNaN(parsed.getTime())) {
+      targetDate = parsed;
+    }
+  }
+  if (!targetDate) {
+    const rangeMatch = dateContent.match(/([A-Z][a-z]+)\s+(\d{1,2})-\d{1,2},?\s+(\d{4})/);
+    if (rangeMatch) {
+      const parsed = /* @__PURE__ */ new Date(`${rangeMatch[1]} ${rangeMatch[2]}, ${rangeMatch[3]}`);
+      if (!isNaN(parsed.getTime())) {
+        targetDate = parsed;
+      }
+    }
+  }
+  if (!targetDate) {
+    const vagueMatch = dateContent.match(
+      /(late|early|mid)[- ]?(?:to[- ]?(?:late|early|mid)[- ]?)?([A-Z][a-z]+)\s+(\d{4})/i
+    );
+    if (vagueMatch) {
+      const month = vagueMatch[2];
+      const year = vagueMatch[3];
+      const modifier = vagueMatch[1].toLowerCase();
+      let day = 15;
+      if (modifier === "early") day = 7;
+      if (modifier === "late") day = 23;
+      const parsed = /* @__PURE__ */ new Date(`${month} ${day}, ${year}`);
+      if (!isNaN(parsed.getTime())) {
+        targetDate = parsed;
+      }
+    }
+  }
+  if (!targetDate) {
+    const crossMonthMatch = dateContent.match(/([A-Z][a-z]+)\s+to\s+(?:early\s+)?([A-Z][a-z]+)\s+(\d{4})/i);
+    if (crossMonthMatch) {
+      const parsed = /* @__PURE__ */ new Date(`${crossMonthMatch[2]} 1, ${crossMonthMatch[3]}`);
+      if (!isNaN(parsed.getTime())) {
+        targetDate = parsed;
+      }
+    }
+  }
+  return targetDate;
+}
+function isFutureIntentObservation(line) {
+  const futureIntentPatterns = [
+    /\bwill\s+(?:be\s+)?(?:\w+ing|\w+)\b/i,
+    /\bplans?\s+to\b/i,
+    /\bplanning\s+to\b/i,
+    /\blooking\s+forward\s+to\b/i,
+    /\bgoing\s+to\b/i,
+    /\bintends?\s+to\b/i,
+    /\bwants?\s+to\b/i,
+    /\bneeds?\s+to\b/i,
+    /\babout\s+to\b/i
+  ];
+  return futureIntentPatterns.some((pattern) => pattern.test(line));
+}
+function expandInlineEstimatedDates(observations, currentDate) {
+  const inlineDateRegex = /\((estimated|meaning)\s+([^)]+\d{4})\)/gi;
+  return observations.replace(inlineDateRegex, (match, prefix, dateContent, offset) => {
+    const targetDate = parseDateFromContent(dateContent);
+    if (targetDate) {
+      const relative = formatRelativeTime(targetDate, currentDate);
+      const lineStart = observations.lastIndexOf("\n", offset) + 1;
+      const lineBeforeDate = observations.slice(lineStart, offset);
+      const isPastDate = targetDate < currentDate;
+      const isFutureIntent = isFutureIntentObservation(lineBeforeDate);
+      if (isPastDate && isFutureIntent) {
+        return `(${prefix} ${dateContent} - ${relative}, likely already happened)`;
+      }
+      return `(${prefix} ${dateContent} - ${relative})`;
+    }
+    return match;
+  });
+}
+function addRelativeTimeToObservations(observations, currentDate) {
+  const withInlineDates = expandInlineEstimatedDates(observations, currentDate);
+  const dateHeaderRegex = /^(Date:\s*)([A-Z][a-z]+ \d{1,2}, \d{4})$/gm;
+  const dates = [];
+  let regexMatch;
+  while ((regexMatch = dateHeaderRegex.exec(withInlineDates)) !== null) {
+    const dateStr = regexMatch[2];
+    const parsed = new Date(dateStr);
+    if (!isNaN(parsed.getTime())) {
+      dates.push({
+        index: regexMatch.index,
+        date: parsed,
+        match: regexMatch[0],
+        prefix: regexMatch[1],
+        dateStr
+      });
+    }
+  }
+  if (dates.length === 0) {
+    return withInlineDates;
+  }
+  let result = "";
+  let lastIndex = 0;
+  for (let i = 0; i < dates.length; i++) {
+    const curr = dates[i];
+    const prev = i > 0 ? dates[i - 1] : null;
+    result += withInlineDates.slice(lastIndex, curr.index);
+    if (prev) {
+      const gap = formatGapBetweenDates(prev.date, curr.date);
+      if (gap) {
+        result += `
+${gap}
+
+`;
+      }
+    }
+    const relative = formatRelativeTime(curr.date, currentDate);
+    result += `${curr.prefix}${curr.dateStr} (${relative})`;
+    lastIndex = curr.index + curr.match.length;
+  }
+  result += withInlineDates.slice(lastIndex);
+  return result;
+}
+
+// src/processors/observational-memory/markers.ts
+function createObservationStartMarker(params) {
+  return {
+    type: "data-om-observation-start",
+    data: {
+      cycleId: params.cycleId,
+      operationType: params.operationType,
+      startedAt: (/* @__PURE__ */ new Date()).toISOString(),
+      tokensToObserve: params.tokensToObserve,
+      recordId: params.recordId,
+      threadId: params.threadId,
+      threadIds: params.threadIds,
+      config: params.config
+    }
+  };
+}
+function createObservationEndMarker(params) {
+  const completedAt = (/* @__PURE__ */ new Date()).toISOString();
+  const durationMs = new Date(completedAt).getTime() - new Date(params.startedAt).getTime();
+  return {
+    type: "data-om-observation-end",
+    data: {
+      cycleId: params.cycleId,
+      operationType: params.operationType,
+      completedAt,
+      durationMs,
+      tokensObserved: params.tokensObserved,
+      observationTokens: params.observationTokens,
+      observations: params.observations,
+      currentTask: params.currentTask,
+      suggestedResponse: params.suggestedResponse,
+      recordId: params.recordId,
+      threadId: params.threadId
+    }
+  };
+}
+function createObservationFailedMarker(params) {
+  const failedAt = (/* @__PURE__ */ new Date()).toISOString();
+  const durationMs = new Date(failedAt).getTime() - new Date(params.startedAt).getTime();
+  return {
+    type: "data-om-observation-failed",
+    data: {
+      cycleId: params.cycleId,
+      operationType: params.operationType,
+      failedAt,
+      durationMs,
+      tokensAttempted: params.tokensAttempted,
+      error: params.error,
+      recordId: params.recordId,
+      threadId: params.threadId
+    }
+  };
+}
+function createBufferingStartMarker(params) {
+  return {
+    type: "data-om-buffering-start",
+    data: {
+      cycleId: params.cycleId,
+      operationType: params.operationType,
+      startedAt: (/* @__PURE__ */ new Date()).toISOString(),
+      tokensToBuffer: params.tokensToBuffer,
+      recordId: params.recordId,
+      threadId: params.threadId,
+      threadIds: params.threadIds,
+      config: params.config
+    }
+  };
+}
+function createBufferingEndMarker(params) {
+  const completedAt = (/* @__PURE__ */ new Date()).toISOString();
+  const durationMs = new Date(completedAt).getTime() - new Date(params.startedAt).getTime();
+  return {
+    type: "data-om-buffering-end",
+    data: {
+      cycleId: params.cycleId,
+      operationType: params.operationType,
+      completedAt,
+      durationMs,
+      tokensBuffered: params.tokensBuffered,
+      bufferedTokens: params.bufferedTokens,
+      recordId: params.recordId,
+      threadId: params.threadId,
+      observations: params.observations
+    }
+  };
+}
+function createBufferingFailedMarker(params) {
+  const failedAt = (/* @__PURE__ */ new Date()).toISOString();
+  const durationMs = new Date(failedAt).getTime() - new Date(params.startedAt).getTime();
+  return {
+    type: "data-om-buffering-failed",
+    data: {
+      cycleId: params.cycleId,
+      operationType: params.operationType,
+      failedAt,
+      durationMs,
+      tokensAttempted: params.tokensAttempted,
+      error: params.error,
+      recordId: params.recordId,
+      threadId: params.threadId
+    }
+  };
+}
+function createActivationMarker(params) {
+  return {
+    type: "data-om-activation",
+    data: {
+      cycleId: params.cycleId,
+      operationType: params.operationType,
+      activatedAt: (/* @__PURE__ */ new Date()).toISOString(),
+      chunksActivated: params.chunksActivated,
+      tokensActivated: params.tokensActivated,
+      observationTokens: params.observationTokens,
+      messagesActivated: params.messagesActivated,
+      recordId: params.recordId,
+      threadId: params.threadId,
+      generationCount: params.generationCount,
+      config: params.config,
+      observations: params.observations
+    }
+  };
+}
+
 // src/processors/observational-memory/observer-agent.ts
 var OBSERVER_EXTRACTION_INSTRUCTIONS = `CRITICAL: DISTINGUISH USER ASSERTIONS FROM QUESTIONS
 
@@ -688,6 +977,29 @@ function optimizeObservationsForContext(observations) {
   return optimized.trim();
 }
 
+// src/processors/observational-memory/operation-registry.ts
+var activeOps = /* @__PURE__ */ new Map();
+function opKey(recordId, op) {
+  return `${recordId}:${op}`;
+}
+function registerOp(recordId, op) {
+  const key = opKey(recordId, op);
+  activeOps.set(key, (activeOps.get(key) ?? 0) + 1);
+}
+function unregisterOp(recordId, op) {
+  const key = opKey(recordId, op);
+  const count = activeOps.get(key);
+  if (!count) return;
+  if (count <= 1) {
+    activeOps.delete(key);
+  } else {
+    activeOps.set(key, count - 1);
+  }
+}
+function isOpActiveInProcess(recordId, op) {
+  return (activeOps.get(opKey(recordId, op)) ?? 0) > 0;
+}
+
 // src/processors/observational-memory/reflector-agent.ts
 function buildReflectorSystemPrompt(instruction) {
   return `You are the memory consciousness of an AI assistant. Your memory observation reflections will be the ONLY information the assistant has about past interactions with this user.
@@ -916,6 +1228,91 @@ function extractReflectorListItems(content) {
 function validateCompression(reflectedTokens, targetThreshold) {
   return reflectedTokens < targetThreshold;
 }
+
+// src/processors/observational-memory/thresholds.ts
+function getMaxThreshold(threshold) {
+  if (typeof threshold === "number") {
+    return threshold;
+  }
+  return threshold.max;
+}
+function calculateDynamicThreshold(threshold, currentObservationTokens) {
+  if (typeof threshold === "number") {
+    return threshold;
+  }
+  const totalBudget = threshold.max;
+  const baseThreshold = threshold.min;
+  const effectiveThreshold = Math.max(totalBudget - currentObservationTokens, baseThreshold);
+  return Math.round(effectiveThreshold);
+}
+function resolveBufferTokens(bufferTokens, messageTokens) {
+  if (bufferTokens === false) return void 0;
+  if (bufferTokens === void 0) return void 0;
+  if (bufferTokens > 0 && bufferTokens < 1) {
+    return Math.round(getMaxThreshold(messageTokens) * bufferTokens);
+  }
+  return bufferTokens;
+}
+function resolveBlockAfter(blockAfter, messageTokens) {
+  if (blockAfter === void 0) return void 0;
+  if (blockAfter >= 1 && blockAfter < 100) {
+    return Math.round(getMaxThreshold(messageTokens) * blockAfter);
+  }
+  return blockAfter;
+}
+function resolveRetentionFloor(bufferActivation, messageTokensThreshold) {
+  if (bufferActivation >= 1e3) return bufferActivation;
+  const ratio = Math.max(0, Math.min(1, bufferActivation));
+  return messageTokensThreshold * (1 - ratio);
+}
+function resolveActivationRatio(bufferActivation, messageTokensThreshold) {
+  if (bufferActivation >= 1e3) {
+    return Math.max(0, Math.min(1, 1 - bufferActivation / messageTokensThreshold));
+  }
+  return Math.max(0, Math.min(1, bufferActivation));
+}
+function calculateProjectedMessageRemoval(chunks, bufferActivation, messageTokensThreshold, currentPendingTokens) {
+  if (chunks.length === 0) return 0;
+  const retentionFloor = resolveRetentionFloor(bufferActivation, messageTokensThreshold);
+  const targetMessageTokens = Math.max(0, currentPendingTokens - retentionFloor);
+  if (targetMessageTokens === 0) return 0;
+  let cumulativeMessageTokens = 0;
+  let bestOverBoundary = 0;
+  let bestOverTokens = 0;
+  let bestUnderBoundary = 0;
+  let bestUnderTokens = 0;
+  for (let i = 0; i < chunks.length; i++) {
+    cumulativeMessageTokens += chunks[i].messageTokens ?? 0;
+    const boundary = i + 1;
+    if (cumulativeMessageTokens >= targetMessageTokens) {
+      if (bestOverBoundary === 0 || cumulativeMessageTokens < bestOverTokens) {
+        bestOverBoundary = boundary;
+        bestOverTokens = cumulativeMessageTokens;
+      }
+    } else {
+      if (cumulativeMessageTokens > bestUnderTokens) {
+        bestUnderBoundary = boundary;
+        bestUnderTokens = cumulativeMessageTokens;
+      }
+    }
+  }
+  const maxOvershoot = retentionFloor * 0.95;
+  const overshoot = bestOverTokens - targetMessageTokens;
+  const remainingAfterOver = currentPendingTokens - bestOverTokens;
+  const remainingAfterUnder = currentPendingTokens - bestUnderTokens;
+  const minRemaining = Math.min(1e3, retentionFloor);
+  let bestBoundaryMessageTokens;
+  if (bestOverBoundary > 0 && overshoot <= maxOvershoot && remainingAfterOver >= minRemaining) {
+    bestBoundaryMessageTokens = bestOverTokens;
+  } else if (bestUnderBoundary > 0 && remainingAfterUnder >= minRemaining) {
+    bestBoundaryMessageTokens = bestUnderTokens;
+  } else if (bestOverBoundary > 0) {
+    bestBoundaryMessageTokens = bestOverTokens;
+  } else {
+    return chunks[0]?.messageTokens ?? 0;
+  }
+  return bestBoundaryMessageTokens;
+}
 var sharedDefaultEncoder;
 function getDefaultEncoder() {
   if (!sharedDefaultEncoder) {
@@ -923,8 +1320,94 @@ function getDefaultEncoder() {
   }
   return sharedDefaultEncoder;
 }
+var TOKEN_ESTIMATE_CACHE_VERSION = 1;
+function buildEstimateKey(kind, text) {
+  const payloadHash = crypto$1.createHash("sha1").update(text).digest("hex");
+  return `${kind}:${payloadHash}`;
+}
+function resolveEncodingId(encoding) {
+  if (!encoding) return "o200k_base";
+  try {
+    return `custom:${crypto$1.createHash("sha1").update(JSON.stringify(encoding)).digest("hex")}`;
+  } catch {
+    return "custom:unknown";
+  }
+}
+function isTokenEstimateEntry(value) {
+  if (!value || typeof value !== "object") return false;
+  const entry = value;
+  return typeof entry.v === "number" && typeof entry.source === "string" && typeof entry.key === "string" && typeof entry.tokens === "number";
+}
+function getCacheEntry(cache, key) {
+  if (!cache || typeof cache !== "object") return void 0;
+  if (isTokenEstimateEntry(cache)) {
+    return cache.key === key ? cache : void 0;
+  }
+  return void 0;
+}
+function getPartCacheEntry(part, key) {
+  const cache = part?.providerMetadata?.mastra?.tokenEstimate;
+  return getCacheEntry(cache, key);
+}
+function setPartCacheEntry(part, _key, entry) {
+  const mutablePart = part;
+  mutablePart.providerMetadata ??= {};
+  mutablePart.providerMetadata.mastra ??= {};
+  mutablePart.providerMetadata.mastra.tokenEstimate = entry;
+}
+function getMessageCacheEntry(message, key) {
+  const content = message.content;
+  if (content && typeof content === "object") {
+    const contentLevelCache = content.metadata?.mastra?.tokenEstimate;
+    const contentLevelEntry = getCacheEntry(contentLevelCache, key);
+    if (contentLevelEntry) return contentLevelEntry;
+  }
+  const messageLevelCache = message?.metadata?.mastra?.tokenEstimate;
+  return getCacheEntry(messageLevelCache, key);
+}
+function setMessageCacheEntry(message, _key, entry) {
+  const content = message.content;
+  if (content && typeof content === "object") {
+    content.metadata ??= {};
+    content.metadata.mastra ??= {};
+    content.metadata.mastra.tokenEstimate = entry;
+    return;
+  }
+  message.metadata ??= {};
+  message.metadata.mastra ??= {};
+  message.metadata.mastra.tokenEstimate = entry;
+}
+function serializePartForTokenCounting(part) {
+  const hasTokenEstimate = Boolean(part?.providerMetadata?.mastra?.tokenEstimate);
+  if (!hasTokenEstimate) {
+    return JSON.stringify(part);
+  }
+  const clonedPart = {
+    ...part,
+    providerMetadata: {
+      ...part.providerMetadata ?? {},
+      mastra: {
+        ...part.providerMetadata?.mastra ?? {}
+      }
+    }
+  };
+  delete clonedPart.providerMetadata.mastra.tokenEstimate;
+  if (Object.keys(clonedPart.providerMetadata.mastra).length === 0) {
+    delete clonedPart.providerMetadata.mastra;
+  }
+  if (Object.keys(clonedPart.providerMetadata).length === 0) {
+    delete clonedPart.providerMetadata;
+  }
+  return JSON.stringify(clonedPart);
+}
+function isValidCacheEntry(entry, expectedKey, expectedSource) {
+  return Boolean(
+    entry && entry.v === TOKEN_ESTIMATE_CACHE_VERSION && entry.source === expectedSource && entry.key === expectedKey && Number.isFinite(entry.tokens)
+  );
+}
 var TokenCounter = class _TokenCounter {
   encoder;
+  cacheSource;
   // Per-message overhead: accounts for role tokens, message framing, and separators.
   // Empirically derived from OpenAI's token counting guide (3 tokens per message base +
   // fractional overhead from name/role encoding). 3.8 is a practical average across models.
@@ -933,6 +1416,7 @@ var TokenCounter = class _TokenCounter {
   static TOKENS_PER_CONVERSATION = 24;
   constructor(encoding) {
     this.encoder = encoding ? new lite.Tiktoken(encoding) : getDefaultEncoder();
+    this.cacheSource = `v${TOKEN_ESTIMATE_CACHE_VERSION}:${resolveEncodingId(encoding)}`;
   }
   /**
    * Count tokens in a plain string
@@ -941,43 +1425,108 @@ var TokenCounter = class _TokenCounter {
     if (!text) return 0;
     return this.encoder.encode(text, "all").length;
   }
+  readOrPersistPartEstimate(part, kind, payload) {
+    const key = buildEstimateKey(kind, payload);
+    const cached = getPartCacheEntry(part, key);
+    if (isValidCacheEntry(cached, key, this.cacheSource)) {
+      return cached.tokens;
+    }
+    const tokens = this.countString(payload);
+    setPartCacheEntry(part, key, {
+      v: TOKEN_ESTIMATE_CACHE_VERSION,
+      source: this.cacheSource,
+      key,
+      tokens
+    });
+    return tokens;
+  }
+  readOrPersistMessageEstimate(message, kind, payload) {
+    const key = buildEstimateKey(kind, payload);
+    const cached = getMessageCacheEntry(message, key);
+    if (isValidCacheEntry(cached, key, this.cacheSource)) {
+      return cached.tokens;
+    }
+    const tokens = this.countString(payload);
+    setMessageCacheEntry(message, key, {
+      v: TOKEN_ESTIMATE_CACHE_VERSION,
+      source: this.cacheSource,
+      key,
+      tokens
+    });
+    return tokens;
+  }
+  resolveToolResultForTokenCounting(part, invocationResult) {
+    const mastraMetadata = part?.providerMetadata?.mastra;
+    if (mastraMetadata && typeof mastraMetadata === "object" && "modelOutput" in mastraMetadata) {
+      return {
+        value: mastraMetadata.modelOutput,
+        usingStoredModelOutput: true
+      };
+    }
+    return {
+      value: invocationResult,
+      usingStoredModelOutput: false
+    };
+  }
   /**
    * Count tokens in a single message
    */
   countMessage(message) {
-    let tokenString = message.role;
+    let payloadTokens = this.countString(message.role);
     let overhead = _TokenCounter.TOKENS_PER_MESSAGE;
     let toolResultCount = 0;
     if (typeof message.content === "string") {
-      tokenString += message.content;
+      payloadTokens += this.readOrPersistMessageEstimate(message, "message-content", message.content);
     } else if (message.content && typeof message.content === "object") {
       if (message.content.content && !Array.isArray(message.content.parts)) {
-        tokenString += message.content.content;
+        payloadTokens += this.readOrPersistMessageEstimate(message, "content-content", message.content.content);
       } else if (Array.isArray(message.content.parts)) {
         for (const part of message.content.parts) {
           if (part.type === "text") {
-            tokenString += part.text;
+            payloadTokens += this.readOrPersistPartEstimate(part, "text", part.text);
           } else if (part.type === "tool-invocation") {
             const invocation = part.toolInvocation;
             if (invocation.state === "call" || invocation.state === "partial-call") {
               if (invocation.toolName) {
-                tokenString += invocation.toolName;
+                payloadTokens += this.readOrPersistPartEstimate(
+                  part,
+                  `tool-${invocation.state}-name`,
+                  invocation.toolName
+                );
               }
               if (invocation.args) {
                 if (typeof invocation.args === "string") {
-                  tokenString += invocation.args;
+                  payloadTokens += this.readOrPersistPartEstimate(
+                    part,
+                    `tool-${invocation.state}-args`,
+                    invocation.args
+                  );
                 } else {
-                  tokenString += JSON.stringify(invocation.args);
+                  const argsJson = JSON.stringify(invocation.args);
+                  payloadTokens += this.readOrPersistPartEstimate(part, `tool-${invocation.state}-args-json`, argsJson);
                   overhead -= 12;
                 }
               }
             } else if (invocation.state === "result") {
               toolResultCount++;
-              if (invocation.result !== void 0) {
-                if (typeof invocation.result === "string") {
-                  tokenString += invocation.result;
+              const { value: resultForCounting, usingStoredModelOutput } = this.resolveToolResultForTokenCounting(
+                part,
+                invocation.result
+              );
+              if (resultForCounting !== void 0) {
+                if (typeof resultForCounting === "string") {
+                  payloadTokens += this.readOrPersistPartEstimate(
+                    part,
+                    usingStoredModelOutput ? "tool-result-model-output" : "tool-result",
+                    resultForCounting
+                  );
                 } else {
-                  tokenString += JSON.stringify(invocation.result);
+                  const resultJson = JSON.stringify(resultForCounting);
+                  payloadTokens += this.readOrPersistPartEstimate(
+                    part,
+                    usingStoredModelOutput ? "tool-result-model-output-json" : "tool-result-json",
+                    resultJson
+                  );
                   overhead -= 12;
                 }
               }
@@ -987,7 +1536,8 @@ var TokenCounter = class _TokenCounter {
               );
             }
           } else if (typeof part.type === "string" && part.type.startsWith("data-")) ; else if (part.type === "reasoning") ; else {
-            tokenString += JSON.stringify(part);
+            const serialized = serializePartForTokenCounting(part);
+            payloadTokens += this.readOrPersistPartEstimate(part, `part-${part.type}`, serialized);
           }
         }
       }
@@ -995,7 +1545,7 @@ var TokenCounter = class _TokenCounter {
     if (toolResultCount > 0) {
       overhead += toolResultCount * _TokenCounter.TOKENS_PER_MESSAGE;
     }
-    return Math.round(this.encoder.encode(tokenString, "all").length + overhead);
+    return Math.round(payloadTokens + overhead);
   }
   /**
    * Count tokens in an array of messages
@@ -1032,19 +1582,6 @@ function omError(msg, err) {
   omDebug(`[OM:ERROR] ${full}`);
 }
 omDebug(`[OM:process-start] OM module loaded, pid=${process.pid}`);
-var activeOps = /* @__PURE__ */ new Set();
-function opKey(recordId, op) {
-  return `${recordId}:${op}`;
-}
-function registerOp(recordId, op) {
-  activeOps.add(opKey(recordId, op));
-}
-function unregisterOp(recordId, op) {
-  activeOps.delete(opKey(recordId, op));
-}
-function isOpActiveInProcess(recordId, op) {
-  return activeOps.has(opKey(recordId, op));
-}
 if (OM_DEBUG_LOG) {
   const _origConsoleError = console.error;
   console.error = (...args) => {
@@ -1054,159 +1591,6 @@ if (OM_DEBUG_LOG) {
     _origConsoleError.apply(console, args);
   };
 }
-function formatRelativeTime(date, currentDate) {
-  const diffMs = currentDate.getTime() - date.getTime();
-  const diffDays = Math.floor(diffMs / (1e3 * 60 * 60 * 24));
-  if (diffDays === 0) return "today";
-  if (diffDays === 1) return "yesterday";
-  if (diffDays < 7) return `${diffDays} days ago`;
-  if (diffDays < 14) return "1 week ago";
-  if (diffDays < 30) return `${Math.floor(diffDays / 7)} weeks ago`;
-  if (diffDays < 60) return "1 month ago";
-  if (diffDays < 365) return `${Math.floor(diffDays / 30)} months ago`;
-  return `${Math.floor(diffDays / 365)} year${Math.floor(diffDays / 365) > 1 ? "s" : ""} ago`;
-}
-function formatGapBetweenDates(prevDate, currDate) {
-  const diffMs = currDate.getTime() - prevDate.getTime();
-  const diffDays = Math.floor(diffMs / (1e3 * 60 * 60 * 24));
-  if (diffDays <= 1) {
-    return null;
-  } else if (diffDays < 7) {
-    return `[${diffDays} days later]`;
-  } else if (diffDays < 14) {
-    return `[1 week later]`;
-  } else if (diffDays < 30) {
-    const weeks = Math.floor(diffDays / 7);
-    return `[${weeks} weeks later]`;
-  } else if (diffDays < 60) {
-    return `[1 month later]`;
-  } else {
-    const months = Math.floor(diffDays / 30);
-    return `[${months} months later]`;
-  }
-}
-function parseDateFromContent(dateContent) {
-  let targetDate = null;
-  const simpleDateMatch = dateContent.match(/([A-Z][a-z]+)\s+(\d{1,2}),?\s+(\d{4})/);
-  if (simpleDateMatch) {
-    const parsed = /* @__PURE__ */ new Date(`${simpleDateMatch[1]} ${simpleDateMatch[2]}, ${simpleDateMatch[3]}`);
-    if (!isNaN(parsed.getTime())) {
-      targetDate = parsed;
-    }
-  }
-  if (!targetDate) {
-    const rangeMatch = dateContent.match(/([A-Z][a-z]+)\s+(\d{1,2})-\d{1,2},?\s+(\d{4})/);
-    if (rangeMatch) {
-      const parsed = /* @__PURE__ */ new Date(`${rangeMatch[1]} ${rangeMatch[2]}, ${rangeMatch[3]}`);
-      if (!isNaN(parsed.getTime())) {
-        targetDate = parsed;
-      }
-    }
-  }
-  if (!targetDate) {
-    const vagueMatch = dateContent.match(
-      /(late|early|mid)[- ]?(?:to[- ]?(?:late|early|mid)[- ]?)?([A-Z][a-z]+)\s+(\d{4})/i
-    );
-    if (vagueMatch) {
-      const month = vagueMatch[2];
-      const year = vagueMatch[3];
-      const modifier = vagueMatch[1].toLowerCase();
-      let day = 15;
-      if (modifier === "early") day = 7;
-      if (modifier === "late") day = 23;
-      const parsed = /* @__PURE__ */ new Date(`${month} ${day}, ${year}`);
-      if (!isNaN(parsed.getTime())) {
-        targetDate = parsed;
-      }
-    }
-  }
-  if (!targetDate) {
-    const crossMonthMatch = dateContent.match(/([A-Z][a-z]+)\s+to\s+(?:early\s+)?([A-Z][a-z]+)\s+(\d{4})/i);
-    if (crossMonthMatch) {
-      const parsed = /* @__PURE__ */ new Date(`${crossMonthMatch[2]} 1, ${crossMonthMatch[3]}`);
-      if (!isNaN(parsed.getTime())) {
-        targetDate = parsed;
-      }
-    }
-  }
-  return targetDate;
-}
-function isFutureIntentObservation(line) {
-  const futureIntentPatterns = [
-    /\bwill\s+(?:be\s+)?(?:\w+ing|\w+)\b/i,
-    /\bplans?\s+to\b/i,
-    /\bplanning\s+to\b/i,
-    /\blooking\s+forward\s+to\b/i,
-    /\bgoing\s+to\b/i,
-    /\bintends?\s+to\b/i,
-    /\bwants?\s+to\b/i,
-    /\bneeds?\s+to\b/i,
-    /\babout\s+to\b/i
-  ];
-  return futureIntentPatterns.some((pattern) => pattern.test(line));
-}
-function expandInlineEstimatedDates(observations, currentDate) {
-  const inlineDateRegex = /\((estimated|meaning)\s+([^)]+\d{4})\)/gi;
-  return observations.replace(inlineDateRegex, (match, prefix, dateContent) => {
-    const targetDate = parseDateFromContent(dateContent);
-    if (targetDate) {
-      const relative = formatRelativeTime(targetDate, currentDate);
-      const matchIndex = observations.indexOf(match);
-      const lineStart = observations.lastIndexOf("\n", matchIndex) + 1;
-      const lineBeforeDate = observations.substring(lineStart, matchIndex);
-      const isPastDate = targetDate < currentDate;
-      const isFutureIntent = isFutureIntentObservation(lineBeforeDate);
-      if (isPastDate && isFutureIntent) {
-        return `(${prefix} ${dateContent} - ${relative}, likely already happened)`;
-      }
-      return `(${prefix} ${dateContent} - ${relative})`;
-    }
-    return match;
-  });
-}
-function addRelativeTimeToObservations(observations, currentDate) {
-  const withInlineDates = expandInlineEstimatedDates(observations, currentDate);
-  const dateHeaderRegex = /^(Date:\s*)([A-Z][a-z]+ \d{1,2}, \d{4})$/gm;
-  const dates = [];
-  let regexMatch;
-  while ((regexMatch = dateHeaderRegex.exec(withInlineDates)) !== null) {
-    const dateStr = regexMatch[2];
-    const parsed = new Date(dateStr);
-    if (!isNaN(parsed.getTime())) {
-      dates.push({
-        index: regexMatch.index,
-        date: parsed,
-        match: regexMatch[0],
-        prefix: regexMatch[1],
-        dateStr
-      });
-    }
-  }
-  if (dates.length === 0) {
-    return withInlineDates;
-  }
-  let result = "";
-  let lastIndex = 0;
-  for (let i = 0; i < dates.length; i++) {
-    const curr = dates[i];
-    const prev = i > 0 ? dates[i - 1] : null;
-    result += withInlineDates.slice(lastIndex, curr.index);
-    if (prev) {
-      const gap = formatGapBetweenDates(prev.date, curr.date);
-      if (gap) {
-        result += `
-${gap}
-
-`;
-      }
-    }
-    const relative = formatRelativeTime(curr.date, currentDate);
-    result += `${curr.prefix}${curr.dateStr} (${relative})`;
-    lastIndex = curr.index + curr.match.length;
-  }
-  result += withInlineDates.slice(lastIndex);
-  return result;
-}
 var OBSERVATIONAL_MEMORY_DEFAULTS = {
   observation: {
     model: "google/gemini-2.5-flash",
@@ -1431,71 +1815,6 @@ var ObservationalMemory = class _ObservationalMemory {
     }
     return [];
   }
-  /**
-   * Resolve bufferActivation config into an absolute retention floor (tokens to keep).
-   * - Value in (0, 1]: ratio → retentionFloor = threshold * (1 - value)
-   * - Value >= 1000: absolute token count → retentionFloor = value
-   */
-  resolveRetentionFloor(bufferActivation, messageTokensThreshold) {
-    if (bufferActivation >= 1e3) return bufferActivation;
-    return messageTokensThreshold * (1 - bufferActivation);
-  }
-  /**
-   * Convert bufferActivation to the equivalent ratio (0-1) for the storage layer.
-   * When bufferActivation >= 1000, it's an absolute retention target, so we compute
-   * the equivalent ratio: 1 - (bufferActivation / threshold).
-   */
-  resolveActivationRatio(bufferActivation, messageTokensThreshold) {
-    if (bufferActivation >= 1e3) {
-      return Math.max(0, Math.min(1, 1 - bufferActivation / messageTokensThreshold));
-    }
-    return bufferActivation;
-  }
-  /**
-   * Calculate the projected message tokens that would be removed if activation happened now.
-   * This replicates the chunk boundary logic in swapBufferedToActive without actually activating.
-   */
-  calculateProjectedMessageRemoval(chunks, bufferActivation, messageTokensThreshold, currentPendingTokens) {
-    if (chunks.length === 0) return 0;
-    const retentionFloor = this.resolveRetentionFloor(bufferActivation, messageTokensThreshold);
-    const targetMessageTokens = Math.max(0, currentPendingTokens - retentionFloor);
-    let cumulativeMessageTokens = 0;
-    let bestOverBoundary = 0;
-    let bestOverTokens = 0;
-    let bestUnderBoundary = 0;
-    let bestUnderTokens = 0;
-    for (let i = 0; i < chunks.length; i++) {
-      cumulativeMessageTokens += chunks[i].messageTokens ?? 0;
-      const boundary = i + 1;
-      if (cumulativeMessageTokens >= targetMessageTokens) {
-        if (bestOverBoundary === 0 || cumulativeMessageTokens < bestOverTokens) {
-          bestOverBoundary = boundary;
-          bestOverTokens = cumulativeMessageTokens;
-        }
-      } else {
-        if (cumulativeMessageTokens > bestUnderTokens) {
-          bestUnderBoundary = boundary;
-          bestUnderTokens = cumulativeMessageTokens;
-        }
-      }
-    }
-    const maxOvershoot = retentionFloor * 0.95;
-    const overshoot = bestOverTokens - targetMessageTokens;
-    const remainingAfterOver = currentPendingTokens - bestOverTokens;
-    const remainingAfterUnder = currentPendingTokens - bestUnderTokens;
-    const minRemaining = Math.min(1e3, retentionFloor);
-    let bestBoundaryMessageTokens;
-    if (bestOverBoundary > 0 && overshoot <= maxOvershoot && remainingAfterOver >= minRemaining) {
-      bestBoundaryMessageTokens = bestOverTokens;
-    } else if (bestUnderBoundary > 0 && remainingAfterUnder >= minRemaining) {
-      bestBoundaryMessageTokens = bestUnderTokens;
-    } else if (bestOverBoundary > 0) {
-      bestBoundaryMessageTokens = bestOverTokens;
-    } else {
-      return chunks[0]?.messageTokens ?? 0;
-    }
-    return bestBoundaryMessageTokens;
-  }
   /**
    * Check if we've crossed a new bufferTokens interval boundary.
    * Returns true if async buffering should be triggered.
@@ -1545,7 +1864,7 @@ var ObservationalMemory = class _ObservationalMemory {
     if (this.isAsyncBufferingInProgress(bufferKey)) return false;
     if (_ObservationalMemory.lastBufferedBoundary.has(bufferKey)) return false;
     if (record.bufferedReflection) return false;
-    const reflectThreshold = this.getMaxThreshold(this.reflectionConfig.observationTokens);
+    const reflectThreshold = getMaxThreshold(this.reflectionConfig.observationTokens);
     const activationPoint = reflectThreshold * this.reflectionConfig.bufferActivation;
     const shouldTrigger = currentObservationTokens >= activationPoint;
     omDebug(
@@ -1662,12 +1981,12 @@ Async buffering is enabled by default \u2014 this opt-out is only needed when us
       },
       providerOptions: config.observation?.providerOptions ?? OBSERVATIONAL_MEMORY_DEFAULTS.observation.providerOptions,
       maxTokensPerBatch: config.observation?.maxTokensPerBatch ?? OBSERVATIONAL_MEMORY_DEFAULTS.observation.maxTokensPerBatch,
-      bufferTokens: asyncBufferingDisabled ? void 0 : this.resolveBufferTokens(
+      bufferTokens: asyncBufferingDisabled ? void 0 : resolveBufferTokens(
         config.observation?.bufferTokens ?? OBSERVATIONAL_MEMORY_DEFAULTS.observation.bufferTokens,
         config.observation?.messageTokens ?? OBSERVATIONAL_MEMORY_DEFAULTS.observation.messageTokens
       ),
       bufferActivation: asyncBufferingDisabled ? void 0 : config.observation?.bufferActivation ?? OBSERVATIONAL_MEMORY_DEFAULTS.observation.bufferActivation,
-      blockAfter: asyncBufferingDisabled ? void 0 : this.resolveBlockAfter(
+      blockAfter: asyncBufferingDisabled ? void 0 : resolveBlockAfter(
         config.observation?.blockAfter ?? (config.observation?.bufferTokens ?? OBSERVATIONAL_MEMORY_DEFAULTS.observation.bufferTokens ? 1.2 : void 0),
         config.observation?.messageTokens ?? OBSERVATIONAL_MEMORY_DEFAULTS.observation.messageTokens
       ),
@@ -1683,7 +2002,7 @@ Async buffering is enabled by default \u2014 this opt-out is only needed when us
       },
       providerOptions: config.reflection?.providerOptions ?? OBSERVATIONAL_MEMORY_DEFAULTS.reflection.providerOptions,
       bufferActivation: asyncBufferingDisabled ? void 0 : config?.reflection?.bufferActivation ?? OBSERVATIONAL_MEMORY_DEFAULTS.reflection.bufferActivation,
-      blockAfter: asyncBufferingDisabled ? void 0 : this.resolveBlockAfter(
+      blockAfter: asyncBufferingDisabled ? void 0 : resolveBlockAfter(
         config.reflection?.blockAfter ?? (config.reflection?.bufferActivation ?? OBSERVATIONAL_MEMORY_DEFAULTS.reflection.bufferActivation ? 1.2 : void 0),
         config.reflection?.observationTokens ?? OBSERVATIONAL_MEMORY_DEFAULTS.reflection.observationTokens
       ),
@@ -1778,7 +2097,7 @@ Async buffering is enabled by default \u2014 this opt-out is only needed when us
         `Async buffering is not yet supported with scope: 'resource'. Use scope: 'thread', or set observation: { bufferTokens: false } to disable async buffering.`
       );
     }
-    const observationThreshold = this.getMaxThreshold(this.observationConfig.messageTokens);
+    const observationThreshold = getMaxThreshold(this.observationConfig.messageTokens);
     if (this.observationConfig.bufferTokens !== void 0) {
       if (this.observationConfig.bufferTokens <= 0) {
         throw new Error(`observation.bufferTokens must be > 0, got ${this.observationConfig.bufferTokens}`);
@@ -1824,7 +2143,7 @@ Async buffering is enabled by default \u2014 this opt-out is only needed when us
       }
     }
     if (this.reflectionConfig.blockAfter !== void 0) {
-      const reflectionThreshold = this.getMaxThreshold(this.reflectionConfig.observationTokens);
+      const reflectionThreshold = getMaxThreshold(this.reflectionConfig.observationTokens);
       if (this.reflectionConfig.blockAfter < reflectionThreshold) {
         throw new Error(
           `reflection.blockAfter (${this.reflectionConfig.blockAfter}) must be >= reflection.observationTokens (${reflectionThreshold})`
@@ -1837,65 +2156,6 @@ Async buffering is enabled by default \u2014 this opt-out is only needed when us
       }
     }
   }
-  /**
-   * Resolve bufferTokens: if it's a fraction (0 < value < 1), multiply by messageTokens threshold.
-   * Otherwise return the absolute token count.
-   */
-  resolveBufferTokens(bufferTokens, messageTokens) {
-    if (bufferTokens === false) return void 0;
-    if (bufferTokens === void 0) return void 0;
-    if (bufferTokens > 0 && bufferTokens < 1) {
-      const threshold = typeof messageTokens === "number" ? messageTokens : messageTokens.max;
-      return Math.round(threshold * bufferTokens);
-    }
-    return bufferTokens;
-  }
-  /**
-   * Resolve blockAfter config value.
-   * Values in [1, 100) are treated as multipliers of the threshold.
-   * e.g. blockAfter: 1.5 with messageTokens: 20_000 → 30_000
-   * Values >= 100 are treated as absolute token counts.
-   * Defaults to 1.2 (120% of threshold) when async buffering is enabled but blockAfter is omitted.
-   */
-  resolveBlockAfter(blockAfter, messageTokens) {
-    if (blockAfter === void 0) return void 0;
-    if (blockAfter >= 1 && blockAfter < 100) {
-      const threshold = typeof messageTokens === "number" ? messageTokens : messageTokens.max;
-      return Math.round(threshold * blockAfter);
-    }
-    return blockAfter;
-  }
-  /**
-   * Get the maximum value from a threshold (simple number or range)
-   */
-  getMaxThreshold(threshold) {
-    if (typeof threshold === "number") {
-      return threshold;
-    }
-    return threshold.max;
-  }
-  /**
-   * Calculate dynamic threshold based on observation space.
-   * When shareTokenBudget is enabled, the message threshold can expand
-   * into unused observation space, up to the total context budget.
-   *
-   * Total budget = messageTokens + observationTokens
-   * Effective threshold = totalBudget - currentObservationTokens
-   *
-   * Example with 30k:40k thresholds (70k total):
-   * - 0 observations → messages can use ~70k
-   * - 10k observations → messages can use ~60k
-   * - 40k observations → messages back to ~30k
-   */
-  calculateDynamicThreshold(threshold, currentObservationTokens) {
-    if (typeof threshold === "number") {
-      return threshold;
-    }
-    const totalBudget = threshold.max;
-    const baseThreshold = threshold.min;
-    const effectiveThreshold = Math.max(totalBudget - currentObservationTokens, baseThreshold);
-    return Math.round(effectiveThreshold);
-  }
   /**
    * Check whether the unobserved message tokens meet the observation threshold.
    */
@@ -1903,7 +2163,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 = this.calculateDynamicThreshold(this.observationConfig.messageTokens, currentObservationTokens);
+    const threshold = calculateDynamicThreshold(this.observationConfig.messageTokens, currentObservationTokens);
     return pendingTokens >= threshold;
   }
   /**
@@ -1983,7 +2243,7 @@ Async buffering is enabled by default \u2014 this opt-out is only needed when us
    * Check if we need to trigger reflection.
    */
   shouldReflect(observationTokens) {
-    const threshold = this.getMaxThreshold(this.reflectionConfig.observationTokens);
+    const threshold = getMaxThreshold(this.reflectionConfig.observationTokens);
     return observationTokens > threshold;
   }
   // ════════════════════════════════════════════════════════════════════════════
@@ -2004,153 +2264,11 @@ Async buffering is enabled by default \u2014 this opt-out is only needed when us
    */
   getObservationMarkerConfig() {
     return {
-      messageTokens: this.getMaxThreshold(this.observationConfig.messageTokens),
-      observationTokens: this.getMaxThreshold(this.reflectionConfig.observationTokens),
+      messageTokens: getMaxThreshold(this.observationConfig.messageTokens),
+      observationTokens: getMaxThreshold(this.reflectionConfig.observationTokens),
       scope: this.scope
     };
   }
-  /**
-   * Create a start marker for when observation begins.
-   */
-  createObservationStartMarker(params) {
-    return {
-      type: "data-om-observation-start",
-      data: {
-        cycleId: params.cycleId,
-        operationType: params.operationType,
-        startedAt: (/* @__PURE__ */ new Date()).toISOString(),
-        tokensToObserve: params.tokensToObserve,
-        recordId: params.recordId,
-        threadId: params.threadId,
-        threadIds: params.threadIds,
-        config: this.getObservationMarkerConfig()
-      }
-    };
-  }
-  /**
-   * Create an end marker for when observation completes successfully.
-   */
-  createObservationEndMarker(params) {
-    const completedAt = (/* @__PURE__ */ new Date()).toISOString();
-    const durationMs = new Date(completedAt).getTime() - new Date(params.startedAt).getTime();
-    return {
-      type: "data-om-observation-end",
-      data: {
-        cycleId: params.cycleId,
-        operationType: params.operationType,
-        completedAt,
-        durationMs,
-        tokensObserved: params.tokensObserved,
-        observationTokens: params.observationTokens,
-        observations: params.observations,
-        currentTask: params.currentTask,
-        suggestedResponse: params.suggestedResponse,
-        recordId: params.recordId,
-        threadId: params.threadId
-      }
-    };
-  }
-  /**
-   * Create a failed marker for when observation fails.
-   */
-  createObservationFailedMarker(params) {
-    const failedAt = (/* @__PURE__ */ new Date()).toISOString();
-    const durationMs = new Date(failedAt).getTime() - new Date(params.startedAt).getTime();
-    return {
-      type: "data-om-observation-failed",
-      data: {
-        cycleId: params.cycleId,
-        operationType: params.operationType,
-        failedAt,
-        durationMs,
-        tokensAttempted: params.tokensAttempted,
-        error: params.error,
-        recordId: params.recordId,
-        threadId: params.threadId
-      }
-    };
-  }
-  /**
-   * Create a start marker for when async buffering begins.
-   */
-  createBufferingStartMarker(params) {
-    return {
-      type: "data-om-buffering-start",
-      data: {
-        cycleId: params.cycleId,
-        operationType: params.operationType,
-        startedAt: (/* @__PURE__ */ new Date()).toISOString(),
-        tokensToBuffer: params.tokensToBuffer,
-        recordId: params.recordId,
-        threadId: params.threadId,
-        threadIds: params.threadIds,
-        config: this.getObservationMarkerConfig()
-      }
-    };
-  }
-  /**
-   * Create an end marker for when async buffering completes successfully.
-   */
-  createBufferingEndMarker(params) {
-    const completedAt = (/* @__PURE__ */ new Date()).toISOString();
-    const durationMs = new Date(completedAt).getTime() - new Date(params.startedAt).getTime();
-    return {
-      type: "data-om-buffering-end",
-      data: {
-        cycleId: params.cycleId,
-        operationType: params.operationType,
-        completedAt,
-        durationMs,
-        tokensBuffered: params.tokensBuffered,
-        bufferedTokens: params.bufferedTokens,
-        recordId: params.recordId,
-        threadId: params.threadId,
-        observations: params.observations
-      }
-    };
-  }
-  /**
-   * Create a failed marker for when async buffering fails.
-   */
-  createBufferingFailedMarker(params) {
-    const failedAt = (/* @__PURE__ */ new Date()).toISOString();
-    const durationMs = new Date(failedAt).getTime() - new Date(params.startedAt).getTime();
-    return {
-      type: "data-om-buffering-failed",
-      data: {
-        cycleId: params.cycleId,
-        operationType: params.operationType,
-        failedAt,
-        durationMs,
-        tokensAttempted: params.tokensAttempted,
-        error: params.error,
-        recordId: params.recordId,
-        threadId: params.threadId
-      }
-    };
-  }
-  /**
-   * Create an activation marker for when buffered observations are activated.
-   */
-  createActivationMarker(params) {
-    return {
-      type: "data-om-activation",
-      data: {
-        cycleId: params.cycleId,
-        operationType: params.operationType,
-        activatedAt: (/* @__PURE__ */ new Date()).toISOString(),
-        chunksActivated: params.chunksActivated,
-        tokensActivated: params.tokensActivated,
-        observationTokens: params.observationTokens,
-        messagesActivated: params.messagesActivated,
-        recordId: params.recordId,
-        threadId: params.threadId,
-        generationCount: params.generationCount,
-        config: this.getObservationMarkerConfig(),
-        observations: params.observations
-      }
-    };
-  }
   /**
    * Persist a data-om-* marker part on the last assistant message in messageList
    * AND save the updated message to the DB so it survives page reload.
@@ -2531,7 +2649,7 @@ Async buffering is enabled by default \u2014 this opt-out is only needed when us
   async callReflector(observations, manualPrompt, streamContext, observationTokensThreshold, abortSignal, skipContinuationHints, compressionStartLevel, requestContext) {
     const agent = this.getReflectorAgent();
     const originalTokens = this.tokenCounter.countObservations(observations);
-    const targetThreshold = observationTokensThreshold ?? this.getMaxThreshold(this.reflectionConfig.observationTokens);
+    const targetThreshold = observationTokensThreshold ?? getMaxThreshold(this.reflectionConfig.observationTokens);
     let totalUsage = { inputTokens: 0, outputTokens: 0, totalTokens: 0 };
     let currentLevel = compressionStartLevel ?? 0;
     const maxLevel = 3;
@@ -2606,7 +2724,7 @@ Async buffering is enabled by default \u2014 this opt-out is only needed when us
         break;
       }
       if (streamContext?.writer) {
-        const failedMarker = this.createObservationFailedMarker({
+        const failedMarker = createObservationFailedMarker({
           cycleId: streamContext.cycleId,
           operationType: "reflection",
           startedAt: streamContext.startedAt,
@@ -2619,13 +2737,14 @@ Async buffering is enabled by default \u2014 this opt-out is only needed when us
         });
         const retryCycleId = crypto.randomUUID();
         streamContext.cycleId = retryCycleId;
-        const startMarker = this.createObservationStartMarker({
+        const startMarker = createObservationStartMarker({
           cycleId: retryCycleId,
           operationType: "reflection",
           tokensToObserve: originalTokens,
           recordId: streamContext.recordId,
           threadId: streamContext.threadId,
-          threadIds: [streamContext.threadId]
+          threadIds: [streamContext.threadId],
+          config: this.getObservationMarkerConfig()
         });
         streamContext.startedAt = startMarker.data.startedAt;
         await streamContext.writer.custom(startMarker).catch(() => {
@@ -2759,8 +2878,8 @@ ${suggestedResponse}
   calculateObservationThresholds(_allMessages, unobservedMessages, _pendingTokens, otherThreadTokens, currentObservationTokens, _record) {
     const contextWindowTokens = this.tokenCounter.countMessages(unobservedMessages);
     const totalPendingTokens = Math.max(0, contextWindowTokens + otherThreadTokens);
-    const threshold = this.calculateDynamicThreshold(this.observationConfig.messageTokens, currentObservationTokens);
-    const baseReflectionThreshold = this.getMaxThreshold(this.reflectionConfig.observationTokens);
+    const threshold = calculateDynamicThreshold(this.observationConfig.messageTokens, currentObservationTokens);
+    const baseReflectionThreshold = getMaxThreshold(this.reflectionConfig.observationTokens);
     const isSharedBudget = typeof this.observationConfig.messageTokens !== "number";
     const totalBudget = isSharedBudget ? this.observationConfig.messageTokens.max : 0;
     const effectiveObservationTokensThreshold = isSharedBudget ? Math.max(totalBudget - threshold, 1e3) : baseReflectionThreshold;
@@ -2794,10 +2913,10 @@ ${suggestedResponse}
       const bufferedObservationTokens = bufferedChunks.reduce((sum, chunk) => sum + (chunk.tokenCount ?? 0), 0);
       const rawBufferedMessageTokens = bufferedChunks.reduce((sum, chunk) => sum + (chunk.messageTokens ?? 0), 0);
       const bufferedMessageTokens = Math.min(rawBufferedMessageTokens, totalPendingTokens);
-      const projectedMessageRemoval = this.calculateProjectedMessageRemoval(
+      const projectedMessageRemoval = calculateProjectedMessageRemoval(
         bufferedChunks,
         this.observationConfig.bufferActivation ?? 1,
-        this.getMaxThreshold(this.observationConfig.messageTokens),
+        getMaxThreshold(this.observationConfig.messageTokens),
         totalPendingTokens
       );
       let obsBufferStatus = "idle";
@@ -3006,7 +3125,39 @@ ${suggestedResponse}
     omDebug(
       `[OM:cleanupBranch] allMsgs=${allMsgs.length}, markerFound=${markerIdx !== -1}, markerIdx=${markerIdx}, observedMessageIds=${observedMessageIds?.length ?? "undefined"}, allIds=${allMsgs.map((m) => m.id?.slice(0, 8)).join(",")}`
     );
-    if (markerMsg && markerIdx !== -1) {
+    if (observedMessageIds && observedMessageIds.length > 0) {
+      const observedSet = new Set(observedMessageIds);
+      const idsToRemove = /* @__PURE__ */ new Set();
+      let skipped = 0;
+      let backoffTriggered = false;
+      for (const msg of allMsgs) {
+        if (!msg?.id || msg.id === "om-continuation" || !observedSet.has(msg.id)) {
+          continue;
+        }
+        if (typeof minRemaining === "number") {
+          const nextRemainingMessages = allMsgs.filter(
+            (m) => m?.id && m.id !== "om-continuation" && !idsToRemove.has(m.id) && m.id !== msg.id
+          );
+          const remainingIfRemoved = this.tokenCounter.countMessages(nextRemainingMessages);
+          if (remainingIfRemoved < minRemaining) {
+            skipped += 1;
+            backoffTriggered = true;
+            break;
+          }
+        }
+        idsToRemove.add(msg.id);
+      }
+      omDebug(
+        `[OM:cleanupActivation] observedSet=${[...observedSet].map((id) => id.slice(0, 8)).join(",")}, matched=${idsToRemove.size}, skipped=${skipped}, backoffTriggered=${backoffTriggered}, idsToRemove=${[...idsToRemove].map((id) => id.slice(0, 8)).join(",")}`
+      );
+      const idsToRemoveList = [...idsToRemove];
+      if (idsToRemoveList.length > 0) {
+        messageList.removeByIds(idsToRemoveList);
+        omDebug(
+          `[OM:cleanupActivation] removed ${idsToRemoveList.length} messages, remaining=${messageList.get.all.db().length}`
+        );
+      }
+    } else if (markerMsg && markerIdx !== -1) {
       const idsToRemove = [];
       const messagesToSave = [];
       for (let i = 0; i < markerIdx; i++) {
@@ -3031,35 +3182,6 @@ ${suggestedResponse}
       if (messagesToSave.length > 0) {
         await this.saveMessagesWithSealedIdTracking(messagesToSave, sealedIds, threadId, resourceId, state);
       }
-    } else if (observedMessageIds && observedMessageIds.length > 0) {
-      const observedSet = new Set(observedMessageIds);
-      const idsToRemove = [];
-      const totalTokens = typeof minRemaining === "number" ? this.tokenCounter.countMessages(allMsgs) : void 0;
-      let removedTokens = 0;
-      let skipped = 0;
-      for (const msg of allMsgs) {
-        if (msg?.id && msg.id !== "om-continuation" && observedSet.has(msg.id)) {
-          if (typeof minRemaining === "number") {
-            const msgTokens = this.tokenCounter.countMessage(msg);
-            const remainingIfRemoved = (totalTokens ?? 0) - removedTokens - msgTokens;
-            if (remainingIfRemoved < minRemaining) {
-              skipped += 1;
-              continue;
-            }
-            removedTokens += msgTokens;
-          }
-          idsToRemove.push(msg.id);
-        }
-      }
-      omDebug(
-        `[OM:cleanupActivation] observedSet=${[...observedSet].map((id) => id.slice(0, 8)).join(",")}, matched=${idsToRemove.length}, skipped=${skipped}, idsToRemove=${idsToRemove.map((id) => id.slice(0, 8)).join(",")}`
-      );
-      if (idsToRemove.length > 0) {
-        messageList.removeByIds(idsToRemove);
-        omDebug(
-          `[OM:cleanupActivation] removed ${idsToRemove.length} messages, remaining=${messageList.get.all.db().length}`
-        );
-      }
     } else {
       const newInput = messageList.clear.input.db();
       const newOutput = messageList.clear.response.db();
@@ -3401,7 +3523,7 @@ ${suggestedResponse}
         );
         if (observationSucceeded) {
           const observedIds = activatedMessageIds?.length ? activatedMessageIds : Array.isArray(updatedRecord.observedMessageIds) ? updatedRecord.observedMessageIds : void 0;
-          const minRemaining = typeof this.observationConfig.bufferActivation === "number" ? Math.min(1e3, this.resolveRetentionFloor(this.observationConfig.bufferActivation, threshold)) : void 0;
+          const minRemaining = typeof this.observationConfig.bufferActivation === "number" ? resolveRetentionFloor(this.observationConfig.bufferActivation, threshold) : void 0;
           omDebug(
             `[OM:cleanup] observedIds=${observedIds?.length ?? "undefined"}, ids=${observedIds?.join(",") ?? "none"}, updatedRecord.observedMessageIds=${JSON.stringify(updatedRecord.observedMessageIds)}, minRemaining=${minRemaining ?? "n/a"}`
           );
@@ -3445,8 +3567,8 @@ ${suggestedResponse}
       const freshUnobservedTokens = this.tokenCounter.countMessages(contextMessages);
       const otherThreadTokens = unobservedContextBlocks ? this.tokenCounter.countString(unobservedContextBlocks) : 0;
       const currentObservationTokens = freshRecord.observationTokenCount ?? 0;
-      const threshold = this.calculateDynamicThreshold(this.observationConfig.messageTokens, currentObservationTokens);
-      const baseReflectionThreshold = this.getMaxThreshold(this.reflectionConfig.observationTokens);
+      const threshold = calculateDynamicThreshold(this.observationConfig.messageTokens, currentObservationTokens);
+      const baseReflectionThreshold = getMaxThreshold(this.reflectionConfig.observationTokens);
       const isSharedBudget = typeof this.observationConfig.messageTokens !== "number";
       const totalBudget = isSharedBudget ? this.observationConfig.messageTokens.max : 0;
       const effectiveObservationTokensThreshold = isSharedBudget ? Math.max(totalBudget - threshold, 1e3) : baseReflectionThreshold;
@@ -3763,13 +3885,14 @@ ${newThreadSection}`;
     const lastMessage = unobservedMessages[unobservedMessages.length - 1];
     const startedAt = (/* @__PURE__ */ new Date()).toISOString();
     if (lastMessage?.id) {
-      const startMarker = this.createObservationStartMarker({
+      const startMarker = createObservationStartMarker({
         cycleId,
         operationType: "observation",
         tokensToObserve,
         recordId: record.id,
         threadId,
-        threadIds: [threadId]
+        threadIds: [threadId],
+        config: this.getObservationMarkerConfig()
       });
       if (writer) {
         await writer.custom(startMarker).catch(() => {
@@ -3837,7 +3960,7 @@ ${result.observations}` : result.observations;
       });
       const actualTokensObserved = this.tokenCounter.countMessages(messagesToObserve);
       if (lastMessage?.id) {
-        const endMarker = this.createObservationEndMarker({
+        const endMarker = createObservationEndMarker({
           cycleId,
           operationType: "observation",
           startedAt,
@@ -3879,7 +4002,7 @@ ${result.observations}` : result.observations;
       });
     } catch (error) {
       if (lastMessage?.id) {
-        const failedMarker = this.createObservationFailedMarker({
+        const failedMarker = createObservationFailedMarker({
           cycleId,
           operationType: "observation",
           startedAt,
@@ -4001,13 +4124,14 @@ ${result.observations}` : result.observations;
     const startedAt = (/* @__PURE__ */ new Date()).toISOString();
     const tokensToBuffer = this.tokenCounter.countMessages(messagesToBuffer);
     if (writer) {
-      const startMarker = this.createBufferingStartMarker({
+      const startMarker = createBufferingStartMarker({
         cycleId,
         operationType: "observation",
         tokensToBuffer,
         recordId: freshRecord.id,
         threadId,
-        threadIds: [threadId]
+        threadIds: [threadId],
+        config: this.getObservationMarkerConfig()
       });
       void writer.custom(startMarker).catch(() => {
       });
@@ -4030,7 +4154,7 @@ ${result.observations}` : result.observations;
       _ObservationalMemory.lastBufferedAtTime.set(bufferKey, cursor);
     } catch (error) {
       if (writer) {
-        const failedMarker = this.createBufferingFailedMarker({
+        const failedMarker = createBufferingFailedMarker({
           cycleId,
           operationType: "observation",
           startedAt,
@@ -4098,7 +4222,7 @@ ${result.observations}` : result.observations;
       const updatedRecord = await this.storage.getObservationalMemory(record.threadId, record.resourceId);
       const updatedChunks = this.getBufferedChunks(updatedRecord);
       const totalBufferedTokens = updatedChunks.reduce((sum, c) => sum + (c.tokenCount ?? 0), 0) || newTokenCount;
-      const endMarker = this.createBufferingEndMarker({
+      const endMarker = createBufferingEndMarker({
         cycleId,
         operationType: "observation",
         startedAt,
@@ -4167,7 +4291,7 @@ ${bufferedObservations}`;
     if (!freshChunks.length) {
       return { success: false };
     }
-    const messageTokensThreshold = this.getMaxThreshold(this.observationConfig.messageTokens);
+    const messageTokensThreshold = getMaxThreshold(this.observationConfig.messageTokens);
     let effectivePendingTokens = currentPendingTokens;
     if (messageList) {
       effectivePendingTokens = this.tokenCounter.countMessages(messageList.get.all.db());
@@ -4179,11 +4303,11 @@ ${bufferedObservations}`;
       }
     }
     const bufferActivation = this.observationConfig.bufferActivation ?? 0.7;
-    const activationRatio = this.resolveActivationRatio(bufferActivation, messageTokensThreshold);
+    const activationRatio = resolveActivationRatio(bufferActivation, messageTokensThreshold);
     const forceMaxActivation = !!(this.observationConfig.blockAfter && effectivePendingTokens >= this.observationConfig.blockAfter);
     const bufferTokens = this.observationConfig.bufferTokens ?? 0;
-    const retentionFloor = this.resolveRetentionFloor(bufferActivation, messageTokensThreshold);
-    const projectedMessageRemoval = this.calculateProjectedMessageRemoval(
+    const retentionFloor = resolveRetentionFloor(bufferActivation, messageTokensThreshold);
+    const projectedMessageRemoval = calculateProjectedMessageRemoval(
       freshChunks,
       bufferActivation,
       messageTokensThreshold,
@@ -4217,7 +4341,7 @@ ${bufferedObservations}`;
       const perChunkMap = new Map(activationResult.perChunk?.map((c) => [c.cycleId, c]));
       for (const cycleId of activationResult.activatedCycleIds) {
         const chunkData = perChunkMap.get(cycleId);
-        const activationMarker = this.createActivationMarker({
+        const activationMarker = createActivationMarker({
           cycleId,
           // Use the original buffering cycleId so UI can link them
           operationType: "observation",
@@ -4228,7 +4352,8 @@ ${bufferedObservations}`;
           recordId: updatedRecord.id,
           threadId: updatedRecord.threadId ?? record.threadId ?? "",
           generationCount: updatedRecord.generationCount ?? 0,
-          observations: chunkData?.observations ?? activationResult.observations
+          observations: chunkData?.observations ?? activationResult.observations,
+          config: this.getObservationMarkerConfig()
         });
         void writer.custom(activationMarker).catch(() => {
         });
@@ -4270,7 +4395,7 @@ ${bufferedObservations}`;
     });
     const asyncOp = this.doAsyncBufferedReflection(record, bufferKey, writer, requestContext).catch(async (error) => {
       if (writer) {
-        const failedMarker = this.createBufferingFailedMarker({
+        const failedMarker = createBufferingFailedMarker({
           cycleId: `reflect-buf-${Date.now()}-${Math.random().toString(36).slice(2, 11)}`,
           operationType: "reflection",
           startedAt: (/* @__PURE__ */ new Date()).toISOString(),
@@ -4301,7 +4426,7 @@ ${bufferedObservations}`;
     const freshRecord = await this.storage.getObservationalMemory(record.threadId, record.resourceId);
     const currentRecord = freshRecord ?? record;
     const observationTokens = currentRecord.observationTokenCount ?? 0;
-    const reflectThreshold = this.getMaxThreshold(this.reflectionConfig.observationTokens);
+    const reflectThreshold = getMaxThreshold(this.reflectionConfig.observationTokens);
     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)}`;
@@ -4323,13 +4448,14 @@ ${bufferedObservations}`;
       `[OM:reflect] doAsyncBufferedReflection: starting reflector call, recordId=${currentRecord.id}, observationTokens=${sliceTokenEstimate}, compressionTarget=${compressionTarget} (inputTokens), activeObsLength=${activeObservations.length}, reflectedLineCount=${reflectedObservationLineCount}`
     );
     if (writer) {
-      const startMarker = this.createBufferingStartMarker({
+      const startMarker = createBufferingStartMarker({
         cycleId,
         operationType: "reflection",
         tokensToBuffer: sliceTokenEstimate,
         recordId: record.id,
         threadId: record.threadId ?? "",
-        threadIds: record.threadId ? [record.threadId] : []
+        threadIds: record.threadId ? [record.threadId] : [],
+        config: this.getObservationMarkerConfig()
       });
       void writer.custom(startMarker).catch(() => {
       });
@@ -4364,7 +4490,7 @@ ${bufferedObservations}`;
       `[OM:reflect] doAsyncBufferedReflection: bufferedReflection saved with lineCount=${reflectedObservationLineCount}`
     );
     if (writer) {
-      const endMarker = this.createBufferingEndMarker({
+      const endMarker = createBufferingEndMarker({
         cycleId,
         operationType: "reflection",
         startedAt,
@@ -4435,7 +4561,7 @@ ${unreflectedContent}` : freshRecord.bufferedReflection;
     );
     if (writer) {
       const originalCycleId = _ObservationalMemory.reflectionBufferCycleIds.get(bufferKey);
-      const activationMarker = this.createActivationMarker({
+      const activationMarker = createActivationMarker({
         cycleId: originalCycleId ?? `reflect-act-${Date.now()}-${Math.random().toString(36).slice(2, 11)}`,
         operationType: "reflection",
         chunksActivated: 1,
@@ -4445,7 +4571,8 @@ ${unreflectedContent}` : freshRecord.bufferedReflection;
         recordId: freshRecord.id,
         threadId: freshRecord.threadId ?? "",
         generationCount: afterRecord?.generationCount ?? freshRecord.generationCount ?? 0,
-        observations: afterRecord?.activeObservations
+        observations: afterRecord?.activeObservations,
+        config: this.getObservationMarkerConfig()
       });
       void writer.custom(activationMarker).catch(() => {
       });
@@ -4527,7 +4654,7 @@ ${unreflectedContent}` : freshRecord.bufferedReflection;
     if (totalMessages === 0) {
       return;
     }
-    const threshold = this.getMaxThreshold(this.observationConfig.messageTokens);
+    const threshold = getMaxThreshold(this.observationConfig.messageTokens);
     const threadTokenCounts = /* @__PURE__ */ new Map();
     for (const [threadId, msgs] of messagesByThread) {
       let tokens = 0;
@@ -4593,13 +4720,14 @@ ${unreflectedContent}` : freshRecord.bufferedReflection;
         const tokensToObserve = this.tokenCounter.countMessages(msgs);
         threadTokensToObserve.set(threadId, tokensToObserve);
         if (lastMessage?.id) {
-          const startMarker = this.createObservationStartMarker({
+          const startMarker = createObservationStartMarker({
             cycleId,
             operationType: "observation",
             tokensToObserve,
             recordId: record.id,
             threadId,
-            threadIds: allThreadIds
+            threadIds: allThreadIds,
+            config: this.getObservationMarkerConfig()
           });
           if (writer) {
             await writer.custom(startMarker).catch(() => {
@@ -4725,7 +4853,7 @@ ${unreflectedContent}` : freshRecord.bufferedReflection;
         const lastMessage = threadMessages[threadMessages.length - 1];
         if (lastMessage?.id) {
           const tokensObserved = threadTokensToObserve.get(threadId) ?? this.tokenCounter.countMessages(threadMessages);
-          const endMarker = this.createObservationEndMarker({
+          const endMarker = createObservationEndMarker({
             cycleId,
             operationType: "observation",
             startedAt: observationStartedAt,
@@ -4757,7 +4885,7 @@ ${unreflectedContent}` : freshRecord.bufferedReflection;
         const lastMessage = msgs[msgs.length - 1];
         if (lastMessage?.id) {
           const tokensAttempted = threadTokensToObserve.get(threadId) ?? 0;
-          const failedMarker = this.createObservationFailedMarker({
+          const failedMarker = createObservationFailedMarker({
             cycleId,
             operationType: "observation",
             startedAt: observationStartedAt,
@@ -4789,7 +4917,7 @@ ${unreflectedContent}` : freshRecord.bufferedReflection;
   async maybeAsyncReflect(record, observationTokens, writer, messageList, requestContext) {
     if (!this.isAsyncReflectionEnabled()) return;
     const lockKey = this.getLockKey(record.threadId, record.resourceId);
-    const reflectThreshold = this.getMaxThreshold(this.reflectionConfig.observationTokens);
+    const reflectThreshold = getMaxThreshold(this.reflectionConfig.observationTokens);
     omDebug(
       `[OM:reflect] maybeAsyncReflect: observationTokens=${observationTokens}, reflectThreshold=${reflectThreshold}, isReflecting=${record.isReflecting}, bufferedReflection=${record.bufferedReflection ? "present (" + record.bufferedReflection.length + " chars)" : "empty"}, recordId=${record.id}, genCount=${record.generationCount}`
     );
@@ -4825,7 +4953,7 @@ ${unreflectedContent}` : freshRecord.bufferedReflection;
   async maybeReflect(opts) {
     const { record, observationTokens, writer, abortSignal, messageList, reflectionHooks, requestContext } = opts;
     const lockKey = this.getLockKey(record.threadId, record.resourceId);
-    const reflectThreshold = this.getMaxThreshold(this.reflectionConfig.observationTokens);
+    const reflectThreshold = getMaxThreshold(this.reflectionConfig.observationTokens);
     if (this.isAsyncReflectionEnabled() && observationTokens < reflectThreshold) {
       if (this.shouldTriggerAsyncReflection(observationTokens, lockKey, record)) {
         this.startAsyncBufferedReflection(record, observationTokens, lockKey, writer, requestContext);
@@ -4866,13 +4994,14 @@ ${unreflectedContent}` : freshRecord.bufferedReflection;
     const startedAt = (/* @__PURE__ */ new Date()).toISOString();
     const threadId = opts.threadId ?? "unknown";
     if (writer) {
-      const startMarker = this.createObservationStartMarker({
+      const startMarker = createObservationStartMarker({
         cycleId,
         operationType: "reflection",
         tokensToObserve: observationTokens,
         recordId: record.id,
         threadId,
-        threadIds: [threadId]
+        threadIds: [threadId],
+        config: this.getObservationMarkerConfig()
       });
       await writer.custom(startMarker).catch(() => {
       });
@@ -4910,7 +5039,7 @@ ${unreflectedContent}` : freshRecord.bufferedReflection;
         tokenCount: reflectionTokenCount
       });
       if (writer && streamContext) {
-        const endMarker = this.createObservationEndMarker({
+        const endMarker = createObservationEndMarker({
           cycleId: streamContext.cycleId,
           operationType: "reflection",
           startedAt: streamContext.startedAt,
@@ -4935,7 +5064,7 @@ ${unreflectedContent}` : freshRecord.bufferedReflection;
       });
     } catch (error) {
       if (writer && streamContext) {
-        const failedMarker = this.createObservationFailedMarker({
+        const failedMarker = createObservationFailedMarker({
           cycleId: streamContext.cycleId,
           operationType: "reflection",
           startedAt: streamContext.startedAt,
@@ -5040,7 +5169,7 @@ ${unreflectedContent}` : freshRecord.bufferedReflection;
     await this.storage.setReflectingFlag(record.id, true);
     registerOp(record.id, "reflecting");
     try {
-      const reflectThreshold = this.getMaxThreshold(this.reflectionConfig.observationTokens);
+      const reflectThreshold = getMaxThreshold(this.reflectionConfig.observationTokens);
       const reflectResult = await this.callReflector(
         record.activeObservations,
         prompt,
@@ -5132,5 +5261,5 @@ exports.formatMessagesForObserver = formatMessagesForObserver;
 exports.hasCurrentTaskSection = hasCurrentTaskSection;
 exports.optimizeObservationsForContext = optimizeObservationsForContext;
 exports.parseObserverOutput = parseObserverOutput;
-//# sourceMappingURL=chunk-5UYAHJVJ.cjs.map
-//# sourceMappingURL=chunk-5UYAHJVJ.cjs.map
+//# sourceMappingURL=chunk-D6II7EP4.cjs.map
+//# sourceMappingURL=chunk-D6II7EP4.cjs.map