@mastra/core 1.2.1-alpha.0 → 1.3.0-alpha.2

package/dist/{chunk-VX7UA3SO.js → chunk-MOOJ3H3C.js}

@@ -1,8 +1,8 @@
-import { MessageList } from './chunk-Z6NRYYOH.js';
-import { TABLE_SCHEMAS, TABLE_SCORERS, listTracesArgsSchema, toTraceSpans, TABLE_WORKFLOW_SNAPSHOT } from './chunk-MNWW2R3U.js';
-import { deepEqual } from './chunk-T6PRRKMW.js';
+import { MessageList } from './chunk-ILQXPZCD.js';
+import { TABLE_SCHEMAS, TABLE_SCORERS, listTracesArgsSchema, toTraceSpans, TABLE_WORKFLOW_SNAPSHOT } from './chunk-OV7OOUUR.js';
+import { deepEqual } from './chunk-ZHFM7HCQ.js';
 import { MastraError } from './chunk-FJEVLHJT.js';
-import { MastraBase } from './chunk-JIT2OY3X.js';
+import { MastraBase } from './chunk-WCAFTXGK.js';
 
 // src/storage/base.ts
 function normalizePerPage(perPageInput, defaultValue) {
@@ -58,7 +58,9 @@ var MastraCompositeStore = class extends MastraBase {
         workflows: domainOverrides.workflows ?? defaultStores?.workflows,
         scores: domainOverrides.scores ?? defaultStores?.scores,
         observability: domainOverrides.observability ?? defaultStores?.observability,
-        agents: domainOverrides.agents ?? defaultStores?.agents
+        agents: domainOverrides.agents ?? defaultStores?.agents,
+        promptBlocks: domainOverrides.promptBlocks ?? defaultStores?.promptBlocks,
+        scorerDefinitions: domainOverrides.scorerDefinitions ?? defaultStores?.scorerDefinitions
       };
     }
   }
@@ -103,6 +105,12 @@ var MastraCompositeStore = class extends MastraBase {
     if (this.stores?.agents) {
       initTasks.push(this.stores.agents.init());
     }
+    if (this.stores?.promptBlocks) {
+      initTasks.push(this.stores.promptBlocks.init());
+    }
+    if (this.stores?.scorerDefinitions) {
+      initTasks.push(this.stores.scorerDefinitions.init());
+    }
     this.hasInitialized = Promise.all(initTasks).then(() => true);
     await this.hasInitialized;
   }
@@ -121,12 +129,12 @@ var StorageDomain = class extends MastraBase {
   }
 };
 
-// src/storage/domains/agents/base.ts
-var AGENT_ORDER_BY_SET = {
+// src/storage/domains/versioned.ts
+var ENTITY_ORDER_BY_SET = {
   createdAt: true,
   updatedAt: true
 };
-var AGENT_SORT_DIRECTION_SET = {
+var SORT_DIRECTION_SET = {
   ASC: true,
   DESC: true
 };
@@ -134,119 +142,106 @@ var VERSION_ORDER_BY_SET = {
   versionNumber: true,
   createdAt: true
 };
-var AgentsStorage = class extends StorageDomain {
-  constructor() {
-    super({
-      component: "STORAGE",
-      name: "AGENTS"
-    });
+var VersionedStorageDomain = class extends StorageDomain {
+  // ==========================================================================
+  // Concrete resolution methods
+  // ==========================================================================
+  /**
+   * Strips version metadata fields from a version row, leaving only snapshot config fields.
+   */
+  extractSnapshotConfig(version) {
+    const result = {};
+    const metadataSet = new Set(this.versionMetadataFields);
+    for (const [key, value] of Object.entries(version)) {
+      if (!metadataSet.has(key)) {
+        result[key] = value;
+      }
+    }
+    return result;
   }
   /**
-   * Retrieves an agent by its unique identifier, resolving config from the active version.
-   * This is the preferred method for fetching stored agents as it ensures the returned
-   * configuration matches the active version.
-   *
-   * @param id - The unique identifier of the agent
-   * @returns The resolved agent (metadata + version config), or null if not found
+   * Resolves an entity by merging its thin record with the active (or latest) version config.
    */
-  async getAgentByIdResolved({ id }) {
-    const agent = await this.getAgentById({ id });
-    if (!agent) {
+  async getByIdResolved(id) {
+    const entity = await this.getById(id);
+    if (!entity) {
       return null;
     }
+    return this.resolveEntity(entity);
+  }
+  /**
+   * Lists entities with version resolution.
+   */
+  async listResolved(args) {
+    const result = await this.list(args);
+    const entities = result[this.listKey];
+    const resolved = await Promise.all(entities.map((entity) => this.resolveEntity(entity)));
+    return {
+      ...result,
+      [this.listKey]: resolved
+    };
+  }
+  /**
+   * Resolves a single entity by merging it with its active or latest version.
+   */
+  async resolveEntity(entity) {
     let version = null;
-    if (agent.activeVersionId) {
-      version = await this.getVersion(agent.activeVersionId);
+    if (entity.activeVersionId) {
+      version = await this.getVersion(entity.activeVersionId);
       if (!version) {
-        console.warn(
-          `[AgentsStorage] Agent ${agent.id} has activeVersionId ${agent.activeVersionId} but version not found. Falling back to latest version.`
+        this.logger?.warn?.(
+          `Entity ${entity.id} has activeVersionId ${entity.activeVersionId} but version not found. Falling back to latest version.`
         );
       }
     }
     if (!version) {
-      version = await this.getLatestVersion(agent.id);
+      version = await this.getLatestVersion(entity.id);
     }
     if (version) {
-      const {
-        id: _versionId,
-        agentId: _agentId,
-        versionNumber: _versionNumber,
-        changedFields: _changedFields,
-        changeMessage: _changeMessage,
-        createdAt: _createdAt,
-        ...snapshotConfig
-      } = version;
+      const snapshotConfig = this.extractSnapshotConfig(version);
       return {
-        ...agent,
+        ...entity,
         ...snapshotConfig
       };
     }
-    return agent;
-  }
-  /**
-   * Lists all agents with version resolution.
-   * For each agent that has an activeVersionId, the config is resolved from the version.
-   *
-   * @param args - Pagination and ordering options
-   * @returns Paginated list of resolved agents
-   */
-  async listAgentsResolved(args) {
-    const result = await this.listAgents(args);
-    const resolvedAgents = await Promise.all(
-      result.agents.map(async (agent) => {
-        let version = null;
-        if (agent.activeVersionId) {
-          version = await this.getVersion(agent.activeVersionId);
-        }
-        if (!version) {
-          version = await this.getLatestVersion(agent.id);
-        }
-        if (version) {
-          const {
-            id: _versionId,
-            agentId: _agentId,
-            versionNumber: _versionNumber,
-            changedFields: _changedFields,
-            changeMessage: _changeMessage,
-            createdAt: _createdAt,
-            ...snapshotConfig
-          } = version;
-          return {
-            ...agent,
-            ...snapshotConfig
-          };
-        }
-        return agent;
-      })
-    );
-    return {
-      ...result,
-      agents: resolvedAgents
-    };
+    return entity;
   }
   // ==========================================================================
   // Protected Helper Methods
   // ==========================================================================
-  /**
-   * Parses orderBy input for consistent agent sorting behavior.
-   */
   parseOrderBy(orderBy, defaultDirection = "DESC") {
     return {
-      field: orderBy?.field && orderBy.field in AGENT_ORDER_BY_SET ? orderBy.field : "createdAt",
-      direction: orderBy?.direction && orderBy.direction in AGENT_SORT_DIRECTION_SET ? orderBy.direction : defaultDirection
+      field: orderBy?.field && orderBy.field in ENTITY_ORDER_BY_SET ? orderBy.field : "createdAt",
+      direction: orderBy?.direction && orderBy.direction in SORT_DIRECTION_SET ? orderBy.direction : defaultDirection
     };
   }
-  /**
-   * Parses orderBy input for consistent version sorting behavior.
-   */
   parseVersionOrderBy(orderBy, defaultDirection = "DESC") {
     return {
       field: orderBy?.field && orderBy.field in VERSION_ORDER_BY_SET ? orderBy.field : "versionNumber",
-      direction: orderBy?.direction && orderBy.direction in AGENT_SORT_DIRECTION_SET ? orderBy.direction : defaultDirection
+      direction: orderBy?.direction && orderBy.direction in SORT_DIRECTION_SET ? orderBy.direction : defaultDirection
     };
   }
 };
 
+// src/storage/domains/agents/base.ts
+var AgentsStorage = class extends VersionedStorageDomain {
+  listKey = "agents";
+  versionMetadataFields = [
+    "id",
+    "agentId",
+    "versionNumber",
+    "changedFields",
+    "changeMessage",
+    "createdAt"
+  ];
+  constructor() {
+    super({
+      component: "STORAGE",
+      name: "AGENTS"
+    });
+  }
+};
+
 // src/storage/domains/agents/inmemory.ts
 var InMemoryAgentsStorage = class extends AgentsStorage {
   db;
@@ -261,13 +256,14 @@ var InMemoryAgentsStorage = class extends AgentsStorage {
   // ==========================================================================
   // Agent CRUD Methods
   // ==========================================================================
-  async getAgentById({ id }) {
-    this.logger.debug(`InMemoryAgentsStorage: getAgentById called for ${id}`);
+  async getById(id) {
+    this.logger.debug(`InMemoryAgentsStorage: getById called for ${id}`);
     const agent = this.db.agents.get(id);
     return agent ? this.deepCopyAgent(agent) : null;
   }
-  async createAgent({ agent }) {
-    this.logger.debug(`InMemoryAgentsStorage: createAgent called for ${agent.id}`);
+  async create(input) {
+    const { agent } = input;
+    this.logger.debug(`InMemoryAgentsStorage: create called for ${agent.id}`);
     if (this.db.agents.has(agent.id)) {
       throw new Error(`Agent with id ${agent.id} already exists`);
     }
@@ -294,8 +290,9 @@ var InMemoryAgentsStorage = class extends AgentsStorage {
     });
     return this.deepCopyAgent(newAgent);
   }
-  async updateAgent({ id, ...updates }) {
-    this.logger.debug(`InMemoryAgentsStorage: updateAgent called for ${id}`);
+  async update(input) {
+    const { id, ...updates } = input;
+    this.logger.debug(`InMemoryAgentsStorage: update called for ${id}`);
     const existingAgent = this.db.agents.get(id);
     if (!existingAgent) {
       throw new Error(`Agent with id ${id} not found`);
@@ -343,36 +340,41 @@ var InMemoryAgentsStorage = class extends AgentsStorage {
         createdAt: _createdAt,
         ...latestConfig
       } = latestVersion;
+      const sanitizedConfigFields = Object.fromEntries(
+        Object.entries(configFields).map(([key, value]) => [key, value === null ? void 0 : value])
+      );
       const newConfig = {
         ...latestConfig,
-        ...configFields
+        ...sanitizedConfigFields
       };
       const changedFields = configFieldNames.filter(
-        (field) => field in configFields && configFields[field] !== latestConfig[field]
+        (field) => field in configFields && JSON.stringify(configFields[field]) !== JSON.stringify(latestConfig[field])
       );
-      const newVersionId = crypto.randomUUID();
-      const newVersionNumber = latestVersion.versionNumber + 1;
-      await this.createVersion({
-        id: newVersionId,
-        agentId: id,
-        versionNumber: newVersionNumber,
-        ...newConfig,
-        changedFields,
-        changeMessage: `Updated ${changedFields.join(", ")}`
-      });
+      if (changedFields.length > 0) {
+        const newVersionId = crypto.randomUUID();
+        const newVersionNumber = latestVersion.versionNumber + 1;
+        await this.createVersion({
+          id: newVersionId,
+          agentId: id,
+          versionNumber: newVersionNumber,
+          ...newConfig,
+          changedFields,
+          changeMessage: `Updated ${changedFields.join(", ")}`
+        });
+      }
     }
     this.db.agents.set(id, updatedAgent);
     return this.deepCopyAgent(updatedAgent);
   }
-  async deleteAgent({ id }) {
-    this.logger.debug(`InMemoryAgentsStorage: deleteAgent called for ${id}`);
+  async delete(id) {
+    this.logger.debug(`InMemoryAgentsStorage: delete called for ${id}`);
     this.db.agents.delete(id);
-    await this.deleteVersionsByAgentId(id);
+    await this.deleteVersionsByParentId(id);
   }
-  async listAgents(args) {
+  async list(args) {
     const { page = 0, perPage: perPageInput, orderBy, authorId, metadata } = args || {};
     const { field, direction } = this.parseOrderBy(orderBy);
-    this.logger.debug(`InMemoryAgentsStorage: listAgents called`);
+    this.logger.debug(`InMemoryAgentsStorage: list called`);
     const perPage = normalizePerPage(perPageInput, 100);
     if (page < 0) {
       throw new Error("page must be >= 0");
@@ -478,11 +480,11 @@ var InMemoryAgentsStorage = class extends AgentsStorage {
     this.logger.debug(`InMemoryAgentsStorage: deleteVersion called for ${id}`);
     this.db.agentVersions.delete(id);
   }
-  async deleteVersionsByAgentId(agentId) {
-    this.logger.debug(`InMemoryAgentsStorage: deleteVersionsByAgentId called for agent ${agentId}`);
+  async deleteVersionsByParentId(entityId) {
+    this.logger.debug(`InMemoryAgentsStorage: deleteVersionsByParentId called for agent ${entityId}`);
     const idsToDelete = [];
     for (const [id, version] of this.db.agentVersions.entries()) {
-      if (version.agentId === agentId) {
+      if (version.agentId === entityId) {
         idsToDelete.push(id);
       }
     }
@@ -516,20 +518,7 @@ var InMemoryAgentsStorage = class extends AgentsStorage {
    * Deep copy a version to prevent external mutation of stored data
    */
   deepCopyVersion(version) {
-    return {
-      ...version,
-      model: { ...version.model },
-      tools: version.tools ? [...version.tools] : version.tools,
-      defaultOptions: version.defaultOptions ? { ...version.defaultOptions } : version.defaultOptions,
-      workflows: version.workflows ? [...version.workflows] : version.workflows,
-      agents: version.agents ? [...version.agents] : version.agents,
-      integrationTools: version.integrationTools ? [...version.integrationTools] : version.integrationTools,
-      inputProcessors: version.inputProcessors ? [...version.inputProcessors] : version.inputProcessors,
-      outputProcessors: version.outputProcessors ? [...version.outputProcessors] : version.outputProcessors,
-      memory: version.memory ? { ...version.memory } : version.memory,
-      scorers: version.scorers ? { ...version.scorers } : version.scorers,
-      changedFields: version.changedFields ? [...version.changedFields] : version.changedFields
-    };
+    return structuredClone(version);
   }
   sortAgents(agents, field, direction) {
     return agents.sort((a, b) => {
@@ -564,6 +553,10 @@ var InMemoryDB = class {
   traces = /* @__PURE__ */ new Map();
   agents = /* @__PURE__ */ new Map();
   agentVersions = /* @__PURE__ */ new Map();
+  promptBlocks = /* @__PURE__ */ new Map();
+  promptBlockVersions = /* @__PURE__ */ new Map();
+  scorerDefinitions = /* @__PURE__ */ new Map();
+  scorerDefinitionVersions = /* @__PURE__ */ new Map();
   /** Observational memory records, keyed by resourceId, each holding array of records (generations) */
   observationalMemory = /* @__PURE__ */ new Map();
   /**
@@ -579,6 +572,10 @@ var InMemoryDB = class {
     this.traces.clear();
     this.agents.clear();
     this.agentVersions.clear();
+    this.promptBlocks.clear();
+    this.promptBlockVersions.clear();
+    this.scorerDefinitions.clear();
+    this.scorerDefinitionVersions.clear();
     this.observationalMemory.clear();
   }
 };
@@ -847,40 +844,29 @@ var MemoryStorage = class extends StorageDomain {
     throw new Error(`Observational memory is not implemented by this storage adapter (${this.constructor.name}).`);
   }
   // ============================================
-  // Buffering Methods (DISABLED - not currently used)
-  // These methods were designed for async observation buffering
-  // which has been disabled. Keeping commented for future reference.
+  // Buffering Methods (for async observation/reflection)
+  // These methods support async buffering when `bufferTokens` is configured.
   // ============================================
-  // /**
-  //  * Update buffered observations.
-  //  * Called when observations are created asynchronously.
-  //  */
-  // async updateBufferedObservations(_input: UpdateBufferedObservationsInput): Promise<void> {
-  //   throw new Error(`Observational memory is not implemented by this storage adapter (${this.constructor.name}).`);
-  // }
-  // /**
-  //  * Swap buffered observations to active.
-  //  * Atomic operation that:
-  //  * 1. Moves bufferedObservations → activeObservations
-  //  * 2. Moves bufferedMessageIds → observedMessageIds
-  //  * 3. Clears buffered state
-  //  */
-  // async swapBufferedToActive(_id: string): Promise<void> {
-  //   throw new Error(`Observational memory is not implemented by this storage adapter (${this.constructor.name}).`);
-  // }
-  // /**
-  //  * Mark messages as currently being observed (in-flight).
-  //  */
-  // async markMessagesAsBuffering(_id: string, _messageIds: string[]): Promise<void> {
-  //   throw new Error(`Observational memory is not implemented by this storage adapter (${this.constructor.name}).`);
-  // }
-  // /**
-  //  * Mark messages as buffered (observation complete but not active).
-  //  * Moves messageIds from bufferingMessageIds → bufferedMessageIds.
-  //  */
-  // async markMessagesAsBuffered(_id: string, _messageIds: string[]): Promise<void> {
-  //   throw new Error(`Observational memory is not implemented by this storage adapter (${this.constructor.name}).`);
-  // }
+  /**
+   * Update buffered observations.
+   * Called when observations are created asynchronously via `bufferTokens`.
+   */
+  async updateBufferedObservations(_input) {
+    throw new Error(`Observational memory is not implemented by this storage adapter (${this.constructor.name}).`);
+  }
+  /**
+   * Swap buffered observations to active.
+   * Atomic operation that:
+   * 1. Appends bufferedObservations → activeObservations (based on activationRatio)
+   * 2. Moves activated bufferedMessageIds → observedMessageIds
+   * 3. Keeps remaining buffered content if activationRatio < 100
+   * 4. Updates lastObservedAt
+   *
+   * Returns info about what was activated for UI feedback.
+   */
+  async swapBufferedToActive(_input) {
+    throw new Error(`Observational memory is not implemented by this storage adapter (${this.constructor.name}).`);
+  }
   /**
    * Create a new generation from a reflection.
    * Creates a new record with:
@@ -891,19 +877,21 @@ var MemoryStorage = class extends StorageDomain {
   async createReflectionGeneration(_input) {
     throw new Error(`Observational memory is not implemented by this storage adapter (${this.constructor.name}).`);
   }
-  // /**
-  //  * Update buffered reflection (async reflection in progress).
-  //  */
-  // async updateBufferedReflection(_id: string, _reflection: string): Promise<void> {
-  //   throw new Error(`Observational memory is not implemented by this storage adapter (${this.constructor.name}).`);
-  // }
-  // /**
-  //  * Swap buffered reflection to active observations.
-  //  * Creates a new generation and makes it the active one.
-  //  */
-  // async swapReflectionToActive(_id: string): Promise<ObservationalMemoryRecord> {
-  //   throw new Error(`Observational memory is not implemented by this storage adapter (${this.constructor.name}).`);
-  // }
+  /**
+   * Update buffered reflection (async reflection in progress).
+   * Called when reflection runs asynchronously via `bufferTokens`.
+   */
+  async updateBufferedReflection(_input) {
+    throw new Error(`Observational memory is not implemented by this storage adapter (${this.constructor.name}).`);
+  }
+  /**
+   * Swap buffered reflection to active observations.
+   * Creates a new generation where activeObservations = bufferedReflection + unreflected observations.
+   * The `tokenCount` in input is the processor-computed token count for the combined content.
+   */
+  async swapBufferedReflectionToActive(_input) {
+    throw new Error(`Observational memory is not implemented by this storage adapter (${this.constructor.name}).`);
+  }
   /**
    * Set the isReflecting flag.
    */
@@ -916,6 +904,23 @@ var MemoryStorage = class extends StorageDomain {
   async setObservingFlag(_id, _isObserving) {
     throw new Error(`Observational memory is not implemented by this storage adapter (${this.constructor.name}).`);
   }
+  /**
+   * Set the isBufferingObservation flag and update lastBufferedAtTokens.
+   * Called when async observation buffering starts (true) or ends/fails (false).
+   * @param id - Record ID
+   * @param isBuffering - Whether buffering is in progress
+   * @param lastBufferedAtTokens - The pending token count at which this buffer was triggered (only set when isBuffering=true)
+   */
+  async setBufferingObservationFlag(_id, _isBuffering, _lastBufferedAtTokens) {
+    throw new Error(`Observational memory is not implemented by this storage adapter (${this.constructor.name}).`);
+  }
+  /**
+   * Set the isBufferingReflection flag.
+   * Called when async reflection buffering starts (true) or ends/fails (false).
+   */
+  async setBufferingReflectionFlag(_id, _isBuffering) {
+    throw new Error(`Observational memory is not implemented by this storage adapter (${this.constructor.name}).`);
+  }
   /**
    * Clear all observational memory for a thread/resource.
    * Removes all records and history.
@@ -924,11 +929,11 @@ var MemoryStorage = class extends StorageDomain {
     throw new Error(`Observational memory is not implemented by this storage adapter (${this.constructor.name}).`);
   }
   /**
-   * Add to the pending message token count.
-   * Called when messages are processed but observation hasn't triggered yet.
-   * This allows accumulating tokens across multiple sessions.
+   * Set the pending message token count.
+   * Called at the end of each OM processing step to persist the current
+   * context window token count so the UI can display it on page load.
    */
-  async addPendingMessageTokens(_id, _tokenCount) {
+  async setPendingMessageTokens(_id, _tokenCount) {
     throw new Error(`Observational memory is not implemented by this storage adapter (${this.constructor.name}).`);
   }
   /**
@@ -1613,6 +1618,10 @@ var InMemoryMemory = class extends MemoryStorage {
       // State flags
       isReflecting: false,
       isObserving: false,
+      isBufferingObservation: false,
+      isBufferingReflection: false,
+      lastBufferedAtTokens: 0,
+      lastBufferedAtTime: null,
       // Configuration
       config,
       // Timezone used for observation date formatting
@@ -1641,46 +1650,114 @@ var InMemoryMemory = class extends MemoryStorage {
     }
   }
   async updateBufferedObservations(input) {
-    const { id, observations } = input;
+    const { id, chunk } = input;
     const record = this.findObservationalMemoryRecordById(id);
     if (!record) {
       throw new Error(`Observational memory record not found: ${id}`);
     }
-    record.bufferedObservations = observations;
+    const newChunk = {
+      id: `ombuf-${crypto.randomUUID()}`,
+      cycleId: chunk.cycleId,
+      observations: chunk.observations,
+      tokenCount: chunk.tokenCount,
+      messageIds: chunk.messageIds,
+      messageTokens: chunk.messageTokens,
+      lastObservedAt: chunk.lastObservedAt,
+      createdAt: /* @__PURE__ */ new Date(),
+      suggestedContinuation: chunk.suggestedContinuation,
+      currentTask: chunk.currentTask
+    };
+    const existingChunks = Array.isArray(record.bufferedObservationChunks) ? record.bufferedObservationChunks : [];
+    record.bufferedObservationChunks = [...existingChunks, newChunk];
+    if (input.lastBufferedAtTime) {
+      record.lastBufferedAtTime = input.lastBufferedAtTime;
+    }
     record.updatedAt = /* @__PURE__ */ new Date();
   }
-  async swapBufferedToActive(id) {
+  async swapBufferedToActive(input) {
+    const { id, activationRatio, lastObservedAt } = input;
     const record = this.findObservationalMemoryRecordById(id);
     if (!record) {
       throw new Error(`Observational memory record not found: ${id}`);
     }
-    if (!record.bufferedObservations) {
-      return;
+    const chunks = Array.isArray(record.bufferedObservationChunks) ? record.bufferedObservationChunks : [];
+    if (chunks.length === 0) {
+      return {
+        chunksActivated: 0,
+        messageTokensActivated: 0,
+        observationTokensActivated: 0,
+        messagesActivated: 0,
+        activatedCycleIds: [],
+        activatedMessageIds: []
+      };
+    }
+    const retentionFloor = input.messageTokensThreshold * (1 - activationRatio);
+    const targetMessageTokens = Math.max(0, input.currentPendingTokens - retentionFloor);
+    let cumulativeMessageTokens = 0;
+    let bestBoundary = 0;
+    let bestBoundaryMessageTokens = 0;
+    for (let i = 0; i < chunks.length; i++) {
+      cumulativeMessageTokens += chunks[i].messageTokens ?? 0;
+      const boundary = i + 1;
+      const isUnder = cumulativeMessageTokens <= targetMessageTokens;
+      const bestIsUnder = bestBoundaryMessageTokens <= targetMessageTokens;
+      if (bestBoundary === 0) {
+        bestBoundary = boundary;
+        bestBoundaryMessageTokens = cumulativeMessageTokens;
+      } else if (isUnder && !bestIsUnder) {
+        bestBoundary = boundary;
+        bestBoundaryMessageTokens = cumulativeMessageTokens;
+      } else if (isUnder && bestIsUnder) {
+        if (cumulativeMessageTokens > bestBoundaryMessageTokens) {
+          bestBoundary = boundary;
+          bestBoundaryMessageTokens = cumulativeMessageTokens;
+        }
+      } else if (!isUnder && !bestIsUnder) {
+        if (cumulativeMessageTokens < bestBoundaryMessageTokens) {
+          bestBoundary = boundary;
+          bestBoundaryMessageTokens = cumulativeMessageTokens;
+        }
+      }
     }
+    const chunksToActivate = bestBoundary === 0 ? 1 : bestBoundary;
+    const activatedChunks = chunks.slice(0, chunksToActivate);
+    const remainingChunks = chunks.slice(chunksToActivate);
+    const activatedContent = activatedChunks.map((c) => c.observations).join("\n\n");
+    const activatedTokens = activatedChunks.reduce((sum, c) => sum + c.tokenCount, 0);
+    const activatedMessageTokens = activatedChunks.reduce((sum, c) => sum + (c.messageTokens ?? 0), 0);
+    const activatedMessageCount = activatedChunks.reduce((sum, c) => sum + c.messageIds.length, 0);
+    const activatedCycleIds = activatedChunks.map((c) => c.cycleId).filter((id2) => !!id2);
+    const activatedMessageIds = activatedChunks.flatMap((c) => c.messageIds);
+    const latestChunk = activatedChunks[activatedChunks.length - 1];
+    const derivedLastObservedAt = lastObservedAt ?? (latestChunk?.lastObservedAt ? new Date(latestChunk.lastObservedAt) : /* @__PURE__ */ new Date());
     if (record.activeObservations) {
       record.activeObservations = `${record.activeObservations}
 
-${record.bufferedObservations}`;
+${activatedContent}`;
     } else {
-      record.activeObservations = record.bufferedObservations;
-    }
-    record.bufferedObservations = void 0;
-    record.lastObservedAt = /* @__PURE__ */ new Date();
-    record.updatedAt = /* @__PURE__ */ new Date();
-  }
-  async markMessagesAsBuffering(id, _messageIds) {
-    const record = this.findObservationalMemoryRecordById(id);
-    if (!record) {
-      throw new Error(`Observational memory record not found: ${id}`);
-    }
-    record.updatedAt = /* @__PURE__ */ new Date();
-  }
-  async markMessagesAsBuffered(id, _messageIds) {
-    const record = this.findObservationalMemoryRecordById(id);
-    if (!record) {
-      throw new Error(`Observational memory record not found: ${id}`);
+      record.activeObservations = activatedContent;
     }
+    record.observationTokenCount = (record.observationTokenCount ?? 0) + activatedTokens;
+    record.pendingMessageTokens = Math.max(0, (record.pendingMessageTokens ?? 0) - activatedMessageTokens);
+    record.bufferedObservationChunks = remainingChunks.length > 0 ? remainingChunks : void 0;
+    record.lastObservedAt = derivedLastObservedAt;
     record.updatedAt = /* @__PURE__ */ new Date();
+    return {
+      chunksActivated: activatedChunks.length,
+      messageTokensActivated: activatedMessageTokens,
+      observationTokensActivated: activatedTokens,
+      messagesActivated: activatedMessageCount,
+      activatedCycleIds,
+      activatedMessageIds,
+      observations: activatedContent,
+      perChunk: activatedChunks.map((c) => ({
+        cycleId: c.cycleId ?? "",
+        messageTokens: c.messageTokens ?? 0,
+        observationTokens: c.tokenCount,
+        messageCount: c.messageIds.length,
+        observations: c.observations
+      }))
+    };
   }
   async createReflectionGeneration(input) {
     const { currentRecord, reflection, tokenCount } = input;
@@ -1705,6 +1782,10 @@ ${record.bufferedObservations}`;
       pendingMessageTokens: 0,
       isReflecting: false,
       isObserving: false,
+      isBufferingObservation: false,
+      isBufferingReflection: false,
+      lastBufferedAtTokens: 0,
+      lastBufferedAtTime: null,
       // Timezone used for observation date formatting
       observedTimezone: currentRecord.observedTimezone,
       // Extensible metadata (optional)
@@ -1714,29 +1795,48 @@ ${record.bufferedObservations}`;
     this.db.observationalMemory.set(key, [newRecord, ...existing]);
     return newRecord;
   }
-  async updateBufferedReflection(id, reflection) {
+  async updateBufferedReflection(input) {
+    const { id, reflection, tokenCount, inputTokenCount, reflectedObservationLineCount } = input;
     const record = this.findObservationalMemoryRecordById(id);
     if (!record) {
       throw new Error(`Observational memory record not found: ${id}`);
     }
-    record.bufferedReflection = reflection;
+    const existing = record.bufferedReflection || "";
+    record.bufferedReflection = existing ? `${existing}
+
+${reflection}` : reflection;
+    record.bufferedReflectionTokens = (record.bufferedReflectionTokens || 0) + tokenCount;
+    record.bufferedReflectionInputTokens = (record.bufferedReflectionInputTokens || 0) + inputTokenCount;
+    record.reflectedObservationLineCount = reflectedObservationLineCount;
     record.updatedAt = /* @__PURE__ */ new Date();
   }
-  async swapReflectionToActive(id) {
-    const record = this.findObservationalMemoryRecordById(id);
+  async swapBufferedReflectionToActive(input) {
+    const { currentRecord } = input;
+    const record = this.findObservationalMemoryRecordById(currentRecord.id);
     if (!record) {
-      throw new Error(`Observational memory record not found: ${id}`);
+      throw new Error(`Observational memory record not found: ${currentRecord.id}`);
     }
     if (!record.bufferedReflection) {
       throw new Error("No buffered reflection to swap");
     }
+    const bufferedReflection = record.bufferedReflection;
+    const reflectedLineCount = record.reflectedObservationLineCount ?? 0;
+    const currentObservations = record.activeObservations ?? "";
+    const allLines = currentObservations.split("\n");
+    const unreflectedLines = allLines.slice(reflectedLineCount);
+    const unreflectedContent = unreflectedLines.join("\n").trim();
+    const newObservations = unreflectedContent ? `${bufferedReflection}
+
+${unreflectedContent}` : bufferedReflection;
     const newRecord = await this.createReflectionGeneration({
       currentRecord: record,
-      reflection: record.bufferedReflection,
-      tokenCount: 0
-      // Will be calculated by caller
+      reflection: newObservations,
+      tokenCount: input.tokenCount
     });
     record.bufferedReflection = void 0;
+    record.bufferedReflectionTokens = void 0;
+    record.bufferedReflectionInputTokens = void 0;
+    record.reflectedObservationLineCount = void 0;
     return newRecord;
   }
   async setReflectingFlag(id, isReflecting) {
@@ -1755,16 +1855,35 @@ ${record.bufferedObservations}`;
     record.isObserving = isObserving;
     record.updatedAt = /* @__PURE__ */ new Date();
   }
+  async setBufferingObservationFlag(id, isBuffering, lastBufferedAtTokens) {
+    const record = this.findObservationalMemoryRecordById(id);
+    if (!record) {
+      throw new Error(`Observational memory record not found: ${id}`);
+    }
+    record.isBufferingObservation = isBuffering;
+    if (lastBufferedAtTokens !== void 0) {
+      record.lastBufferedAtTokens = lastBufferedAtTokens;
+    }
+    record.updatedAt = /* @__PURE__ */ new Date();
+  }
+  async setBufferingReflectionFlag(id, isBuffering) {
+    const record = this.findObservationalMemoryRecordById(id);
+    if (!record) {
+      throw new Error(`Observational memory record not found: ${id}`);
+    }
+    record.isBufferingReflection = isBuffering;
+    record.updatedAt = /* @__PURE__ */ new Date();
+  }
   async clearObservationalMemory(threadId, resourceId) {
     const key = this.getObservationalMemoryKey(threadId, resourceId);
     this.db.observationalMemory.delete(key);
   }
-  async addPendingMessageTokens(id, tokenCount) {
+  async setPendingMessageTokens(id, tokenCount) {
     const record = this.findObservationalMemoryRecordById(id);
     if (!record) {
       throw new Error(`Observational memory record not found: ${id}`);
     }
-    record.pendingMessageTokens = (record.pendingMessageTokens ?? 0) + tokenCount;
+    record.pendingMessageTokens = tokenCount;
     record.updatedAt = /* @__PURE__ */ new Date();
   }
   /**
@@ -2216,6 +2335,638 @@ var ObservabilityInMemory = class extends ObservabilityStorage {
   }
 };
 
+// src/storage/domains/prompt-blocks/base.ts
+var PromptBlocksStorage = class extends VersionedStorageDomain {
+  listKey = "promptBlocks";
+  versionMetadataFields = [
+    "id",
+    "blockId",
+    "versionNumber",
+    "changedFields",
+    "changeMessage",
+    "createdAt"
+  ];
+  constructor() {
+    super({
+      component: "STORAGE",
+      name: "PROMPT_BLOCKS"
+    });
+  }
+};
+
+// src/storage/domains/prompt-blocks/inmemory.ts
+var InMemoryPromptBlocksStorage = class extends PromptBlocksStorage {
+  db;
+  constructor({ db }) {
+    super();
+    this.db = db;
+  }
+  async dangerouslyClearAll() {
+    this.db.promptBlocks.clear();
+    this.db.promptBlockVersions.clear();
+  }
+  // ==========================================================================
+  // Prompt Block CRUD Methods
+  // ==========================================================================
+  async getById(id) {
+    this.logger.debug(`InMemoryPromptBlocksStorage: getById called for ${id}`);
+    const block = this.db.promptBlocks.get(id);
+    return block ? this.deepCopyBlock(block) : null;
+  }
+  async create(input) {
+    const { promptBlock } = input;
+    this.logger.debug(`InMemoryPromptBlocksStorage: create called for ${promptBlock.id}`);
+    if (this.db.promptBlocks.has(promptBlock.id)) {
+      throw new Error(`Prompt block with id ${promptBlock.id} already exists`);
+    }
+    const now = /* @__PURE__ */ new Date();
+    const newBlock = {
+      id: promptBlock.id,
+      status: "draft",
+      activeVersionId: void 0,
+      authorId: promptBlock.authorId,
+      metadata: promptBlock.metadata,
+      createdAt: now,
+      updatedAt: now
+    };
+    this.db.promptBlocks.set(promptBlock.id, newBlock);
+    const { id: _id, authorId: _authorId, metadata: _metadata, ...snapshotConfig } = promptBlock;
+    const versionId = crypto.randomUUID();
+    await this.createVersion({
+      id: versionId,
+      blockId: promptBlock.id,
+      versionNumber: 1,
+      ...snapshotConfig,
+      changedFields: Object.keys(snapshotConfig),
+      changeMessage: "Initial version"
+    });
+    return this.deepCopyBlock(newBlock);
+  }
+  async update(input) {
+    const { id, ...updates } = input;
+    this.logger.debug(`InMemoryPromptBlocksStorage: update called for ${id}`);
+    const existingBlock = this.db.promptBlocks.get(id);
+    if (!existingBlock) {
+      throw new Error(`Prompt block with id ${id} not found`);
+    }
+    const { authorId, activeVersionId, metadata, status, ...configFields } = updates;
+    const configFieldNames = ["name", "description", "content", "rules"];
+    const hasConfigUpdate = configFieldNames.some((field) => field in configFields);
+    const updatedBlock = {
+      ...existingBlock,
+      ...authorId !== void 0 && { authorId },
+      ...activeVersionId !== void 0 && { activeVersionId },
+      ...status !== void 0 && { status },
+      ...metadata !== void 0 && {
+        metadata: { ...existingBlock.metadata, ...metadata }
+      },
+      updatedAt: /* @__PURE__ */ new Date()
+    };
+    if (activeVersionId !== void 0) {
+      updatedBlock.status = "published";
+    }
+    if (hasConfigUpdate) {
+      const latestVersion = await this.getLatestVersion(id);
+      if (!latestVersion) {
+        throw new Error(`No versions found for prompt block ${id}`);
+      }
+      const {
+        id: _versionId,
+        blockId: _blockId,
+        versionNumber: _versionNumber,
+        changedFields: _changedFields,
+        changeMessage: _changeMessage,
+        createdAt: _createdAt,
+        ...latestConfig
+      } = latestVersion;
+      const newConfig = {
+        ...latestConfig,
+        ...configFields
+      };
+      const changedFields = configFieldNames.filter(
+        (field) => field in configFields && JSON.stringify(configFields[field]) !== JSON.stringify(latestConfig[field])
+      );
+      if (changedFields.length > 0) {
+        const newVersionId = crypto.randomUUID();
+        const newVersionNumber = latestVersion.versionNumber + 1;
+        await this.createVersion({
+          id: newVersionId,
+          blockId: id,
+          versionNumber: newVersionNumber,
+          ...newConfig,
+          changedFields,
+          changeMessage: `Updated ${changedFields.join(", ")}`
+        });
+      }
+    }
+    this.db.promptBlocks.set(id, updatedBlock);
+    return this.deepCopyBlock(updatedBlock);
+  }
+  async delete(id) {
+    this.logger.debug(`InMemoryPromptBlocksStorage: delete called for ${id}`);
+    this.db.promptBlocks.delete(id);
+    await this.deleteVersionsByParentId(id);
+  }
+  async list(args) {
+    const { page = 0, perPage: perPageInput, orderBy, authorId, metadata } = args || {};
+    const { field, direction } = this.parseOrderBy(orderBy);
+    this.logger.debug(`InMemoryPromptBlocksStorage: list called`);
+    const perPage = normalizePerPage(perPageInput, 100);
+    if (page < 0) {
+      throw new Error("page must be >= 0");
+    }
+    const maxOffset = Number.MAX_SAFE_INTEGER / 2;
+    if (page * perPage > maxOffset) {
+      throw new Error("page value too large");
+    }
+    let blocks = Array.from(this.db.promptBlocks.values());
+    if (authorId !== void 0) {
+      blocks = blocks.filter((block) => block.authorId === authorId);
+    }
+    if (metadata && Object.keys(metadata).length > 0) {
+      blocks = blocks.filter((block) => {
+        if (!block.metadata) return false;
+        return Object.entries(metadata).every(([key, value]) => deepEqual(block.metadata[key], value));
+      });
+    }
+    const sortedBlocks = this.sortBlocks(blocks, field, direction);
+    const clonedBlocks = sortedBlocks.map((block) => this.deepCopyBlock(block));
+    const { offset, perPage: perPageForResponse } = calculatePagination(page, perPageInput, perPage);
+    return {
+      promptBlocks: clonedBlocks.slice(offset, offset + perPage),
+      total: clonedBlocks.length,
+      page,
+      perPage: perPageForResponse,
+      hasMore: offset + perPage < clonedBlocks.length
+    };
+  }
+  // ==========================================================================
+  // Prompt Block Version Methods
+  // ==========================================================================
+  async createVersion(input) {
+    this.logger.debug(`InMemoryPromptBlocksStorage: createVersion called for block ${input.blockId}`);
+    if (this.db.promptBlockVersions.has(input.id)) {
+      throw new Error(`Version with id ${input.id} already exists`);
+    }
+    for (const version2 of this.db.promptBlockVersions.values()) {
+      if (version2.blockId === input.blockId && version2.versionNumber === input.versionNumber) {
+        throw new Error(`Version number ${input.versionNumber} already exists for prompt block ${input.blockId}`);
+      }
+    }
+    const version = {
+      ...input,
+      createdAt: /* @__PURE__ */ new Date()
+    };
+    this.db.promptBlockVersions.set(input.id, this.deepCopyVersion(version));
+    return this.deepCopyVersion(version);
+  }
+  async getVersion(id) {
+    this.logger.debug(`InMemoryPromptBlocksStorage: getVersion called for ${id}`);
+    const version = this.db.promptBlockVersions.get(id);
+    return version ? this.deepCopyVersion(version) : null;
+  }
+  async getVersionByNumber(blockId, versionNumber) {
+    this.logger.debug(`InMemoryPromptBlocksStorage: getVersionByNumber called for block ${blockId}, v${versionNumber}`);
+    for (const version of this.db.promptBlockVersions.values()) {
+      if (version.blockId === blockId && version.versionNumber === versionNumber) {
+        return this.deepCopyVersion(version);
+      }
+    }
+    return null;
+  }
+  async getLatestVersion(blockId) {
+    this.logger.debug(`InMemoryPromptBlocksStorage: getLatestVersion called for block ${blockId}`);
+    let latest = null;
+    for (const version of this.db.promptBlockVersions.values()) {
+      if (version.blockId === blockId) {
+        if (!latest || version.versionNumber > latest.versionNumber) {
+          latest = version;
+        }
+      }
+    }
+    return latest ? this.deepCopyVersion(latest) : null;
+  }
+  async listVersions(input) {
+    const { blockId, page = 0, perPage: perPageInput, orderBy } = input;
+    const { field, direction } = this.parseVersionOrderBy(orderBy);
+    this.logger.debug(`InMemoryPromptBlocksStorage: listVersions called for block ${blockId}`);
+    const perPage = normalizePerPage(perPageInput, 20);
+    if (page < 0) {
+      throw new Error("page must be >= 0");
+    }
+    const maxOffset = Number.MAX_SAFE_INTEGER / 2;
+    if (page * perPage > maxOffset) {
+      throw new Error("page value too large");
+    }
+    let versions = Array.from(this.db.promptBlockVersions.values()).filter((v) => v.blockId === blockId);
+    versions = this.sortVersions(versions, field, direction);
+    const clonedVersions = versions.map((v) => this.deepCopyVersion(v));
+    const total = clonedVersions.length;
+    const { offset, perPage: perPageForResponse } = calculatePagination(page, perPageInput, perPage);
+    const paginatedVersions = clonedVersions.slice(offset, offset + perPage);
+    return {
+      versions: paginatedVersions,
+      total,
+      page,
+      perPage: perPageForResponse,
+      hasMore: offset + perPage < total
+    };
+  }
+  async deleteVersion(id) {
+    this.logger.debug(`InMemoryPromptBlocksStorage: deleteVersion called for ${id}`);
+    this.db.promptBlockVersions.delete(id);
+  }
+  async deleteVersionsByParentId(entityId) {
+    this.logger.debug(`InMemoryPromptBlocksStorage: deleteVersionsByParentId called for block ${entityId}`);
+    const idsToDelete = [];
+    for (const [id, version] of this.db.promptBlockVersions.entries()) {
+      if (version.blockId === entityId) {
+        idsToDelete.push(id);
+      }
+    }
+    for (const id of idsToDelete) {
+      this.db.promptBlockVersions.delete(id);
+    }
+  }
+  async countVersions(blockId) {
+    this.logger.debug(`InMemoryPromptBlocksStorage: countVersions called for block ${blockId}`);
+    let count = 0;
+    for (const version of this.db.promptBlockVersions.values()) {
+      if (version.blockId === blockId) {
+        count++;
+      }
+    }
+    return count;
+  }
+  // ==========================================================================
+  // Private Helper Methods
+  // ==========================================================================
+  deepCopyBlock(block) {
+    return {
+      ...block,
+      metadata: block.metadata ? { ...block.metadata } : block.metadata
+    };
+  }
+  deepCopyVersion(version) {
+    return {
+      ...version,
+      rules: version.rules ? JSON.parse(JSON.stringify(version.rules)) : version.rules,
+      changedFields: version.changedFields ? [...version.changedFields] : version.changedFields
+    };
+  }
+  sortBlocks(blocks, field, direction) {
+    return blocks.sort((a, b) => {
+      const aValue = a[field].getTime();
+      const bValue = b[field].getTime();
+      return direction === "ASC" ? aValue - bValue : bValue - aValue;
+    });
+  }
+  sortVersions(versions, field, direction) {
+    return versions.sort((a, b) => {
+      let aVal;
+      let bVal;
+      if (field === "createdAt") {
+        aVal = a.createdAt.getTime();
+        bVal = b.createdAt.getTime();
+      } else {
+        aVal = a.versionNumber;
+        bVal = b.versionNumber;
+      }
+      return direction === "ASC" ? aVal - bVal : bVal - aVal;
+    });
+  }
+};
+
+// src/storage/domains/scorer-definitions/base.ts
+var ScorerDefinitionsStorage = class extends VersionedStorageDomain {
+  listKey = "scorerDefinitions";
+  versionMetadataFields = [
+    "id",
+    "scorerDefinitionId",
+    "versionNumber",
+    "changedFields",
+    "changeMessage",
+    "createdAt"
+  ];
+  constructor() {
+    super({
+      component: "STORAGE",
+      name: "SCORER_DEFINITIONS"
+    });
+  }
+};
+
+// src/storage/domains/scorer-definitions/inmemory.ts
+var InMemoryScorerDefinitionsStorage = class extends ScorerDefinitionsStorage {
+  db;
+  constructor({ db }) {
+    super();
+    this.db = db;
+  }
+  async dangerouslyClearAll() {
+    this.db.scorerDefinitions.clear();
+    this.db.scorerDefinitionVersions.clear();
+  }
+  // ==========================================================================
+  // Scorer Definition CRUD Methods
+  // ==========================================================================
+  async getById(id) {
+    this.logger.debug(`InMemoryScorerDefinitionsStorage: getById called for ${id}`);
+    const scorer = this.db.scorerDefinitions.get(id);
+    return scorer ? this.deepCopyScorer(scorer) : null;
+  }
+  async create(input) {
+    const { scorerDefinition } = input;
+    this.logger.debug(`InMemoryScorerDefinitionsStorage: create called for ${scorerDefinition.id}`);
+    if (this.db.scorerDefinitions.has(scorerDefinition.id)) {
+      throw new Error(`Scorer definition with id ${scorerDefinition.id} already exists`);
+    }
+    const now = /* @__PURE__ */ new Date();
+    const newScorer = {
+      id: scorerDefinition.id,
+      status: "draft",
+      activeVersionId: void 0,
+      authorId: scorerDefinition.authorId,
+      metadata: scorerDefinition.metadata,
+      createdAt: now,
+      updatedAt: now
+    };
+    this.db.scorerDefinitions.set(scorerDefinition.id, newScorer);
+    const { id: _id, authorId: _authorId, metadata: _metadata, ...snapshotConfig } = scorerDefinition;
+    const versionId = crypto.randomUUID();
+    await this.createVersion({
+      id: versionId,
+      scorerDefinitionId: scorerDefinition.id,
+      versionNumber: 1,
+      ...snapshotConfig,
+      changedFields: Object.keys(snapshotConfig),
+      changeMessage: "Initial version"
+    });
+    return this.deepCopyScorer(newScorer);
+  }
+  async update(input) {
+    const { id, ...updates } = input;
+    this.logger.debug(`InMemoryScorerDefinitionsStorage: update called for ${id}`);
+    const existingScorer = this.db.scorerDefinitions.get(id);
+    if (!existingScorer) {
+      throw new Error(`Scorer definition with id ${id} not found`);
+    }
+    const { authorId, activeVersionId, metadata, status, ...configFields } = updates;
+    const configFieldNames = [
+      "name",
+      "description",
+      "type",
+      "model",
+      "instructions",
+      "scoreRange",
+      "presetConfig",
+      "defaultSampling"
+    ];
+    const hasConfigUpdate = configFieldNames.some((field) => field in configFields);
+    const updatedScorer = {
+      ...existingScorer,
+      ...authorId !== void 0 && { authorId },
+      ...activeVersionId !== void 0 && { activeVersionId },
+      ...status !== void 0 && { status },
+      ...metadata !== void 0 && {
+        metadata: { ...existingScorer.metadata, ...metadata }
+      },
+      updatedAt: /* @__PURE__ */ new Date()
+    };
+    if (activeVersionId !== void 0) {
+      updatedScorer.status = "published";
+    }
+    if (hasConfigUpdate) {
+      const latestVersion = await this.getLatestVersion(id);
+      if (!latestVersion) {
+        throw new Error(`No versions found for scorer definition ${id}`);
+      }
+      const {
+        id: _versionId,
+        scorerDefinitionId: _scorerDefinitionId,
+        versionNumber: _versionNumber,
+        changedFields: _changedFields,
+        changeMessage: _changeMessage,
+        createdAt: _createdAt,
+        ...latestConfig
+      } = latestVersion;
+      const newConfig = {
+        ...latestConfig,
+        ...configFields
+      };
+      const changedFields = configFieldNames.filter(
+        (field) => field in configFields && JSON.stringify(configFields[field]) !== JSON.stringify(latestConfig[field])
+      );
+      if (changedFields.length > 0) {
+        const newVersionId = crypto.randomUUID();
+        const newVersionNumber = latestVersion.versionNumber + 1;
+        await this.createVersion({
+          id: newVersionId,
+          scorerDefinitionId: id,
+          versionNumber: newVersionNumber,
+          ...newConfig,
+          changedFields,
+          changeMessage: `Updated ${changedFields.join(", ")}`
+        });
+      }
+    }
+    this.db.scorerDefinitions.set(id, updatedScorer);
+    return this.deepCopyScorer(updatedScorer);
+  }
+  async delete(id) {
+    this.logger.debug(`InMemoryScorerDefinitionsStorage: delete called for ${id}`);
+    this.db.scorerDefinitions.delete(id);
+    await this.deleteVersionsByParentId(id);
+  }
+  async list(args) {
+    const { page = 0, perPage: perPageInput, orderBy, authorId, metadata } = args || {};
+    const { field, direction } = this.parseOrderBy(orderBy);
+    this.logger.debug(`InMemoryScorerDefinitionsStorage: list called`);
+    const perPage = normalizePerPage(perPageInput, 100);
+    if (page < 0) {
+      throw new Error("page must be >= 0");
+    }
+    const maxOffset = Number.MAX_SAFE_INTEGER / 2;
+    if (page * perPage > maxOffset) {
+      throw new Error("page value too large");
+    }
+    let scorers = Array.from(this.db.scorerDefinitions.values());
+    if (authorId !== void 0) {
+      scorers = scorers.filter((scorer) => scorer.authorId === authorId);
+    }
+    if (metadata && Object.keys(metadata).length > 0) {
+      scorers = scorers.filter((scorer) => {
+        if (!scorer.metadata) return false;
+        return Object.entries(metadata).every(([key, value]) => deepEqual(scorer.metadata[key], value));
+      });
+    }
+    const sortedScorers = this.sortScorers(scorers, field, direction);
+    const clonedScorers = sortedScorers.map((scorer) => this.deepCopyScorer(scorer));
+    const { offset, perPage: perPageForResponse } = calculatePagination(page, perPageInput, perPage);
+    return {
+      scorerDefinitions: clonedScorers.slice(offset, offset + perPage),
+      total: clonedScorers.length,
+      page,
+      perPage: perPageForResponse,
+      hasMore: offset + perPage < clonedScorers.length
+    };
+  }
+  // ==========================================================================
+  // Scorer Definition Version Methods
+  // ==========================================================================
+  async createVersion(input) {
+    this.logger.debug(
+      `InMemoryScorerDefinitionsStorage: createVersion called for scorer definition ${input.scorerDefinitionId}`
+    );
+    if (this.db.scorerDefinitionVersions.has(input.id)) {
+      throw new Error(`Version with id ${input.id} already exists`);
+    }
+    for (const version2 of this.db.scorerDefinitionVersions.values()) {
+      if (version2.scorerDefinitionId === input.scorerDefinitionId && version2.versionNumber === input.versionNumber) {
+        throw new Error(
+          `Version number ${input.versionNumber} already exists for scorer definition ${input.scorerDefinitionId}`
+        );
+      }
+    }
+    const version = {
+      ...input,
+      createdAt: /* @__PURE__ */ new Date()
+    };
+    this.db.scorerDefinitionVersions.set(input.id, this.deepCopyVersion(version));
+    return this.deepCopyVersion(version);
+  }
+  async getVersion(id) {
+    this.logger.debug(`InMemoryScorerDefinitionsStorage: getVersion called for ${id}`);
+    const version = this.db.scorerDefinitionVersions.get(id);
+    return version ? this.deepCopyVersion(version) : null;
+  }
+  async getVersionByNumber(scorerDefinitionId, versionNumber) {
+    this.logger.debug(
+      `InMemoryScorerDefinitionsStorage: getVersionByNumber called for scorer definition ${scorerDefinitionId}, v${versionNumber}`
+    );
+    for (const version of this.db.scorerDefinitionVersions.values()) {
+      if (version.scorerDefinitionId === scorerDefinitionId && version.versionNumber === versionNumber) {
+        return this.deepCopyVersion(version);
+      }
+    }
+    return null;
+  }
+  async getLatestVersion(scorerDefinitionId) {
+    this.logger.debug(
+      `InMemoryScorerDefinitionsStorage: getLatestVersion called for scorer definition ${scorerDefinitionId}`
+    );
+    let latest = null;
+    for (const version of this.db.scorerDefinitionVersions.values()) {
+      if (version.scorerDefinitionId === scorerDefinitionId) {
+        if (!latest || version.versionNumber > latest.versionNumber) {
+          latest = version;
+        }
+      }
+    }
+    return latest ? this.deepCopyVersion(latest) : null;
+  }
+  async listVersions(input) {
+    const { scorerDefinitionId, page = 0, perPage: perPageInput, orderBy } = input;
+    const { field, direction } = this.parseVersionOrderBy(orderBy);
+    this.logger.debug(
+      `InMemoryScorerDefinitionsStorage: listVersions called for scorer definition ${scorerDefinitionId}`
+    );
+    const perPage = normalizePerPage(perPageInput, 20);
+    if (page < 0) {
+      throw new Error("page must be >= 0");
+    }
+    const maxOffset = Number.MAX_SAFE_INTEGER / 2;
+    if (page * perPage > maxOffset) {
+      throw new Error("page value too large");
+    }
+    let versions = Array.from(this.db.scorerDefinitionVersions.values()).filter(
+      (v) => v.scorerDefinitionId === scorerDefinitionId
+    );
+    versions = this.sortVersions(versions, field, direction);
+    const clonedVersions = versions.map((v) => this.deepCopyVersion(v));
+    const total = clonedVersions.length;
+    const { offset, perPage: perPageForResponse } = calculatePagination(page, perPageInput, perPage);
+    const paginatedVersions = clonedVersions.slice(offset, offset + perPage);
+    return {
+      versions: paginatedVersions,
+      total,
+      page,
+      perPage: perPageForResponse,
+      hasMore: offset + perPage < total
+    };
+  }
+  async deleteVersion(id) {
+    this.logger.debug(`InMemoryScorerDefinitionsStorage: deleteVersion called for ${id}`);
+    this.db.scorerDefinitionVersions.delete(id);
+  }
+  async deleteVersionsByParentId(entityId) {
+    this.logger.debug(
+      `InMemoryScorerDefinitionsStorage: deleteVersionsByParentId called for scorer definition ${entityId}`
+    );
+    const idsToDelete = [];
+    for (const [id, version] of this.db.scorerDefinitionVersions.entries()) {
+      if (version.scorerDefinitionId === entityId) {
+        idsToDelete.push(id);
+      }
+    }
+    for (const id of idsToDelete) {
+      this.db.scorerDefinitionVersions.delete(id);
+    }
+  }
+  async countVersions(scorerDefinitionId) {
+    this.logger.debug(
+      `InMemoryScorerDefinitionsStorage: countVersions called for scorer definition ${scorerDefinitionId}`
+    );
+    let count = 0;
+    for (const version of this.db.scorerDefinitionVersions.values()) {
+      if (version.scorerDefinitionId === scorerDefinitionId) {
+        count++;
+      }
+    }
+    return count;
+  }
+  // ==========================================================================
+  // Private Helper Methods
+  // ==========================================================================
+  deepCopyScorer(scorer) {
+    return {
+      ...scorer,
+      metadata: scorer.metadata ? { ...scorer.metadata } : scorer.metadata
+    };
+  }
+  deepCopyVersion(version) {
+    return {
+      ...version,
+      model: version.model ? JSON.parse(JSON.stringify(version.model)) : version.model,
+      scoreRange: version.scoreRange ? JSON.parse(JSON.stringify(version.scoreRange)) : version.scoreRange,
+      presetConfig: version.presetConfig ? JSON.parse(JSON.stringify(version.presetConfig)) : version.presetConfig,
+      defaultSampling: version.defaultSampling ? JSON.parse(JSON.stringify(version.defaultSampling)) : version.defaultSampling,
+      changedFields: version.changedFields ? [...version.changedFields] : version.changedFields
+    };
+  }
+  sortScorers(scorers, field, direction) {
+    return scorers.sort((a, b) => {
+      const aValue = a[field].getTime();
+      const bValue = b[field].getTime();
+      return direction === "ASC" ? aValue - bValue : bValue - aValue;
+    });
+  }
+  sortVersions(versions, field, direction) {
+    return versions.sort((a, b) => {
+      let aVal;
+      let bVal;
+      if (field === "createdAt") {
+        aVal = a.createdAt.getTime();
+        bVal = b.createdAt.getTime();
+      } else {
+        aVal = a.versionNumber;
+        bVal = b.versionNumber;
+      }
+      return direction === "ASC" ? aVal - bVal : bVal - aVal;
+    });
+  }
+};
+
 // src/storage/domains/scores/base.ts
 var ScoresStorage = class extends StorageDomain {
   constructor() {
@@ -2638,7 +3389,9 @@ var InMemoryStore = class extends MastraCompositeStore {
       workflows: new WorkflowsInMemory({ db: this.#db }),
       scores: new ScoresInMemory({ db: this.#db }),
       observability: new ObservabilityInMemory({ db: this.#db }),
-      agents: new InMemoryAgentsStorage({ db: this.#db })
+      agents: new InMemoryAgentsStorage({ db: this.#db }),
+      promptBlocks: new InMemoryPromptBlocksStorage({ db: this.#db }),
+      scorerDefinitions: new InMemoryScorerDefinitionsStorage({ db: this.#db })
     };
   }
   /**
@@ -2773,7 +3526,11 @@ var StoreOperationsInMemory = class extends StoreOperations {
       mastra_ai_spans: /* @__PURE__ */ new Map(),
       mastra_agents: /* @__PURE__ */ new Map(),
       mastra_agent_versions: /* @__PURE__ */ new Map(),
-      mastra_observational_memory: /* @__PURE__ */ new Map()
+      mastra_observational_memory: /* @__PURE__ */ new Map(),
+      mastra_prompt_blocks: /* @__PURE__ */ new Map(),
+      mastra_prompt_block_versions: /* @__PURE__ */ new Map(),
+      mastra_scorer_definitions: /* @__PURE__ */ new Map(),
+      mastra_scorer_definition_versions: /* @__PURE__ */ new Map()
     };
   }
   getDatabase() {
@@ -2838,6 +3595,6 @@ var StoreOperationsInMemory = class extends StoreOperations {
   }
 };
 
-export { AgentsStorage, InMemoryAgentsStorage, InMemoryDB, InMemoryMemory, InMemoryStore, MastraCompositeStore, MastraStorage, MemoryStorage, MockStore, ObservabilityInMemory, ObservabilityStorage, ScoresInMemory, ScoresStorage, StorageDomain, StoreOperations, StoreOperationsInMemory, WorkflowsInMemory, WorkflowsStorage, calculatePagination, createPendingMarker, createStorageErrorId, createStoreErrorId, createVectorErrorId, ensureDate, filterByDateRange, getDefaultValue, getSqlType, jsonValueEquals, normalizePerPage, safelyParseJSON, serializeDate, transformRow, transformScoreRow };
-//# sourceMappingURL=chunk-VX7UA3SO.js.map
-//# sourceMappingURL=chunk-VX7UA3SO.js.map
+export { AgentsStorage, InMemoryAgentsStorage, InMemoryDB, InMemoryMemory, InMemoryPromptBlocksStorage, InMemoryScorerDefinitionsStorage, InMemoryStore, MastraCompositeStore, MastraStorage, MemoryStorage, MockStore, ObservabilityInMemory, ObservabilityStorage, PromptBlocksStorage, ScorerDefinitionsStorage, ScoresInMemory, ScoresStorage, StorageDomain, StoreOperations, StoreOperationsInMemory, VersionedStorageDomain, WorkflowsInMemory, WorkflowsStorage, calculatePagination, createPendingMarker, createStorageErrorId, createStoreErrorId, createVectorErrorId, ensureDate, filterByDateRange, getDefaultValue, getSqlType, jsonValueEquals, normalizePerPage, safelyParseJSON, serializeDate, transformRow, transformScoreRow };
+//# sourceMappingURL=chunk-MOOJ3H3C.js.map
+//# sourceMappingURL=chunk-MOOJ3H3C.js.map