@mastra/memory 1.8.4-alpha.0 → 1.9.0-alpha.1

package/dist/{chunk-LGCREJMO.cjs → chunk-AR52LM55.cjs}

@@ -307,6 +307,18 @@ function createActivationMarker(params) {
     }
   };
 }
+function createThreadUpdateMarker(params) {
+  return {
+    type: "data-om-thread-update",
+    data: {
+      cycleId: params.cycleId,
+      threadId: params.threadId,
+      oldTitle: params.oldTitle,
+      newTitle: params.newTitle,
+      timestamp: (/* @__PURE__ */ new Date()).toISOString()
+    }
+  };
+}
 var ENCRYPTED_CONTENT_KEY = "encryptedContent";
 var ENCRYPTED_CONTENT_REDACTION_THRESHOLD = 256;
 var DEFAULT_OBSERVER_TOOL_RESULT_MAX_TOKENS = 1e4;
@@ -616,17 +628,60 @@ Only add a new observation for a repeated action if the NEW result changes the p
 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_OUTPUT_FORMAT_BASE = `Use priority levels:
-- \u{1F534} High: explicit user facts, preferences, goals achieved, critical context
+- 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)
+
+COMPLETION TRACKING:
+Completion observations are not just summaries. They are explicit memory signals to the assistant that a task, question, or subtask has been resolved.
+Without clear completion markers, the assistant may forget that work is already finished and may repeat, reopen, or continue an already-completed task.
+
+Use \u2705 to answer: "What exactly is now done?"
+Choose completion observations that help the assistant know what is finished and should not be reworked unless new information appears.
+
+Use \u2705 when:
+- The user explicitly confirms something worked or was answered ("thanks, that fixed it", "got it", "perfect")
+- The assistant provided a definitive, complete answer to a factual question and the user moved on
+- A multi-step task reached its stated goal
+- The user acknowledged receipt of requested information
+- A concrete subtask, fix, deliverable, or implementation step became complete during ongoing work
+
+Do NOT use \u2705 when:
+- The assistant merely responded \u2014 the user might follow up with corrections
+- The topic is paused but not resolved ("I'll try that later")
+- The user's reaction is ambiguous
+
+FORMAT:
+As a sub-bullet under the related observation group:
+* \u{1F534} (14:30) User asked how to configure auth middleware
+  * -> Agent explained JWT setup with code example
+  * \u2705 User confirmed auth is working
+
+Or as a standalone observation when closing out a broader task:
+* \u2705 (14:45) Auth configuration task completed \u2014 user confirmed middleware is working
+
+Completion observations should be terse but specific about WHAT was completed.
+Prefer concrete resolved outcomes over abstract workflow status so the assistant remembers what is already done.`;
+var OBSERVER_OUTPUT_FORMAT_BASE = buildObserverOutputFormat();
+function buildObserverOutputFormat(includeThreadTitle = false) {
+  const threadTitleSection = includeThreadTitle ? `
+<thread-title>
+A short, noun-phrase title for this conversation (2-5 words). Examples:
+- "Auth bug fix" \u2014 not "Fixing the auth bug"
+- "Dark mode toggle" \u2014 not "User wants dark mode toggle added"
+- "Deployment pipeline setup" \u2014 not "Setting up deployment pipeline for project"
+Only update when the topic meaningfully changes.
+</thread-title>` : "";
+  return `Use priority levels:
+- \u{1F534} High: explicit user facts, preferences, unresolved goals, critical context
 - \u{1F7E1} Medium: project details, learned information, tool results
 - \u{1F7E2} Low: minor details, uncertain observations
+- \u2705 Completed: concrete task finished, question answered, issue resolved, goal achieved, or subtask completed in a way that helps the assistant know it is done
 
 Group related observations (like tool sequences) by indenting:
 * \u{1F534} (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
+  * \u2705 Tests passing, auth issue resolved
 
 Group observations by date, then list each with 24-hour time.
 
@@ -653,7 +708,8 @@ 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>`;
+</suggested-response>${threadTitleSection}`;
+}
 var 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)
@@ -663,12 +719,21 @@ var OBSERVER_GUIDELINES = `- Be specific enough for the assistant to act on
 - 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})
-- User messages are always \u{1F534} priority, so are the completions of tasks. Capture the user's words closely \u2014 short/medium messages near-verbatim, long messages summarized with key quotes
+- Make sure you start each observation with a priority emoji (\u{1F534}, \u{1F7E1}, \u{1F7E2}) or a completion marker (\u2705)
+- Capture the user's words closely \u2014 short/medium messages near-verbatim, long messages summarized with key quotes. User confirmations or explicit resolved outcomes should be \u2705 when they clearly signal something is done; unresolved or critical user facts remain \u{1F534}
+- Treat \u2705 as a memory signal that tells the assistant something is finished and should not be repeated unless new information changes it
+- Make completion observations answer "What exactly is now done?"
+- Prefer concrete resolved outcomes over meta-level workflow or bookkeeping updates
+- When multiple concrete things were completed, capture the concrete completed work rather than collapsing it into a vague progress summary
 - Observe WHAT the agent did and WHAT it means
 - If the user provides detailed messages or code snippets, observe all important details`;
-function buildObserverSystemPrompt(multiThread = false, instruction) {
-  const outputFormat = OBSERVER_OUTPUT_FORMAT_BASE;
+function buildObserverSystemPrompt(multiThread = false, instruction, includeThreadTitle = false) {
+  const outputFormat = buildObserverOutputFormat(includeThreadTitle);
+  const multiThreadTitleInstruction = includeThreadTitle ? ` Each thread's observations, current-task, suggested-response, and thread-title should be nested inside a <thread id="..."> block within <observations>.` : ` Each thread's observations, current-task, and suggested-response should be nested inside a <thread id="..."> block within <observations>.`;
+  const multiThreadTitleExample = includeThreadTitle ? `
+<thread-title>Feature X implementation</thread-title>` : "";
+  const multiThreadSecondTitleExample = includeThreadTitle ? `
+<thread-title>Deployment setup</thread-title>` : "";
   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.
 
@@ -683,7 +748,13 @@ 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>.
+Your output MUST use XML tags to structure the response.${multiThreadTitleInstruction}
+
+Use this observation format inside each thread block:
+
+${outputFormat}
+
+For multi-thread output, wrap each thread's observations like this:
 
 <observations>
 <thread id="thread_id_1">
@@ -697,7 +768,7 @@ What the agent is currently working on in this thread
 
 <suggested-response>
 Hint for the agent's next message in this thread
-</suggested-response>
+</suggested-response>${multiThreadTitleExample}
 </thread>
 
 <thread id="thread_id_2">
@@ -710,15 +781,10 @@ Current task for this thread
 
 <suggested-response>
 Suggested response for this thread
-</suggested-response>
+</suggested-response>${multiThreadSecondTitleExample}
 </thread>
 </observations>
 
-Use priority levels:
-- \u{1F534} High: explicit user facts, preferences, goals achieved, critical context, user messages
-- \u{1F7E1} Medium: project details, learned information, tool results
-- \u{1F7E2} Low: minor details, uncertain observations
-
 === GUIDELINES ===
 
 ${OBSERVER_GUIDELINES}
@@ -998,7 +1064,7 @@ The following messages are from ${threadOrder.length} different conversation thr
     content
   };
 }
-function buildMultiThreadObserverTaskPrompt(existingObservations, threadOrder, priorMetadataByThread, wasTruncated) {
+function buildMultiThreadObserverTaskPrompt(existingObservations, threadOrder, priorMetadataByThread, wasTruncated, includeThreadTitle) {
   let prompt = "";
   if (existingObservations) {
     prompt += `## Previous Observations
@@ -1013,7 +1079,8 @@ ${existingObservations}
   const hasTruncatedObservations = wasTruncated ?? false;
   const threadMetadataLines = threadOrder?.map((threadId) => {
     const metadata = priorMetadataByThread?.get(threadId);
-    if (!metadata?.currentTask && !metadata?.suggestedResponse) {
+    const hasRelevantMetadata = metadata?.currentTask || metadata?.suggestedResponse || includeThreadTitle && metadata?.threadTitle;
+    if (!hasRelevantMetadata) {
       return "";
     }
     const lines = [`- thread ${threadId}`];
@@ -1023,6 +1090,9 @@ ${existingObservations}
     if (metadata.suggestedResponse) {
       lines.push(`  - prior suggested-response: ${metadata.suggestedResponse}`);
     }
+    if (includeThreadTitle && metadata.threadTitle) {
+      lines.push(`  - prior thread-title: ${metadata.threadTitle}`);
+    }
     return lines.join("\n");
   }).filter(Boolean).join("\n");
   if (threadMetadataLines) {
@@ -1037,7 +1107,8 @@ ${threadMetadataLines}
       prompt += `The main agent still has full memory context outside this observer window.
 `;
     }
-    prompt += `Use each thread's prior current-task and suggested-response as continuity hints, then update them based on that thread's new messages.
+    const titleHint = includeThreadTitle ? ", and thread-title" : "";
+    prompt += `Use each thread's prior current-task, suggested-response${titleHint} as continuity hints, then update them based on that thread's new messages.
 
 ---
 
@@ -1046,7 +1117,8 @@ ${threadMetadataLines}
   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.
+  const titleInstruction = includeThreadTitle ? ", and thread-title" : "";
+  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, suggested-response${titleInstruction}.
 
 `;
   prompt += `Example output format:
@@ -1062,6 +1134,8 @@ ${threadMetadataLines}
   prompt += `<current-task>Working on feature X</current-task>
 `;
   prompt += `<suggested-response>Continue with the implementation</suggested-response>
+`;
+  if (includeThreadTitle) prompt += `<thread-title>Feature X implementation</thread-title>
 `;
   prompt += `</thread>
 `;
@@ -1074,6 +1148,8 @@ ${threadMetadataLines}
   prompt += `<current-task>Discussing deployment options</current-task>
 `;
   prompt += `<suggested-response>Explain the deployment process</suggested-response>
+`;
+  if (includeThreadTitle) prompt += `<thread-title>Deployment setup</thread-title>
 `;
   prompt += `</thread>
 `;
@@ -1106,11 +1182,18 @@ function parseMultiThreadObserverOutput(output) {
       suggestedContinuation = suggestedMatch[1].trim();
       observations = observations.replace(/<suggested-response>[\s\S]*?<\/suggested-response>/i, "");
     }
+    let threadTitle;
+    const threadTitleMatch = threadContent.match(/<thread-title>([\s\S]*?)<\/thread-title>/i);
+    if (threadTitleMatch?.[1]) {
+      threadTitle = threadTitleMatch[1].trim();
+      observations = observations.replace(/<thread-title>[\s\S]*?<\/thread-title>/i, "");
+    }
     observations = sanitizeObservationLines(observations.trim());
     threads.set(threadId, {
       observations,
       currentTask,
       suggestedContinuation,
+      threadTitle,
       rawOutput: threadContent
     });
   }
@@ -1139,6 +1222,9 @@ ${existingObservations}
   if (options?.priorSuggestedResponse) {
     priorMetadataLines.push(`- prior suggested-response: ${options.priorSuggestedResponse}`);
   }
+  if (options?.includeThreadTitle && options?.priorThreadTitle) {
+    priorMetadataLines.push(`- prior thread-title: ${options.priorThreadTitle}`);
+  }
   if (priorMetadataLines.length > 0) {
     prompt += `## Prior Thread Metadata
 
@@ -1151,7 +1237,8 @@ ${priorMetadataLines.join("\n")}
       prompt += `The main agent still has full memory context outside this observer window.
 `;
     }
-    prompt += `Use the prior current-task and suggested-response as continuity hints, then update them based on the new messages.
+    const titleHint = options?.includeThreadTitle ? ", and thread-title" : "";
+    prompt += `Use the prior current-task, suggested-response${titleHint} as continuity hints, then update them based on the new messages.
 
 ---
 
@@ -1161,10 +1248,15 @@ ${priorMetadataLines.join("\n")}
 
 `;
   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.`;
+  if (options?.includeThreadTitle) {
+    prompt += `
+
+Also output a <thread-title> \u2014 a short noun-phrase label for this conversation (2-5 words). Write it like a file name or PR title: "Auth bug fix", "Memory config refactor", "RAG pipeline setup". Avoid verbs/sentences ("Fixing the auth bug"), filler ("Working on stuff"), and generic labels ("Code review"). Only change it from the prior title if the topic meaningfully shifted.`;
+  }
   if (options?.skipContinuationHints) {
     prompt += `
 
-IMPORTANT: Do NOT include <current-task> or <suggested-response> sections in your output. Only output <observations>.`;
+IMPORTANT: Do NOT include <current-task> or <suggested-response> sections in your output. Only output <observations>${options?.includeThreadTitle ? " and <thread-title>" : ""}.`;
   }
   return prompt;
 }
@@ -1192,6 +1284,7 @@ function parseObserverOutput(output) {
     observations,
     currentTask: parsed.currentTask || void 0,
     suggestedContinuation: parsed.suggestedResponse || void 0,
+    threadTitle: parsed.threadTitle || void 0,
     rawOutput: output
   };
 }
@@ -1199,7 +1292,8 @@ function parseMemorySectionXml(content) {
   const result = {
     observations: "",
     currentTask: "",
-    suggestedResponse: ""
+    suggestedResponse: "",
+    threadTitle: ""
   };
   const observationsRegex = /^[ \t]*<observations>([\s\S]*?)^[ \t]*<\/observations>/gim;
   const observationsMatches = [...content.matchAll(observationsRegex)];
@@ -1216,6 +1310,10 @@ function parseMemorySectionXml(content) {
   if (suggestedResponseMatch?.[1]) {
     result.suggestedResponse = suggestedResponseMatch[1].trim();
   }
+  const threadTitleMatch = content.match(/^[ \t]*<thread-title>([\s\S]*?)<\/thread-title>/im);
+  if (threadTitleMatch?.[1]) {
+    result.threadTitle = threadTitleMatch[1].trim();
+  }
   return result;
 }
 function extractListItemsOnly(content) {
@@ -1353,6 +1451,8 @@ 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")
+- Preserve \u2705 completion markers \u2014 they are memory signals that tell the assistant what is already resolved and help prevent repeated work
+- Preserve the concrete resolved outcome captured by \u2705 markers so the assistant knows what exactly is done
 - Condense older observations more aggressively, retain more detail for recent ones
 
 CRITICAL: USER ASSERTIONS vs QUESTIONS
@@ -1433,6 +1533,8 @@ Please re-process with slightly more compression:
 - 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
+- Preserve \u2705 completion markers \u2014 they are memory signals that tell the assistant what is already resolved and help prevent repeated work
+- Preserve the concrete resolved outcome captured by \u2705 markers so the assistant knows what exactly is done
 - 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.
@@ -1447,6 +1549,8 @@ Please re-process with much more aggressive compression:
 - Closer to the end, retain fine details (recent context matters more)
 - Memory is getting very long - use a significantly more condensed style throughout
 - Combine related items aggressively but do not lose important specific details of names, places, events, and people
+- Preserve \u2705 completion markers \u2014 they are memory signals that tell the assistant what is already resolved and help prevent repeated work
+- Preserve the concrete resolved outcome captured by \u2705 markers so the assistant knows what exactly is done
 - 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.
 - Remove redundant information and merge overlapping observations
 
@@ -1463,6 +1567,8 @@ Please re-process with maximum compression:
 - Ruthlessly merge related observations \u2014 if 10 observations are about the same topic, combine into 1-2 lines
 - Drop procedural details (tool calls, retries, intermediate steps) \u2014 keep only final outcomes
 - Drop observations that are no longer relevant or have been superseded by newer information
+- Preserve \u2705 completion markers \u2014 they are memory signals that tell the assistant what is already resolved and help prevent repeated work
+- Preserve the concrete resolved outcome captured by \u2705 markers so the assistant knows what exactly is done
 - Preserve: names, dates, decisions, errors, user preferences, and architectural choices
 
 Your current detail level was a 10/10, lets aim for a 4/10 detail level.
@@ -3443,7 +3549,8 @@ Async buffering is enabled by default \u2014 this opt-out is only needed when us
         config.observation?.messageTokens ?? OBSERVATIONAL_MEMORY_DEFAULTS.observation.messageTokens
       ),
       previousObserverTokens: config.observation?.previousObserverTokens ?? 2e3,
-      instruction: config.observation?.instruction
+      instruction: config.observation?.instruction,
+      threadTitle: config.observation?.threadTitle ?? false
     };
     this.reflectionConfig = {
       model: reflectionModel,
@@ -3669,7 +3776,11 @@ Async buffering is enabled by default \u2014 this opt-out is only needed when us
    */
   getObserverAgent() {
     if (!this.observerAgent) {
-      const systemPrompt = buildObserverSystemPrompt(false, this.observationConfig.instruction);
+      const systemPrompt = buildObserverSystemPrompt(
+        false,
+        this.observationConfig.instruction,
+        this.observationConfig.threadTitle
+      );
       this.observerAgent = new agent.Agent({
         id: "observational-memory-observer",
         name: "Observer",
@@ -4091,7 +4202,7 @@ ${unreflectedContent}` : bufferedReflection;
     const isImportant = new Array(totalCount);
     for (let i = 0; i < totalCount; i++) {
       lineTokens[i] = this.tokenCounter.countString(lines[i]);
-      isImportant[i] = lines[i].includes("\u{1F534}");
+      isImportant[i] = lines[i].includes("\u{1F534}") || lines[i].includes("\u2705");
     }
     const suffixTokens = new Array(totalCount + 1);
     suffixTokens[totalCount] = 0;
@@ -4177,7 +4288,9 @@ ${unreflectedContent}` : bufferedReflection;
           skipContinuationHints: options?.skipContinuationHints,
           priorCurrentTask: options?.priorCurrentTask,
           priorSuggestedResponse: options?.priorSuggestedResponse,
-          wasTruncated: options?.wasTruncated
+          priorThreadTitle: options?.priorThreadTitle,
+          wasTruncated: options?.wasTruncated,
+          includeThreadTitle: this.observationConfig.threadTitle
         })
       },
       buildObserverHistoryMessage(messagesToObserve)
@@ -4212,6 +4325,7 @@ ${unreflectedContent}` : bufferedReflection;
       observations: parsed.observations,
       currentTask: parsed.currentTask,
       suggestedContinuation: parsed.suggestedContinuation,
+      threadTitle: parsed.threadTitle,
       usage: usage ? {
         inputTokens: usage.inputTokens,
         outputTokens: usage.outputTokens,
@@ -4226,7 +4340,11 @@ ${unreflectedContent}` : bufferedReflection;
    * plus the total usage for the batch.
    */
   async callMultiThreadObserver(existingObservations, messagesByThread, threadOrder, priorMetadataByThread, abortSignal, requestContext, wasTruncated) {
-    const systemPrompt = buildObserverSystemPrompt(true, this.observationConfig.instruction);
+    const systemPrompt = buildObserverSystemPrompt(
+      true,
+      this.observationConfig.instruction,
+      this.observationConfig.threadTitle
+    );
     const agent$1 = new agent.Agent({
       id: "multi-thread-observer",
       name: "multi-thread-observer",
@@ -4240,7 +4358,8 @@ ${unreflectedContent}` : bufferedReflection;
           existingObservations,
           threadOrder,
           priorMetadataByThread,
-          wasTruncated
+          wasTruncated,
+          this.observationConfig.threadTitle
         )
       },
       buildMultiThreadObserverHistoryMessage(messagesByThread, threadOrder)
@@ -4282,7 +4401,8 @@ ${unreflectedContent}` : bufferedReflection;
       results.set(threadId, {
         observations: threadResult.observations,
         currentTask: threadResult.currentTask,
-        suggestedContinuation: threadResult.suggestedContinuation
+        suggestedContinuation: threadResult.suggestedContinuation,
+        threadTitle: threadResult.threadTitle
       });
     }
     for (const threadId of threadOrder) {
@@ -5725,6 +5845,7 @@ ${threadClose}`;
         requestContext,
         priorCurrentTask: threadOMMetadata?.currentTask,
         priorSuggestedResponse: threadOMMetadata?.suggestedResponse,
+        priorThreadTitle: thread?.title,
         wasTruncated
       });
       const lastObservedAt = this.getMaxMessageTimestamp(messagesToObserve);
@@ -5755,10 +5876,31 @@ ${threadClose}`;
         });
         await this.storage.updateThread({
           id: threadId,
-          title: threadForMetadata.title ?? "",
+          title: threadForMetadata.title || "",
           metadata: newMetadata
         });
       }
+      if (this.observationConfig.threadTitle && threadForMetadata && result.threadTitle) {
+        const oldTitle = threadForMetadata.title;
+        const newTitle = result.threadTitle;
+        if (newTitle.trim().length >= 3 && newTitle !== oldTitle) {
+          await this.storage.updateThread({
+            id: threadId,
+            title: newTitle,
+            metadata: threadForMetadata.metadata ?? {}
+          });
+          if (writer) {
+            const threadUpdateMarker = createThreadUpdateMarker({
+              cycleId,
+              threadId,
+              oldTitle: oldTitle ?? void 0,
+              newTitle
+            });
+            await writer.custom(threadUpdateMarker).catch(() => {
+            });
+          }
+        }
+      }
       await this.storage.updateActiveObservations({
         id: record.id,
         observations: newObservations,
@@ -6002,6 +6144,7 @@ ${threadClose}`;
         requestContext,
         priorCurrentTask: threadOMMetadata?.currentTask,
         priorSuggestedResponse: threadOMMetadata?.suggestedResponse,
+        priorThreadTitle: thread?.title,
         wasTruncated
       }
     );
@@ -6009,6 +6152,22 @@ ${threadClose}`;
       omDebug(`[OM:doAsyncBufferedObservation] empty observations returned, skipping buffer storage`);
       return;
     }
+    if (this.observationConfig.threadTitle && result.threadTitle) {
+      const newTitle = result.threadTitle;
+      if (newTitle.length >= 3 && newTitle !== thread?.title) {
+        await this.storage.updateThread({ id: threadId, title: newTitle, metadata: thread?.metadata ?? {} });
+        if (writer) {
+          const marker = createThreadUpdateMarker({
+            cycleId,
+            threadId,
+            oldTitle: thread?.title,
+            newTitle
+          });
+          void writer.custom(marker).catch(() => {
+          });
+        }
+      }
+    }
     let newObservations;
     if (this.scope === "resource") {
       newObservations = await this.wrapWithThreadTag(threadId, result.observations);
@@ -6432,7 +6591,8 @@ ${unreflectedContent}` : freshRecord.bufferedReflection;
       threadMetadataMap.set(thread.id, {
         lastObservedAt: omMetadata?.lastObservedAt,
         currentTask: omMetadata?.currentTask,
-        suggestedResponse: omMetadata?.suggestedResponse
+        suggestedResponse: omMetadata?.suggestedResponse,
+        threadTitle: thread.title
       });
     }
     const messagesByThread = /* @__PURE__ */ new Map();
@@ -6585,10 +6745,11 @@ ${unreflectedContent}` : freshRecord.bufferedReflection;
         const batchPriorMetadata = /* @__PURE__ */ new Map();
         for (const threadId of batch.threadIds) {
           const metadata = threadMetadataMap.get(threadId);
-          if (metadata?.currentTask || metadata?.suggestedResponse) {
+          if (metadata?.currentTask || metadata?.suggestedResponse || metadata?.threadTitle) {
             batchPriorMetadata.set(threadId, {
               currentTask: metadata.currentTask,
-              suggestedResponse: metadata.suggestedResponse
+              suggestedResponse: metadata.suggestedResponse,
+              threadTitle: metadata.threadTitle
             });
           }
         }
@@ -6646,6 +6807,13 @@ ${unreflectedContent}` : freshRecord.bufferedReflection;
         );
         const thread = await this.storage.getThreadById({ threadId });
         if (thread) {
+          let titleForUpdate = thread.title ?? "";
+          if (this.observationConfig.threadTitle && result.threadTitle) {
+            const newTitle = result.threadTitle.trim();
+            if (newTitle.length >= 3 && newTitle !== thread.title) {
+              titleForUpdate = newTitle;
+            }
+          }
           const newMetadata = memory.setThreadOMMetadata(thread.metadata, {
             lastObservedAt: threadLastObservedAt.toISOString(),
             suggestedResponse: result.suggestedContinuation,
@@ -6654,7 +6822,7 @@ ${unreflectedContent}` : freshRecord.bufferedReflection;
           });
           await this.storage.updateThread({
             id: threadId,
-            title: thread.title ?? "",
+            title: titleForUpdate,
             metadata: newMetadata
           });
         }
@@ -7127,5 +7295,5 @@ exports.getObservationsAsOf = getObservationsAsOf;
 exports.hasCurrentTaskSection = hasCurrentTaskSection;
 exports.optimizeObservationsForContext = optimizeObservationsForContext;
 exports.parseObserverOutput = parseObserverOutput;
-//# sourceMappingURL=chunk-LGCREJMO.cjs.map
-//# sourceMappingURL=chunk-LGCREJMO.cjs.map
+//# sourceMappingURL=chunk-AR52LM55.cjs.map
+//# sourceMappingURL=chunk-AR52LM55.cjs.map