@mastra/memory 1.20.1 → 1.20.2

package/dist/chunk-WCGXQIEN.js

@@ -0,0 +1,103 @@
+import { createHash } from 'crypto';
+import { structuredPatch } from 'diff';
+
+// src/processors/working-memory-state/processor.ts
+var WORKING_MEMORY_STATE_ID = "working-memory";
+var WORKING_MEMORY_STATE_PROCESSOR_ID = "working-memory-state";
+var WorkingMemoryStateProcessor = class {
+  constructor(memory, memoryConfig) {
+    this.memory = memory;
+    this.memoryConfig = memoryConfig;
+  }
+  memory;
+  memoryConfig;
+  id = WORKING_MEMORY_STATE_PROCESSOR_ID;
+  stateId = WORKING_MEMORY_STATE_ID;
+  async computeStateSignal(args) {
+    const template = await this.memory.getWorkingMemoryTemplate({ memoryConfig: this.memoryConfig });
+    if (!template) return;
+    const data = await this.memory.getWorkingMemory({
+      threadId: args.threadId,
+      resourceId: args.resourceId,
+      memoryConfig: this.memoryConfig
+    });
+    const contents = data?.trim();
+    if (!contents) return;
+    const cacheKey = stableWorkingMemoryCacheKey({ format: template.format, data: contents });
+    const shouldMakeSnapshot = !args.contextWindow.hasSnapshot;
+    if (args.tracking?.currentCacheKey === cacheKey && !shouldMakeSnapshot) return;
+    const mergedConfig = this.memory.getMergedThreadConfig(this.memoryConfig);
+    const scope = mergedConfig.workingMemory?.scope ?? "resource";
+    const deltaCandidate = template.format === "markdown" && !shouldMakeSnapshot ? buildMarkdownDelta({
+      lastSnapshot: args.lastSnapshot,
+      deltasSinceSnapshot: args.deltasSinceSnapshot,
+      nextContents: contents
+    }) : void 0;
+    if (deltaCandidate) {
+      return {
+        id: WORKING_MEMORY_STATE_ID,
+        mode: "delta",
+        cacheKey,
+        tagName: "working-memory",
+        contents: deltaCandidate.contents,
+        delta: deltaCandidate.contents,
+        // Stash the full post-edit text on the signal so the next turn can
+        // diff against the most recently emitted state instead of the older
+        // snapshot. Invisible to the model.
+        value: contents,
+        attributes: {
+          format: template.format,
+          scope,
+          patch: "unified-diff"
+        }
+      };
+    }
+    return {
+      id: WORKING_MEMORY_STATE_ID,
+      mode: "snapshot",
+      cacheKey,
+      tagName: "working-memory",
+      contents,
+      // Mirror contents in value so the first delta after a snapshot has a
+      // typed prior-state to diff against without falling back to contents.
+      value: contents,
+      attributes: {
+        format: template.format,
+        scope
+      }
+    };
+  }
+};
+function stableWorkingMemoryCacheKey(input) {
+  const hash = createHash("sha256");
+  hash.update(input.format);
+  hash.update("\0");
+  hash.update(input.data ?? "");
+  return `sha256:${hash.digest("hex")}`;
+}
+function buildMarkdownDelta(args) {
+  const { lastSnapshot, deltasSinceSnapshot, nextContents } = args;
+  const latestDelta = deltasSinceSnapshot.at(-1);
+  const prior = pickStringValue(readSignalValue(latestDelta)) ?? pickStringValue(readSignalValue(lastSnapshot)) ?? (typeof lastSnapshot?.contents === "string" ? lastSnapshot.contents : void 0);
+  if (!prior) return;
+  const patch = renderHunksOnly(prior, nextContents);
+  return { contents: patch };
+}
+function pickStringValue(value) {
+  return typeof value === "string" ? value : void 0;
+}
+function readSignalValue(signal) {
+  return signal?.metadata?.value;
+}
+function renderHunksOnly(prior, next) {
+  const { hunks } = structuredPatch("", "", prior, next, "", "", { context: 0 });
+  return hunks.map((hunk) => {
+    const header = `@@ -${hunk.oldStart},${hunk.oldLines} +${hunk.newStart},${hunk.newLines} @@`;
+    const lines = hunk.lines.filter((line) => !line.startsWith("\"));
+    return [header, ...lines].join("\n");
+  }).join("\n");
+}
+
+export { WORKING_MEMORY_STATE_ID, WORKING_MEMORY_STATE_PROCESSOR_ID, WorkingMemoryStateProcessor, stableWorkingMemoryCacheKey };
+//# sourceMappingURL=chunk-WCGXQIEN.js.map
+//# sourceMappingURL=chunk-WCGXQIEN.js.map

package/dist/chunk-WCGXQIEN.js.map

@@ -0,0 +1 @@
+{"version":3,"sources":["../src/processors/working-memory-state/processor.ts"],"names":[],"mappings":"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","file":"chunk-WCGXQIEN.js","sourcesContent":["/**\n * WorkingMemoryStateProcessor\n *\n * Experimental: delivers working memory to the model as a state signal instead\n * of folding it into the system message. Storage and the `setWorkingMemory`\n * tool are unchanged — this processor only changes the delivery path.\n *\n * Pattern matches `BrowserContextProcessor` in `@mastra/core/browser`:\n * - `stateId` namespaces the state lane on the thread.\n * - `cacheKey` is derived from the rendered payload so dedup is automatic.\n * - `contextWindow.hasSnapshot` re-injection ensures the model still sees the\n *   current snapshot after older messages drop out of the window.\n *\n * Delta emission (markdown mode only): when a prior snapshot exists in the\n * context window, the processor emits a unified-diff delta against that\n * snapshot's contents. Schema mode and the snapshot fallback always emit a\n * full snapshot.\n *\n * @example\n * ```ts\n * new Memory({\n *   options: {\n *     workingMemory: {\n *       enabled: true,\n *       template: '...',\n *       useStateSignals: true, // auto-attaches this processor\n *     },\n *   },\n * });\n * ```\n */\n\nimport { createHash } from 'node:crypto';\n\nimport type { MastraMemory, MemoryConfigInternal, WorkingMemoryTemplate } from '@mastra/core/memory';\nimport type {\n  ComputeStateSignalArgs,\n  ComputeStateSignalResult,\n  Processor,\n  ProcessorActiveStateSignal,\n} from '@mastra/core/processors';\nimport { structuredPatch } from 'diff';\n\nexport const WORKING_MEMORY_STATE_ID = 'working-memory';\nexport const WORKING_MEMORY_STATE_PROCESSOR_ID = 'working-memory-state';\n\nexport class WorkingMemoryStateProcessor implements Processor<typeof WORKING_MEMORY_STATE_PROCESSOR_ID> {\n  readonly id = WORKING_MEMORY_STATE_PROCESSOR_ID;\n  readonly stateId = WORKING_MEMORY_STATE_ID;\n\n  constructor(\n    private readonly memory: MastraMemory,\n    private readonly memoryConfig?: MemoryConfigInternal,\n  ) {}\n\n  async computeStateSignal(args: ComputeStateSignalArgs): Promise<ComputeStateSignalResult> {\n    const template = await this.memory.getWorkingMemoryTemplate({ memoryConfig: this.memoryConfig });\n    if (!template) return;\n\n    const data = await this.memory.getWorkingMemory({\n      threadId: args.threadId,\n      resourceId: args.resourceId,\n      memoryConfig: this.memoryConfig,\n    });\n\n    // Nothing stored yet — no state to broadcast. The setWorkingMemory tool\n    // description tells the model the expected shape; the signal carries state.\n    const contents = data?.trim();\n    if (!contents) return;\n\n    const cacheKey = stableWorkingMemoryCacheKey({ format: template.format, data: contents });\n    const shouldMakeSnapshot = !args.contextWindow.hasSnapshot;\n    if (args.tracking?.currentCacheKey === cacheKey && !shouldMakeSnapshot) return;\n\n    const mergedConfig = this.memory.getMergedThreadConfig(this.memoryConfig);\n    const scope = mergedConfig.workingMemory?.scope ?? 'resource';\n\n    const deltaCandidate =\n      template.format === 'markdown' && !shouldMakeSnapshot\n        ? buildMarkdownDelta({\n            lastSnapshot: args.lastSnapshot,\n            deltasSinceSnapshot: args.deltasSinceSnapshot,\n            nextContents: contents,\n          })\n        : undefined;\n\n    if (deltaCandidate) {\n      return {\n        id: WORKING_MEMORY_STATE_ID,\n        mode: 'delta',\n        cacheKey,\n        tagName: 'working-memory',\n        contents: deltaCandidate.contents,\n        delta: deltaCandidate.contents,\n        // Stash the full post-edit text on the signal so the next turn can\n        // diff against the most recently emitted state instead of the older\n        // snapshot. Invisible to the model.\n        value: contents,\n        attributes: {\n          format: template.format,\n          scope,\n          patch: 'unified-diff',\n        },\n      };\n    }\n\n    return {\n      id: WORKING_MEMORY_STATE_ID,\n      mode: 'snapshot',\n      cacheKey,\n      tagName: 'working-memory',\n      contents,\n      // Mirror contents in value so the first delta after a snapshot has a\n      // typed prior-state to diff against without falling back to contents.\n      value: contents,\n      attributes: {\n        format: template.format,\n        scope,\n      },\n    };\n  }\n}\n\n/**\n * Stable cache key for the rendered working memory payload. Returns a SHA-256\n * digest so dedup metadata stays compact regardless of payload size (working\n * memory blobs can grow arbitrarily long).\n */\nexport function stableWorkingMemoryCacheKey(input: {\n  format: WorkingMemoryTemplate['format'];\n  data: string | null;\n}): string {\n  const hash = createHash('sha256');\n  hash.update(input.format);\n  hash.update('\\0');\n  hash.update(input.data ?? '');\n  return `sha256:${hash.digest('hex')}`;\n}\n\n/**\n * Build a unified-diff delta against the most recently emitted state. Prefers\n * the latest delta's `value` (the post-edit full text) when available, falling\n * back to the snapshot's `value` and finally the snapshot's `contents`. This\n * keeps deltas incremental (B→C) instead of cumulative against a stale\n * snapshot (A→C), which matters when many small edits land between snapshots.\n *\n * Returns undefined when:\n * - there's no prior state to diff against\n * - the prior state isn't a plain string (multimodal signal)\n *\n * In either case the caller falls back to emitting a full snapshot.\n */\nfunction buildMarkdownDelta(args: {\n  lastSnapshot?: ProcessorActiveStateSignal;\n  deltasSinceSnapshot: ProcessorActiveStateSignal[];\n  nextContents: string;\n}): { contents: string } | undefined {\n  const { lastSnapshot, deltasSinceSnapshot, nextContents } = args;\n\n  // `value` is stored on the persisted signal's metadata (see applyStateSignal\n  // in @mastra/core/agent/state-signals). Read from there to recover the\n  // post-edit full text from the most recently emitted state.\n  const latestDelta = deltasSinceSnapshot.at(-1);\n  const prior =\n    pickStringValue(readSignalValue(latestDelta)) ??\n    pickStringValue(readSignalValue(lastSnapshot)) ??\n    (typeof lastSnapshot?.contents === 'string' ? lastSnapshot.contents : undefined);\n  ('');\n  if (!prior) return;\n\n  const patch = renderHunksOnly(prior, nextContents);\n\n  return { contents: patch };\n}\n\nfunction pickStringValue(value: unknown): string | undefined {\n  return typeof value === 'string' ? value : undefined;\n}\n\nfunction readSignalValue(signal: ProcessorActiveStateSignal | undefined): unknown {\n  return (signal?.metadata as { value?: unknown } | undefined)?.value;\n}\n\n/**\n * Render a unified-diff-style patch body containing only `@@` hunks and their\n * lines — dropping the filename preamble (`Index:` / `===` / `---` / `+++`)\n * that `createPatch` emits and the `\` trailer.\n * The preamble exists for tooling like `patch -p1` to know which file to\n * apply to; we only ever diff a single working-memory blob. The newline\n * trailer is semantically meaningless to the model and adds noise to the\n * state signal.\n */\nfunction renderHunksOnly(prior: string, next: string): string {\n  const { hunks } = structuredPatch('', '', prior, next, '', '', { context: 0 });\n  return hunks\n    .map(hunk => {\n      const header = `@@ -${hunk.oldStart},${hunk.oldLines} +${hunk.newStart},${hunk.newLines} @@`;\n      const lines = hunk.lines.filter(line => !line.startsWith('\\\'));\n      return [header, ...lines].join('\\n');\n    })\n    .join('\\n');\n}\n"]}

package/dist/constants-DVRTNEGY.js

@@ -0,0 +1,3 @@
+export { OBSERVATIONAL_MEMORY_DEFAULTS, OBSERVATION_CONTEXT_INSTRUCTIONS, OBSERVATION_CONTEXT_PROMPT, OBSERVATION_CONTINUATION_HINT, OBSERVATION_RETRIEVAL_INSTRUCTIONS } from './chunk-LSJJAJAF.js';
+//# sourceMappingURL=constants-DVRTNEGY.js.map
+//# sourceMappingURL=constants-DVRTNEGY.js.map

package/dist/{constants-SPS7MR4D.js.map → constants-DVRTNEGY.js.map}

@@ -1 +1 @@
-{"version":3,"sources":[],"names":[],"mappings":"","file":"constants-SPS7MR4D.js"}
+{"version":3,"sources":[],"names":[],"mappings":"","file":"constants-DVRTNEGY.js"}

package/dist/{constants-D6W7OWCP.cjs → constants-JS5SS7GS.cjs}

@@ -1,28 +1,28 @@
 'use strict';
 
-var chunk3Q3LOVQP_cjs = require('./chunk-3Q3LOVQP.cjs');
+var chunkD4J4XPGM_cjs = require('./chunk-D4J4XPGM.cjs');
 
 
 
 Object.defineProperty(exports, "OBSERVATIONAL_MEMORY_DEFAULTS", {
   enumerable: true,
-  get: function () { return chunk3Q3LOVQP_cjs.OBSERVATIONAL_MEMORY_DEFAULTS; }
+  get: function () { return chunkD4J4XPGM_cjs.OBSERVATIONAL_MEMORY_DEFAULTS; }
 });
 Object.defineProperty(exports, "OBSERVATION_CONTEXT_INSTRUCTIONS", {
   enumerable: true,
-  get: function () { return chunk3Q3LOVQP_cjs.OBSERVATION_CONTEXT_INSTRUCTIONS; }
+  get: function () { return chunkD4J4XPGM_cjs.OBSERVATION_CONTEXT_INSTRUCTIONS; }
 });
 Object.defineProperty(exports, "OBSERVATION_CONTEXT_PROMPT", {
   enumerable: true,
-  get: function () { return chunk3Q3LOVQP_cjs.OBSERVATION_CONTEXT_PROMPT; }
+  get: function () { return chunkD4J4XPGM_cjs.OBSERVATION_CONTEXT_PROMPT; }
 });
 Object.defineProperty(exports, "OBSERVATION_CONTINUATION_HINT", {
   enumerable: true,
-  get: function () { return chunk3Q3LOVQP_cjs.OBSERVATION_CONTINUATION_HINT; }
+  get: function () { return chunkD4J4XPGM_cjs.OBSERVATION_CONTINUATION_HINT; }
 });
 Object.defineProperty(exports, "OBSERVATION_RETRIEVAL_INSTRUCTIONS", {
   enumerable: true,
-  get: function () { return chunk3Q3LOVQP_cjs.OBSERVATION_RETRIEVAL_INSTRUCTIONS; }
+  get: function () { return chunkD4J4XPGM_cjs.OBSERVATION_RETRIEVAL_INSTRUCTIONS; }
 });
-//# sourceMappingURL=constants-D6W7OWCP.cjs.map
-//# sourceMappingURL=constants-D6W7OWCP.cjs.map
+//# sourceMappingURL=constants-JS5SS7GS.cjs.map
+//# sourceMappingURL=constants-JS5SS7GS.cjs.map

package/dist/{constants-D6W7OWCP.cjs.map → constants-JS5SS7GS.cjs.map}

@@ -1 +1 @@
-{"version":3,"sources":[],"names":[],"mappings":"","file":"constants-D6W7OWCP.cjs"}
+{"version":3,"sources":[],"names":[],"mappings":"","file":"constants-JS5SS7GS.cjs"}

package/dist/docs/SKILL.md

@@ -3,7 +3,7 @@ name: mastra-memory
 description: Documentation for @mastra/memory. Use when working with @mastra/memory APIs, configuration, or implementation.
 metadata:
   package: "@mastra/memory"
-  version: "1.20.1"
+  version: "1.20.2"
 ---
 
 ## When to use

package/dist/docs/assets/SOURCE_MAP.json

@@ -1,136 +1,149 @@
 {
-  "version": "1.20.1",
+  "version": "1.20.2",
   "package": "@mastra/memory",
   "exports": {
     "ModelByInputTokens": {
       "types": "dist/processors/index.d.ts",
-      "implementation": "dist/chunk-KMJQDCCZ.js",
+      "implementation": "dist/chunk-SXFOZU7K.js",
       "line": 787
     },
     "OBSERVER_SYSTEM_PROMPT": {
       "types": "dist/processors/index.d.ts",
-      "implementation": "dist/chunk-KMJQDCCZ.js"
+      "implementation": "dist/chunk-SXFOZU7K.js"
     },
     "ObservationalMemory": {
       "types": "dist/processors/index.d.ts",
-      "implementation": "dist/chunk-KMJQDCCZ.js",
+      "implementation": "dist/chunk-SXFOZU7K.js",
       "line": 7175
     },
     "ObservationalMemoryProcessor": {
       "types": "dist/processors/index.d.ts",
-      "implementation": "dist/chunk-KMJQDCCZ.js",
+      "implementation": "dist/chunk-SXFOZU7K.js",
       "line": 9747
     },
     "TokenCounter": {
       "types": "dist/processors/index.d.ts",
-      "implementation": "dist/chunk-KMJQDCCZ.js",
+      "implementation": "dist/chunk-SXFOZU7K.js",
       "line": 6506
     },
     "buildObserverPrompt": {
       "types": "dist/processors/index.d.ts",
-      "implementation": "dist/chunk-KMJQDCCZ.js",
+      "implementation": "dist/chunk-SXFOZU7K.js",
       "line": 3774
     },
     "buildObserverSystemPrompt": {
       "types": "dist/processors/index.d.ts",
-      "implementation": "dist/chunk-KMJQDCCZ.js",
+      "implementation": "dist/chunk-SXFOZU7K.js",
       "line": 3045
     },
     "combineObservationGroupRanges": {
       "types": "dist/processors/index.d.ts",
-      "implementation": "dist/chunk-KMJQDCCZ.js",
+      "implementation": "dist/chunk-SXFOZU7K.js",
       "line": 879
     },
     "deriveObservationGroupProvenance": {
       "types": "dist/processors/index.d.ts",
-      "implementation": "dist/chunk-KMJQDCCZ.js",
+      "implementation": "dist/chunk-SXFOZU7K.js",
       "line": 913
     },
     "extractCurrentTask": {
       "types": "dist/processors/index.d.ts",
-      "implementation": "dist/chunk-KMJQDCCZ.js",
+      "implementation": "dist/chunk-SXFOZU7K.js",
       "line": 3888
     },
     "formatMessagesForObserver": {
       "types": "dist/processors/index.d.ts",
-      "implementation": "dist/chunk-KMJQDCCZ.js",
+      "implementation": "dist/chunk-SXFOZU7K.js",
       "line": 3500
     },
     "getObservationsAsOf": {
       "types": "dist/processors/index.d.ts",
-      "implementation": "dist/chunk-KMJQDCCZ.js",
+      "implementation": "dist/chunk-SXFOZU7K.js",
       "line": 9960
     },
     "hasCurrentTaskSection": {
       "types": "dist/processors/index.d.ts",
-      "implementation": "dist/chunk-KMJQDCCZ.js",
+      "implementation": "dist/chunk-SXFOZU7K.js",
       "line": 3876
     },
     "injectAnchorIds": {
       "types": "dist/processors/index.d.ts",
-      "implementation": "dist/chunk-KMJQDCCZ.js",
+      "implementation": "dist/chunk-SXFOZU7K.js",
       "line": 2593
     },
     "optimizeObservationsForContext": {
       "types": "dist/processors/index.d.ts",
-      "implementation": "dist/chunk-KMJQDCCZ.js",
+      "implementation": "dist/chunk-SXFOZU7K.js",
       "line": 3899
     },
     "parseAnchorId": {
       "types": "dist/processors/index.d.ts",
-      "implementation": "dist/chunk-KMJQDCCZ.js",
+      "implementation": "dist/chunk-SXFOZU7K.js",
       "line": 2566
     },
     "parseObservationGroups": {
       "types": "dist/processors/index.d.ts",
-      "implementation": "dist/chunk-KMJQDCCZ.js",
+      "implementation": "dist/chunk-SXFOZU7K.js",
       "line": 848
     },
     "parseObserverOutput": {
       "types": "dist/processors/index.d.ts",
-      "implementation": "dist/chunk-KMJQDCCZ.js",
+      "implementation": "dist/chunk-SXFOZU7K.js",
       "line": 3784
     },
     "reconcileObservationGroupsFromReflection": {
       "types": "dist/processors/index.d.ts",
-      "implementation": "dist/chunk-KMJQDCCZ.js",
+      "implementation": "dist/chunk-SXFOZU7K.js",
       "line": 937
     },
     "renderObservationGroupsForReflection": {
       "types": "dist/processors/index.d.ts",
-      "implementation": "dist/chunk-KMJQDCCZ.js",
+      "implementation": "dist/chunk-SXFOZU7K.js",
       "line": 893
     },
     "stripEphemeralAnchorIds": {
       "types": "dist/processors/index.d.ts",
-      "implementation": "dist/chunk-KMJQDCCZ.js",
+      "implementation": "dist/chunk-SXFOZU7K.js",
       "line": 2623
     },
     "stripObservationGroups": {
       "types": "dist/processors/index.d.ts",
-      "implementation": "dist/chunk-KMJQDCCZ.js",
+      "implementation": "dist/chunk-SXFOZU7K.js",
       "line": 870
     },
     "wrapInObservationGroup": {
       "types": "dist/processors/index.d.ts",
-      "implementation": "dist/chunk-KMJQDCCZ.js",
+      "implementation": "dist/chunk-SXFOZU7K.js",
       "line": 841
     },
     "OBSERVATIONAL_MEMORY_DEFAULTS": {
       "types": "dist/processors/index.d.ts",
-      "implementation": "dist/chunk-VKRZ3O5X.js"
+      "implementation": "dist/chunk-LSJJAJAF.js"
     },
     "OBSERVATION_CONTEXT_INSTRUCTIONS": {
       "types": "dist/processors/index.d.ts",
-      "implementation": "dist/chunk-VKRZ3O5X.js"
+      "implementation": "dist/chunk-LSJJAJAF.js"
     },
     "OBSERVATION_CONTEXT_PROMPT": {
       "types": "dist/processors/index.d.ts",
-      "implementation": "dist/chunk-VKRZ3O5X.js"
+      "implementation": "dist/chunk-LSJJAJAF.js"
     },
     "OBSERVATION_CONTINUATION_HINT": {
       "types": "dist/processors/index.d.ts",
-      "implementation": "dist/chunk-VKRZ3O5X.js"
+      "implementation": "dist/chunk-LSJJAJAF.js"
+    },
+    "WORKING_MEMORY_STATE_ID": {
+      "types": "dist/index.d.ts",
+      "implementation": "dist/chunk-WCGXQIEN.js"
+    },
+    "WORKING_MEMORY_STATE_PROCESSOR_ID": {
+      "types": "dist/index.d.ts",
+      "implementation": "dist/chunk-WCGXQIEN.js"
+    },
+    "WorkingMemoryStateProcessor": {
+      "types": "dist/index.d.ts",
+      "implementation": "dist/chunk-WCGXQIEN.js",
+      "line": 7
     },
     "MessageHistory": {
       "types": "dist/index.d.ts",
@@ -149,8 +162,8 @@
     "processors": {
       "index": "dist/processors/index.js",
       "chunks": [
-        "chunk-KMJQDCCZ.js",
-        "chunk-VKRZ3O5X.js"
+        "chunk-SXFOZU7K.js",
+        "chunk-LSJJAJAF.js"
       ]
     }
   }

package/dist/docs/references/docs-memory-multi-user-threads.md

@@ -135,7 +135,7 @@ const memory = new Memory({
 
 The model reads identity from the `<turn>` tag on the current message and from prior tagged messages brought back through `lastMessages`.
 
-### With observational memory (recommended)
+### With Observational Memory (recommended)
 
 [Observational Memory](https://mastra.ai/docs/memory/observational-memory) (OM) extracts per-user facts into a background log without burning the agent's tool budget. The default Observer model reads `<turn>` tags natively and produces named attribution like `Alice stated her favorite color is teal.` and `Bob asked for QA sign-off before publish.`
 

package/dist/docs/references/docs-memory-working-memory.md

@@ -393,6 +393,33 @@ const response = await agent.generate('What do you know about me?', {
 })
 ```
 
+## Opt in to state signals (experimental)
+
+By default, working memory reaches the model as part of the system message. You can opt into delivering it as a [state signal](https://mastra.ai/docs/agents/signals) instead by setting `useStateSignals: true`:
+
+```typescript
+const memory = new Memory({
+  storage: new LibSQLStore({ url: 'file:./mastra.db' }),
+  options: {
+    workingMemory: {
+      enabled: true,
+      template: '# User\n- name:\n- location:',
+      useStateSignals: true, // experimental: deliver as state signal
+    },
+  },
+})
+```
+
+What changes:
+
+- **Storage is identical.** The same resource/thread `workingMemory` field is read and written.
+- **The tool is the same shape, exposed under a new name.** Writes still flow through the same underlying tool; on this path it is registered as `setWorkingMemory` (instead of `updateWorkingMemory`). The rename keeps legacy strip filters from removing tool-call parts so they persist as a normal audit trail and the next model step picks the new value up automatically.
+- **Delivery only.** Instead of folding into the system prompt, `Memory` auto-attaches a `WorkingMemoryStateProcessor` that emits the current working memory as a `state` signal with `stateId: 'working-memory'`.
+
+You inherit the standard state-signal benefits: thread-scoped tracking metadata, `cacheKey` dedup so identical snapshots are only emitted once, and `contextWindow.hasSnapshot` re-injection when an older snapshot rolls out of the window.
+
+The default (`useStateSignals: false`) keeps the existing system-message behavior unchanged. `useStateSignals` is not supported with template working memory `version: 'vnext'`.
+
 ## Examples
 
 - [Working memory with template](https://github.com/mastra-ai/mastra/tree/main/examples/memory-with-template)

package/dist/docs/references/reference-storage-libsql.md

@@ -93,6 +93,12 @@ storage: new LibSQLStore({
 
 **authToken** (`string`): Authentication token for remote libSQL databases.
 
+## Managed tables
+
+The storage implementation creates the core storage tables automatically, including `mastra_notifications` for notification inbox records and delivery metadata.
+
+`LibSQLStore` exposes notification storage through `getStore('notifications')`.
+
 ## Initialization
 
 When you pass storage to the Mastra class, `init()` is called automatically to create the [core schema](https://mastra.ai/reference/storage/overview):

package/dist/docs/references/reference-storage-mongodb.md

@@ -97,6 +97,9 @@ The storage implementation handles collection creation and management automatica
 - `mastra_traces`: Stores telemetry and tracing data
 - `mastra_scorers`: Stores scoring and evaluation data
 - `mastra_resources`: Stores resource working memory data
+- `mastra_notifications`: Stores notification inbox records and delivery metadata
+
+`MongoDBStore` exposes notification storage through `getStore('notifications')`.
 
 ### Initialization
 

package/dist/docs/references/reference-storage-postgresql.md

@@ -132,6 +132,9 @@ The storage implementation handles schema creation and updates automatically. It
 - `mastra_traces`: Stores telemetry and tracing data
 - `mastra_scorers`: Stores scoring and evaluation data
 - `mastra_resources`: Stores resource working memory data
+- `mastra_notifications`: Stores notification inbox records and delivery metadata
+
+`PostgresStore` exposes notification storage through `getStore('notifications')`.
 
 ### Observability