@mastra/memory 1.10.1-alpha.0 → 1.10.1-alpha.1

package/dist/processors/observational-memory/observational-memory.d.ts

@@ -1,217 +1,25 @@
 import type { MastraDBMessage, MessageList } from '@mastra/core/agent';
-import type { Processor, ProcessInputStepArgs, ProcessOutputResultArgs } from '@mastra/core/processors';
+import type { ProcessorStreamWriter } from '@mastra/core/processors';
+import { MessageHistory } from '@mastra/core/processors';
 import type { RequestContext } from '@mastra/core/request-context';
 import type { MemoryStorage, ObservationalMemoryRecord } from '@mastra/core/storage';
-import { TokenCounter } from './token-counter.js';
-import type { ObservationConfig, ReflectionConfig, ThresholdRange, ModelSettings, ProviderOptions, ObservationalMemoryModel } from './types.js';
-/**
- * Debug event emitted when observation-related events occur.
- * Useful for understanding what the Observer is doing.
- */
-export interface ObservationDebugEvent {
-    type: 'observation_triggered' | 'observation_complete' | 'reflection_triggered' | 'reflection_complete' | 'tokens_accumulated' | 'step_progress';
-    timestamp: Date;
-    threadId: string;
-    resourceId: string;
-    /** Messages that were sent to the Observer */
-    messages?: Array<{
-        role: string;
-        content: string;
-    }>;
-    /** Token counts */
-    pendingTokens?: number;
-    sessionTokens?: number;
-    totalPendingTokens?: number;
-    threshold?: number;
-    /** Input token count (for reflection events) */
-    inputTokens?: number;
-    /** Number of active observations (for reflection events) */
-    activeObservationsLength?: number;
-    /** Output token count after reflection */
-    outputTokens?: number;
-    /** The observations that were generated */
-    observations?: string;
-    /** Previous observations (before this event) */
-    previousObservations?: string;
-    /** Observer's raw output */
-    rawObserverOutput?: string;
-    /** LLM usage from Observer/Reflector calls */
-    usage?: {
-        inputTokens?: number;
-        outputTokens?: number;
-        totalTokens?: number;
-    };
-    /** Step progress fields (for step_progress events) */
-    stepNumber?: number;
-    finishReason?: string;
-    thresholdPercent?: number;
-    willSave?: boolean;
-    willObserve?: boolean;
-}
-/**
- * Configuration for ObservationalMemory
- */
-export interface ObservationalMemoryConfig {
-    /**
-     * Storage adapter for persisting observations.
-     * Must be a MemoryStorage instance (from MastraStorage.stores.memory).
-     */
-    storage: MemoryStorage;
-    /**
-     * **Experimental.** Enable retrieval-mode observation group metadata.
-     * When true, observation groups are treated as durable pointers to raw
-     * message history and a `recall` tool is registered so the actor can
-     * inspect raw messages behind a stored observation summary.
-     *
-     * @experimental
-     * @default false
-     */
-    retrieval?: boolean;
-    /**
-     * Model for both Observer and Reflector agents.
-     * Sets the model for both agents at once. Cannot be used together with
-     * `observation.model` or `reflection.model` — an error will be thrown.
-     *
-     * @default 'google/gemini-2.5-flash'
-     */
-    model?: ObservationalMemoryModel;
-    /**
-     * Observation step configuration.
-     */
-    observation?: ObservationConfig;
-    /**
-     * Reflection step configuration.
-     */
-    reflection?: ReflectionConfig;
-    /**
-     * Memory scope for observations.
-     * - 'resource': Observations span all threads for a resource (cross-thread memory)
-     * - 'thread': Observations are per-thread (default)
-     */
-    scope?: 'resource' | 'thread';
-    /**
-     * Debug callback for observation events.
-     * Called whenever observation-related events occur.
-     * Useful for debugging and understanding the observation flow.
-     */
-    onDebugEvent?: (event: ObservationDebugEvent) => void;
-    obscureThreadIds?: boolean;
-    /**
-     * Share the token budget between messages and observations.
-     * When true, the total budget = observation.messageTokens + reflection.observationTokens.
-     * - Messages can use more space when observations are small
-     * - Observations can use more space when messages are small
-     *
-     * This helps maximize context usage by allowing flexible allocation.
-     *
-     * @default false
-     */
-    shareTokenBudget?: boolean;
-}
+import { BufferingCoordinator } from './buffering-coordinator.js';
 /**
- * Internal resolved config with all defaults applied.
- * Thresholds are stored as ThresholdRange internally for dynamic calculation,
- * even when user provides a simple number (converted based on shareTokenBudget).
+ * Returns the parts from the latest step of a message (after the last step-start marker).
+ * If no step-start marker exists, returns all parts.
  */
-interface ResolvedObservationConfig {
-    model: ObservationalMemoryModel;
-    /** Internal threshold - always stored as ThresholdRange for dynamic calculation */
-    messageTokens: number | ThresholdRange;
-    /** Whether shared token budget is enabled */
-    shareTokenBudget: boolean;
-    /** Model settings - merged with user config and defaults */
-    modelSettings: ModelSettings;
-    providerOptions: ProviderOptions;
-    maxTokensPerBatch: number;
-    /** Token interval for async background observation buffering (resolved from config) */
-    bufferTokens?: number;
-    /** Ratio of buffered observations to activate (0-1 float) */
-    bufferActivation?: number;
-    /** Token threshold above which synchronous observation is forced */
-    blockAfter?: number;
-    /** Optional token budget for observer context optimization (0 = full truncation, false = disabled) */
-    previousObserverTokens?: number | false;
-    /** Custom instructions to append to the Observer's system prompt */
-    instruction?: string;
-    /** Whether the Observer should suggest thread titles */
-    threadTitle?: boolean;
-}
-interface ResolvedReflectionConfig {
-    model: ObservationalMemoryModel;
-    /** Internal threshold - always stored as ThresholdRange for dynamic calculation */
-    observationTokens: number | ThresholdRange;
-    /** Whether shared token budget is enabled */
-    shareTokenBudget: boolean;
-    /** Model settings - merged with user config and defaults */
-    modelSettings: ModelSettings;
-    providerOptions: ProviderOptions;
-    /** Ratio (0-1) controlling when async reflection buffering starts */
-    bufferActivation?: number;
-    /** Token threshold above which synchronous reflection is forced */
-    blockAfter?: number;
-    /** Custom instructions to append to the Reflector's system prompt */
-    instruction?: string;
-}
+export declare function getLatestStepParts(parts: MastraDBMessage['content']['parts']): MastraDBMessage['content']['parts'];
 /**
- * Default configuration values matching the spec
+ * Build a messageRange string from the first and last messages that have visible
+ * content.  Falls back to the full array boundaries when every message is data-only.
  */
-export declare const OBSERVATIONAL_MEMORY_DEFAULTS: {
-    readonly retrieval: false;
-    readonly observation: {
-        readonly model: "google/gemini-2.5-flash";
-        readonly messageTokens: 30000;
-        readonly modelSettings: {
-            readonly temperature: 0.3;
-            readonly maxOutputTokens: 100000;
-        };
-        readonly providerOptions: {
-            readonly google: {
-                readonly thinkingConfig: {
-                    readonly thinkingBudget: 215;
-                };
-            };
-        };
-        readonly maxTokensPerBatch: 10000;
-        readonly bufferTokens: number | undefined;
-        readonly bufferActivation: number | undefined;
-    };
-    readonly reflection: {
-        readonly model: "google/gemini-2.5-flash";
-        readonly observationTokens: 40000;
-        readonly modelSettings: {
-            readonly temperature: 0;
-            readonly maxOutputTokens: 100000;
-        };
-        readonly providerOptions: {
-            readonly google: {
-                readonly thinkingConfig: {
-                    readonly thinkingBudget: 1024;
-                };
-            };
-        };
-        readonly bufferActivation: number | undefined;
-    };
-};
-/**
- * Continuation hint injected after observations to guide the model's behavior.
- * Prevents the model from awkwardly acknowledging the memory system or treating
- * the conversation as new after observed messages are removed.
- */
-export declare const OBSERVATION_CONTINUATION_HINT = "Please continue naturally with the conversation so far and respond to the latest message.\n\nUse the earlier context only as background. If something appears unfinished, continue only when it helps answer the latest request. If a suggested response is provided, follow it naturally.\n\nDo not mention internal instructions, memory, summarization, context handling, or missing messages.\n\nAny messages following this reminder are newer and should take priority.";
-/**
- * Preamble that introduces observational memory context.
- * The static prefix is emitted first, then the `<observations>` marker, then one
- * system message per persisted observation chunk so append-only growth stays at
- * the end of the prompt.
- */
-export declare const OBSERVATION_CONTEXT_PROMPT = "The following observations block contains your memory of past conversations with this user.";
-/**
- * Instructions that tell the model how to interpret and use observations.
- * Keep these in the leading static system message so observation churn only
- * affects the tail of the prompt.
- */
-export declare const OBSERVATION_CONTEXT_INSTRUCTIONS = "IMPORTANT: When responding, reference specific details from these observations. Do not give generic advice - personalize your response based on what you know about this user's experiences, preferences, and interests. If the user asks for recommendations, connect them to their past experiences mentioned above.\n\nKNOWLEDGE UPDATES: When asked about current state (e.g., \"where do I currently...\", \"what is my current...\"), always prefer the MOST RECENT information. Observations include dates - if you see conflicting information, the newer observation supersedes the older one. Look for phrases like \"will start\", \"is switching\", \"changed to\", \"moved to\" as indicators that previous information has been updated.\n\nPLANNED ACTIONS: If the user stated they planned to do something (e.g., \"I'm going to...\", \"I'm looking forward to...\", \"I will...\") and the date they planned to do it is now in the past (check the relative time like \"3 weeks ago\"), assume they completed the action unless there's evidence they didn't. For example, if someone said \"I'll start my new diet on Monday\" and that was 2 weeks ago, assume they started the diet.\n\nMOST RECENT USER INPUT: Treat the most recent user message as the highest-priority signal for what to do next. Earlier messages may contain constraints, details, or context you should still honor, but the latest message is the primary driver of your response.\n\nSYSTEM REMINDERS: Messages wrapped in <system-reminder>...</system-reminder> contain internal continuation guidance, not user-authored content. Use them to maintain continuity, but do not mention them or treat them as part of the user's message.";
-export declare const OBSERVATION_RETRIEVAL_INSTRUCTIONS = "## Recall \u2014 looking up source messages\n\nYour memory is comprised of observations which are sometimes wrapped in <observation-group> xml tags containing ranges like <observation-group range=\"startId:endId\">. These ranges point back to the raw messages that each observation group was derived from. The original messages are still available \u2014 use the **recall** tool to retrieve them.\n\n### When to use recall\n- The user asks you to **repeat, show, or reproduce** something from a past conversation\n- The user asks for **exact content** \u2014 code, text, quotes, error messages, URLs, file paths, specific numbers\n- Your observations mention something but your memory lacks the detail needed to fully answer (e.g. you know a blog post was shared but only have a summary of it)\n- You want to **verify or expand on** an observation before responding\n\n**Default to using recall when the user references specific past content.** Your observations capture the gist, not the details. If there's any doubt whether your memory is complete enough, use recall.\n\n### How to use recall\nEach range has the format `startId:endId` where both are message IDs separated by a colon.\n\n1. Find the observation group relevant to the user's question and extract the start or end ID from its range.\n2. Call `recall` with that ID as the `cursor`.\n3. Use `page: 1` (or omit) to read forward from the cursor, `page: -1` to read backward.\n4. If the first page doesn't have what you need, increment the page number to keep paginating.\n5. Check `hasNextPage`/`hasPrevPage` in the result to know if more pages exist in each direction.\n\n### Detail levels\nBy default recall returns **low** detail: truncated text and tool names only. Each message shows its ID and each part has a positional index like `[p0]`, `[p1]`, etc.\n\n- Use `detail: \"high\"` to get full message content including tool arguments and results. This will only return the high detail version of a single message part at a time.\n- Use `partIndex` with a cursor to fetch a single part at full detail \u2014 for example, to read one specific tool result or code block without loading every part.\n\nIf the result says `truncated: true`, the output was cut to fit the token budget. You can paginate or use `partIndex` to target specific content.\n\n### Following up on truncated parts\nLow-detail results may include truncation hints like:\n`[truncated \u2014 call recall cursor=\"...\" partIndex=N detail=\"high\" for full content]`\n\n**When you see these hints and need the full content, make the exact call described in the hint.** This is the normal workflow: first recall at low detail to scan, then drill into specific parts at high detail. Do not stop at the low-detail result if the user asked for exact content.\n\n### When recall is NOT needed\n- The user is asking for a high-level summary and your observations already cover it\n- The question is about general preferences or facts that don't require source text\n- There is no relevant range in your observations for the topic\n\nObservation groups with range IDs and your recall tool allows you to think back and remember details you're fuzzy on.";
+export declare function buildMessageRange(messages: MastraDBMessage[]): string;
+import { ObservationTurn } from './observation-turn/index.js';
+import { ObserverRunner } from './observer-runner.js';
+import type { CompressionLevel } from './reflector-agent.js';
+import { ReflectorRunner } from './reflector-runner.js';
+import { TokenCounter } from './token-counter.js';
+import type { ObservationDebugEvent, ObservationalMemoryConfig, ObserveHooks, ResolvedObservationConfig, ResolvedReflectionConfig, ThresholdRange } from './types.js';
 /**
  * ObservationalMemory - A three-agent memory system for long conversations.
  *
@@ -251,37 +59,30 @@ export declare const OBSERVATION_RETRIEVAL_INSTRUCTIONS = "## Recall \u2014 look
  * });
  * ```
  */
-export interface ObserveHooks {
-    onObservationStart?: () => void;
-    onObservationEnd?: () => void;
-    onReflectionStart?: () => void;
-    onReflectionEnd?: () => void;
-}
-export declare class ObservationalMemory implements Processor<'observational-memory'> {
-    readonly id: "observational-memory";
-    readonly name = "Observational Memory";
+export declare class ObservationalMemory {
     private storage;
     private tokenCounter;
-    private scope;
-    private retrieval;
+    readonly scope: 'resource' | 'thread';
+    /** Whether retrieval-mode observation groups are enabled (thread scope only). */
+    readonly retrieval: boolean;
     private observationConfig;
     private reflectionConfig;
     private onDebugEvent?;
-    /** Internal Observer agent - created lazily */
-    private observerAgent?;
-    private observerAgentModel?;
-    /** Internal Reflector agent - created lazily */
-    private reflectorAgent?;
-    private reflectorAgentModel?;
+    /** Observer agent runner — handles LLM calls for extracting observations. */
+    readonly observer: ObserverRunner;
+    /** Reflector agent runner — handles LLM calls for compressing observations. */
+    readonly reflector: ReflectorRunner;
+    /** Buffering state coordinator — manages static maps and buffering lifecycle. */
+    readonly buffering: BufferingCoordinator;
     private shouldObscureThreadIds;
     private hasher;
-    private threadIdCache;
     /**
      * Track message IDs observed during this instance's lifetime.
      * Prevents re-observing messages when per-thread lastObservedAt cursors
      * haven't fully advanced past messages observed in a prior cycle.
+     * @internal Used by observation strategies. Do not call directly.
      */
-    private observedMessageIds;
+    observedMessageIds: Set<string>;
     /** Internal MessageHistory for message persistence */
     private messageHistory;
     /**
@@ -297,116 +98,11 @@ export declare class ObservationalMemory implements Processor<'observational-mem
      * accept eventual consistency (acceptable for v1).
      */
     private locks;
-    /**
-     * Track in-flight async buffering operations per resource/thread.
-     * STATIC: Shared across all ObservationalMemory instances in this process.
-     * This is critical because multiple OM instances are created per agent loop step,
-     * and we need them to share knowledge of in-flight operations.
-     * Key format: "obs:{lockKey}" or "refl:{lockKey}"
-     * Value: Promise that resolves when buffering completes
-     */
-    private static asyncBufferingOps;
-    /**
-     * Track the last token boundary at which we started buffering.
-     * STATIC: Shared across all instances so boundary tracking persists across OM recreations.
-     * Key format: "obs:{lockKey}" or "refl:{lockKey}"
-     */
-    private static lastBufferedBoundary;
-    /**
-     * Track the timestamp cursor for buffered messages.
-     * STATIC: Shared across all instances so each buffer only observes messages
-     * newer than the previous buffer's boundary.
-     * Key format: "obs:{lockKey}"
-     */
-    private static lastBufferedAtTime;
-    /**
-     * Tracks cycleId for in-flight buffered reflections.
-     * STATIC: Shared across instances so we can match cycleId at activation time.
-     * Key format: "refl:{lockKey}"
-     */
-    private static reflectionBufferCycleIds;
-    /**
-     * Track message IDs that have been sealed during async buffering.
-     * STATIC: Shared across all instances so saveMessagesWithSealedIdTracking
-     * generates new IDs when re-saving messages that were sealed in a previous step.
-     * Key format: threadId
-     * Value: Set of sealed message IDs
-     */
-    private static sealedMessageIds;
-    /**
-     * Check if async buffering is enabled for observations.
-     */
-    private isAsyncObservationEnabled;
-    /**
-     * Check if async buffering is enabled for reflections.
-     * Reflection buffering is enabled when bufferActivation is set (triggers at threshold * bufferActivation).
-     */
-    private isAsyncReflectionEnabled;
-    /**
-     * Get the buffer interval boundary key for observations.
-     */
-    private getObservationBufferKey;
-    /**
-     * Get the buffer interval boundary key for reflections.
-     */
-    private getReflectionBufferKey;
-    /**
-     * Clean up static maps for a thread/resource to prevent memory leaks.
-     * Called after activation (to remove activated message IDs from sealedMessageIds)
-     * and from clear() (to fully remove all static state for a thread).
-     */
-    private cleanupStaticMaps;
-    /**
-     * Await any in-flight async buffering operations for a given thread/resource.
-     * Returns once all buffering promises have settled (or after timeout).
-     */
-    static awaitBuffering(threadId: string | null | undefined, resourceId: string | null | undefined, scope: 'thread' | 'resource', timeoutMs?: number): Promise<void>;
-    /**
-     * Safely get bufferedObservationChunks as an array.
-     * Handles cases where it might be a JSON string or undefined.
-     */
-    private getBufferedChunks;
-    /**
-     * Refresh per-chunk messageTokens from the current in-memory message list.
-     *
-     * Buffered chunks store a messageTokens snapshot from when they were created,
-     * but messages can be edited/sealed between buffering and activation, changing
-     * their token weight. Using stale weights causes projected-removal math to
-     * over- or under-estimate, leading to skipped activations or over-activation.
-     *
-     * Token recount only runs when the full chunk is present in the message list.
-     * Partial recount is skipped because it would undercount and could cause
-     * over-activation of buffered chunks.
-     */
-    private refreshBufferedChunkMessageTokens;
-    /**
-     * Check if we've crossed a new bufferTokens interval boundary.
-     * Returns true if async buffering should be triggered.
-     *
-     * When pending tokens are within ~1 bufferTokens of the observation threshold,
-     * the buffer interval is halved to produce finer-grained chunks right before
-     * activation. This improves chunk boundary selection, reducing overshoot.
-     */
-    private shouldTriggerAsyncObservation;
-    /**
-     * Check if async reflection buffering should be triggered.
-     * Triggers once when observation tokens reach `threshold * bufferActivation`.
-     * Only allows one buffered reflection at a time.
-     */
-    private shouldTriggerAsyncReflection;
-    /**
-     * Check if an async buffering operation is already in progress.
-     */
-    private isAsyncBufferingInProgress;
     /**
      * Acquire a lock for the given key, execute the callback, then release.
      * If a lock is already held, waits for it to be released before acquiring.
      */
     private withLock;
-    /**
-     * Get the lock key for the current scope
-     */
-    private getLockKey;
     constructor(config: ObservationalMemoryConfig);
     /**
      * Get the current configuration for this OM instance.
@@ -436,40 +132,28 @@ export declare class ObservationalMemory implements Processor<'observational-mem
      * Get the default compression start level based on model behavior.
      * gemini-2.5-flash is a faithful transcriber that needs explicit pressure to compress effectively.
      */
-    private getCompressionStartLevel;
-    private getRuntimeModelContext;
-    private runWithTokenCounterModelContext;
-    private formatRoutingModel;
-    private withOmTracingSpan;
+    getCompressionStartLevel(requestContext?: RequestContext): Promise<CompressionLevel>;
     /**
      * Get the full config including resolved model names.
      * This is async because it needs to resolve the model configs.
      */
     getResolvedConfig(requestContext?: RequestContext): Promise<{
         scope: 'resource' | 'thread';
-        shareTokenBudget: boolean;
         observation: {
             messageTokens: number | ThresholdRange;
             model: string;
             previousObserverTokens: number | false | undefined;
-            routing?: Array<{
-                upTo: number;
-                model: string;
-            }>;
         };
         reflection: {
             observationTokens: number | ThresholdRange;
             model: string;
-            routing?: Array<{
-                upTo: number;
-                model: string;
-            }>;
         };
     }>;
     /**
-     * Emit a debug event if the callback is configured
+     * Emit a debug event if the callback is configured.
+     * @internal Used by observation strategies. Do not call directly.
      */
-    private emitDebugEvent;
+    emitDebugEvent(event: ObservationDebugEvent): void;
     /**
      * Validate buffer configuration on first use.
      * Ensures bufferTokens is less than the threshold and bufferActivation is valid.
@@ -479,14 +163,6 @@ export declare class ObservationalMemory implements Processor<'observational-mem
      * Check whether the unobserved message tokens meet the observation threshold.
      */
     private meetsObservationThreshold;
-    /**
-     * Get or create the Observer agent
-     */
-    private getObserverAgent;
-    /**
-     * Get or create the Reflector agent
-     */
-    private getReflectorAgent;
     /**
      * Get thread/resource IDs for storage lookup
      */
@@ -496,10 +172,6 @@ export declare class ObservationalMemory implements Processor<'observational-mem
      * Returns the existing record if one exists, otherwise initializes a new one.
      */
     getOrCreateRecord(threadId: string, resourceId?: string): Promise<ObservationalMemoryRecord>;
-    /**
-     * Check if we need to trigger reflection.
-     */
-    private shouldReflect;
     /**
      * Get current config snapshot for observation markers.
      */
@@ -508,14 +180,22 @@ export declare class ObservationalMemory implements Processor<'observational-mem
      * 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.
      * (data-* parts are filtered out before sending to the LLM, so they don't affect model calls.)
+     * @internal Used by ReflectorRunner. Do not call directly.
      */
-    private persistMarkerToMessage;
+    persistMarkerToMessage(marker: {
+        type: string;
+        data: unknown;
+    }, messageList: MessageList | undefined, threadId: string, resourceId?: string): Promise<void>;
     /**
      * Persist a marker to the last assistant message in storage.
      * Unlike persistMarkerToMessage, this fetches messages directly from the DB
      * so it works even when no MessageList is available (e.g. async buffering ops).
+     * @internal Used by observation strategies. Do not call directly.
      */
-    private persistMarkerToStorage;
+    persistMarkerToStorage(marker: {
+        type: string;
+        data: unknown;
+    }, threadId: string, resourceId?: string): Promise<void>;
     /**
      * Find the last completed observation boundary in a message's parts.
      * A completed observation is a start marker followed by an end marker.
@@ -523,7 +203,6 @@ export declare class ObservationalMemory implements Processor<'observational-mem
      * Returns the index of the END marker (which is the observation boundary),
      * or -1 if no completed observation is found.
      */
-    private findLastCompletedObservationBoundary;
     /**
      * Check if a message has an in-progress observation (start without end).
      */
@@ -544,7 +223,8 @@ export declare class ObservationalMemory implements Processor<'observational-mem
      *
      * @param messages - Messages to seal (mutated in place)
      */
-    private sealMessagesForBuffering;
+    /** @internal Used by ObservationStep. */
+    sealMessagesForBuffering(messages: MastraDBMessage[]): void;
     /**
      * Insert an observation marker into a message.
      * The marker is appended directly to the message's parts array (mutating in place).
@@ -559,17 +239,6 @@ export declare class ObservationalMemory implements Processor<'observational-mem
      * For end/failed markers, this should be called AFTER writer.custom() has added the part,
      * so we just find the part and add sealing metadata.
      */
-    /**
-     * Get unobserved parts from a message.
-     * If the message has a completed observation (start + end), only return parts after the end.
-     * If observation is in progress (start without end), include parts before the start.
-     * Otherwise, return all parts.
-     */
-    private getUnobservedParts;
-    /**
-     * Check if a message has any unobserved parts.
-     */
-    private hasUnobservedParts;
     /**
      * Create a virtual message containing only the unobserved parts.
      * This is used for token counting and observation.
@@ -585,21 +254,20 @@ export declare class ObservationalMemory implements Processor<'observational-mem
      * This handles the case where a single message accumulates many parts
      * (like tool calls) during an agentic loop - we only observe the new parts.
      */
-    private getUnobservedMessages;
-    /**
-     * Wrapper for observer/reflector agent.generate() calls that checks for abort.
-     * agent.generate() returns an empty result on abort instead of throwing,
-     * so we must check the signal before and after the call.
-     * Retries are handled by Mastra's built-in p-retry at the model execution layer.
-     */
-    private withAbortCheck;
+    /** @internal Used by ObservationStep. */
+    getUnobservedMessages(allMessages: MastraDBMessage[], record: ObservationalMemoryRecord, opts?: {
+        excludeBuffered?: boolean;
+    }): MastraDBMessage[];
     /**
      * Prepare optimized observer context by applying truncation and buffered-reflection inclusion.
      *
      * Returns the (possibly optimized) observations string to pass as "Previous Observations"
      * to the observer prompt. When no optimization options are set, returns the input unchanged.
      */
-    private prepareObserverContext;
+    prepareObserverContext(existingObservations: string | undefined, record?: ObservationalMemoryRecord | null): {
+        context: string | undefined;
+        wasTruncated: boolean;
+    };
     /**
      * Truncate observations to fit within a token budget.
      *
@@ -610,22 +278,6 @@ export declare class ObservationalMemory implements Processor<'observational-mem
      * 4. Enforce that at least 50% of kept observations remain raw tail observations.
      */
     private truncateObservationsToTokenBudget;
-    /**
-     * Call the Observer agent to extract observations.
-     */
-    private callObserver;
-    /**
-     * Call the Observer agent for multiple threads in a single batched request.
-     * This is more efficient than calling the Observer for each thread individually.
-     * Returns per-thread results with observations, currentTask, and suggestedContinuation,
-     * plus the total usage for the batch.
-     */
-    private callMultiThreadObserver;
-    /**
-     * Call the Reflector agent to condense observations.
-     * Includes compression validation and retry logic.
-     */
-    private callReflector;
     /**
      * Format observations for injection into context.
      * Applies token optimization before presenting to the Actor.
@@ -633,12 +285,6 @@ export declare class ObservationalMemory implements Processor<'observational-mem
      * In resource scope mode, filters continuity messages to only show
      * the message for the current thread.
      */
-    /**
-     * Format observations for injection into the Actor's context.
-     * @param observations - The observations to inject
-     * @param suggestedResponse - Thread-specific suggested response (from thread metadata)
-     * @param unobservedContextBlocks - Formatted <unobserved-context> blocks from other threads
-     */
     private formatObservationsForContext;
     private splitObservationContextChunks;
     /**
@@ -650,77 +296,19 @@ export declare class ObservationalMemory implements Processor<'observational-mem
     /**
      * Get threadId and resourceId from either RequestContext or MessageList
      */
-    private getThreadContext;
-    /**
-     * Load historical unobserved messages into the message list (step 0 only).
-     * In resource scope, loads only current thread's messages.
-     * In thread scope, loads all unobserved messages for the thread.
-     */
-    private loadHistoricalMessagesIfNeeded;
-    /**
-     * Calculate all threshold-related values for observation decision making.
-     */
-    private calculateObservationThresholds;
-    /**
-     * Emit debug event and stream progress part for UI feedback.
-     */
-    private emitStepProgress;
-    /**
-     * Handle observation when threshold is reached.
-     * Tries async activation first if enabled, then falls back to sync observation.
-     * Returns whether observation succeeded.
-     */
-    private handleThresholdReached;
-    /**
-     * Remove observed messages from message list after successful observation.
-     * Accepts optional observedMessageIds for activation-based cleanup (when no markers are present).
-     */
-    private cleanupAfterObservation;
-    /**
-     * Handle per-step save when threshold is not reached.
-     * Persists messages incrementally to prevent data loss on interruption.
-     */
-    private handlePerStepSave;
-    /**
-     * Inject observations as system message and add continuation reminder.
-     */
-    private injectObservationsIntoContext;
-    /**
-     * Filter out already-observed messages from the in-memory context.
-     *
-     * Marker-boundary pruning is safest at step 0 (historical resume/rebuild), where
-     * list ordering mirrors persisted history.
-     * For step > 0, the list may include mid-loop mutations (sealing/splitting/trim),
-     * so we prefer record-based fallback pruning over position-based marker pruning.
-     */
-    private filterAlreadyObservedMessages;
-    /**
-     * Process input at each step - check threshold, observe if needed, save, inject observations.
-     * This is the ONLY processor method - all OM logic happens here.
-     *
-     * Flow:
-     * 1. Load historical messages (step 0 only)
-     * 2. Check if observation threshold is reached
-     * 3. If threshold reached: observe, save messages with markers
-     * 4. Inject observations into context
-     * 5. Filter out already-observed messages
-     */
-    processInputStep(args: ProcessInputStepArgs): Promise<MessageList | MastraDBMessage[]>;
-    /**
-     * Save any unsaved messages at the end of the agent turn.
-     *
-     * This is the "final save" that catches messages that processInputStep didn't save
-     * (e.g., when the observation threshold was never reached, or on single-step execution).
-     * Without this, messages would be lost because MessageHistory is disabled when OM is active.
-     */
-    processOutputResult(args: ProcessOutputResultArgs): Promise<MessageList | MastraDBMessage[]>;
+    getThreadContext(requestContext: RequestContext | undefined, messageList: MessageList): {
+        threadId: string;
+        resourceId?: string;
+    } | null;
     /**
-     * Save messages to storage while preventing duplicate inserts for sealed messages.
+     * Save messages to storage, skipping messages that were already persisted by
+     * async buffering. Uses the message-level sealed flag (metadata.mastra.sealed)
+     * to detect already-persisted messages, avoiding redundant DB operations.
      *
-     * Sealed messages that do not yet contain a completed observation boundary are
-     * skipped because async buffering already persisted them.
+     * Messages with observation markers are always saved (upserted) even if sealed,
+     * because the markers need to be persisted to storage.
      */
-    private saveMessagesWithSealedIdTracking;
+    persistMessages(messagesToSave: MastraDBMessage[], threadId: string, resourceId: string | undefined): Promise<void>;
     /**
      * Load messages from storage that haven't been observed yet.
      * Uses cursor-based query with lastObservedAt timestamp for efficiency.
@@ -729,12 +317,6 @@ export declare class ObservationalMemory implements Processor<'observational-mem
      * In thread scope mode, loads messages for just the current thread.
      */
     private loadUnobservedMessages;
-    /**
-     * Load unobserved messages from other threads (not the current thread) for a resource.
-     * Called fresh each step so it reflects the latest lastObservedAt cursors
-     * after observations complete.
-     */
-    private loadOtherThreadsContext;
     /**
      * Format unobserved messages from other threads as <unobserved-context> blocks.
      * These are injected into the Actor's context so it has awareness of activity
@@ -742,32 +324,18 @@ export declare class ObservationalMemory implements Processor<'observational-mem
      */
     private formatUnobservedContextBlocks;
     private representThreadIDInContext;
-    /**
-     * Strip any thread tags that the Observer might have added.
-     * Thread attribution is handled externally by the system, not by the Observer.
-     * This is a defense-in-depth measure.
-     */
-    private stripThreadTags;
     /**
      * Get the maximum createdAt timestamp from a list of messages.
      * Used to set lastObservedAt to the most recent message timestamp instead of current time.
      * This ensures historical data (like LongMemEval fixtures) works correctly.
      */
     private getMaxMessageTimestamp;
-    /**
-     * Compute a cursor pointing at the latest message by createdAt.
-     * Used to derive a stable observation boundary for replay pruning.
-     */
-    private getLastObservedMessageCursor;
-    /**
-     * Check if a message is at or before a cursor (by createdAt then id).
-     */
-    private isMessageAtOrBeforeCursor;
     /**
      * Wrap observations in a thread attribution tag.
      * Used in resource scope to track which thread observations came from.
+     * @internal Used by observation strategies. Do not call directly.
      */
-    private wrapWithThreadTag;
+    wrapWithThreadTag(threadId: string, observations: string, messageRange?: string): Promise<string>;
     /**
      * Append or merge new thread sections.
      * If the new section has the same thread ID and date as an existing section,
@@ -776,15 +344,9 @@ export declare class ObservationalMemory implements Processor<'observational-mem
      */
     private replaceOrAppendThreadSection;
     /**
-     * Sort threads by their oldest unobserved message.
-     * Returns thread IDs in order from oldest to most recent.
-     * This ensures no thread's messages get "stuck" unobserved.
-     */
-    private sortThreadsByOldestMessage;
-    /**
-     * Do synchronous observation (fallback when no buffering)
+     * @internal Used by observation strategies. Do not call directly.
      */
-    private doSynchronousObservation;
+    wrapObservations(rawObservations: string, existingObservations: string, threadId: string, lastObservedAt?: Date, messageRange?: string): Promise<string> | string;
     /**
      * Start an async background observation that stores results to bufferedObservations.
      * This is a fire-and-forget operation that runs in the background.
@@ -806,81 +368,318 @@ export declare class ObservationalMemory implements Processor<'observational-mem
      */
     private runAsyncBufferedObservation;
     /**
-     * Perform async buffered observation - observes messages and stores to bufferedObservations.
-     * Does NOT update activeObservations or trigger reflection.
+     * Trigger async buffered observation if the token count has crossed a new interval.
      *
-     * The observer sees: active observations + existing buffered observations + message history
-     * (excluding already-buffered messages).
+     * Encapsulates the shouldTrigger check + startAsyncBufferedObservation call.
+     * Returns whether buffering was actually triggered.
      */
-    private doAsyncBufferedObservation;
+    triggerAsyncBuffering(opts: {
+        threadId: string;
+        resourceId?: string;
+        record: ObservationalMemoryRecord;
+        pendingTokens: number;
+        unbufferedPendingTokens: number;
+        unobservedMessages: MastraDBMessage[];
+        threshold: number;
+        writer?: ProcessorStreamWriter;
+        requestContext?: RequestContext;
+    }): Promise<boolean>;
+    private isMessageList;
+    private removeIdsFromArray;
     /**
-     * Combine active and buffered observations for the buffering observer context.
-     * The buffering observer needs to see both so it doesn't duplicate content.
+     * Mutate partially observed messages in place and return the fully observed
+     * message IDs that should be removed from the live context.
+     *
+     * This is the shared activation-cleanup primitive used by both the processor
+     * and AI SDK integrations: callers pass the current live messages, OM trims
+     * any partially observed messages down to their unobserved parts, and OM
+     * returns only the IDs that are safe to remove entirely.
      */
-    private combineObservationsForBuffering;
+    getObservedMessageIdsForCleanup(opts: {
+        threadId: string;
+        resourceId?: string;
+        messages: MastraDBMessage[];
+        observedMessageIds?: string[];
+        retentionFloor?: number;
+    }): Promise<string[]>;
     /**
-     * Try to activate buffered observations when threshold is reached.
-     * Returns true if activation succeeded, false if no buffered content or activation failed.
+     * Clean up observed content from either a live MessageList or a plain message array.
      *
-     * @param record - Current OM record
-     * @param lockKey - Lock key for this scope
-     * @param writer - Optional writer for emitting UI markers
+     * - MessageList input: mutates the live container in place and returns the remaining messages
+     * - Array input: mutates the array in place and returns it
+     *
+     * This is the shared cleanup primitive intended for both processor and non-processor
+     * integrations. The processor may still pass sealedIds/state so marker/fallback cleanup
+     * can persist messages safely, but callers that do not need that bookkeeping can omit it.
      */
-    private tryActivateBufferedObservations;
+    /** @internal Used by ObservationStep. */
+    cleanupMessages(opts: {
+        threadId: string;
+        resourceId?: string;
+        messages: MessageList | MastraDBMessage[];
+        observedMessageIds?: string[];
+        retentionFloor?: number;
+    }): Promise<MastraDBMessage[]>;
     /**
-     * Start an async background reflection that stores results to bufferedReflection.
-     * This is a fire-and-forget operation that runs in the background.
-     * The results will be swapped to active when the main reflection threshold is reached.
+     * Clean up the message context after a successful observation.
      *
-     * @param record - Current OM record
-     * @param observationTokens - Current observation token count
-     * @param lockKey - Lock key for this scope
+     * Handles both activation-based cleanup (using observedMessageIds) and
+     * marker-based cleanup (using observation boundary markers). Respects
+     * retention floors to prevent removing too many messages.
+     */
+    cleanupObservedContext(opts: {
+        messageList: MessageList;
+        threadId: string;
+        resourceId?: string;
+        observedMessageIds?: string[];
+        retentionFloor?: number;
+    }): Promise<void>;
+    /**
+     * Reset buffering state after a successful observation activation.
+     *
+     * Clears the lastBufferedBoundary, buffering flag, and optionally cleans up
+     * static maps for activated message IDs.
      */
-    private startAsyncBufferedReflection;
+    /** @internal Used by ObservationStep. */
+    resetBufferingState(opts: {
+        threadId: string;
+        resourceId?: string;
+        recordId: string;
+        activatedMessageIds?: string[];
+    }): Promise<void>;
     /**
-     * Perform async buffered reflection - reflects observations and stores to bufferedReflection.
-     * Does NOT create a new generation or update activeObservations.
+     * Build the observation system message string for injection into an LLM prompt.
+     *
+     * Loads thread metadata (currentTask, suggestedResponse), formats observations
+     * with context prompts and instructions, and returns the fully-formed string.
+     * Returns undefined if no observations exist.
+     *
+     * This is the public entry point for context formatting — used by both
+     * Memory.getContext() (standalone) and the processor (via injectObservationsIntoMessages).
+     *
+     * @example
+     * ```ts
+     * const systemMsg = await om.buildContextSystemMessage({ threadId: 'thread-1' });
+     * if (systemMsg) {
+     *   const result = await generateText({ system: systemMsg, messages });
+     * }
+     * ```
      */
-    private doAsyncBufferedReflection;
+    buildContextSystemMessage(opts: {
+        threadId: string;
+        resourceId?: string;
+        record?: ObservationalMemoryRecord;
+        unobservedContextBlocks?: string;
+        currentDate?: Date;
+    }): Promise<string | undefined>;
     /**
-     * Try to activate buffered reflection when threshold is reached.
-     * Returns true if activation succeeded, false if no buffered content or activation failed.
+     * Build observation context as an array of system message chunks.
+     * Each chunk is a separate system message for better LLM cache hit rates.
+     * Used by the processor to inject multiple system messages.
+     * @internal
+     */
+    buildContextSystemMessages(opts: {
+        threadId: string;
+        resourceId?: string;
+        record?: ObservationalMemoryRecord;
+        unobservedContextBlocks?: string;
+        currentDate?: Date;
+    }): Promise<string[] | undefined>;
+    /**
+     * Get unobserved messages from other threads for resource-scoped observation.
      *
-     * @param record - Current OM record
-     * @param lockKey - Lock key for this scope
+     * Lists all threads for the resource, filters to unobserved messages,
+     * and formats them as context blocks.
+     */
+    /** @internal Used by ObservationTurn. */
+    getOtherThreadsContext(resourceId: string, currentThreadId: string): Promise<string | undefined>;
+    /**
+     * Emit debug event and stream progress for UI feedback.
+     */
+    emitProgress(opts: {
+        record: ObservationalMemoryRecord;
+        pendingTokens: number;
+        threshold: number;
+        effectiveObservationTokensThreshold: number;
+        currentObservationTokens: number;
+        writer?: ProcessorStreamWriter;
+        stepNumber: number;
+        threadId: string;
+        resourceId?: string;
+    }): Promise<void>;
+    /**
+     * Get the current observation status for a thread/resource.
+     *
+     * Loads unobserved messages from storage, counts tokens, and checks against
+     * configured thresholds. Returns a comprehensive status object that tells the
+     * caller what actions are needed.
+     *
+     * This is a pure read operation with no side effects.
+     *
+     * @example
+     * ```ts
+     * const status = await om.getStatus({ threadId });
+     * if (status.shouldObserve) {
+     *   await om.observe({ threadId });
+     * } else if (status.shouldBuffer) {
+     *   await om.buffer({ threadId });
+     * }
+     * if (status.shouldReflect) {
+     *   await om.reflect(threadId);
+     * }
+     * ```
      */
-    private tryActivateBufferedReflection;
+    getStatus(opts: {
+        threadId: string;
+        resourceId?: string;
+        messages?: MastraDBMessage[];
+    }): Promise<{
+        record: ObservationalMemoryRecord;
+        pendingTokens: number;
+        threshold: number;
+        effectiveObservationTokensThreshold: number;
+        unbufferedPendingTokens: number;
+        shouldObserve: boolean;
+        shouldBuffer: boolean;
+        shouldReflect: boolean;
+        bufferedChunkCount: number;
+        bufferedChunkTokens: number;
+        canActivate: boolean;
+        asyncObservationEnabled: boolean;
+        asyncReflectionEnabled: boolean;
+        scope: 'resource' | 'thread';
+    }>;
     /**
-     * Resource-scoped observation: observe ALL threads with unobserved messages.
-     * Threads are observed in oldest-first order to ensure no thread's messages
-     * get "stuck" unobserved forever.
+     * Finalize the observation lifecycle: activate any remaining buffered chunks,
+     * then observe if the threshold is crossed.
      *
-     * Key differences from thread-scoped observation:
-     * 1. Loads messages from ALL threads for the resource
-     * 2. Observes threads one-by-one in oldest-first order
-     * 3. Only updates lastObservedAt AFTER all threads are observed
-     * 4. Only triggers reflection AFTER all threads are observed
+     * Call this at the end of a conversation, session, or turn sequence to ensure
+     * no buffered observations are left orphaned and the observation cursor is
+     * advanced. Produces a clean terminal state (no pending chunks, cursor up to date).
+     *
+     * @example
+     * ```ts
+     * // After all turns are complete
+     * const result = await om.finalize({ threadId });
+     * // result.activated: true if buffered chunks were promoted
+     * // result.observed: true if a full observation pass ran
+     * ```
      */
-    private doResourceScopedObservation;
+    finalize(opts: {
+        threadId: string;
+        resourceId?: string;
+        messages?: MastraDBMessage[];
+    }): Promise<{
+        activated: boolean;
+        observed: boolean;
+        reflected: boolean;
+        record: ObservationalMemoryRecord;
+    }>;
     /**
-     * Check if async reflection should be triggered or activated.
-     * Only handles the async path — will never do synchronous (blocking) reflection.
-     * Safe to call after buffered observation activation.
+     * Return only the messages that haven't been fully observed yet.
+     *
+     * Use this to prune observed messages from an in-memory message array,
+     * preventing unbounded context growth across steps in a multi-step loop.
+     * This is the array-based equivalent of the processor's `cleanupObservedContext()`.
+     *
+     * @example
+     * ```ts
+     * // In a prepareStep hook, prune before sending to the model
+     * messages = await om.pruneObserved({ threadId, messages });
+     * ```
      */
-    private maybeAsyncReflect;
+    pruneObserved(opts: {
+        threadId: string;
+        resourceId?: string;
+        messages: MastraDBMessage[];
+    }): Promise<MastraDBMessage[]>;
+    /**
+     * Create a buffered observation chunk without merging into active observations.
+     *
+     * Loads unobserved messages from storage (filtered by the buffer cursor to avoid
+     * re-buffering), calls the observer LLM, and stores the result as a pending
+     * buffered chunk in the DB. The chunk can later be merged into active observations
+     * via `activate()`.
+     *
+     * This is a synchronous (awaited) operation — the caller decides whether to
+     * `await` it or fire-and-forget. All state lives in storage; no in-process
+     * coordination is needed.
+     *
+     * @example
+     * ```ts
+     * const status = await om.getStatus({ threadId });
+     * if (status.shouldBuffer) {
+     *   await om.buffer({ threadId });
+     * }
+     * ```
+     */
+    /** @internal Used by ObservationStep. */
+    buffer(opts: {
+        threadId: string;
+        resourceId?: string;
+        messages?: MastraDBMessage[];
+        /** The freshly-counted pending token count from the caller. If not provided,
+         *  falls back to record.pendingMessageTokens (which may be stale). */
+        pendingTokens?: number;
+        /** Pre-loaded record to skip the initial getOrCreateRecord() fetch.
+         *  When called fire-and-forget, passing the record avoids an async gap
+         *  before lastBufferedBoundary is set. */
+        record?: ObservationalMemoryRecord;
+        writer?: ProcessorStreamWriter;
+        requestContext?: RequestContext;
+        /** Called with the final candidate messages after cursor filtering, before the observer runs.
+         *  Use this to seal messages in a live MessageList and persist them to storage. */
+        beforeBuffer?: (candidates: MastraDBMessage[]) => Promise<void>;
+    }): Promise<{
+        buffered: boolean;
+        record: ObservationalMemoryRecord;
+    }>;
     /**
-     * Check if reflection needed and trigger if so.
-     * Supports both synchronous reflection and async buffered reflection.
-     * When async buffering is enabled via `bufferTokens`, reflection is triggered
-     * in the background at intervals, and activated when the threshold is reached.
+     * Activate buffered observation chunks by merging them into active observations.
+     *
+     * This is a pure storage operation — no LLM call. It reads buffered chunks from
+     * the DB and swaps them into active observations via `storage.swapBufferedToActive()`.
+     *
+     * Call this after `buffer()` has created chunks, typically at the start of a new
+     * turn or when `getStatus().canActivate` is true.
+     *
+     * @example
+     * ```ts
+     * const status = await om.getStatus({ threadId });
+     * if (status.canActivate) {
+     *   const result = await om.activate({ threadId });
+     *   if (result.activated) {
+     *     console.log('Activated', result.activatedMessageIds?.length, 'message observations');
+     *   }
+     * }
+     * ```
      */
-    private maybeReflect;
+    /** @internal Used by ObservationStep. */
+    activate(opts: {
+        threadId: string;
+        resourceId?: string;
+        /** When true, skip activation if pending tokens are below the observation threshold. */
+        checkThreshold?: boolean;
+        /** Messages to use for threshold check (in-memory). If omitted, loads from storage. */
+        messages?: MastraDBMessage[];
+        /** Stream writer for emitting activation markers to the UI. */
+        writer?: ProcessorStreamWriter;
+        /** MessageList for persisting activation markers on the last assistant message. */
+        messageList?: MessageList;
+    }): Promise<{
+        activated: boolean;
+        record: ObservationalMemoryRecord;
+        activatedMessageIds?: string[];
+    }>;
     /**
      * Manually trigger observation.
      *
      * When `messages` is provided, those are used directly (filtered for unobserved)
      * instead of reading from storage. This allows external systems (e.g., opencode)
      * to pass conversation messages without duplicating them into Mastra's DB.
+     *
+     * Returns a result indicating whether observation and/or reflection occurred,
+     * along with the updated record.
      */
     observe(opts: {
         threadId: string;
@@ -888,7 +687,12 @@ export declare class ObservationalMemory implements Processor<'observational-mem
         messages?: MastraDBMessage[];
         hooks?: ObserveHooks;
         requestContext?: RequestContext;
-    }): Promise<void>;
+        writer?: ProcessorStreamWriter;
+    }): Promise<{
+        observed: boolean;
+        reflected: boolean;
+        record: ObservationalMemoryRecord;
+    }>;
     /**
      * Manually trigger reflection with optional guidance prompt.
      *
@@ -900,7 +704,10 @@ export declare class ObservationalMemory implements Processor<'observational-mem
      * );
      * ```
      */
-    reflect(threadId: string, resourceId?: string, prompt?: string, requestContext?: RequestContext): Promise<void>;
+    reflect(threadId: string, resourceId?: string, prompt?: string, requestContext?: RequestContext): Promise<{
+        reflected: boolean;
+        record: ObservationalMemoryRecord;
+    }>;
     /**
      * Get current observations for a thread/resource
      */
@@ -933,6 +740,34 @@ export declare class ObservationalMemory implements Processor<'observational-mem
      * Get current reflection configuration
      */
     getReflectionConfig(): ResolvedReflectionConfig;
+    /**
+     * Get the message history instance for marker persistence.
+     */
+    getMessageHistory(): MessageHistory;
+    /**
+     * Get whether thread IDs should be obscured in observations.
+     */
+    getObscureThreadIds(): boolean;
+    /**
+     * 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: {
+        threadId: string;
+        resourceId?: string;
+        messageList: MessageList;
+    }): ObservationTurn;
 }
-export {};
 //# sourceMappingURL=observational-memory.d.ts.map