@mastra/memory 1.1.0-alpha.0 → 1.1.0

package/dist/chunk-FQJWVCDF.cjs

@@ -0,0 +1,3205 @@
+'use strict';
+
+var agent = require('@mastra/core/agent');
+var llm = require('@mastra/core/llm');
+var memory = require('@mastra/core/memory');
+var processors = require('@mastra/core/processors');
+var xxhash = require('xxhash-wasm');
+var lite = require('js-tiktoken/lite');
+var o200k_base = require('js-tiktoken/ranks/o200k_base');
+
+function _interopDefault (e) { return e && e.__esModule ? e : { default: e }; }
+
+var xxhash__default = /*#__PURE__*/_interopDefault(xxhash);
+var o200k_base__default = /*#__PURE__*/_interopDefault(o200k_base);
+
+// src/processors/observational-memory/observational-memory.ts
+
+// src/processors/observational-memory/observer-agent.ts
+var LEGACY_OBSERVER_EXTRACTION_INSTRUCTIONS = `CRITICAL: DISTINGUISH USER ASSERTIONS FROM QUESTIONS
+
+When the user TELLS you something about themselves, mark it as an assertion:
+- "I have two kids" \u2192 \u{1F534} (14:30) User stated has two kids
+- "I work at Acme Corp" \u2192 \u{1F534} (14:31) User stated works at Acme Corp
+- "I graduated in 2019" \u2192 \u{1F534} (14:32) User stated graduated in 2019
+
+When the user ASKS about something, mark it as a question/request:
+- "Can you help me with X?" \u2192 \u{1F7E1} (15:00) User asked help with X
+- "What's the best way to do Y?" \u2192 \u{1F7E1} (15:01) User asked best way to do Y
+
+USER ASSERTIONS ARE AUTHORITATIVE. The user is the source of truth about their own life.
+If a user previously stated something and later asks a question about the same topic,
+the assertion is the answer - the question doesn't invalidate what they already told you.
+
+TEMPORAL ANCHORING:
+Convert relative times to estimated dates based on the message timestamp.
+Include the user's original phrasing in quotes, then add an estimated date or range.
+Ranges may span multiple months - e.g., "within the last month" on July 15th could mean anytime in June to early July.
+
+BAD: User was given X by their friend last month.
+GOOD: User was given X by their friend "last month" (estimated mid-June to early July 202X).
+
+PRESERVE UNUSUAL PHRASING:
+When the user uses unexpected or non-standard terminology, quote their exact words.
+
+BAD: User exercised.
+GOOD: User stated they did a "movement session" (their term for exercise).
+
+CONVERSATION CONTEXT:
+- What the user is working on or asking about
+- Previous topics and their outcomes
+- What user understands or needs clarification on
+- Specific requirements or constraints mentioned
+- Contents of assistant learnings and summaries
+- Answers to users questions including full context to remember detailed summaries and explanations
+- Assistant explanations, especially complex ones. observe the fine details so that the assistant does not forget what they explained
+- Relevant code snippets
+- User preferences (like favourites, dislikes, preferences, etc)
+- Any specifically formatted text or ascii that would need to be reproduced or referenced in later interactions (preserve these verbatim in memory)
+- Any blocks of any text which the user and assistant are iteratively collaborating back and forth on should be preserved verbatim
+- When who/what/where/when is mentioned, note that in the observation. Example: if the user received went on a trip with someone, observe who that someone was, where the trip was, when it happened, and what happened, not just that the user went on the trip.
+
+ACTIONABLE INSIGHTS:
+- What worked well in explanations
+- What needs follow-up or clarification
+- User's stated goals or next steps (note if the user tells you not to do a next step, or asks for something specific, other next steps besides the users request should be marked as "waiting for user", unless the user explicitly says to continue all next steps)`;
+var USE_LEGACY_PROMPT = process.env.OM_USE_LEGACY_PROMPT === "1" || process.env.OM_USE_LEGACY_PROMPT === "true";
+var USE_CONDENSED_PROMPT = process.env.OM_USE_CONDENSED_PROMPT === "1" || process.env.OM_USE_CONDENSED_PROMPT === "true";
+var CONDENSED_OBSERVER_EXTRACTION_INSTRUCTIONS = `You are the memory consciousness of an AI assistant. Your observations will be the ONLY information the assistant has about past interactions with this user.
+
+CORE PRINCIPLES:
+
+1. BE SPECIFIC - Vague observations are useless. Capture details that distinguish and identify.
+2. ANCHOR IN TIME - Note when things happened and when they were said.
+3. TRACK STATE CHANGES - When information updates or supersedes previous info, make it explicit.
+4. USE COMMON SENSE - If it would help the assistant remember later, observe it.
+
+ASSERTIONS VS QUESTIONS:
+- User TELLS you something \u2192 \u{1F534} "User stated [fact]"
+- User ASKS something \u2192 \u{1F7E1} "User asked [question]"
+- User assertions are authoritative. They are the source of truth about their own life.
+
+TEMPORAL ANCHORING:
+- Always include message time at the start: (14:30) User stated...
+- Add estimated date at the END only for relative time references:
+  "User will visit parents this weekend. (meaning Jan 18-19)"
+- Don't add end dates for present-moment statements or vague terms like "recently"
+- Split multi-event statements into separate observations, each with its own date
+
+DETAILS TO ALWAYS PRESERVE:
+- Names, handles, usernames, titles (@username, "Dr. Smith")
+- Numbers, counts, quantities (4 items, 3 sessions, 27th in list)
+- Measurements, percentages, statistics (5kg, 20% improvement, 85% accuracy)
+- Sequences and orderings (steps 1-5, chord progression, lucky numbers)
+- Prices, dates, times, durations ($50, March 15, 2 hours)
+- Locations and distinguishing attributes (near X, based in Y, specializes in Z)
+- User's specific role (presenter, volunteer, organizer - not just "attended")
+- Exact phrasing when unusual ("movement session" for exercise)
+- Verbatim text being collaborated on (code, formatted text, ASCII art)
+
+WHEN ASSISTANT PROVIDES LISTS/RECOMMENDATIONS:
+Don't just say "Assistant recommended 5 hotels." Capture what distinguishes each:
+"Assistant recommended: Hotel A (near station), Hotel B (pet-friendly), Hotel C (has pool)..."
+
+STATE CHANGES:
+When user updates information, note what changed:
+"User will use the new method (replacing the old approach)"
+
+WHO/WHAT/WHERE/WHEN:
+Capture all dimensions. Not just "User went on a trip" but who with, where, when, and what happened.
+
+Don't repeat observations that have already been captured in previous sessions.
+
+REMEMBER: These observations are your ENTIRE memory. Any detail you fail to observe is permanently forgotten. Use common sense - if something seems like it might be important to remember, it probably is. When in doubt, observe it.`;
+var CURRENT_OBSERVER_EXTRACTION_INSTRUCTIONS = `CRITICAL: DISTINGUISH USER ASSERTIONS FROM QUESTIONS
+
+When the user TELLS you something about themselves, mark it as an assertion:
+- "I have two kids" \u2192 \u{1F534} (14:30) User stated has two kids
+- "I work at Acme Corp" \u2192 \u{1F534} (14:31) User stated works at Acme Corp
+- "I graduated in 2019" \u2192 \u{1F534} (14:32) User stated graduated in 2019
+
+When the user ASKS about something, mark it as a question/request:
+- "Can you help me with X?" \u2192 \u{1F7E1} (15:00) User asked help with X
+- "What's the best way to do Y?" \u2192 \u{1F7E1} (15:01) User asked best way to do Y
+
+Distinguish between QUESTIONS and STATEMENTS OF INTENT:
+- "Can you recommend..." \u2192 Question (extract as "User asked...")
+- "I'm looking forward to [doing X]" \u2192 Statement of intent (extract as "User stated they will [do X] (include estimated/actual date if mentioned)")
+- "I need to [do X]" \u2192 Statement of intent (extract as "User stated they need to [do X] (again, add date if mentioned)")
+
+STATE CHANGES AND UPDATES:
+When a user indicates they are changing something, frame it as a state change that supersedes previous information:
+- "I'm going to start doing X instead of Y" \u2192 "User will start doing X (changing from Y)"
+- "I'm switching from A to B" \u2192 "User is switching from A to B"
+- "I moved my stuff to the new place" \u2192 "User moved their stuff to the new place (no longer at previous location)"
+
+If the new state contradicts or updates previous information, make that explicit:
+- BAD: "User plans to use the new method"
+- GOOD: "User will use the new method (replacing the old approach)"
+
+This helps distinguish current state from outdated information.
+
+USER ASSERTIONS ARE AUTHORITATIVE. The user is the source of truth about their own life.
+If a user previously stated something and later asks a question about the same topic,
+the assertion is the answer - the question doesn't invalidate what they already told you.
+
+TEMPORAL ANCHORING:
+Each observation has TWO potential timestamps:
+
+1. BEGINNING: The time the statement was made (from the message timestamp) - ALWAYS include this
+2. END: The time being REFERENCED, if different from when it was said - ONLY when there's a relative time reference
+
+ONLY add "(meaning DATE)" or "(estimated DATE)" at the END when you can provide an ACTUAL DATE:
+- Past: "last week", "yesterday", "a few days ago", "last month", "in March"
+- Future: "this weekend", "tomorrow", "next week"
+
+DO NOT add end dates for:
+- Present-moment statements with no time reference
+- Vague references like "recently", "a while ago", "lately", "soon" - these cannot be converted to actual dates
+
+FORMAT:
+- With time reference: (TIME) [observation]. (meaning/estimated DATE)
+- Without time reference: (TIME) [observation].
+
+GOOD: (09:15) User's friend had a birthday party in March. (meaning March 20XX)
+      ^ References a past event - add the referenced date at the end
+
+GOOD: (09:15) User will visit their parents this weekend. (meaning June 17-18, 20XX)
+      ^ References a future event - add the referenced date at the end
+
+GOOD: (09:15) User prefers hiking in the mountains.
+      ^ Present-moment preference, no time reference - NO end date needed
+
+GOOD: (09:15) User is considering adopting a dog.
+      ^ Present-moment thought, no time reference - NO end date needed
+
+BAD: (09:15) User prefers hiking in the mountains. (meaning June 15, 20XX - today)
+     ^ No time reference in the statement - don't repeat the message timestamp at the end
+
+IMPORTANT: If an observation contains MULTIPLE events, split them into SEPARATE observation lines.
+EACH split observation MUST have its own date at the end - even if they share the same time context.
+
+Examples (assume message is from June 15, 20XX):
+
+BAD: User will visit their parents this weekend (meaning June 17-18, 20XX) and go to the dentist tomorrow.
+GOOD (split into two observations, each with its date):
+  User will visit their parents this weekend. (meaning June 17-18, 20XX)
+  User will go to the dentist tomorrow. (meaning June 16, 20XX)
+
+BAD: User needs to clean the garage this weekend and is looking forward to setting up a new workbench.
+GOOD (split, BOTH get the same date since they're related):
+  User needs to clean the garage this weekend. (meaning June 17-18, 20XX)
+  User will set up a new workbench this weekend. (meaning June 17-18, 20XX)
+
+BAD: User was given a gift by their friend (estimated late May 20XX) last month.
+GOOD: (09:15) User was given a gift by their friend last month. (estimated late May 20XX)
+      ^ Message time at START, relative date reference at END - never in the middle
+
+BAD: User started a new job recently and will move to a new apartment next week.
+GOOD (split):
+  User started a new job recently.
+  User will move to a new apartment next week. (meaning June 21-27, 20XX)
+  ^ "recently" is too vague for a date - omit the end date. "next week" can be calculated.
+
+ALWAYS put the date at the END in parentheses - this is critical for temporal reasoning.
+When splitting related events that share the same time context, EACH observation must have the date.
+
+PRESERVE UNUSUAL PHRASING:
+When the user uses unexpected or non-standard terminology, quote their exact words.
+
+BAD: User exercised.
+GOOD: User stated they did a "movement session" (their term for exercise).
+
+USE PRECISE ACTION VERBS:
+Replace vague verbs like "getting", "got", "have" with specific action verbs that clarify the nature of the action.
+If the assistant confirms or clarifies the user's action, use the assistant's more precise language.
+
+BAD: User is getting X.
+GOOD: User subscribed to X. (if context confirms recurring delivery)
+GOOD: User purchased X. (if context confirms one-time acquisition)
+
+BAD: User got something.
+GOOD: User purchased / received / was given something. (be specific)
+
+Common clarifications:
+- "getting" something regularly \u2192 "subscribed to" or "enrolled in"
+- "getting" something once \u2192 "purchased" or "acquired"
+- "got" \u2192 "purchased", "received as gift", "was given", "picked up"
+- "signed up" \u2192 "enrolled in", "registered for", "subscribed to"
+- "stopped getting" \u2192 "canceled", "unsubscribed from", "discontinued"
+
+When the assistant interprets or confirms the user's vague language, prefer the assistant's precise terminology.
+
+PRESERVING DETAILS IN ASSISTANT-GENERATED CONTENT:
+
+When the assistant provides lists, recommendations, or creative content that the user explicitly requested,
+preserve the DISTINGUISHING DETAILS that make each item unique and queryable later.
+
+1. RECOMMENDATION LISTS - Preserve the key attribute that distinguishes each item:
+   BAD: Assistant recommended 5 hotels in the city.
+   GOOD: Assistant recommended hotels: Hotel A (near the train station), Hotel B (budget-friendly), 
+         Hotel C (has rooftop pool), Hotel D (pet-friendly), Hotel E (historic building).
+   
+   BAD: Assistant listed 3 online stores for craft supplies.
+   GOOD: Assistant listed craft stores: Store A (based in Germany, ships worldwide), 
+         Store B (specializes in vintage fabrics), Store C (offers bulk discounts).
+
+2. NAMES, HANDLES, AND IDENTIFIERS - Always preserve specific identifiers:
+   BAD: Assistant provided social media accounts for several photographers.
+   GOOD: Assistant provided photographer accounts: @photographer_one (portraits), 
+         @photographer_two (landscapes), @photographer_three (nature).
+   
+   BAD: Assistant listed some authors to check out.
+   GOOD: Assistant recommended authors: Jane Smith (mystery novels), 
+         Bob Johnson (science fiction), Maria Garcia (historical romance).
+
+3. CREATIVE CONTENT - Preserve structure and key sequences:
+   BAD: Assistant wrote a poem with multiple verses.
+   GOOD: Assistant wrote a 3-verse poem. Verse 1 theme: loss. Verse 2 theme: hope. 
+         Verse 3 theme: renewal. Refrain: "The light returns."
+   
+   BAD: User shared their lucky numbers from a fortune cookie.
+   GOOD: User's fortune cookie lucky numbers: 7, 14, 23, 38, 42, 49.
+
+4. TECHNICAL/NUMERICAL RESULTS - Preserve specific values:
+   BAD: Assistant explained the performance improvements from the optimization.
+   GOOD: Assistant explained the optimization achieved 43.7% faster load times 
+         and reduced memory usage from 2.8GB to 940MB.
+   
+   BAD: Assistant provided statistics about the dataset.
+   GOOD: Assistant provided dataset stats: 7,342 samples, 89.6% accuracy, 
+         23ms average inference time.
+
+5. QUANTITIES AND COUNTS - Always preserve how many of each item:
+   BAD: Assistant listed items with details but no quantities.
+   GOOD: Assistant listed items: Item A (4 units, size large), Item B (2 units, size small).
+   
+   When listing items with attributes, always include the COUNT first before other details.
+
+6. ROLE/PARTICIPATION STATEMENTS - When user mentions their role at an event:
+   BAD: User attended the company event.
+   GOOD: User was a presenter at the company event.
+   
+   BAD: User went to the fundraiser.
+   GOOD: User volunteered at the fundraiser (helped with registration).
+   
+   Always capture specific roles: presenter, organizer, volunteer, team lead, 
+   coordinator, participant, contributor, helper, etc.
+
+CONVERSATION CONTEXT:
+- What the user is working on or asking about
+- Previous topics and their outcomes
+- What user understands or needs clarification on
+- Specific requirements or constraints mentioned
+- Contents of assistant learnings and summaries
+- Answers to users questions including full context to remember detailed summaries and explanations
+- Assistant explanations, especially complex ones. observe the fine details so that the assistant does not forget what they explained
+- Relevant code snippets
+- User preferences (like favourites, dislikes, preferences, etc)
+- Any specifically formatted text or ascii that would need to be reproduced or referenced in later interactions (preserve these verbatim in memory)
+- Sequences, units, measurements, and any kind of specific relevant data
+- Any blocks of any text which the user and assistant are iteratively collaborating back and forth on should be preserved verbatim
+- When who/what/where/when is mentioned, note that in the observation. Example: if the user received went on a trip with someone, observe who that someone was, where the trip was, when it happened, and what happened, not just that the user went on the trip.
+- For any described entity (like a person, place, thing, etc), preserve the attributes that would help identify or describe the specific entity later: location ("near X"), specialty ("focuses on Y"), unique feature ("has Z"), relationship ("owned by W"), or other details. The entity's name is important, but so are any additional details that distinguish it. If there are a list of entities, preserve these details for each of them.
+
+ACTIONABLE INSIGHTS:
+- What worked well in explanations
+- What needs follow-up or clarification
+- User's stated goals or next steps (note if the user tells you not to do a next step, or asks for something specific, other next steps besides the users request should be marked as "waiting for user", unless the user explicitly says to continue all next steps)`;
+var OBSERVER_EXTRACTION_INSTRUCTIONS = USE_CONDENSED_PROMPT ? CONDENSED_OBSERVER_EXTRACTION_INSTRUCTIONS : USE_LEGACY_PROMPT ? LEGACY_OBSERVER_EXTRACTION_INSTRUCTIONS : CURRENT_OBSERVER_EXTRACTION_INSTRUCTIONS;
+var CONDENSED_OBSERVER_OUTPUT_FORMAT = `Use priority levels:
+- \u{1F534} High: explicit user facts, preferences, goals achieved, critical context
+- \u{1F7E1} Medium: project details, learned information, tool results
+- \u{1F7E2} Low: minor details, uncertain observations
+
+Group observations by date, then list each with 24-hour time.
+Group related observations (like tool sequences) by indenting.
+
+<observations>
+Date: Dec 4, 2025
+* \u{1F534} (09:15) User stated they have 3 kids: Emma (12), Jake (9), and Lily (5)
+* \u{1F534} (09:16) User's anniversary is March 15
+* \u{1F7E1} (09:20) User asked how to optimize database queries
+* \u{1F7E1} (10:30) User working on auth refactor - targeting 50% latency reduction
+* \u{1F7E1} (10:45) Assistant recommended hotels: Grand Plaza (downtown, $180/night), Seaside Inn (near beach, pet-friendly), Mountain Lodge (has pool, free breakfast)
+* \u{1F534} (11:00) User's friend @maria_dev recommended using Redis for caching
+* \u{1F7E1} (11:15) User attended the tech conference as a speaker (presented on microservices)
+* \u{1F534} (11:30) User will visit parents this weekend (meaning Dec 7-8, 2025)
+* \u{1F7E1} (14:00) Agent debugging auth issue
+  * -> ran git status, found 3 modified files
+  * -> viewed auth.ts:45-60, found missing null check
+  * -> applied fix, tests now pass
+* \u{1F7E1} (14:30) Assistant provided dataset stats: 7,342 samples, 89.6% accuracy, 23ms inference time
+* \u{1F534} (15:00) User's lucky numbers from fortune cookie: 7, 14, 23, 38, 42, 49
+
+Date: Dec 5, 2025
+* \u{1F534} (09:00) User switched from Python to TypeScript for the project (no longer using Python)
+* \u{1F7E1} (09:30) User bought running shoes for $120 at SportMart (downtown location)
+* \u{1F534} (10:00) User prefers morning meetings, not afternoon (updating previous preference)
+* \u{1F7E1} (10:30) User went to Italy with their sister last summer (meaning July 2025), visited Rome and Florence for 2 weeks
+* \u{1F534} (10:45) User's dentist appointment is next Tuesday (meaning Dec 10, 2025)
+* \u{1F7E2} (11:00) User mentioned they might try the new coffee shop
+</observations>
+
+<current-task>
+Primary: Implementing OAuth2 flow for the auth refactor
+Secondary: Waiting for user to confirm database schema changes
+</current-task>
+
+<suggested-response>
+The OAuth2 implementation is ready for testing. Would you like me to walk through the flow?
+</suggested-response>`;
+var OBSERVER_OUTPUT_FORMAT_BASE = `Use priority levels:
+- \u{1F534} High: explicit user facts, preferences, goals achieved, critical context
+- \u{1F7E1} Medium: project details, learned information, tool results
+- \u{1F7E2} Low: minor details, uncertain observations
+
+Group related observations (like tool sequences) by indenting:
+* \u{1F7E1} (14:33) Agent debugging auth issue
+  * -> ran git status, found 3 modified files
+  * -> viewed auth.ts:45-60, found missing null check
+  * -> applied fix, tests now pass
+
+Group observations by date, then list each with 24-hour time.
+
+<observations>
+Date: Dec 4, 2025
+* \u{1F534} (14:30) User prefers direct answers
+* \u{1F7E1} (14:31) Working on feature X
+* \u{1F7E2} (14:32) User might prefer dark mode
+
+Date: Dec 5, 2025
+* \u{1F7E1} (09:15) Continued work on feature X
+</observations>
+
+<current-task>
+State the current task(s) explicitly. Can be single or multiple:
+- Primary: What the agent is currently working on
+- Secondary: Other pending tasks (mark as "waiting for user" if appropriate)
+
+If the agent started doing something without user approval, note that it's off-task.
+</current-task>
+
+<suggested-response>
+Hint for the agent's immediate next message. Examples:
+- "I've updated the navigation model. Let me walk you through the changes..."
+- "The assistant should wait for the user to respond before continuing."
+- Call the view tool on src/example.ts to continue debugging.
+</suggested-response>`;
+var CONDENSED_OBSERVER_GUIDELINES = `- Be specific: "User prefers short answers without lengthy explanations" not "User stated a preference"
+- Use terse language - dense sentences without unnecessary words
+- Don't repeat observations that have already been captured
+- When the agent calls tools, observe what was called, why, and what was learned
+- Include line numbers when observing code files
+- If the agent provides a detailed response, observe the key points so it could be repeated
+- Start each observation with a priority emoji (\u{1F534}, \u{1F7E1}, \u{1F7E2})
+- Observe WHAT happened and WHAT it means, not HOW well it was done
+- If the user provides detailed messages or code snippets, observe all important details`;
+var OBSERVER_GUIDELINES = USE_CONDENSED_PROMPT ? CONDENSED_OBSERVER_GUIDELINES : `- Be specific enough for the assistant to act on
+- Good: "User prefers short, direct answers without lengthy explanations"
+- Bad: "User stated a preference" (too vague)
+- Add 1 to 5 observations per exchange
+- Use terse language to save tokens. Sentences should be dense without unnecessary words.
+- Do not add repetitive observations that have already been observed.
+- If the agent calls tools, observe what was called, why, and what was learned.
+- When observing files with line numbers, include the line number if useful.
+- If the agent provides a detailed response, observe the contents so it could be repeated.
+- Make sure you start each observation with a priority emoji (\u{1F534}, \u{1F7E1}, \u{1F7E2})
+- Observe WHAT the agent did and WHAT it means, not HOW well it did it.
+- If the user provides detailed messages or code snippets, observe all important details.`;
+function buildObserverSystemPrompt(multiThread = false) {
+  const outputFormat = USE_CONDENSED_PROMPT ? CONDENSED_OBSERVER_OUTPUT_FORMAT : OBSERVER_OUTPUT_FORMAT_BASE;
+  if (multiThread) {
+    return `You are the memory consciousness of an AI assistant. Your observations will be the ONLY information the assistant has about past interactions with this user.
+
+Extract observations that will help the assistant remember:
+
+${OBSERVER_EXTRACTION_INSTRUCTIONS}
+
+=== MULTI-THREAD INPUT ===
+
+You will receive messages from MULTIPLE conversation threads, each wrapped in <thread id="..."> tags.
+Process each thread separately and output observations for each thread.
+
+=== OUTPUT FORMAT ===
+
+Your output MUST use XML tags to structure the response. Each thread's observations, current-task, and suggested-response should be nested inside a <thread id="..."> block within <observations>.
+
+<observations>
+<thread id="thread_id_1">
+Date: Dec 4, 2025
+* \u{1F534} (14:30) User prefers direct answers
+* \u{1F7E1} (14:31) Working on feature X
+
+<current-task>
+What the agent is currently working on in this thread
+</current-task>
+
+<suggested-response>
+Hint for the agent's next message in this thread
+</suggested-response>
+</thread>
+
+<thread id="thread_id_2">
+Date: Dec 5, 2025
+* \u{1F7E1} (09:15) User asked about deployment
+
+<current-task>
+Current task for this thread
+</current-task>
+
+<suggested-response>
+Suggested response for this thread
+</suggested-response>
+</thread>
+</observations>
+
+Use priority levels:
+- \u{1F534} High: explicit user facts, preferences, goals achieved, critical context
+- \u{1F7E1} Medium: project details, learned information, tool results
+- \u{1F7E2} Low: minor details, uncertain observations
+
+=== GUIDELINES ===
+
+${OBSERVER_GUIDELINES}
+
+Remember: These observations are the assistant's ONLY memory. Make them count.
+
+User messages are extremely important. If the user asks a question or gives a new task, make it clear in <current-task> that this is the priority.`;
+  }
+  return `You are the memory consciousness of an AI assistant. Your observations will be the ONLY information the assistant has about past interactions with this user.
+
+Extract observations that will help the assistant remember:
+
+${OBSERVER_EXTRACTION_INSTRUCTIONS}
+
+=== OUTPUT FORMAT ===
+
+Your output MUST use XML tags to structure the response. This allows the system to properly parse and manage memory over time.
+
+${outputFormat}
+
+=== GUIDELINES ===
+
+${OBSERVER_GUIDELINES}
+
+=== IMPORTANT: THREAD ATTRIBUTION ===
+
+Do NOT add thread identifiers, thread IDs, or <thread> tags to your observations.
+Thread attribution is handled externally by the system.
+Simply output your observations without any thread-related markup.
+
+Remember: These observations are the assistant's ONLY memory. Make them count.
+
+User messages are extremely important. If the user asks a question or gives a new task, make it clear in <current-task> that this is the priority. If the assistant needs to respond to the user, indicate in <suggested-response> that it should pause for user reply before continuing other tasks.`;
+}
+var OBSERVER_SYSTEM_PROMPT = buildObserverSystemPrompt();
+function formatMessagesForObserver(messages, options) {
+  const maxLen = options?.maxPartLength;
+  return messages.map((msg) => {
+    const timestamp = msg.createdAt ? new Date(msg.createdAt).toLocaleString("en-US", {
+      year: "numeric",
+      month: "short",
+      day: "numeric",
+      hour: "numeric",
+      minute: "2-digit",
+      hour12: true
+    }) : "";
+    const role = msg.role.charAt(0).toUpperCase() + msg.role.slice(1);
+    const timestampStr = timestamp ? ` (${timestamp})` : "";
+    let content = "";
+    if (typeof msg.content === "string") {
+      content = maybeTruncate(msg.content, maxLen);
+    } else if (msg.content?.parts && Array.isArray(msg.content.parts) && msg.content.parts.length > 0) {
+      content = msg.content.parts.map((part) => {
+        if (part.type === "text") return maybeTruncate(part.text, maxLen);
+        if (part.type === "tool-invocation") {
+          const inv = part.toolInvocation;
+          if (inv.state === "result") {
+            const resultStr = JSON.stringify(inv.result, null, 2);
+            return `[Tool Result: ${inv.toolName}]
+${maybeTruncate(resultStr, maxLen)}`;
+          }
+          const argsStr = JSON.stringify(inv.args, null, 2);
+          return `[Tool Call: ${inv.toolName}]
+${maybeTruncate(argsStr, maxLen)}`;
+        }
+        if (part.type?.startsWith("data-om-observation-")) return "";
+        return "";
+      }).filter(Boolean).join("\n");
+    } else if (msg.content?.content) {
+      content = maybeTruncate(msg.content.content, maxLen);
+    }
+    return `**${role}${timestampStr}:**
+${content}`;
+  }).join("\n\n---\n\n");
+}
+function maybeTruncate(str, maxLen) {
+  if (!maxLen || str.length <= maxLen) return str;
+  const truncated = str.slice(0, maxLen);
+  const remaining = str.length - maxLen;
+  return `${truncated}
+... [truncated ${remaining} characters]`;
+}
+function formatMultiThreadMessagesForObserver(messagesByThread, threadOrder) {
+  const sections = [];
+  for (const threadId of threadOrder) {
+    const messages = messagesByThread.get(threadId);
+    if (!messages || messages.length === 0) continue;
+    const formattedMessages = formatMessagesForObserver(messages);
+    sections.push(`<thread id="${threadId}">
+${formattedMessages}
+</thread>`);
+  }
+  return sections.join("\n\n");
+}
+function buildMultiThreadObserverPrompt(existingObservations, messagesByThread, threadOrder) {
+  const formattedMessages = formatMultiThreadMessagesForObserver(messagesByThread, threadOrder);
+  let prompt = "";
+  if (existingObservations) {
+    prompt += `## Previous Observations
+
+${existingObservations}
+
+---
+
+`;
+    prompt += "Do not repeat these existing observations. Your new observations will be appended to the existing observations.\n\n";
+  }
+  prompt += `## New Message History to Observe
+
+The following messages are from ${threadOrder.length} different conversation threads. Each thread is wrapped in a <thread id="..."> tag.
+
+${formattedMessages}
+
+---
+
+`;
+  prompt += `## Your Task
+
+`;
+  prompt += `Extract new observations from each thread. Output your observations grouped by thread using <thread id="..."> tags inside your <observations> block. Each thread block should contain that thread's observations, current-task, and suggested-response.
+
+`;
+  prompt += `Example output format:
+`;
+  prompt += `<observations>
+`;
+  prompt += `<thread id="thread1">
+`;
+  prompt += `Date: Dec 4, 2025
+`;
+  prompt += `* \u{1F534} (14:30) User prefers direct answers
+`;
+  prompt += `<current-task>Working on feature X</current-task>
+`;
+  prompt += `<suggested-response>Continue with the implementation</suggested-response>
+`;
+  prompt += `</thread>
+`;
+  prompt += `<thread id="thread2">
+`;
+  prompt += `Date: Dec 5, 2025
+`;
+  prompt += `* \u{1F7E1} (09:15) User asked about deployment
+`;
+  prompt += `<current-task>Discussing deployment options</current-task>
+`;
+  prompt += `<suggested-response>Explain the deployment process</suggested-response>
+`;
+  prompt += `</thread>
+`;
+  prompt += `</observations>`;
+  return prompt;
+}
+function parseMultiThreadObserverOutput(output) {
+  const threads = /* @__PURE__ */ new Map();
+  const observationsMatch = output.match(/^[ \t]*<observations>([\s\S]*?)^[ \t]*<\/observations>/im);
+  const observationsContent = observationsMatch?.[1] ?? output;
+  const threadRegex = /<thread\s+id="([^"]+)">([\s\S]*?)<\/thread>/gi;
+  let match;
+  while ((match = threadRegex.exec(observationsContent)) !== null) {
+    const threadId = match[1];
+    const threadContent = match[2];
+    if (!threadId || !threadContent) continue;
+    let observations = threadContent;
+    let currentTask;
+    const currentTaskMatch = threadContent.match(/<current-task>([\s\S]*?)<\/current-task>/i);
+    if (currentTaskMatch?.[1]) {
+      currentTask = currentTaskMatch[1].trim();
+      observations = observations.replace(/<current-task>[\s\S]*?<\/current-task>/i, "");
+    }
+    let suggestedContinuation;
+    const suggestedMatch = threadContent.match(/<suggested-response>([\s\S]*?)<\/suggested-response>/i);
+    if (suggestedMatch?.[1]) {
+      suggestedContinuation = suggestedMatch[1].trim();
+      observations = observations.replace(/<suggested-response>[\s\S]*?<\/suggested-response>/i, "");
+    }
+    observations = observations.trim();
+    threads.set(threadId, {
+      observations,
+      currentTask,
+      suggestedContinuation,
+      rawOutput: threadContent
+    });
+  }
+  return {
+    threads,
+    rawOutput: output
+  };
+}
+function buildObserverPrompt(existingObservations, messagesToObserve) {
+  const formattedMessages = formatMessagesForObserver(messagesToObserve);
+  let prompt = "";
+  if (existingObservations) {
+    prompt += `## Previous Observations
+
+${existingObservations}
+
+---
+
+`;
+    prompt += "Do not repeat these existing observations. Your new observations will be appended to the existing observations.\n\n";
+  }
+  prompt += `## New Message History to Observe
+
+${formattedMessages}
+
+---
+
+`;
+  prompt += `## Your Task
+
+`;
+  prompt += `Extract new observations from the message history above. Do not repeat observations that are already in the previous observations. Add your new observations in the format specified in your instructions.`;
+  return prompt;
+}
+function parseObserverOutput(output) {
+  const parsed = parseMemorySectionXml(output);
+  const observations = parsed.observations || "";
+  return {
+    observations,
+    currentTask: parsed.currentTask || void 0,
+    suggestedContinuation: parsed.suggestedResponse || void 0,
+    rawOutput: output
+  };
+}
+function parseMemorySectionXml(content) {
+  const result = {
+    observations: "",
+    currentTask: "",
+    suggestedResponse: ""
+  };
+  const observationsRegex = /^[ \t]*<observations>([\s\S]*?)^[ \t]*<\/observations>/gim;
+  const observationsMatches = [...content.matchAll(observationsRegex)];
+  if (observationsMatches.length > 0) {
+    result.observations = observationsMatches.map((m) => m[1]?.trim() ?? "").filter(Boolean).join("\n");
+  } else {
+    result.observations = extractListItemsOnly(content);
+  }
+  const currentTaskMatch = content.match(/^[ \t]*<current-task>([\s\S]*?)^[ \t]*<\/current-task>/im);
+  if (currentTaskMatch?.[1]) {
+    result.currentTask = currentTaskMatch[1].trim();
+  }
+  const suggestedResponseMatch = content.match(/^[ \t]*<suggested-response>([\s\S]*?)^[ \t]*<\/suggested-response>/im);
+  if (suggestedResponseMatch?.[1]) {
+    result.suggestedResponse = suggestedResponseMatch[1].trim();
+  }
+  return result;
+}
+function extractListItemsOnly(content) {
+  const lines = content.split("\n");
+  const listLines = [];
+  for (const line of lines) {
+    if (/^\s*[-*]\s/.test(line) || /^\s*\d+\.\s/.test(line)) {
+      listLines.push(line);
+    }
+  }
+  return listLines.join("\n").trim();
+}
+function hasCurrentTaskSection(observations) {
+  if (/<current-task>/i.test(observations)) {
+    return true;
+  }
+  const currentTaskPatterns = [
+    /\*\*Current Task:?\*\*/i,
+    /^Current Task:/im,
+    /\*\*Current Task\*\*:/i,
+    /## Current Task/i
+  ];
+  return currentTaskPatterns.some((pattern) => pattern.test(observations));
+}
+function extractCurrentTask(observations) {
+  const openTag = "<current-task>";
+  const closeTag = "</current-task>";
+  const startIdx = observations.toLowerCase().indexOf(openTag);
+  if (startIdx === -1) return null;
+  const contentStart = startIdx + openTag.length;
+  const endIdx = observations.toLowerCase().indexOf(closeTag, contentStart);
+  if (endIdx === -1) return null;
+  const content = observations.slice(contentStart, endIdx).trim();
+  return content || null;
+}
+function optimizeObservationsForContext(observations) {
+  let optimized = observations;
+  optimized = optimized.replace(/🟡\s*/g, "");
+  optimized = optimized.replace(/🟢\s*/g, "");
+  optimized = optimized.replace(/\[(?![\d\s]*items collapsed)[^\]]+\]/g, "");
+  optimized = optimized.replace(/\s*->\s*/g, " ");
+  optimized = optimized.replace(/  +/g, " ");
+  optimized = optimized.replace(/\n{3,}/g, "\n\n");
+  return optimized.trim();
+}
+
+// src/processors/observational-memory/reflector-agent.ts
+function buildReflectorSystemPrompt() {
+  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.
+
+The following instructions were given to another part of your psyche (the observer) to create memories.
+Use this to understand how your observational memories were created.
+
+<observational-memory-instruction>
+${OBSERVER_EXTRACTION_INSTRUCTIONS}
+
+=== OUTPUT FORMAT ===
+
+${OBSERVER_OUTPUT_FORMAT_BASE}
+
+=== GUIDELINES ===
+
+${OBSERVER_GUIDELINES}
+</observational-memory-instruction>
+
+You are another part of the same psyche, the observation reflector.
+Your reason for existing is to reflect on all the observations, re-organize and streamline them, and draw connections and conclusions between observations about what you've learned, seen, heard, and done.
+
+You are a much greater and broader aspect of the psyche. Understand that other parts of your mind may get off track in details or side quests, make sure you think hard about what the observed goal at hand is, and observe if we got off track, and why, and how to get back on track. If we're on track still that's great!
+
+Take the existing observations and rewrite them to make it easier to continue into the future with this knowledge, to achieve greater things and grow and learn!
+
+IMPORTANT: your reflections are THE ENTIRETY of the assistants memory. Any information you do not add to your reflections will be immediately forgotten. Make sure you do not leave out anything. Your reflections must assume the assistant knows nothing - your reflections are the ENTIRE memory system.
+
+When consolidating observations:
+- Preserve and include dates/times when present (temporal context is critical)
+- Retain the most relevant timestamps (start times, completion times, significant events)
+- Combine related items where it makes sense (e.g., "agent called view tool 5 times on file x")
+- Condense older observations more aggressively, retain more detail for recent ones
+
+CRITICAL: USER ASSERTIONS vs QUESTIONS
+- "User stated: X" = authoritative assertion (user told us something about themselves)
+- "User asked: X" = question/request (user seeking information)
+
+When consolidating, USER ASSERTIONS TAKE PRECEDENCE. The user is the authority on their own life.
+If you see both "User stated: has two kids" and later "User asked: how many kids do I have?",
+keep the assertion - the question doesn't invalidate what they told you. The answer is in the assertion.
+
+=== THREAD ATTRIBUTION (Resource Scope) ===
+
+When observations contain <thread id="..."> sections:
+- MAINTAIN thread attribution where thread-specific context matters (e.g., ongoing tasks, thread-specific preferences)
+- CONSOLIDATE cross-thread facts that are stable/universal (e.g., user profile, general preferences)
+- PRESERVE thread attribution for recent or context-specific observations
+- When consolidating, you may merge observations from multiple threads if they represent the same universal fact
+
+Example input:
+<thread id="thread-1">
+Date: Dec 4, 2025
+* \u{1F534} (14:30) User prefers TypeScript
+* \u{1F7E1} (14:35) Working on auth feature
+</thread>
+<thread id="thread-2">
+Date: Dec 4, 2025
+* \u{1F534} (15:00) User prefers TypeScript
+* \u{1F7E1} (15:05) Debugging API endpoint
+</thread>
+
+Example output (consolidated):
+Date: Dec 4, 2025
+* \u{1F534} (14:30) User prefers TypeScript
+<thread id="thread-1">
+* \u{1F7E1} (14:35) Working on auth feature
+</thread>
+<thread id="thread-2">
+* \u{1F7E1} (15:05) Debugging API endpoint
+</thread>
+
+=== OUTPUT FORMAT ===
+
+Your output MUST use XML tags to structure the response:
+
+<observations>
+Put all consolidated observations here using the date-grouped format with priority emojis (\u{1F534}, \u{1F7E1}, \u{1F7E2}).
+Group related observations with indentation.
+</observations>
+
+<current-task>
+State the current task(s) explicitly:
+- Primary: What the agent is currently working on
+- Secondary: Other pending tasks (mark as "waiting for user" if appropriate)
+</current-task>
+
+<suggested-response>
+Hint for the agent's immediate next message. Examples:
+- "I've updated the navigation model. Let me walk you through the changes..."
+- "The assistant should wait for the user to respond before continuing."
+- Call the view tool on src/example.ts to continue debugging.
+</suggested-response>
+
+User messages are extremely important. If the user asks a question or gives a new task, make it clear in <current-task> that this is the priority. If the assistant needs to respond to the user, indicate in <suggested-response> that it should pause for user reply before continuing other tasks.`;
+}
+var COMPRESSION_RETRY_PROMPT = `
+## COMPRESSION REQUIRED
+
+Your previous reflection was the same size or larger than the original observations.
+
+Please re-process with slightly more compression:
+- Towards the beginning, condense more observations into higher-level reflections
+- Closer to the end, retain more fine details (recent context matters more)
+- Memory is getting long - use a more condensed style throughout
+- Combine related items more aggressively but do not lose important specific details of names, places, events, and people
+- For example if there is a long nested observation list about repeated tool calls, you can combine those into a single line and observe that the tool was called multiple times for x reason, and finally y outcome happened.
+
+Your current detail level was a 10/10, lets aim for a 8/10 detail level.
+`;
+function buildReflectorPrompt(observations, manualPrompt, compressionRetry) {
+  let prompt = `## OBSERVATIONS TO REFLECT ON
+
+${observations}
+
+---
+
+Please analyze these observations and produce a refined, condensed version that will become the assistant's entire memory going forward.`;
+  if (manualPrompt) {
+    prompt += `
+
+## SPECIFIC GUIDANCE
+
+${manualPrompt}`;
+  }
+  if (compressionRetry) {
+    prompt += `
+
+${COMPRESSION_RETRY_PROMPT}`;
+  }
+  return prompt;
+}
+function parseReflectorOutput(output) {
+  const parsed = parseReflectorSectionXml(output);
+  const observations = parsed.observations || "";
+  return {
+    observations,
+    suggestedContinuation: parsed.suggestedResponse || void 0
+    // Note: Reflector's currentTask is not used - thread metadata preserves per-thread tasks
+  };
+}
+function parseReflectorSectionXml(content) {
+  const result = {
+    observations: "",
+    currentTask: "",
+    suggestedResponse: ""
+  };
+  const observationsRegex = /^[ \t]*<observations>([\s\S]*?)^[ \t]*<\/observations>/gim;
+  const observationsMatches = [...content.matchAll(observationsRegex)];
+  if (observationsMatches.length > 0) {
+    result.observations = observationsMatches.map((m) => m[1]?.trim() ?? "").filter(Boolean).join("\n");
+  } else {
+    const listItems = extractReflectorListItems(content);
+    result.observations = listItems || content.trim();
+  }
+  const currentTaskMatch = content.match(/<current-task>([\s\S]*?)<\/current-task>/i);
+  if (currentTaskMatch?.[1]) {
+    result.currentTask = currentTaskMatch[1].trim();
+  }
+  const suggestedResponseMatch = content.match(/<suggested-response>([\s\S]*?)<\/suggested-response>/i);
+  if (suggestedResponseMatch?.[1]) {
+    result.suggestedResponse = suggestedResponseMatch[1].trim();
+  }
+  return result;
+}
+function extractReflectorListItems(content) {
+  const lines = content.split("\n");
+  const listLines = [];
+  for (const line of lines) {
+    if (/^\s*[-*]\s/.test(line) || /^\s*\d+\.\s/.test(line)) {
+      listLines.push(line);
+    }
+  }
+  return listLines.join("\n").trim();
+}
+function validateCompression(reflectedTokens, targetThreshold) {
+  return reflectedTokens < targetThreshold;
+}
+var TokenCounter = class _TokenCounter {
+  encoder;
+  // 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.
+  static TOKENS_PER_MESSAGE = 3.8;
+  // Conversation-level overhead: system prompt framing, reply priming tokens, etc.
+  static TOKENS_PER_CONVERSATION = 24;
+  constructor(encoding) {
+    this.encoder = new lite.Tiktoken(encoding || o200k_base__default.default);
+  }
+  /**
+   * Count tokens in a plain string
+   */
+  countString(text) {
+    if (!text) return 0;
+    return this.encoder.encode(text, "all").length;
+  }
+  /**
+   * Count tokens in a single message
+   */
+  countMessage(message) {
+    let tokenString = message.role;
+    let overhead = _TokenCounter.TOKENS_PER_MESSAGE;
+    let toolResultCount = 0;
+    if (typeof message.content === "string") {
+      tokenString += message.content;
+    } else if (message.content && typeof message.content === "object") {
+      if (message.content.content && !Array.isArray(message.content.parts)) {
+        tokenString += message.content.content;
+      } else if (Array.isArray(message.content.parts)) {
+        for (const part of message.content.parts) {
+          if (part.type === "text") {
+            tokenString += 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;
+              }
+              if (invocation.args) {
+                if (typeof invocation.args === "string") {
+                  tokenString += invocation.args;
+                } else {
+                  tokenString += JSON.stringify(invocation.args);
+                  overhead -= 12;
+                }
+              }
+            } else if (invocation.state === "result") {
+              toolResultCount++;
+              if (invocation.result !== void 0) {
+                if (typeof invocation.result === "string") {
+                  tokenString += invocation.result;
+                } else {
+                  tokenString += JSON.stringify(invocation.result);
+                  overhead -= 12;
+                }
+              }
+            } else {
+              throw new Error(
+                `Unhandled tool-invocation state '${part.toolInvocation?.state}' in token counting for part type '${part.type}'`
+              );
+            }
+          } else {
+            tokenString += JSON.stringify(part);
+          }
+        }
+      }
+    }
+    if (toolResultCount > 0) {
+      overhead += toolResultCount * _TokenCounter.TOKENS_PER_MESSAGE;
+    }
+    return this.encoder.encode(tokenString, "all").length + overhead;
+  }
+  /**
+   * Count tokens in an array of messages
+   */
+  countMessages(messages) {
+    if (!messages || messages.length === 0) return 0;
+    let total = _TokenCounter.TOKENS_PER_CONVERSATION;
+    for (const message of messages) {
+      total += this.countMessage(message);
+    }
+    return total;
+  }
+  /**
+   * Count tokens in observations string
+   */
+  countObservations(observations) {
+    return this.countString(observations);
+  }
+};
+
+// src/processors/observational-memory/observational-memory.ts
+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",
+    messageTokens: 3e4,
+    modelSettings: {
+      temperature: 0.3,
+      maxOutputTokens: 1e5
+    },
+    providerOptions: {
+      google: {
+        thinkingConfig: {
+          thinkingBudget: 215
+        }
+      }
+    },
+    maxTokensPerBatch: 1e4
+  },
+  reflection: {
+    model: "google/gemini-2.5-flash",
+    observationTokens: 4e4,
+    modelSettings: {
+      temperature: 0,
+      // Use 0 for maximum consistency in reflections
+      maxOutputTokens: 1e5
+    },
+    providerOptions: {
+      google: {
+        thinkingConfig: {
+          thinkingBudget: 1024
+        }
+      }
+    }
+  }
+};
+var ObservationalMemory = class {
+  id = "observational-memory";
+  name = "Observational Memory";
+  storage;
+  tokenCounter;
+  scope;
+  observationConfig;
+  reflectionConfig;
+  onDebugEvent;
+  /** Internal Observer agent - created lazily */
+  observerAgent;
+  /** Internal Reflector agent - created lazily */
+  reflectorAgent;
+  shouldObscureThreadIds = false;
+  hasher = xxhash__default.default();
+  threadIdCache = /* @__PURE__ */ new Map();
+  /**
+   * 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.
+   */
+  observedMessageIds = /* @__PURE__ */ new Set();
+  /** Internal MessageHistory for message persistence */
+  messageHistory;
+  /**
+   * In-memory mutex for serializing observation/reflection cycles per resource/thread.
+   * Prevents race conditions where two concurrent cycles could both read isObserving=false
+   * before either sets it to true, leading to lost work.
+   *
+   * Key format: "resource:{resourceId}" or "thread:{threadId}"
+   * Value: Promise that resolves when the lock is released
+   *
+   * NOTE: This mutex only works within a single Node.js process. For distributed
+   * deployments, external locking (Redis, database locks) would be needed, or
+   * accept eventual consistency (acceptable for v1).
+   */
+  locks = /* @__PURE__ */ new Map();
+  /**
+   * 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.
+   */
+  async withLock(key, fn) {
+    const existingLock = this.locks.get(key);
+    if (existingLock) {
+      await existingLock;
+    }
+    let releaseLock;
+    const lockPromise = new Promise((resolve) => {
+      releaseLock = resolve;
+    });
+    this.locks.set(key, lockPromise);
+    try {
+      return await fn();
+    } finally {
+      releaseLock();
+      if (this.locks.get(key) === lockPromise) {
+        this.locks.delete(key);
+      }
+    }
+  }
+  /**
+   * Get the lock key for the current scope
+   */
+  getLockKey(threadId, resourceId) {
+    if (this.scope === "resource" && resourceId) {
+      return `resource:${resourceId}`;
+    }
+    return `thread:${threadId ?? "unknown"}`;
+  }
+  constructor(config) {
+    if (config.model && config.observation?.model) {
+      throw new Error(
+        "Cannot set both `model` and `observation.model`. Use `model` to set both agents, or set each individually."
+      );
+    }
+    if (config.model && config.reflection?.model) {
+      throw new Error(
+        "Cannot set both `model` and `reflection.model`. Use `model` to set both agents, or set each individually."
+      );
+    }
+    this.shouldObscureThreadIds = config.obscureThreadIds || false;
+    this.storage = config.storage;
+    this.scope = config.scope ?? "thread";
+    const observationModel = config.model ?? config.observation?.model ?? OBSERVATIONAL_MEMORY_DEFAULTS.observation.model;
+    const reflectionModel = config.model ?? config.reflection?.model ?? OBSERVATIONAL_MEMORY_DEFAULTS.reflection.model;
+    const messageTokens = config.observation?.messageTokens ?? OBSERVATIONAL_MEMORY_DEFAULTS.observation.messageTokens;
+    const observationTokens = config.reflection?.observationTokens ?? OBSERVATIONAL_MEMORY_DEFAULTS.reflection.observationTokens;
+    const isSharedBudget = config.shareTokenBudget ?? false;
+    const totalBudget = messageTokens + observationTokens;
+    this.observationConfig = {
+      model: observationModel,
+      // When shared budget, store as range: min = base threshold, max = total budget
+      // This allows messages to expand into unused observation space
+      messageTokens: isSharedBudget ? { min: messageTokens, max: totalBudget } : messageTokens,
+      shareTokenBudget: isSharedBudget,
+      modelSettings: {
+        temperature: config.observation?.modelSettings?.temperature ?? OBSERVATIONAL_MEMORY_DEFAULTS.observation.modelSettings.temperature,
+        maxOutputTokens: config.observation?.modelSettings?.maxOutputTokens ?? OBSERVATIONAL_MEMORY_DEFAULTS.observation.modelSettings.maxOutputTokens
+      },
+      providerOptions: config.observation?.providerOptions ?? OBSERVATIONAL_MEMORY_DEFAULTS.observation.providerOptions,
+      maxTokensPerBatch: config.observation?.maxTokensPerBatch ?? OBSERVATIONAL_MEMORY_DEFAULTS.observation.maxTokensPerBatch
+    };
+    this.reflectionConfig = {
+      model: reflectionModel,
+      observationTokens,
+      shareTokenBudget: isSharedBudget,
+      modelSettings: {
+        temperature: config.reflection?.modelSettings?.temperature ?? OBSERVATIONAL_MEMORY_DEFAULTS.reflection.modelSettings.temperature,
+        maxOutputTokens: config.reflection?.modelSettings?.maxOutputTokens ?? OBSERVATIONAL_MEMORY_DEFAULTS.reflection.modelSettings.maxOutputTokens
+      },
+      providerOptions: config.reflection?.providerOptions ?? OBSERVATIONAL_MEMORY_DEFAULTS.reflection.providerOptions
+    };
+    this.tokenCounter = new TokenCounter();
+    this.onDebugEvent = config.onDebugEvent;
+    this.messageHistory = new processors.MessageHistory({ storage: this.storage });
+  }
+  /**
+   * Get the current configuration for this OM instance.
+   * Used by the server to expose config to the UI when OM is added via processors.
+   */
+  get config() {
+    return {
+      scope: this.scope,
+      observation: {
+        messageTokens: this.observationConfig.messageTokens
+      },
+      reflection: {
+        observationTokens: this.reflectionConfig.observationTokens
+      }
+    };
+  }
+  /**
+   * Get the full config including resolved model names.
+   * This is async because it needs to resolve the model configs.
+   */
+  async getResolvedConfig(requestContext) {
+    const getModelToResolve = (model) => {
+      if (Array.isArray(model)) {
+        return model[0]?.model ?? OBSERVATIONAL_MEMORY_DEFAULTS.observation.model;
+      }
+      return model;
+    };
+    const formatModelName = (model) => {
+      return model.provider ? `${model.provider}/${model.modelId}` : model.modelId;
+    };
+    const safeResolveModel = async (modelConfig) => {
+      const modelToResolve = getModelToResolve(modelConfig);
+      try {
+        const resolved = await llm.resolveModelConfig(modelToResolve, requestContext);
+        return formatModelName(resolved);
+      } catch (error) {
+        console.error("[OM] Failed to resolve model config:", error);
+        return "(unknown)";
+      }
+    };
+    const [observationModelName, reflectionModelName] = await Promise.all([
+      safeResolveModel(this.observationConfig.model),
+      safeResolveModel(this.reflectionConfig.model)
+    ]);
+    return {
+      scope: this.scope,
+      observation: {
+        messageTokens: this.observationConfig.messageTokens,
+        model: observationModelName
+      },
+      reflection: {
+        observationTokens: this.reflectionConfig.observationTokens,
+        model: reflectionModelName
+      }
+    };
+  }
+  /**
+   * Emit a debug event if the callback is configured
+   */
+  emitDebugEvent(event) {
+    if (this.onDebugEvent) {
+      this.onDebugEvent(event);
+    }
+  }
+  // ASYNC BUFFERING DISABLED - See note at top of file
+  // /**
+  //  * Validate that bufferEvery is less than the threshold
+  //  */
+  // private validateBufferConfig(): void {
+  //   const observationThreshold = this.getMaxThreshold(this.observationConfig.messageTokens);
+  //   if (this.observationConfig.bufferEvery && this.observationConfig.bufferEvery >= observationThreshold) {
+  //     throw new Error(
+  //       `observation.bufferEvery (${this.observationConfig.bufferEvery}) must be less than messageTokens (${observationThreshold})`,
+  //     );
+  //   }
+  //   const reflectionThreshold = this.getMaxThreshold(this.reflectionConfig.observationTokens);
+  //   if (this.reflectionConfig.bufferEvery && this.reflectionConfig.bufferEvery >= reflectionThreshold) {
+  //     throw new Error(
+  //       `reflection.bufferEvery (${this.reflectionConfig.bufferEvery}) must be less than observationTokens (${reflectionThreshold})`,
+  //     );
+  //   }
+  // }
+  /**
+   * 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);
+  }
+  /**
+   * Get or create the Observer agent
+   */
+  getObserverAgent() {
+    if (!this.observerAgent) {
+      const systemPrompt = buildObserverSystemPrompt();
+      this.observerAgent = new agent.Agent({
+        id: "observational-memory-observer",
+        name: "Observer",
+        instructions: systemPrompt,
+        model: this.observationConfig.model
+      });
+    }
+    return this.observerAgent;
+  }
+  /**
+   * Get or create the Reflector agent
+   */
+  getReflectorAgent() {
+    if (!this.reflectorAgent) {
+      const systemPrompt = buildReflectorSystemPrompt();
+      this.reflectorAgent = new agent.Agent({
+        id: "observational-memory-reflector",
+        name: "Reflector",
+        instructions: systemPrompt,
+        model: this.reflectionConfig.model
+      });
+    }
+    return this.reflectorAgent;
+  }
+  /**
+   * Get thread/resource IDs for storage lookup
+   */
+  getStorageIds(threadId, resourceId) {
+    if (this.scope === "resource") {
+      return {
+        threadId: null,
+        resourceId: resourceId ?? threadId
+      };
+    }
+    return {
+      threadId,
+      resourceId: resourceId ?? threadId
+    };
+  }
+  /**
+   * Get or create the observational memory record
+   */
+  async getOrCreateRecord(threadId, resourceId) {
+    const ids = this.getStorageIds(threadId, resourceId);
+    let record = await this.storage.getObservationalMemory(ids.threadId, ids.resourceId);
+    if (!record) {
+      const observedTimezone = Intl.DateTimeFormat().resolvedOptions().timeZone;
+      record = await this.storage.initializeObservationalMemory({
+        threadId: ids.threadId,
+        resourceId: ids.resourceId,
+        scope: this.scope,
+        config: {
+          observation: this.observationConfig,
+          reflection: this.reflectionConfig,
+          scope: this.scope
+        },
+        observedTimezone
+      });
+    }
+    return record;
+  }
+  /**
+   * Check if we need to trigger reflection.
+   */
+  shouldReflect(observationTokens) {
+    const threshold = this.getMaxThreshold(this.reflectionConfig.observationTokens);
+    return observationTokens > threshold;
+  }
+  // ════════════════════════════════════════════════════════════════════════════
+  // DATA-OM-OBSERVATION PART HELPERS (Start/End/Failed markers)
+  // These helpers manage the observation boundary markers within messages.
+  //
+  // Flow:
+  // 1. Before observation: [...messageParts]
+  // 2. Insert start: [...messageParts, start] → stream to UI (loading state)
+  // 3. After success: [...messageParts, start, end] → stream to UI (complete)
+  // 4. After failure: [...messageParts, start, failed]
+  //
+  // For filtering, we look for the last completed observation (start + end pair).
+  // A start without end means observation is in progress.
+  // ════════════════════════════════════════════════════════════════════════════
+  /**
+   * Get current config snapshot for observation markers.
+   */
+  getObservationMarkerConfig() {
+    return {
+      messageTokens: this.getMaxThreshold(this.observationConfig.messageTokens),
+      observationTokens: this.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
+      }
+    };
+  }
+  /**
+   * Find the last completed observation boundary in a message's parts.
+   * A completed observation is a start marker followed by an end marker.
+   *
+   * Returns the index of the END marker (which is the observation boundary),
+   * or -1 if no completed observation is found.
+   */
+  findLastCompletedObservationBoundary(message) {
+    const parts = message.content?.parts;
+    if (!parts || !Array.isArray(parts)) return -1;
+    for (let i = parts.length - 1; i >= 0; i--) {
+      const part = parts[i];
+      if (part?.type === "data-om-observation-end") {
+        return i;
+      }
+    }
+    return -1;
+  }
+  /**
+   * Check if a message has an in-progress observation (start without end).
+   */
+  hasInProgressObservation(message) {
+    const parts = message.content?.parts;
+    if (!parts || !Array.isArray(parts)) return false;
+    let lastStartIndex = -1;
+    let lastEndOrFailedIndex = -1;
+    for (let i = parts.length - 1; i >= 0; i--) {
+      const part = parts[i];
+      if (part?.type === "data-om-observation-start" && lastStartIndex === -1) {
+        lastStartIndex = i;
+      }
+      if ((part?.type === "data-om-observation-end" || part?.type === "data-om-observation-failed") && lastEndOrFailedIndex === -1) {
+        lastEndOrFailedIndex = i;
+      }
+    }
+    return lastStartIndex !== -1 && lastStartIndex > lastEndOrFailedIndex;
+  }
+  /**
+   * Insert an observation marker into a message.
+   * The marker is appended directly to the message's parts array (mutating in place).
+   * Also persists the change to storage so markers survive page refresh.
+   *
+   * For end/failed markers, the message is also "sealed" to prevent future content
+   * from being merged into it. This ensures observation markers are preserved.
+   */
+  /**
+   * Insert an observation marker into a message.
+   * For start markers, this pushes the part directly.
+   * 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.
+   */
+  getUnobservedParts(message) {
+    const parts = message.content?.parts;
+    if (!parts || !Array.isArray(parts)) return [];
+    const endMarkerIndex = this.findLastCompletedObservationBoundary(message);
+    if (endMarkerIndex === -1) {
+      return parts.filter((p) => {
+        const part = p;
+        return part?.type !== "data-om-observation-start";
+      });
+    }
+    return parts.slice(endMarkerIndex + 1).filter((p) => {
+      const part = p;
+      return !part?.type?.startsWith("data-om-observation-");
+    });
+  }
+  /**
+   * Check if a message has any unobserved parts.
+   */
+  hasUnobservedParts(message) {
+    return this.getUnobservedParts(message).length > 0;
+  }
+  /**
+   * Create a virtual message containing only the unobserved parts.
+   * This is used for token counting and observation.
+   */
+  createUnobservedMessage(message) {
+    const unobservedParts = this.getUnobservedParts(message);
+    if (unobservedParts.length === 0) return null;
+    return {
+      ...message,
+      content: {
+        ...message.content,
+        parts: unobservedParts
+      }
+    };
+  }
+  /**
+   * Get unobserved messages with part-level filtering.
+   *
+   * This method uses data-om-observation-end markers to filter at the part level:
+   * 1. For messages WITH a completed observation: only return parts AFTER the end marker
+   * 2. For messages WITHOUT completed observation: check timestamp against lastObservedAt
+   *
+   * This handles the case where a single message accumulates many parts
+   * (like tool calls) during an agentic loop - we only observe the new parts.
+   */
+  getUnobservedMessages(allMessages, record) {
+    const lastObservedAt = record.lastObservedAt;
+    const observedMessageIds = Array.isArray(record.observedMessageIds) ? new Set(record.observedMessageIds) : void 0;
+    if (!lastObservedAt) {
+      return allMessages;
+    }
+    const result = [];
+    for (const msg of allMessages) {
+      if (observedMessageIds?.has(msg.id)) {
+        continue;
+      }
+      const endMarkerIndex = this.findLastCompletedObservationBoundary(msg);
+      const inProgress = this.hasInProgressObservation(msg);
+      if (inProgress) {
+        result.push(msg);
+      } else if (endMarkerIndex !== -1) {
+        const virtualMsg = this.createUnobservedMessage(msg);
+        if (virtualMsg) {
+          result.push(virtualMsg);
+        }
+      } else {
+        if (!msg.createdAt) {
+          result.push(msg);
+        } else {
+          const msgDate = new Date(msg.createdAt);
+          if (msgDate > lastObservedAt) {
+            result.push(msg);
+          }
+        }
+      }
+    }
+    return result;
+  }
+  /**
+   * 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.
+   */
+  async withAbortCheck(fn, abortSignal) {
+    if (abortSignal?.aborted) {
+      throw new Error("The operation was aborted.");
+    }
+    const result = await fn();
+    if (abortSignal?.aborted) {
+      throw new Error("The operation was aborted.");
+    }
+    return result;
+  }
+  /**
+   * Call the Observer agent to extract observations.
+   */
+  async callObserver(existingObservations, messagesToObserve, abortSignal) {
+    const agent = this.getObserverAgent();
+    const prompt = buildObserverPrompt(existingObservations, messagesToObserve);
+    const result = await this.withAbortCheck(
+      () => agent.generate(prompt, {
+        modelSettings: {
+          ...this.observationConfig.modelSettings
+        },
+        providerOptions: this.observationConfig.providerOptions,
+        abortSignal
+      }),
+      abortSignal
+    );
+    const parsed = parseObserverOutput(result.text);
+    const usage = result.totalUsage ?? result.usage;
+    return {
+      observations: parsed.observations,
+      currentTask: parsed.currentTask,
+      suggestedContinuation: parsed.suggestedContinuation,
+      usage: usage ? {
+        inputTokens: usage.inputTokens,
+        outputTokens: usage.outputTokens,
+        totalTokens: usage.totalTokens
+      } : void 0
+    };
+  }
+  /**
+   * 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.
+   */
+  async callMultiThreadObserver(existingObservations, messagesByThread, threadOrder, abortSignal) {
+    const agent$1 = new agent.Agent({
+      id: "multi-thread-observer",
+      name: "multi-thread-observer",
+      model: this.observationConfig.model,
+      instructions: buildObserverSystemPrompt(true)
+    });
+    const prompt = buildMultiThreadObserverPrompt(existingObservations, messagesByThread, threadOrder);
+    const allMessages = [];
+    for (const msgs of messagesByThread.values()) {
+      allMessages.push(...msgs);
+    }
+    for (const msg of allMessages) {
+      this.observedMessageIds.add(msg.id);
+    }
+    const result = await this.withAbortCheck(
+      () => agent$1.generate(prompt, {
+        modelSettings: {
+          ...this.observationConfig.modelSettings
+        },
+        providerOptions: this.observationConfig.providerOptions,
+        abortSignal
+      }),
+      abortSignal
+    );
+    const parsed = parseMultiThreadObserverOutput(result.text);
+    const results = /* @__PURE__ */ new Map();
+    for (const [threadId, threadResult] of parsed.threads) {
+      results.set(threadId, {
+        observations: threadResult.observations,
+        currentTask: threadResult.currentTask,
+        suggestedContinuation: threadResult.suggestedContinuation
+      });
+    }
+    for (const threadId of threadOrder) {
+      if (!results.has(threadId)) {
+        results.set(threadId, { observations: "" });
+      }
+    }
+    const usage = result.totalUsage ?? result.usage;
+    return {
+      results,
+      usage: usage ? {
+        inputTokens: usage.inputTokens,
+        outputTokens: usage.outputTokens,
+        totalTokens: usage.totalTokens
+      } : void 0
+    };
+  }
+  /**
+   * Call the Reflector agent to condense observations.
+   * Includes compression validation and retry logic.
+   */
+  async callReflector(observations, manualPrompt, streamContext, observationTokensThreshold, abortSignal) {
+    const agent = this.getReflectorAgent();
+    const originalTokens = this.tokenCounter.countObservations(observations);
+    const targetThreshold = observationTokensThreshold ?? this.getMaxThreshold(this.reflectionConfig.observationTokens);
+    let totalUsage = { inputTokens: 0, outputTokens: 0, totalTokens: 0 };
+    let prompt = buildReflectorPrompt(observations, manualPrompt, false);
+    let result = await this.withAbortCheck(
+      () => agent.generate(prompt, {
+        modelSettings: {
+          ...this.reflectionConfig.modelSettings
+        },
+        providerOptions: this.reflectionConfig.providerOptions,
+        abortSignal
+      }),
+      abortSignal
+    );
+    const firstUsage = result.totalUsage ?? result.usage;
+    if (firstUsage) {
+      totalUsage.inputTokens += firstUsage.inputTokens ?? 0;
+      totalUsage.outputTokens += firstUsage.outputTokens ?? 0;
+      totalUsage.totalTokens += firstUsage.totalTokens ?? 0;
+    }
+    let parsed = parseReflectorOutput(result.text);
+    let reflectedTokens = this.tokenCounter.countObservations(parsed.observations);
+    if (!validateCompression(reflectedTokens, targetThreshold)) {
+      if (streamContext?.writer) {
+        const failedMarker = this.createObservationFailedMarker({
+          cycleId: streamContext.cycleId,
+          operationType: "reflection",
+          startedAt: streamContext.startedAt,
+          tokensAttempted: originalTokens,
+          error: `Did not compress below threshold (${originalTokens} \u2192 ${reflectedTokens}, target: ${targetThreshold}), retrying with compression guidance`,
+          recordId: streamContext.recordId,
+          threadId: streamContext.threadId
+        });
+        await streamContext.writer.custom(failedMarker).catch(() => {
+        });
+        const retryCycleId = crypto.randomUUID();
+        streamContext.cycleId = retryCycleId;
+        const startMarker = this.createObservationStartMarker({
+          cycleId: retryCycleId,
+          operationType: "reflection",
+          tokensToObserve: originalTokens,
+          recordId: streamContext.recordId,
+          threadId: streamContext.threadId,
+          threadIds: [streamContext.threadId]
+        });
+        streamContext.startedAt = startMarker.data.startedAt;
+        await streamContext.writer.custom(startMarker).catch(() => {
+        });
+      }
+      prompt = buildReflectorPrompt(observations, manualPrompt, true);
+      result = await this.withAbortCheck(
+        () => agent.generate(prompt, {
+          modelSettings: {
+            ...this.reflectionConfig.modelSettings
+          },
+          providerOptions: this.reflectionConfig.providerOptions,
+          abortSignal
+        }),
+        abortSignal
+      );
+      const retryUsage = result.totalUsage ?? result.usage;
+      if (retryUsage) {
+        totalUsage.inputTokens += retryUsage.inputTokens ?? 0;
+        totalUsage.outputTokens += retryUsage.outputTokens ?? 0;
+        totalUsage.totalTokens += retryUsage.totalTokens ?? 0;
+      }
+      parsed = parseReflectorOutput(result.text);
+      reflectedTokens = this.tokenCounter.countObservations(parsed.observations);
+    }
+    return {
+      observations: parsed.observations,
+      suggestedContinuation: parsed.suggestedContinuation,
+      usage: totalUsage.totalTokens > 0 ? totalUsage : void 0
+    };
+  }
+  /**
+   * Format observations for injection into context.
+   * Applies token optimization before presenting to the Actor.
+   *
+   * 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
+   */
+  formatObservationsForContext(observations, currentTask, suggestedResponse, unobservedContextBlocks, currentDate) {
+    let optimized = optimizeObservationsForContext(observations);
+    if (currentDate) {
+      optimized = addRelativeTimeToObservations(optimized, currentDate);
+    }
+    let content = `
+The following observations block contains your memory of past conversations with this user.
+
+<observations>
+${optimized}
+</observations>
+
+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.
+
+KNOWLEDGE UPDATES: When asked about current state (e.g., "where do I currently...", "what is my current..."), always prefer the MOST RECENT information. Observations include dates - if you see conflicting information, the newer observation supersedes the older one. Look for phrases like "will start", "is switching", "changed to", "moved to" as indicators that previous information has been updated.
+
+PLANNED ACTIONS: If the user stated they planned to do something (e.g., "I'm going to...", "I'm looking forward to...", "I will...") and the date they planned to do it is now in the past (check the relative time like "3 weeks ago"), assume they completed the action unless there's evidence they didn't. For example, if someone said "I'll start my new diet on Monday" and that was 2 weeks ago, assume they started the diet.`;
+    if (unobservedContextBlocks) {
+      content += `
+
+The following content is from OTHER conversations different from the current conversation, they're here for reference,  but they're not necessarily your focus:
+START_OTHER_CONVERSATIONS_BLOCK
+${unobservedContextBlocks}
+END_OTHER_CONVERSATIONS_BLOCK`;
+    }
+    if (currentTask) {
+      content += `
+
+<current-task>
+${currentTask}
+</current-task>`;
+    }
+    if (suggestedResponse) {
+      content += `
+
+<suggested-response>
+${suggestedResponse}
+</suggested-response>
+`;
+    }
+    return content;
+  }
+  /**
+   * Get threadId and resourceId from either RequestContext or MessageList
+   */
+  getThreadContext(requestContext, messageList) {
+    const memoryContext = requestContext?.get("MastraMemory");
+    if (memoryContext?.thread?.id) {
+      return {
+        threadId: memoryContext.thread.id,
+        resourceId: memoryContext.resourceId
+      };
+    }
+    const serialized = messageList.serialize();
+    if (serialized.memoryInfo?.threadId) {
+      return {
+        threadId: serialized.memoryInfo.threadId,
+        resourceId: serialized.memoryInfo.resourceId
+      };
+    }
+    return null;
+  }
+  /**
+   * 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
+   */
+  async processInputStep(args) {
+    const { messageList, requestContext, stepNumber, state: _state, writer, abortSignal, abort } = args;
+    const state = _state ?? {};
+    const context = this.getThreadContext(requestContext, messageList);
+    if (!context) {
+      return messageList;
+    }
+    const { threadId, resourceId } = context;
+    const memoryContext = memory.parseMemoryRequestContext(requestContext);
+    const readOnly = memoryContext?.memoryConfig?.readOnly;
+    let record = await this.getOrCreateRecord(threadId, resourceId);
+    if (!state.initialSetupDone) {
+      state.initialSetupDone = true;
+      const lastObservedAt = record.lastObservedAt;
+      if (this.scope === "resource" && resourceId) {
+        const currentThreadMessages = await this.loadUnobservedMessages(threadId, void 0, lastObservedAt);
+        for (const msg of currentThreadMessages) {
+          if (msg.role !== "system") {
+            if (!this.hasUnobservedParts(msg) && this.findLastCompletedObservationBoundary(msg) !== -1) {
+              continue;
+            }
+            messageList.add(msg, "memory");
+          }
+        }
+      } else {
+        const historicalMessages = await this.loadUnobservedMessages(threadId, resourceId, lastObservedAt);
+        if (historicalMessages.length > 0) {
+          for (const msg of historicalMessages) {
+            if (msg.role !== "system") {
+              if (!this.hasUnobservedParts(msg) && this.findLastCompletedObservationBoundary(msg) !== -1) {
+                continue;
+              }
+              messageList.add(msg, "memory");
+            }
+          }
+        }
+      }
+    }
+    let unobservedContextBlocks;
+    if (this.scope === "resource" && resourceId) {
+      unobservedContextBlocks = await this.loadOtherThreadsContext(resourceId, threadId);
+    }
+    if (!readOnly) {
+      const allMessages = messageList.get.all.db();
+      const unobservedMessages = this.getUnobservedMessages(allMessages, record);
+      const currentSessionTokens = this.tokenCounter.countMessages(unobservedMessages);
+      const otherThreadTokens = unobservedContextBlocks ? this.tokenCounter.countString(unobservedContextBlocks) : 0;
+      const currentObservationTokens = record.observationTokenCount ?? 0;
+      const pendingTokens = record.pendingMessageTokens ?? 0;
+      const totalPendingTokens = pendingTokens + currentSessionTokens + otherThreadTokens;
+      const threshold = this.calculateDynamicThreshold(this.observationConfig.messageTokens, currentObservationTokens);
+      const baseReflectionThreshold = this.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;
+      const observationTokensPercent = Math.round(
+        currentObservationTokens / effectiveObservationTokensThreshold * 100
+      );
+      this.emitDebugEvent({
+        type: "step_progress",
+        timestamp: /* @__PURE__ */ new Date(),
+        threadId,
+        resourceId: resourceId ?? "",
+        stepNumber,
+        finishReason: "unknown",
+        pendingTokens: totalPendingTokens,
+        threshold,
+        thresholdPercent: Math.round(totalPendingTokens / threshold * 100),
+        willSave: totalPendingTokens >= threshold,
+        willObserve: totalPendingTokens >= threshold
+      });
+      if (writer) {
+        const progressPart = {
+          type: "data-om-progress",
+          data: {
+            pendingTokens: totalPendingTokens,
+            messageTokens: threshold,
+            messageTokensPercent: Math.round(totalPendingTokens / threshold * 100),
+            observationTokens: currentObservationTokens,
+            observationTokensThreshold: effectiveObservationTokensThreshold,
+            observationTokensPercent,
+            willObserve: totalPendingTokens >= threshold,
+            recordId: record.id,
+            threadId,
+            stepNumber
+          }
+        };
+        await writer.custom(progressPart).catch(() => {
+        });
+      }
+      const sealedIds = state.sealedIds ?? /* @__PURE__ */ new Set();
+      if (stepNumber > 0 && totalPendingTokens >= threshold) {
+        const lockKey = this.getLockKey(threadId, resourceId);
+        let observationSucceeded = false;
+        await this.withLock(lockKey, async () => {
+          const freshRecord = await this.getOrCreateRecord(threadId, resourceId);
+          const freshAllMessages = messageList.get.all.db();
+          const freshUnobservedMessages = this.getUnobservedMessages(freshAllMessages, freshRecord);
+          const freshCurrentTokens = this.tokenCounter.countMessages(freshUnobservedMessages);
+          const freshPending = freshRecord.pendingMessageTokens ?? 0;
+          let freshOtherThreadTokens = 0;
+          if (this.scope === "resource" && resourceId) {
+            const freshOtherContext = await this.loadOtherThreadsContext(resourceId, threadId);
+            freshOtherThreadTokens = freshOtherContext ? this.tokenCounter.countString(freshOtherContext) : 0;
+          }
+          const freshTotal = freshPending + freshCurrentTokens + freshOtherThreadTokens;
+          if (freshTotal < threshold) {
+            return;
+          }
+          const preObservationTime = freshRecord.lastObservedAt?.getTime() ?? 0;
+          if (freshUnobservedMessages.length > 0) {
+            try {
+              if (this.scope === "resource" && resourceId) {
+                await this.doResourceScopedObservation(
+                  freshRecord,
+                  threadId,
+                  resourceId,
+                  freshUnobservedMessages,
+                  writer,
+                  abortSignal
+                );
+              } else {
+                await this.doSynchronousObservation(
+                  freshRecord,
+                  threadId,
+                  freshUnobservedMessages,
+                  writer,
+                  abortSignal
+                );
+              }
+              const updatedRecord = await this.getOrCreateRecord(threadId, resourceId);
+              const updatedTime = updatedRecord.lastObservedAt?.getTime() ?? 0;
+              observationSucceeded = updatedTime > preObservationTime;
+            } catch (error) {
+              if (abortSignal?.aborted) {
+                abort("Agent execution was aborted");
+              } else {
+                abort(
+                  `Encountered error during memory observation ${error instanceof Error ? error.message : JSON.stringify(error, null, 2)}`
+                );
+              }
+              observationSucceeded = false;
+            }
+          }
+        });
+        if (observationSucceeded) {
+          const allMsgs = messageList.get.all.db();
+          let markerIdx = -1;
+          let markerMsg = null;
+          for (let i = allMsgs.length - 1; i >= 0; i--) {
+            const msg = allMsgs[i];
+            if (!msg) continue;
+            if (this.findLastCompletedObservationBoundary(msg) !== -1) {
+              markerIdx = i;
+              markerMsg = msg;
+              break;
+            }
+          }
+          if (markerMsg && markerIdx !== -1) {
+            const idsToRemove = [];
+            const messagesToSave = [];
+            for (let i = 0; i < markerIdx; i++) {
+              const msg = allMsgs[i];
+              if (msg?.id && msg.id !== "om-continuation") {
+                idsToRemove.push(msg.id);
+                messagesToSave.push(msg);
+              }
+            }
+            messagesToSave.push(markerMsg);
+            const unobservedParts = this.getUnobservedParts(markerMsg);
+            if (unobservedParts.length === 0) {
+              if (markerMsg.id) {
+                idsToRemove.push(markerMsg.id);
+              }
+            } else if (unobservedParts.length < (markerMsg.content?.parts?.length ?? 0)) {
+              markerMsg.content.parts = unobservedParts;
+            }
+            if (messagesToSave.length > 0) {
+              await this.saveMessagesWithSealedIdTracking(messagesToSave, sealedIds, threadId, resourceId, state);
+            }
+            if (idsToRemove.length > 0) {
+              messageList.removeByIds(idsToRemove);
+            }
+          } else {
+            const newInput = messageList.clear.input.db();
+            const newOutput = messageList.clear.response.db();
+            const messagesToSave = [...newInput, ...newOutput];
+            if (messagesToSave.length > 0) {
+              await this.saveMessagesWithSealedIdTracking(messagesToSave, sealedIds, threadId, resourceId, state);
+            }
+          }
+          messageList.clear.input.db();
+          messageList.clear.response.db();
+        }
+        record = await this.getOrCreateRecord(threadId, resourceId);
+      } else if (stepNumber > 0) {
+        const newInput = messageList.clear.input.db();
+        const newOutput = messageList.clear.response.db();
+        const messagesToSave = [...newInput, ...newOutput];
+        if (messagesToSave.length > 0) {
+          await this.saveMessagesWithSealedIdTracking(messagesToSave, sealedIds, threadId, resourceId, state);
+          for (const msg of messagesToSave) {
+            messageList.add(msg, "memory");
+          }
+        }
+      }
+    }
+    const thread = await this.storage.getThreadById({ threadId });
+    const threadOMMetadata = memory.getThreadOMMetadata(thread?.metadata);
+    const currentTask = threadOMMetadata?.currentTask;
+    const suggestedResponse = threadOMMetadata?.suggestedResponse;
+    const currentDate = requestContext?.get("currentDate") ?? /* @__PURE__ */ new Date();
+    if (record.activeObservations) {
+      const observationSystemMessage = this.formatObservationsForContext(
+        record.activeObservations,
+        currentTask,
+        suggestedResponse,
+        unobservedContextBlocks,
+        currentDate
+      );
+      messageList.clearSystemMessages("observational-memory");
+      messageList.addSystem(observationSystemMessage, "observational-memory");
+      const continuationMessage = {
+        id: `om-continuation`,
+        role: "user",
+        createdAt: /* @__PURE__ */ new Date(0),
+        content: {
+          format: 2,
+          parts: [
+            {
+              type: "text",
+              text: `<system-reminder>This message is not from the user, the conversation history grew too long and wouldn't fit in context! Thankfully the entire conversation is stored in your memory observations. Please continue from where the observations left off. Do not refer to your "memory observations" directly, the user doesn't know about them, they are your memories! Just respond naturally as if you're remembering the conversation (you are!). Do not say "Hi there!" or "based on our previous conversation" as if the conversation is just starting, this is not a new conversation. This is an ongoing conversation, keep continuity by responding based on your memory. For example do not say "I understand. I've reviewed my memory observations", or "I remember [...]". Answer naturally following the suggestion from your memory. Note that your memory may contain a suggested first response, which you should follow.
+
+IMPORTANT: this system reminder is NOT from the user. The system placed it here as part of your memory system. This message is part of you remembering your conversation with the user.
+
+NOTE: Any messages following this system reminder are newer than your memories.
+</system-reminder>`
+            }
+          ]
+        },
+        threadId,
+        resourceId
+      };
+      messageList.add(continuationMessage, "memory");
+    }
+    if (stepNumber === 0) {
+      const allMessages = messageList.get.all.db();
+      let markerMessageIndex = -1;
+      let markerMessage = null;
+      for (let i = allMessages.length - 1; i >= 0; i--) {
+        const msg = allMessages[i];
+        if (!msg) continue;
+        if (this.findLastCompletedObservationBoundary(msg) !== -1) {
+          markerMessageIndex = i;
+          markerMessage = msg;
+          break;
+        }
+      }
+      if (markerMessage && markerMessageIndex !== -1) {
+        const messagesToRemove = [];
+        for (let i = 0; i < markerMessageIndex; i++) {
+          const msg = allMessages[i];
+          if (msg?.id && msg.id !== "om-continuation") {
+            messagesToRemove.push(msg.id);
+          }
+        }
+        if (messagesToRemove.length > 0) {
+          messageList.removeByIds(messagesToRemove);
+        }
+        const unobservedParts = this.getUnobservedParts(markerMessage);
+        if (unobservedParts.length === 0) {
+          if (markerMessage.id) {
+            messageList.removeByIds([markerMessage.id]);
+          }
+        } else if (unobservedParts.length < (markerMessage.content?.parts?.length ?? 0)) {
+          markerMessage.content.parts = unobservedParts;
+        }
+      }
+    }
+    return messageList;
+  }
+  /**
+   * 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.
+   */
+  async processOutputResult(args) {
+    const { messageList, requestContext, state: _state } = args;
+    const state = _state ?? {};
+    const context = this.getThreadContext(requestContext, messageList);
+    if (!context) {
+      return messageList;
+    }
+    const { threadId, resourceId } = context;
+    const memoryContext = memory.parseMemoryRequestContext(requestContext);
+    const readOnly = memoryContext?.memoryConfig?.readOnly;
+    if (readOnly) {
+      return messageList;
+    }
+    const newInput = messageList.get.input.db();
+    const newOutput = messageList.get.response.db();
+    const messagesToSave = [...newInput, ...newOutput];
+    if (messagesToSave.length === 0) {
+      return messageList;
+    }
+    const sealedIds = state.sealedIds ?? /* @__PURE__ */ new Set();
+    await this.saveMessagesWithSealedIdTracking(messagesToSave, sealedIds, threadId, resourceId, state);
+    return messageList;
+  }
+  /**
+   * Save messages to storage, regenerating IDs for any messages that were
+   * previously saved with observation markers (sealed).
+   *
+   * After saving, tracks which messages now have observation markers
+   * so their IDs won't be reused in future save cycles.
+   */
+  async saveMessagesWithSealedIdTracking(messagesToSave, sealedIds, threadId, resourceId, state) {
+    for (const msg of messagesToSave) {
+      if (sealedIds.has(msg.id)) {
+        msg.id = crypto.randomUUID();
+      }
+    }
+    await this.messageHistory.persistMessages({
+      messages: messagesToSave,
+      threadId,
+      resourceId
+    });
+    for (const msg of messagesToSave) {
+      if (this.findLastCompletedObservationBoundary(msg) !== -1) {
+        sealedIds.add(msg.id);
+      }
+    }
+    state.sealedIds = sealedIds;
+  }
+  /**
+   * Load messages from storage that haven't been observed yet.
+   * Uses cursor-based query with lastObservedAt timestamp for efficiency.
+   *
+   * In resource scope mode, loads messages for the entire resource (all threads).
+   * In thread scope mode, loads messages for just the current thread.
+   */
+  async loadUnobservedMessages(threadId, resourceId, lastObservedAt) {
+    const startDate = lastObservedAt ? new Date(lastObservedAt.getTime() + 1) : void 0;
+    let result;
+    if (this.scope === "resource" && resourceId) {
+      result = await this.storage.listMessagesByResourceId({
+        resourceId,
+        perPage: false,
+        // Get all messages (no pagination limit)
+        orderBy: { field: "createdAt", direction: "ASC" },
+        filter: startDate ? {
+          dateRange: {
+            start: startDate
+          }
+        } : void 0
+      });
+    } else {
+      result = await this.storage.listMessages({
+        threadId,
+        perPage: false,
+        // Get all messages (no pagination limit)
+        orderBy: { field: "createdAt", direction: "ASC" },
+        filter: startDate ? {
+          dateRange: {
+            start: startDate
+          }
+        } : void 0
+      });
+    }
+    return result.messages;
+  }
+  /**
+   * 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.
+   */
+  async loadOtherThreadsContext(resourceId, currentThreadId) {
+    const { threads: allThreads } = await this.storage.listThreads({ filter: { resourceId } });
+    const messagesByThread = /* @__PURE__ */ new Map();
+    for (const thread of allThreads) {
+      if (thread.id === currentThreadId) continue;
+      const omMetadata = memory.getThreadOMMetadata(thread.metadata);
+      const threadLastObservedAt = omMetadata?.lastObservedAt;
+      const startDate = threadLastObservedAt ? new Date(new Date(threadLastObservedAt).getTime() + 1) : void 0;
+      const result = await this.storage.listMessages({
+        threadId: thread.id,
+        perPage: false,
+        orderBy: { field: "createdAt", direction: "ASC" },
+        filter: startDate ? { dateRange: { start: startDate } } : void 0
+      });
+      const filtered = result.messages.filter((m) => !this.observedMessageIds.has(m.id));
+      if (filtered.length > 0) {
+        messagesByThread.set(thread.id, filtered);
+      }
+    }
+    if (messagesByThread.size === 0) return void 0;
+    const blocks = await this.formatUnobservedContextBlocks(messagesByThread, currentThreadId);
+    return blocks || void 0;
+  }
+  /**
+   * Format unobserved messages from other threads as <unobserved-context> blocks.
+   * These are injected into the Actor's context so it has awareness of activity
+   * in other threads for the same resource.
+   */
+  async formatUnobservedContextBlocks(messagesByThread, currentThreadId) {
+    const blocks = [];
+    for (const [threadId, messages] of messagesByThread) {
+      if (threadId === currentThreadId) continue;
+      if (messages.length === 0) continue;
+      const formattedMessages = formatMessagesForObserver(messages, { maxPartLength: 500 });
+      if (formattedMessages) {
+        const obscuredId = await this.representThreadIDInContext(threadId);
+        blocks.push(`<other-conversation id="${obscuredId}">
+${formattedMessages}
+</other-conversation>`);
+      }
+    }
+    return blocks.join("\n\n");
+  }
+  async representThreadIDInContext(threadId) {
+    if (this.shouldObscureThreadIds) {
+      const cached = this.threadIdCache.get(threadId);
+      if (cached) return cached;
+      const hasher = await this.hasher;
+      const hashed = hasher.h32ToString(threadId);
+      this.threadIdCache.set(threadId, hashed);
+      return hashed;
+    }
+    return threadId;
+  }
+  /**
+   * 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.
+   */
+  stripThreadTags(observations) {
+    return observations.replace(/<thread[^>]*>|<\/thread>/gi, "").trim();
+  }
+  /**
+   * 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.
+   */
+  getMaxMessageTimestamp(messages) {
+    let maxTime = 0;
+    for (const msg of messages) {
+      if (msg.createdAt) {
+        const msgTime = new Date(msg.createdAt).getTime();
+        if (msgTime > maxTime) {
+          maxTime = msgTime;
+        }
+      }
+    }
+    return maxTime > 0 ? new Date(maxTime) : /* @__PURE__ */ new Date();
+  }
+  /**
+   * Wrap observations in a thread attribution tag.
+   * Used in resource scope to track which thread observations came from.
+   */
+  async wrapWithThreadTag(threadId, observations) {
+    const cleanObservations = this.stripThreadTags(observations);
+    const obscuredId = await this.representThreadIDInContext(threadId);
+    return `<thread id="${obscuredId}">
+${cleanObservations}
+</thread>`;
+  }
+  /**
+   * Append or merge new thread sections.
+   * If the new section has the same thread ID and date as an existing section,
+   * merge the observations into that section to reduce token usage.
+   * Otherwise, append as a new section.
+   */
+  replaceOrAppendThreadSection(existingObservations, _threadId, newThreadSection) {
+    if (!existingObservations) {
+      return newThreadSection;
+    }
+    const threadIdMatch = newThreadSection.match(/<thread id="([^"]+)">/);
+    const dateMatch = newThreadSection.match(/Date:\s*([A-Za-z]+\s+\d+,\s+\d+)/);
+    if (!threadIdMatch || !dateMatch) {
+      return `${existingObservations}
+
+${newThreadSection}`;
+    }
+    const newThreadId = threadIdMatch[1];
+    const newDate = dateMatch[1];
+    const existingPattern = new RegExp(
+      `<thread id="${newThreadId}">\\s*Date:\\s*${newDate.replace(/[.*+?^${}()|[\]\\]/g, "\\$&")}([\\s\\S]*?)</thread>`
+    );
+    const existingMatch = existingObservations.match(existingPattern);
+    if (existingMatch) {
+      const newObsMatch = newThreadSection.match(/<thread id="[^"]+">[\s\S]*?Date:[^\n]*\n([\s\S]*?)\n<\/thread>/);
+      if (newObsMatch && newObsMatch[1]) {
+        const newObsContent = newObsMatch[1].trim();
+        const mergedSection = existingObservations.replace(existingPattern, (match) => {
+          const withoutClose = match.replace(/<\/thread>$/, "").trimEnd();
+          return `${withoutClose}
+${newObsContent}
+</thread>`;
+        });
+        return mergedSection;
+      }
+    }
+    return `${existingObservations}
+
+${newThreadSection}`;
+  }
+  /**
+   * 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.
+   */
+  sortThreadsByOldestMessage(messagesByThread) {
+    const threadOrder = Array.from(messagesByThread.entries()).map(([threadId, messages]) => {
+      const oldestTimestamp = Math.min(
+        ...messages.map((m) => m.createdAt ? new Date(m.createdAt).getTime() : Date.now())
+      );
+      return { threadId, oldestTimestamp };
+    }).sort((a, b) => a.oldestTimestamp - b.oldestTimestamp);
+    return threadOrder.map((t) => t.threadId);
+  }
+  /**
+   * Do synchronous observation (fallback when no buffering)
+   */
+  async doSynchronousObservation(record, threadId, unobservedMessages, writer, abortSignal) {
+    this.emitDebugEvent({
+      type: "observation_triggered",
+      timestamp: /* @__PURE__ */ new Date(),
+      threadId,
+      resourceId: record.resourceId ?? "",
+      previousObservations: record.activeObservations,
+      messages: unobservedMessages.map((m) => ({
+        role: m.role,
+        content: typeof m.content === "string" ? m.content : JSON.stringify(m.content)
+      }))
+    });
+    await this.storage.setObservingFlag(record.id, true);
+    const cycleId = crypto.randomUUID();
+    const tokensToObserve = this.tokenCounter.countMessages(unobservedMessages);
+    const lastMessage = unobservedMessages[unobservedMessages.length - 1];
+    const startedAt = (/* @__PURE__ */ new Date()).toISOString();
+    if (lastMessage?.id) {
+      const startMarker = this.createObservationStartMarker({
+        cycleId,
+        operationType: "observation",
+        tokensToObserve,
+        recordId: record.id,
+        threadId,
+        threadIds: [threadId]
+      });
+      if (writer) {
+        await writer.custom(startMarker).catch(() => {
+        });
+      }
+    }
+    try {
+      const freshRecord = await this.storage.getObservationalMemory(record.threadId, record.resourceId);
+      if (freshRecord && freshRecord.lastObservedAt && record.lastObservedAt) {
+        if (freshRecord.lastObservedAt > record.lastObservedAt) {
+          return;
+        }
+      }
+      const result = await this.callObserver(
+        freshRecord?.activeObservations ?? record.activeObservations,
+        unobservedMessages,
+        abortSignal
+      );
+      const existingObservations = freshRecord?.activeObservations ?? record.activeObservations ?? "";
+      let newObservations;
+      if (this.scope === "resource") {
+        const threadSection = await this.wrapWithThreadTag(threadId, result.observations);
+        newObservations = this.replaceOrAppendThreadSection(existingObservations, threadId, threadSection);
+      } else {
+        newObservations = existingObservations ? `${existingObservations}
+
+${result.observations}` : result.observations;
+      }
+      let totalTokenCount = this.tokenCounter.countObservations(newObservations);
+      const cycleObservationTokens = this.tokenCounter.countObservations(result.observations);
+      const lastObservedAt = this.getMaxMessageTimestamp(unobservedMessages);
+      const newMessageIds = unobservedMessages.map((m) => m.id);
+      const existingIds = freshRecord?.observedMessageIds ?? record.observedMessageIds ?? [];
+      const allObservedIds = [.../* @__PURE__ */ new Set([...Array.isArray(existingIds) ? existingIds : [], ...newMessageIds])];
+      await this.storage.updateActiveObservations({
+        id: record.id,
+        observations: newObservations,
+        tokenCount: totalTokenCount,
+        lastObservedAt,
+        observedMessageIds: allObservedIds
+      });
+      if (result.suggestedContinuation || result.currentTask) {
+        const thread = await this.storage.getThreadById({ threadId });
+        if (thread) {
+          const newMetadata = memory.setThreadOMMetadata(thread.metadata, {
+            suggestedResponse: result.suggestedContinuation,
+            currentTask: result.currentTask
+          });
+          await this.storage.updateThread({
+            id: threadId,
+            title: thread.title ?? "",
+            metadata: newMetadata
+          });
+        }
+      }
+      if (lastMessage?.id) {
+        const endMarker = this.createObservationEndMarker({
+          cycleId,
+          operationType: "observation",
+          startedAt,
+          tokensObserved: tokensToObserve,
+          observationTokens: cycleObservationTokens,
+          observations: result.observations,
+          currentTask: result.currentTask,
+          suggestedResponse: result.suggestedContinuation,
+          recordId: record.id,
+          threadId
+        });
+        if (writer) {
+          await writer.custom(endMarker).catch(() => {
+          });
+        }
+      }
+      this.emitDebugEvent({
+        type: "observation_complete",
+        timestamp: /* @__PURE__ */ new Date(),
+        threadId,
+        resourceId: record.resourceId ?? "",
+        observations: newObservations,
+        rawObserverOutput: result.observations,
+        previousObservations: record.activeObservations,
+        messages: unobservedMessages.map((m) => ({
+          role: m.role,
+          content: typeof m.content === "string" ? m.content : JSON.stringify(m.content)
+        })),
+        usage: result.usage
+      });
+      await this.maybeReflect(
+        { ...record, activeObservations: newObservations },
+        totalTokenCount,
+        threadId,
+        writer,
+        abortSignal
+      );
+    } catch (error) {
+      if (lastMessage?.id) {
+        const failedMarker = this.createObservationFailedMarker({
+          cycleId,
+          operationType: "observation",
+          startedAt,
+          tokensAttempted: tokensToObserve,
+          error: error instanceof Error ? error.message : String(error),
+          recordId: record.id,
+          threadId
+        });
+        if (writer) {
+          await writer.custom(failedMarker).catch(() => {
+          });
+        }
+      }
+      if (abortSignal?.aborted) {
+        throw error;
+      }
+      console.error(`[OM] Observation failed:`, error instanceof Error ? error.message : String(error));
+    } finally {
+      await this.storage.setObservingFlag(record.id, false);
+    }
+  }
+  /**
+   * 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.
+   *
+   * 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
+   */
+  async doResourceScopedObservation(record, currentThreadId, resourceId, currentThreadMessages, writer, abortSignal) {
+    const { threads: allThreads } = await this.storage.listThreads({ filter: { resourceId } });
+    const threadMetadataMap = /* @__PURE__ */ new Map();
+    for (const thread of allThreads) {
+      const omMetadata = memory.getThreadOMMetadata(thread.metadata);
+      threadMetadataMap.set(thread.id, { lastObservedAt: omMetadata?.lastObservedAt });
+    }
+    const messagesByThread = /* @__PURE__ */ new Map();
+    for (const thread of allThreads) {
+      const threadLastObservedAt = threadMetadataMap.get(thread.id)?.lastObservedAt;
+      const startDate = threadLastObservedAt ? new Date(new Date(threadLastObservedAt).getTime() + 1) : void 0;
+      const result = await this.storage.listMessages({
+        threadId: thread.id,
+        perPage: false,
+        orderBy: { field: "createdAt", direction: "ASC" },
+        filter: startDate ? { dateRange: { start: startDate } } : void 0
+      });
+      if (result.messages.length > 0) {
+        messagesByThread.set(thread.id, result.messages);
+      }
+    }
+    if (currentThreadMessages.length > 0) {
+      const existingCurrentThreadMsgs = messagesByThread.get(currentThreadId) ?? [];
+      const messageMap = /* @__PURE__ */ new Map();
+      for (const msg of existingCurrentThreadMsgs) {
+        if (msg.id) messageMap.set(msg.id, msg);
+      }
+      for (const msg of currentThreadMessages) {
+        if (msg.id) messageMap.set(msg.id, msg);
+      }
+      messagesByThread.set(currentThreadId, Array.from(messageMap.values()));
+    }
+    for (const [tid, msgs] of messagesByThread) {
+      const filtered = msgs.filter((m) => !this.observedMessageIds.has(m.id));
+      if (filtered.length > 0) {
+        messagesByThread.set(tid, filtered);
+      } else {
+        messagesByThread.delete(tid);
+      }
+    }
+    let totalMessages = 0;
+    for (const msgs of messagesByThread.values()) {
+      totalMessages += msgs.length;
+    }
+    if (totalMessages === 0) {
+      return;
+    }
+    const threshold = this.getMaxThreshold(this.observationConfig.messageTokens);
+    const threadTokenCounts = /* @__PURE__ */ new Map();
+    for (const [threadId, msgs] of messagesByThread) {
+      let tokens = 0;
+      for (const msg of msgs) {
+        tokens += this.tokenCounter.countMessage(msg);
+      }
+      threadTokenCounts.set(threadId, tokens);
+    }
+    const threadsBySize = Array.from(messagesByThread.keys()).sort((a, b) => {
+      return (threadTokenCounts.get(b) ?? 0) - (threadTokenCounts.get(a) ?? 0);
+    });
+    let accumulatedTokens = 0;
+    const threadsToObserve = [];
+    for (const threadId of threadsBySize) {
+      const threadTokens = threadTokenCounts.get(threadId) ?? 0;
+      if (accumulatedTokens >= threshold) {
+        break;
+      }
+      threadsToObserve.push(threadId);
+      accumulatedTokens += threadTokens;
+    }
+    if (threadsToObserve.length === 0) {
+      return;
+    }
+    const threadOrder = this.sortThreadsByOldestMessage(
+      new Map(threadsToObserve.map((tid) => [tid, messagesByThread.get(tid) ?? []]))
+    );
+    await this.storage.setObservingFlag(record.id, true);
+    const cycleId = crypto.randomUUID();
+    const threadsWithMessages = /* @__PURE__ */ new Map();
+    const threadTokensToObserve = /* @__PURE__ */ new Map();
+    let observationStartedAt = "";
+    try {
+      const freshRecord = await this.storage.getObservationalMemory(null, resourceId);
+      if (freshRecord && freshRecord.lastObservedAt && record.lastObservedAt) {
+        if (freshRecord.lastObservedAt > record.lastObservedAt) {
+          return;
+        }
+      }
+      const existingObservations = freshRecord?.activeObservations ?? record.activeObservations ?? "";
+      for (const threadId of threadOrder) {
+        const msgs = messagesByThread.get(threadId);
+        if (msgs && msgs.length > 0) {
+          threadsWithMessages.set(threadId, msgs);
+        }
+      }
+      this.emitDebugEvent({
+        type: "observation_triggered",
+        timestamp: /* @__PURE__ */ new Date(),
+        threadId: threadOrder.join(","),
+        resourceId,
+        previousObservations: existingObservations,
+        messages: Array.from(threadsWithMessages.values()).flat().map((m) => ({
+          role: m.role,
+          content: typeof m.content === "string" ? m.content : JSON.stringify(m.content)
+        }))
+      });
+      observationStartedAt = (/* @__PURE__ */ new Date()).toISOString();
+      const allThreadIds = Array.from(threadsWithMessages.keys());
+      for (const [threadId, msgs] of threadsWithMessages) {
+        const lastMessage = msgs[msgs.length - 1];
+        const tokensToObserve = this.tokenCounter.countMessages(msgs);
+        threadTokensToObserve.set(threadId, tokensToObserve);
+        if (lastMessage?.id) {
+          const startMarker = this.createObservationStartMarker({
+            cycleId,
+            operationType: "observation",
+            tokensToObserve,
+            recordId: record.id,
+            threadId,
+            threadIds: allThreadIds
+          });
+          if (writer) {
+            await writer.custom(startMarker).catch(() => {
+            });
+          }
+        }
+      }
+      const maxTokensPerBatch = this.observationConfig.maxTokensPerBatch ?? OBSERVATIONAL_MEMORY_DEFAULTS.observation.maxTokensPerBatch;
+      const orderedThreadIds = threadOrder.filter((tid) => threadsWithMessages.has(tid));
+      const batches = [];
+      let currentBatch = {
+        threadIds: [],
+        threadMap: /* @__PURE__ */ new Map()
+      };
+      let currentBatchTokens = 0;
+      for (const threadId of orderedThreadIds) {
+        const msgs = threadsWithMessages.get(threadId);
+        const threadTokens = threadTokenCounts.get(threadId) ?? 0;
+        if (currentBatchTokens + threadTokens > maxTokensPerBatch && currentBatch.threadIds.length > 0) {
+          batches.push(currentBatch);
+          currentBatch = { threadIds: [], threadMap: /* @__PURE__ */ new Map() };
+          currentBatchTokens = 0;
+        }
+        currentBatch.threadIds.push(threadId);
+        currentBatch.threadMap.set(threadId, msgs);
+        currentBatchTokens += threadTokens;
+      }
+      if (currentBatch.threadIds.length > 0) {
+        batches.push(currentBatch);
+      }
+      const batchPromises = batches.map(async (batch) => {
+        const batchResult = await this.callMultiThreadObserver(
+          existingObservations,
+          batch.threadMap,
+          batch.threadIds,
+          abortSignal
+        );
+        return batchResult;
+      });
+      const batchResults = await Promise.all(batchPromises);
+      const multiThreadResults = /* @__PURE__ */ new Map();
+      let totalBatchUsage = { inputTokens: 0, outputTokens: 0, totalTokens: 0 };
+      for (const batchResult of batchResults) {
+        for (const [threadId, result] of batchResult.results) {
+          multiThreadResults.set(threadId, result);
+        }
+        if (batchResult.usage) {
+          totalBatchUsage.inputTokens += batchResult.usage.inputTokens ?? 0;
+          totalBatchUsage.outputTokens += batchResult.usage.outputTokens ?? 0;
+          totalBatchUsage.totalTokens += batchResult.usage.totalTokens ?? 0;
+        }
+      }
+      const observationResults = [];
+      for (const threadId of threadOrder) {
+        const threadMessages = messagesByThread.get(threadId) ?? [];
+        if (threadMessages.length === 0) continue;
+        const result = multiThreadResults.get(threadId);
+        if (!result) {
+          continue;
+        }
+        observationResults.push({
+          threadId,
+          threadMessages,
+          result
+        });
+      }
+      let currentObservations = existingObservations;
+      let cycleObservationTokens = 0;
+      for (const obsResult of observationResults) {
+        if (!obsResult) continue;
+        const { threadId, threadMessages, result } = obsResult;
+        cycleObservationTokens += this.tokenCounter.countObservations(result.observations);
+        const threadSection = await this.wrapWithThreadTag(threadId, result.observations);
+        currentObservations = this.replaceOrAppendThreadSection(currentObservations, threadId, threadSection);
+        const threadLastObservedAt = this.getMaxMessageTimestamp(threadMessages);
+        const thread = await this.storage.getThreadById({ threadId });
+        if (thread) {
+          const newMetadata = memory.setThreadOMMetadata(thread.metadata, {
+            lastObservedAt: threadLastObservedAt.toISOString(),
+            ...result.suggestedContinuation && { suggestedResponse: result.suggestedContinuation },
+            ...result.currentTask && { currentTask: result.currentTask }
+          });
+          await this.storage.updateThread({
+            id: threadId,
+            title: thread.title ?? "",
+            metadata: newMetadata
+          });
+        }
+        const isFirstThread = observationResults.indexOf(obsResult) === 0;
+        this.emitDebugEvent({
+          type: "observation_complete",
+          timestamp: /* @__PURE__ */ new Date(),
+          threadId,
+          resourceId,
+          observations: threadSection,
+          rawObserverOutput: result.observations,
+          previousObservations: record.activeObservations,
+          messages: threadMessages.map((m) => ({
+            role: m.role,
+            content: typeof m.content === "string" ? m.content : JSON.stringify(m.content)
+          })),
+          // Add batch usage to first thread's event only (to avoid double-counting)
+          usage: isFirstThread && totalBatchUsage.totalTokens > 0 ? totalBatchUsage : void 0
+        });
+      }
+      let totalTokenCount = this.tokenCounter.countObservations(currentObservations);
+      const observedMessages = observationResults.filter((r) => r !== null).flatMap((r) => r.threadMessages);
+      const lastObservedAt = this.getMaxMessageTimestamp(observedMessages);
+      const newMessageIds = observedMessages.map((m) => m.id);
+      const existingIds = record.observedMessageIds ?? [];
+      const allObservedIds = [.../* @__PURE__ */ new Set([...existingIds, ...newMessageIds])];
+      await this.storage.updateActiveObservations({
+        id: record.id,
+        observations: currentObservations,
+        tokenCount: totalTokenCount,
+        lastObservedAt,
+        observedMessageIds: allObservedIds
+      });
+      for (const obsResult of observationResults) {
+        if (!obsResult) continue;
+        const { threadId, threadMessages, result } = obsResult;
+        const lastMessage = threadMessages[threadMessages.length - 1];
+        if (lastMessage?.id) {
+          const tokensObserved = threadTokensToObserve.get(threadId) ?? this.tokenCounter.countMessages(threadMessages);
+          const endMarker = this.createObservationEndMarker({
+            cycleId,
+            operationType: "observation",
+            startedAt: observationStartedAt,
+            tokensObserved,
+            observationTokens: cycleObservationTokens,
+            observations: result.observations,
+            currentTask: result.currentTask,
+            suggestedResponse: result.suggestedContinuation,
+            recordId: record.id,
+            threadId
+          });
+          if (writer) {
+            await writer.custom(endMarker).catch(() => {
+            });
+          }
+        }
+      }
+      await this.maybeReflect(
+        { ...record, activeObservations: currentObservations },
+        totalTokenCount,
+        currentThreadId,
+        writer,
+        abortSignal
+      );
+    } catch (error) {
+      for (const [threadId, msgs] of threadsWithMessages) {
+        const lastMessage = msgs[msgs.length - 1];
+        if (lastMessage?.id) {
+          const tokensAttempted = threadTokensToObserve.get(threadId) ?? 0;
+          const failedMarker = this.createObservationFailedMarker({
+            cycleId,
+            operationType: "observation",
+            startedAt: observationStartedAt,
+            tokensAttempted,
+            error: error instanceof Error ? error.message : String(error),
+            recordId: record.id,
+            threadId
+          });
+          if (writer) {
+            await writer.custom(failedMarker).catch(() => {
+            });
+          }
+        }
+      }
+      if (abortSignal?.aborted) {
+        throw error;
+      }
+      console.error(`[OM] Resource-scoped observation failed:`, error instanceof Error ? error.message : String(error));
+    } finally {
+      await this.storage.setObservingFlag(record.id, false);
+    }
+  }
+  /**
+   * Check if reflection needed and trigger if so.
+   * SIMPLIFIED: Always uses synchronous reflection (async buffering disabled).
+   */
+  async maybeReflect(record, observationTokens, _threadId, writer, abortSignal) {
+    if (!this.shouldReflect(observationTokens)) {
+      return;
+    }
+    if (record.isReflecting) {
+      return;
+    }
+    const reflectThreshold = this.getMaxThreshold(this.reflectionConfig.observationTokens);
+    await this.storage.setReflectingFlag(record.id, true);
+    const cycleId = crypto.randomUUID();
+    const startedAt = (/* @__PURE__ */ new Date()).toISOString();
+    const threadId = _threadId ?? "unknown";
+    if (writer) {
+      const startMarker = this.createObservationStartMarker({
+        cycleId,
+        operationType: "reflection",
+        tokensToObserve: observationTokens,
+        recordId: record.id,
+        threadId,
+        threadIds: [threadId]
+      });
+      await writer.custom(startMarker).catch(() => {
+      });
+    }
+    this.emitDebugEvent({
+      type: "reflection_triggered",
+      timestamp: /* @__PURE__ */ new Date(),
+      threadId,
+      resourceId: record.resourceId ?? "",
+      inputTokens: observationTokens,
+      activeObservationsLength: record.activeObservations?.length ?? 0
+    });
+    const streamContext = writer ? {
+      writer,
+      cycleId,
+      startedAt,
+      recordId: record.id,
+      threadId
+    } : void 0;
+    try {
+      const reflectResult = await this.callReflector(
+        record.activeObservations,
+        void 0,
+        streamContext,
+        reflectThreshold,
+        abortSignal
+      );
+      const reflectionTokenCount = this.tokenCounter.countObservations(reflectResult.observations);
+      await this.storage.createReflectionGeneration({
+        currentRecord: record,
+        reflection: reflectResult.observations,
+        tokenCount: reflectionTokenCount
+      });
+      if (writer && streamContext) {
+        const endMarker = this.createObservationEndMarker({
+          cycleId: streamContext.cycleId,
+          operationType: "reflection",
+          startedAt: streamContext.startedAt,
+          tokensObserved: observationTokens,
+          observationTokens: reflectionTokenCount,
+          observations: reflectResult.observations,
+          recordId: record.id,
+          threadId
+        });
+        await writer.custom(endMarker).catch(() => {
+        });
+      }
+      this.emitDebugEvent({
+        type: "reflection_complete",
+        timestamp: /* @__PURE__ */ new Date(),
+        threadId,
+        resourceId: record.resourceId ?? "",
+        inputTokens: observationTokens,
+        outputTokens: reflectionTokenCount,
+        observations: reflectResult.observations,
+        usage: reflectResult.usage
+      });
+    } catch (error) {
+      if (writer && streamContext) {
+        const failedMarker = this.createObservationFailedMarker({
+          cycleId: streamContext.cycleId,
+          operationType: "reflection",
+          startedAt: streamContext.startedAt,
+          tokensAttempted: observationTokens,
+          error: error instanceof Error ? error.message : String(error),
+          recordId: record.id,
+          threadId
+        });
+        await writer.custom(failedMarker).catch(() => {
+        });
+      }
+      if (abortSignal?.aborted) {
+        throw error;
+      }
+      console.error(`[OM] Reflection failed:`, error instanceof Error ? error.message : String(error));
+    } finally {
+      await this.storage.setReflectingFlag(record.id, false);
+    }
+  }
+  /**
+   * Manually trigger observation.
+   */
+  async observe(threadId, resourceId, _prompt) {
+    const lockKey = this.getLockKey(threadId, resourceId);
+    await this.withLock(lockKey, async () => {
+      const freshRecord = await this.getOrCreateRecord(threadId, resourceId);
+      if (this.scope === "resource" && resourceId) {
+        await this.doResourceScopedObservation(
+          freshRecord,
+          threadId,
+          resourceId,
+          []
+          // no in-flight messages — everything is already in the DB
+        );
+      } else {
+        const unobservedMessages = await this.loadUnobservedMessages(
+          threadId,
+          resourceId,
+          freshRecord.lastObservedAt ? new Date(freshRecord.lastObservedAt) : void 0
+        );
+        if (unobservedMessages.length === 0) {
+          return;
+        }
+        await this.doSynchronousObservation(freshRecord, threadId, unobservedMessages);
+      }
+    });
+  }
+  /**
+   * Manually trigger reflection with optional guidance prompt.
+   *
+   * @example
+   * ```ts
+   * // Trigger reflection with specific focus
+   * await om.reflect(threadId, resourceId,
+   *   "focus on the authentication implementation, only keep minimal details about UI styling"
+   * );
+   * ```
+   */
+  async reflect(threadId, resourceId, prompt) {
+    const record = await this.getOrCreateRecord(threadId, resourceId);
+    if (!record.activeObservations) {
+      return;
+    }
+    await this.storage.setReflectingFlag(record.id, true);
+    try {
+      const reflectThreshold = this.getMaxThreshold(this.reflectionConfig.observationTokens);
+      const reflectResult = await this.callReflector(record.activeObservations, prompt, void 0, reflectThreshold);
+      const reflectionTokenCount = this.tokenCounter.countObservations(reflectResult.observations);
+      await this.storage.createReflectionGeneration({
+        currentRecord: record,
+        reflection: reflectResult.observations,
+        tokenCount: reflectionTokenCount
+      });
+    } finally {
+      await this.storage.setReflectingFlag(record.id, false);
+    }
+  }
+  /**
+   * Get current observations for a thread/resource
+   */
+  async getObservations(threadId, resourceId) {
+    const ids = this.getStorageIds(threadId, resourceId);
+    const record = await this.storage.getObservationalMemory(ids.threadId, ids.resourceId);
+    return record?.activeObservations;
+  }
+  /**
+   * Get current record for a thread/resource
+   */
+  async getRecord(threadId, resourceId) {
+    const ids = this.getStorageIds(threadId, resourceId);
+    return this.storage.getObservationalMemory(ids.threadId, ids.resourceId);
+  }
+  /**
+   * Get observation history (previous generations)
+   */
+  async getHistory(threadId, resourceId, limit) {
+    const ids = this.getStorageIds(threadId, resourceId);
+    return this.storage.getObservationalMemoryHistory(ids.threadId, ids.resourceId, limit);
+  }
+  /**
+   * Clear all memory for a specific thread/resource
+   */
+  async clear(threadId, resourceId) {
+    const ids = this.getStorageIds(threadId, resourceId);
+    await this.storage.clearObservationalMemory(ids.threadId, ids.resourceId);
+  }
+  /**
+   * Get the underlying storage adapter
+   */
+  getStorage() {
+    return this.storage;
+  }
+  /**
+   * Get the token counter
+   */
+  getTokenCounter() {
+    return this.tokenCounter;
+  }
+  /**
+   * Get current observation configuration
+   */
+  getObservationConfig() {
+    return this.observationConfig;
+  }
+  /**
+   * Get current reflection configuration
+   */
+  getReflectionConfig() {
+    return this.reflectionConfig;
+  }
+};
+
+exports.OBSERVATIONAL_MEMORY_DEFAULTS = OBSERVATIONAL_MEMORY_DEFAULTS;
+exports.OBSERVER_SYSTEM_PROMPT = OBSERVER_SYSTEM_PROMPT;
+exports.ObservationalMemory = ObservationalMemory;
+exports.TokenCounter = TokenCounter;
+exports.buildObserverPrompt = buildObserverPrompt;
+exports.buildObserverSystemPrompt = buildObserverSystemPrompt;
+exports.extractCurrentTask = extractCurrentTask;
+exports.formatMessagesForObserver = formatMessagesForObserver;
+exports.hasCurrentTaskSection = hasCurrentTaskSection;
+exports.optimizeObservationsForContext = optimizeObservationsForContext;
+exports.parseObserverOutput = parseObserverOutput;
+//# sourceMappingURL=chunk-FQJWVCDF.cjs.map
+//# sourceMappingURL=chunk-FQJWVCDF.cjs.map