@mastra/core 1.9.0 → 1.10.0

package/dist/{chunk-ZBESCKPX.cjs → chunk-7AHCLTZZ.cjs}

@@ -1,15 +1,27 @@
 'use strict';
 
-var chunk3ZF7IC6Q_cjs = require('./chunk-3ZF7IC6Q.cjs');
-var chunk3ZBLD2Y4_cjs = require('./chunk-3ZBLD2Y4.cjs');
-var chunkQNXY3J6B_cjs = require('./chunk-QNXY3J6B.cjs');
+var chunkYZMSJKAK_cjs = require('./chunk-YZMSJKAK.cjs');
+var chunkHH76UOJL_cjs = require('./chunk-HH76UOJL.cjs');
+var chunkGCRPNAAR_cjs = require('./chunk-GCRPNAAR.cjs');
 var chunk4U7ZLI36_cjs = require('./chunk-4U7ZLI36.cjs');
 var chunkRO47SMI7_cjs = require('./chunk-RO47SMI7.cjs');
 var jsonToZod = require('@mastra/schema-compat/json-to-zod');
 var zod = require('zod');
 var crypto$1 = require('crypto');
+var path = require('path');
+var child_process = require('child_process');
+var fs = require('fs');
 
 // src/storage/base.ts
+var EDITOR_DOMAINS = [
+  "agents",
+  "promptBlocks",
+  "scorerDefinitions",
+  "mcpClients",
+  "mcpServers",
+  "workspaces",
+  "skills"
+];
 function normalizePerPage(perPageInput, defaultValue) {
   if (perPageInput === false) {
     return Number.MAX_SAFE_INTEGER;
@@ -48,30 +60,39 @@ var MastraCompositeStore = class extends chunkRO47SMI7_cjs.MastraBase {
     });
     this.id = config.id;
     this.disableInit = config.disableInit ?? false;
-    if (config.default || config.domains) {
+    if (config.default || config.editor || config.domains) {
       const defaultStores = config.default?.stores;
+      const editorStores = config.editor?.stores;
       const domainOverrides = config.domains ?? {};
       const hasDefaultDomains = defaultStores && Object.values(defaultStores).some((v) => v !== void 0);
+      const hasEditorDomains = editorStores && Object.values(editorStores).some((v) => v !== void 0);
       const hasOverrideDomains = Object.values(domainOverrides).some((v) => v !== void 0);
-      if (!hasDefaultDomains && !hasOverrideDomains) {
+      if (!hasDefaultDomains && !hasEditorDomains && !hasOverrideDomains) {
         throw new Error(
-          "MastraCompositeStore requires at least one storage source. Provide either a default storage with domains or domain overrides."
+          "MastraCompositeStore requires at least one storage source. Provide a default storage, an editor storage, or domain overrides."
         );
       }
+      const editorDomainSet = new Set(EDITOR_DOMAINS);
+      const resolve3 = (key) => {
+        if (domainOverrides[key] !== void 0) return domainOverrides[key];
+        if (editorDomainSet.has(key) && editorStores?.[key] !== void 0) return editorStores[key];
+        return defaultStores?.[key];
+      };
       this.stores = {
-        memory: domainOverrides.memory ?? defaultStores?.memory,
-        workflows: domainOverrides.workflows ?? defaultStores?.workflows,
-        scores: domainOverrides.scores ?? defaultStores?.scores,
-        observability: domainOverrides.observability ?? defaultStores?.observability,
-        agents: domainOverrides.agents ?? defaultStores?.agents,
-        datasets: domainOverrides.datasets ?? defaultStores?.datasets,
-        experiments: domainOverrides.experiments ?? defaultStores?.experiments,
-        promptBlocks: domainOverrides.promptBlocks ?? defaultStores?.promptBlocks,
-        scorerDefinitions: domainOverrides.scorerDefinitions ?? defaultStores?.scorerDefinitions,
-        mcpClients: domainOverrides.mcpClients ?? defaultStores?.mcpClients,
-        mcpServers: domainOverrides.mcpServers ?? defaultStores?.mcpServers,
-        workspaces: domainOverrides.workspaces ?? defaultStores?.workspaces,
-        skills: domainOverrides.skills ?? defaultStores?.skills
+        memory: resolve3("memory"),
+        workflows: resolve3("workflows"),
+        scores: resolve3("scores"),
+        observability: resolve3("observability"),
+        agents: resolve3("agents"),
+        datasets: resolve3("datasets"),
+        experiments: resolve3("experiments"),
+        promptBlocks: resolve3("promptBlocks"),
+        scorerDefinitions: resolve3("scorerDefinitions"),
+        mcpClients: resolve3("mcpClients"),
+        mcpServers: resolve3("mcpServers"),
+        workspaces: resolve3("workspaces"),
+        skills: resolve3("skills"),
+        blobs: resolve3("blobs")
       };
     }
   }
@@ -384,7 +405,7 @@ var InMemoryAgentsStorage = class extends AgentsStorage {
     if (metadata && Object.keys(metadata).length > 0) {
       agents = agents.filter((agent) => {
         if (!agent.metadata) return false;
-        return Object.entries(metadata).every(([key, value]) => chunkQNXY3J6B_cjs.deepEqual(agent.metadata[key], value));
+        return Object.entries(metadata).every(([key, value]) => chunkGCRPNAAR_cjs.deepEqual(agent.metadata[key], value));
       });
     }
     const sortedAgents = this.sortAgents(agents, field, direction);
@@ -1240,6 +1261,7 @@ var ExperimentsInMemory = class extends ExperimentsStorage {
     const updated = {
       ...existing,
       status: input.status ?? existing.status,
+      totalItems: input.totalItems ?? existing.totalItems,
       succeededCount: input.succeededCount ?? existing.succeededCount,
       failedCount: input.failedCount ?? existing.failedCount,
       skippedCount: input.skippedCount ?? existing.skippedCount,
@@ -1514,7 +1536,7 @@ var InMemoryMCPClientsStorage = class extends MCPClientsStorage {
     if (metadata && Object.keys(metadata).length > 0) {
       configs = configs.filter((config) => {
         if (!config.metadata) return false;
-        return Object.entries(metadata).every(([key, value]) => chunkQNXY3J6B_cjs.deepEqual(config.metadata[key], value));
+        return Object.entries(metadata).every(([key, value]) => chunkGCRPNAAR_cjs.deepEqual(config.metadata[key], value));
       });
     }
     const sortedConfigs = this.sortConfigs(configs, field, direction);
@@ -1782,7 +1804,7 @@ var InMemoryMCPServersStorage = class extends MCPServersStorage {
     if (metadata && Object.keys(metadata).length > 0) {
       configs = configs.filter((config) => {
         if (!config.metadata) return false;
-        return Object.entries(metadata).every(([key, value]) => chunkQNXY3J6B_cjs.deepEqual(config.metadata[key], value));
+        return Object.entries(metadata).every(([key, value]) => chunkGCRPNAAR_cjs.deepEqual(config.metadata[key], value));
       });
     }
     const sortedConfigs = this.sortConfigs(configs, field, direction);
@@ -1953,7 +1975,7 @@ function safelyParseJSON(input) {
 }
 function transformRow(row, tableName, options = {}) {
   const { preferredTimestampFields = {}, convertTimestamps = false, nullValuePattern, fieldMappings = {} } = options;
-  const tableSchema = chunk3ZBLD2Y4_cjs.TABLE_SCHEMAS[tableName];
+  const tableSchema = chunkHH76UOJL_cjs.TABLE_SCHEMAS[tableName];
   const result = {};
   for (const [key, columnSchema] of Object.entries(tableSchema)) {
     const sourceKey = fieldMappings[key] ?? key;
@@ -1984,7 +2006,7 @@ function transformRow(row, tableName, options = {}) {
   return result;
 }
 function transformScoreRow(row, options = {}) {
-  return transformRow(row, chunk3ZBLD2Y4_cjs.TABLE_SCORERS, options);
+  return transformRow(row, chunkHH76UOJL_cjs.TABLE_SCORERS, options);
 }
 function toUpperSnakeCase(str) {
   return str.replace(/([a-z])([A-Z])/g, "$1_$2").replace(/([A-Z])([A-Z][a-z])/g, "$1_$2").toUpperCase().replace(/[^A-Z0-9]+/g, "_").replace(/^_+|_+$/g, "");
@@ -2613,7 +2635,7 @@ var InMemoryMemory = class extends MemoryStorage {
     });
     const total = messages.length;
     const paginatedMessages = messages.slice(offset, offset + perPage);
-    const list = new chunk3ZF7IC6Q_cjs.MessageList().add(
+    const list = new chunkYZMSJKAK_cjs.MessageList().add(
       paginatedMessages.map((m) => this.parseStoredMessage(m)),
       "memory"
     );
@@ -2647,7 +2669,7 @@ var InMemoryMemory = class extends MemoryStorage {
   async listMessagesById({ messageIds }) {
     this.logger.debug(`InMemoryMemory: listMessagesById called`);
     const rawMessages = messageIds.map((id) => this.db.messages.get(id)).filter((message) => !!message);
-    const list = new chunk3ZF7IC6Q_cjs.MessageList().add(
+    const list = new chunkYZMSJKAK_cjs.MessageList().add(
       rawMessages.map((m) => this.parseStoredMessage(m)),
       "memory"
     );
@@ -2679,7 +2701,7 @@ var InMemoryMemory = class extends MemoryStorage {
       };
       this.db.messages.set(key, storageMessage);
     }
-    const list = new chunk3ZF7IC6Q_cjs.MessageList().add(messages, "memory");
+    const list = new chunkYZMSJKAK_cjs.MessageList().add(messages, "memory");
     return { messages: list.get.all.db() };
   }
   async updateMessages(args) {
@@ -3550,7 +3572,7 @@ var ObservabilityInMemory = class extends ObservabilityStorage {
     };
   }
   async listTraces(args) {
-    const { filters, pagination, orderBy } = chunk3ZBLD2Y4_cjs.listTracesArgsSchema.parse(args);
+    const { filters, pagination, orderBy } = chunkHH76UOJL_cjs.listTracesArgsSchema.parse(args);
     const matchingRootSpans = [];
     for (const [, traceEntry] of this.db.traces) {
       if (!traceEntry.rootSpan) continue;
@@ -3579,7 +3601,7 @@ var ObservabilityInMemory = class extends ObservabilityStorage {
     const end = start + perPage;
     const paged = matchingRootSpans.slice(start, end);
     return {
-      spans: chunk3ZBLD2Y4_cjs.toTraceSpans(paged),
+      spans: chunkHH76UOJL_cjs.toTraceSpans(paged),
       pagination: { total, page, perPage, hasMore: end < total }
     };
   }
@@ -3845,7 +3867,7 @@ var InMemoryPromptBlocksStorage = class extends PromptBlocksStorage {
     if (metadata && Object.keys(metadata).length > 0) {
       blocks = blocks.filter((block) => {
         if (!block.metadata) return false;
-        return Object.entries(metadata).every(([key, value]) => chunkQNXY3J6B_cjs.deepEqual(block.metadata[key], value));
+        return Object.entries(metadata).every(([key, value]) => chunkGCRPNAAR_cjs.deepEqual(block.metadata[key], value));
       });
     }
     const sortedBlocks = this.sortBlocks(blocks, field, direction);
@@ -4111,7 +4133,7 @@ var InMemoryScorerDefinitionsStorage = class extends ScorerDefinitionsStorage {
     if (metadata && Object.keys(metadata).length > 0) {
       scorers = scorers.filter((scorer) => {
         if (!scorer.metadata) return false;
-        return Object.entries(metadata).every(([key, value]) => chunkQNXY3J6B_cjs.deepEqual(scorer.metadata[key], value));
+        return Object.entries(metadata).every(([key, value]) => chunkGCRPNAAR_cjs.deepEqual(scorer.metadata[key], value));
       });
     }
     const sortedScorers = this.sortScorers(scorers, field, direction);
@@ -5159,7 +5181,7 @@ var InMemoryWorkspacesStorage = class extends WorkspacesStorage {
     if (metadata && Object.keys(metadata).length > 0) {
       configs = configs.filter((config) => {
         if (!config.metadata) return false;
-        return Object.entries(metadata).every(([key, value]) => chunkQNXY3J6B_cjs.deepEqual(config.metadata[key], value));
+        return Object.entries(metadata).every(([key, value]) => chunkGCRPNAAR_cjs.deepEqual(config.metadata[key], value));
       });
     }
     const sortedConfigs = this.sortConfigs(configs, field, direction);
@@ -5348,6 +5370,1508 @@ var InMemoryStore = class extends MastraCompositeStore {
   }
 };
 var MockStore = InMemoryStore;
+var GitHistory = class {
+  /** Cache: dir → repo root (string) or `false` if not a repo. */
+  repoRootCache = /* @__PURE__ */ new Map();
+  /** Cache: `dir:filename:limit` → ordered commits (newest first). */
+  commitCache = /* @__PURE__ */ new Map();
+  /** Cache: `dir:commitHash:filename` → parsed JSON. */
+  snapshotCache = /* @__PURE__ */ new Map();
+  // ===========================================================================
+  // Public API
+  // ===========================================================================
+  /**
+   * Returns `true` if `dir` is inside a Git repository.
+   * Result is cached after the first call per directory.
+   */
+  async isGitRepo(dir) {
+    const cached = this.repoRootCache.get(dir);
+    if (cached === false) return false;
+    if (typeof cached === "string") return true;
+    try {
+      const root = (await this.exec(dir, ["rev-parse", "--show-toplevel"])).trim();
+      this.repoRootCache.set(dir, root);
+      return true;
+    } catch {
+      this.repoRootCache.set(dir, false);
+      return false;
+    }
+  }
+  /**
+   * Get the list of commits that touched a specific file, newest first.
+   * Returns an empty array if Git is unavailable or the file has no history.
+   *
+   * @param dir      Absolute path to the storage directory
+   * @param filename The JSON filename relative to `dir` (e.g., 'agents.json')
+   * @param limit    Maximum number of commits to retrieve
+   */
+  async getFileHistory(dir, filename, limit = 50) {
+    const cacheKey = `${dir}:${filename}:${limit}`;
+    if (this.commitCache.has(cacheKey)) {
+      return this.commitCache.get(cacheKey);
+    }
+    if (!await this.isGitRepo(dir)) {
+      this.commitCache.set(cacheKey, []);
+      return [];
+    }
+    try {
+      const raw = await this.exec(dir, [
+        "log",
+        `--max-count=${limit}`,
+        "--format=%H|%aI|%aN|%s",
+        "--follow",
+        "--",
+        filename
+      ]);
+      const commits = [];
+      for (const line of raw.split("\n")) {
+        const trimmed = line.trim();
+        if (!trimmed) continue;
+        const pipeIdx1 = trimmed.indexOf("|");
+        const pipeIdx2 = trimmed.indexOf("|", pipeIdx1 + 1);
+        const pipeIdx3 = trimmed.indexOf("|", pipeIdx2 + 1);
+        if (pipeIdx1 === -1 || pipeIdx2 === -1 || pipeIdx3 === -1) continue;
+        commits.push({
+          hash: trimmed.slice(0, pipeIdx1),
+          date: new Date(trimmed.slice(pipeIdx1 + 1, pipeIdx2)),
+          author: trimmed.slice(pipeIdx2 + 1, pipeIdx3),
+          message: trimmed.slice(pipeIdx3 + 1)
+        });
+      }
+      this.commitCache.set(cacheKey, commits);
+      return commits;
+    } catch {
+      this.commitCache.set(cacheKey, []);
+      return [];
+    }
+  }
+  /**
+   * Read and parse a JSON file at a specific Git commit.
+   * Returns the parsed entity map, or `null` if the file didn't exist at that commit.
+   *
+   * @param dir        Absolute path to the storage directory
+   * @param commitHash Full or abbreviated commit SHA
+   * @param filename   The JSON filename relative to `dir` (e.g., 'agents.json')
+   */
+  async getFileAtCommit(dir, commitHash, filename) {
+    const cacheKey = `${dir}:${commitHash}:${filename}`;
+    if (this.snapshotCache.has(cacheKey)) {
+      return this.snapshotCache.get(cacheKey);
+    }
+    if (!await this.isGitRepo(dir)) return null;
+    try {
+      const relPath = this.relativeToRepo(dir, filename);
+      const raw = await this.exec(dir, ["show", `${commitHash}:${relPath}`]);
+      const parsed = JSON.parse(raw);
+      this.snapshotCache.set(cacheKey, parsed);
+      return parsed;
+    } catch {
+      return null;
+    }
+  }
+  /**
+   * Invalidate all caches. Call after external operations that change Git state
+   * (e.g., the user commits or pulls).
+   */
+  invalidateCache() {
+    this.repoRootCache.clear();
+    this.commitCache.clear();
+    this.snapshotCache.clear();
+  }
+  // ===========================================================================
+  // Internals
+  // ===========================================================================
+  /**
+   * Get the relative path from the Git repo root to a file in the storage directory.
+   */
+  relativeToRepo(dir, filename) {
+    const root = this.repoRootCache.get(dir);
+    if (!root) {
+      throw new Error(`Not a git repository: ${dir}`);
+    }
+    const realRoot = fs.realpathSync(root);
+    const realDir = fs.realpathSync(dir);
+    const relDir = path.relative(realRoot, realDir);
+    return relDir ? `${relDir}/${filename}` : filename;
+  }
+  /**
+   * Execute a git command and return stdout.
+   */
+  exec(cwd, args) {
+    return new Promise((resolve3, reject) => {
+      child_process.execFile("git", args, { cwd, maxBuffer: 10 * 1024 * 1024 }, (error, stdout) => {
+        if (error) reject(error);
+        else resolve3(stdout);
+      });
+    });
+  }
+};
+
+// src/storage/filesystem-versioned.ts
+var GIT_VERSION_PREFIX = "git-";
+var FilesystemVersionedHelpers = class _FilesystemVersionedHelpers {
+  db;
+  entitiesFile;
+  parentIdField;
+  name;
+  versionMetadataFields;
+  gitHistoryLimit;
+  /**
+   * In-memory entity records (thin metadata), keyed by entity ID.
+   */
+  entities = /* @__PURE__ */ new Map();
+  /**
+   * In-memory version records, keyed by version ID.
+   * Includes both in-memory/hydrated versions and git-based versions (metadata only).
+   */
+  versions = /* @__PURE__ */ new Map();
+  /**
+   * Whether we've loaded from disk yet.
+   */
+  hydrated = false;
+  /**
+   * Git history utility instance (shared across all helpers).
+   */
+  static gitHistory = new GitHistory();
+  /**
+   * Promise that resolves when git history has been loaded.
+   * null means git history loading hasn't been triggered yet.
+   */
+  gitHistoryPromise = null;
+  /**
+   * The highest version number from git history, per entity ID.
+   * Used to assign version numbers to new in-memory versions that continue
+   * after the git history.
+   */
+  gitVersionCounts = /* @__PURE__ */ new Map();
+  constructor(config) {
+    this.db = config.db;
+    this.entitiesFile = config.entitiesFile;
+    this.parentIdField = config.parentIdField;
+    this.name = config.name;
+    this.versionMetadataFields = config.versionMetadataFields;
+    this.gitHistoryLimit = config.gitHistoryLimit ?? 50;
+  }
+  /**
+   * Check if a version ID represents a git-based version.
+   */
+  static isGitVersion(id) {
+    return id.startsWith(GIT_VERSION_PREFIX);
+  }
+  /**
+   * Hydrate in-memory state from the on-disk JSON file.
+   * For each entry on disk, creates an in-memory entity (status: 'published')
+   * and a synthetic version with the snapshot config.
+   *
+   * Also kicks off async git history loading in the background.
+   * Version numbers for hydrated entities are assigned as 1 initially,
+   * but will be reassigned after git history loads.
+   */
+  hydrate() {
+    if (this.hydrated) return;
+    this.hydrated = true;
+    const diskData = this.db.readDomain(this.entitiesFile);
+    for (const [entityId, snapshotConfig] of Object.entries(diskData)) {
+      if (!snapshotConfig || typeof snapshotConfig !== "object") continue;
+      const versionId = `hydrated-${entityId}-v1`;
+      const now = /* @__PURE__ */ new Date();
+      const entity = {
+        id: entityId,
+        status: "published",
+        activeVersionId: versionId,
+        createdAt: now,
+        updatedAt: now
+      };
+      this.entities.set(entityId, entity);
+      const version = {
+        id: versionId,
+        [this.parentIdField]: entityId,
+        versionNumber: 1,
+        ...snapshotConfig,
+        createdAt: now
+      };
+      this.versions.set(versionId, version);
+    }
+    this.gitHistoryPromise = this.loadGitHistory();
+  }
+  /**
+   * Ensure git history has been loaded before proceeding.
+   * Call this in version-related methods to ensure git versions are available.
+   */
+  async ensureGitHistory() {
+    this.hydrate();
+    if (this.gitHistoryPromise) {
+      await this.gitHistoryPromise;
+    }
+  }
+  /**
+   * Load git commit history for the domain's JSON file.
+   * Creates read-only version records (metadata + snapshot config) for each
+   * commit where an entity existed. Reassigns version numbers for
+   * hydrated (current disk) versions to sit on top of git history.
+   */
+  async loadGitHistory() {
+    const git = _FilesystemVersionedHelpers.gitHistory;
+    const dir = this.db.dir;
+    const isRepo = await git.isGitRepo(dir);
+    if (!isRepo) return;
+    const commits = await git.getFileHistory(dir, this.entitiesFile, this.gitHistoryLimit);
+    if (commits.length === 0) return;
+    const orderedCommits = [...commits].reverse();
+    const entityVersionCount = /* @__PURE__ */ new Map();
+    const previousSnapshots = /* @__PURE__ */ new Map();
+    for (let i = 0; i < orderedCommits.length; i++) {
+      const commit = orderedCommits[i];
+      const fileContent = await git.getFileAtCommit(
+        dir,
+        commit.hash,
+        this.entitiesFile
+      );
+      if (!fileContent) continue;
+      for (const [entityId, snapshotConfig] of Object.entries(fileContent)) {
+        if (!snapshotConfig || typeof snapshotConfig !== "object") continue;
+        const serialized = JSON.stringify(snapshotConfig);
+        if (previousSnapshots.get(entityId) === serialized) continue;
+        previousSnapshots.set(entityId, serialized);
+        const count = (entityVersionCount.get(entityId) ?? 0) + 1;
+        entityVersionCount.set(entityId, count);
+        const versionId = `${GIT_VERSION_PREFIX}${commit.hash}-${entityId}`;
+        if (this.versions.has(versionId)) continue;
+        const version = {
+          id: versionId,
+          [this.parentIdField]: entityId,
+          versionNumber: count,
+          changeMessage: commit.message,
+          ...snapshotConfig,
+          createdAt: commit.date
+        };
+        this.versions.set(versionId, version);
+      }
+    }
+    this.gitVersionCounts = entityVersionCount;
+    for (const [entityId, gitCount] of entityVersionCount) {
+      const hydratedVersionId = `hydrated-${entityId}-v1`;
+      const version = this.versions.get(hydratedVersionId);
+      if (version) {
+        version.versionNumber = gitCount + 1;
+      }
+    }
+  }
+  // ==========================================================================
+  // Disk persistence — only published snapshot configs
+  // ==========================================================================
+  /**
+   * Write the published snapshot config for an entity to disk.
+   * Strips all entity metadata and version metadata fields, leaving only
+   * the clean primitive configuration.
+   */
+  persistToDisk() {
+    const diskData = {};
+    for (const [entityId, entity] of this.entities) {
+      if (entity.status !== "published" || !entity.activeVersionId) continue;
+      const version = this.versions.get(entity.activeVersionId);
+      if (!version) continue;
+      const snapshotConfig = this.extractSnapshotConfig(version);
+      diskData[entityId] = snapshotConfig;
+    }
+    this.db.writeDomain(this.entitiesFile, diskData);
+  }
+  /**
+   * Extract the snapshot config from a version, stripping version metadata fields.
+   */
+  extractSnapshotConfig(version) {
+    const metadataSet = new Set(this.versionMetadataFields);
+    const result = {};
+    for (const [key, value] of Object.entries(version)) {
+      if (!metadataSet.has(key)) {
+        result[key] = value;
+      }
+    }
+    return result;
+  }
+  // ==========================================================================
+  // Entity CRUD
+  // ==========================================================================
+  async getById(id) {
+    this.hydrate();
+    return this.entities.has(id) ? structuredClone(this.entities.get(id)) : null;
+  }
+  async createEntity(id, entity) {
+    this.hydrate();
+    if (this.entities.has(id)) {
+      throw new Error(`${this.name}: entity with id ${id} already exists`);
+    }
+    this.entities.set(id, structuredClone(entity));
+    return structuredClone(entity);
+  }
+  async updateEntity(id, updates) {
+    this.hydrate();
+    const existing = this.entities.get(id);
+    if (!existing) {
+      throw new Error(`${this.name}: entity with id ${id} not found`);
+    }
+    const updated = { ...existing };
+    for (const [key, value] of Object.entries(updates)) {
+      if (key === "id") continue;
+      if (value === void 0) continue;
+      if (key === "metadata" && typeof value === "object" && value !== null) {
+        updated["metadata"] = {
+          ...updated["metadata"] ?? {},
+          ...value
+        };
+      } else {
+        updated[key] = value;
+      }
+    }
+    updated["updatedAt"] = /* @__PURE__ */ new Date();
+    const updatedEntity = updated;
+    this.entities.set(id, structuredClone(updatedEntity));
+    const wasPublished = existing.status === "published";
+    const isPublished = updatedEntity.status === "published" && updatedEntity.activeVersionId;
+    if (isPublished || wasPublished && updates["status"] !== void 0) {
+      this.persistToDisk();
+    }
+    return structuredClone(updatedEntity);
+  }
+  async deleteEntity(id) {
+    this.hydrate();
+    this.entities.delete(id);
+    await this.deleteVersionsByParentId(id);
+    this.persistToDisk();
+  }
+  async listEntities(args) {
+    this.hydrate();
+    const { page = 0, perPage: perPageInput, orderBy, filters, listKey } = args;
+    const perPage = normalizePerPage(perPageInput, 100);
+    if (page < 0) throw new Error("page must be >= 0");
+    let entities = Array.from(this.entities.values());
+    if (filters) {
+      for (const [key, value] of Object.entries(filters)) {
+        if (value === void 0) continue;
+        if (key === "metadata" && typeof value === "object" && value !== null) {
+          entities = entities.filter((e) => {
+            const meta = e["metadata"];
+            if (!meta) return false;
+            return Object.entries(value).every(
+              ([k, v]) => JSON.stringify(meta[k]) === JSON.stringify(v)
+            );
+          });
+        } else {
+          entities = entities.filter((e) => e[key] === value);
+        }
+      }
+    }
+    const field = orderBy?.field ?? "createdAt";
+    const direction = orderBy?.direction ?? "DESC";
+    entities.sort((a, b) => {
+      const aVal = new Date(a[field]).getTime();
+      const bVal = new Date(b[field]).getTime();
+      return direction === "ASC" ? aVal - bVal : bVal - aVal;
+    });
+    const { offset, perPage: perPageForResponse } = calculatePagination(page, perPageInput, perPage);
+    return {
+      [listKey]: entities.slice(offset, offset + perPage),
+      total: entities.length,
+      page,
+      perPage: perPageForResponse,
+      hasMore: offset + perPage < entities.length
+    };
+  }
+  // ==========================================================================
+  // Version Methods (in-memory + git history)
+  // ==========================================================================
+  async createVersion(input) {
+    await this.ensureGitHistory();
+    if (this.versions.has(input.id)) {
+      throw new Error(`${this.name}: version with id ${input.id} already exists`);
+    }
+    const parentId = input[this.parentIdField];
+    for (const v of this.versions.values()) {
+      if (v[this.parentIdField] === parentId && v.versionNumber === input.versionNumber) {
+        throw new Error(`${this.name}: version number ${input.versionNumber} already exists for entity ${parentId}`);
+      }
+    }
+    const version = {
+      ...input,
+      createdAt: /* @__PURE__ */ new Date()
+    };
+    this.versions.set(input.id, structuredClone(version));
+    return structuredClone(version);
+  }
+  async getVersion(id) {
+    await this.ensureGitHistory();
+    return this.versions.has(id) ? structuredClone(this.versions.get(id)) : null;
+  }
+  async getVersionByNumber(entityId, versionNumber) {
+    await this.ensureGitHistory();
+    for (const v of this.versions.values()) {
+      if (v[this.parentIdField] === entityId && v.versionNumber === versionNumber) {
+        return structuredClone(v);
+      }
+    }
+    return null;
+  }
+  async getLatestVersion(entityId) {
+    await this.ensureGitHistory();
+    let latest = null;
+    for (const v of this.versions.values()) {
+      if (v[this.parentIdField] === entityId) {
+        if (!latest || v.versionNumber > latest.versionNumber) {
+          latest = v;
+        }
+      }
+    }
+    return latest ? structuredClone(latest) : null;
+  }
+  async listVersions(input, parentIdField) {
+    await this.ensureGitHistory();
+    const { page = 0, perPage: perPageInput, orderBy } = input;
+    const entityId = input[parentIdField];
+    const perPage = normalizePerPage(perPageInput, 20);
+    if (page < 0) throw new Error("page must be >= 0");
+    let versions = Array.from(this.versions.values()).filter(
+      (v) => v[this.parentIdField] === entityId
+    );
+    const field = orderBy?.field ?? "versionNumber";
+    const direction = orderBy?.direction ?? "DESC";
+    versions.sort((a, b) => {
+      const aVal = field === "createdAt" ? new Date(a.createdAt).getTime() : a.versionNumber;
+      const bVal = field === "createdAt" ? new Date(b.createdAt).getTime() : b.versionNumber;
+      return direction === "ASC" ? aVal - bVal : bVal - aVal;
+    });
+    const { offset, perPage: perPageForResponse } = calculatePagination(page, perPageInput, perPage);
+    return {
+      versions: versions.slice(offset, offset + perPage),
+      total: versions.length,
+      page,
+      perPage: perPageForResponse,
+      hasMore: offset + perPage < versions.length
+    };
+  }
+  async deleteVersion(id) {
+    await this.ensureGitHistory();
+    if (_FilesystemVersionedHelpers.isGitVersion(id)) return;
+    this.versions.delete(id);
+  }
+  async deleteVersionsByParentId(entityId) {
+    await this.ensureGitHistory();
+    for (const [versionId, version] of this.versions) {
+      if (version[this.parentIdField] === entityId) {
+        if (_FilesystemVersionedHelpers.isGitVersion(versionId)) continue;
+        this.versions.delete(versionId);
+      }
+    }
+  }
+  async countVersions(entityId) {
+    await this.ensureGitHistory();
+    let count = 0;
+    for (const v of this.versions.values()) {
+      if (v[this.parentIdField] === entityId) {
+        count++;
+      }
+    }
+    return count;
+  }
+  async getNextVersionNumber(entityId) {
+    await this.ensureGitHistory();
+    return this._getNextVersionNumber(entityId);
+  }
+  _getNextVersionNumber(entityId) {
+    const gitCount = this.gitVersionCounts.get(entityId) ?? 0;
+    let maxVersion = gitCount;
+    for (const v of this.versions.values()) {
+      if (v[this.parentIdField] === entityId) {
+        maxVersion = Math.max(maxVersion, v.versionNumber);
+      }
+    }
+    return maxVersion + 1;
+  }
+  async dangerouslyClearAll() {
+    this.entities.clear();
+    this.versions.clear();
+    this.gitVersionCounts.clear();
+    this.gitHistoryPromise = null;
+    this.hydrated = false;
+    this.db.clearDomain(this.entitiesFile);
+  }
+};
+
+// src/storage/domains/agents/filesystem.ts
+var PERSISTED_SNAPSHOT_FIELDS = /* @__PURE__ */ new Set([
+  "name",
+  "instructions",
+  "model",
+  "tools",
+  "integrationTools",
+  "mcpClients",
+  "requestContextSchema"
+]);
+function stripUnusedFields(obj) {
+  const result = {};
+  for (const [key, value] of Object.entries(obj)) {
+    if (PERSISTED_SNAPSHOT_FIELDS.has(key)) {
+      result[key] = value;
+    }
+  }
+  return result;
+}
+var FilesystemAgentsStorage = class extends AgentsStorage {
+  helpers;
+  constructor({ db }) {
+    super();
+    this.helpers = new FilesystemVersionedHelpers({
+      db,
+      entitiesFile: "agents.json",
+      parentIdField: "agentId",
+      name: "FilesystemAgentsStorage",
+      versionMetadataFields: ["id", "agentId", "versionNumber", "changedFields", "changeMessage", "createdAt"]
+    });
+  }
+  async init() {
+    await this.helpers.db.init();
+  }
+  async dangerouslyClearAll() {
+    await this.helpers.dangerouslyClearAll();
+  }
+  async getById(id) {
+    return this.helpers.getById(id);
+  }
+  async create(input) {
+    const { agent } = input;
+    const now = /* @__PURE__ */ new Date();
+    const entity = {
+      id: agent.id,
+      status: "draft",
+      activeVersionId: void 0,
+      authorId: agent.authorId,
+      metadata: agent.metadata,
+      createdAt: now,
+      updatedAt: now
+    };
+    await this.helpers.createEntity(agent.id, entity);
+    const { id: _id, authorId: _authorId, metadata: _metadata, ...snapshotConfig } = agent;
+    const filtered = stripUnusedFields(snapshotConfig);
+    const versionId = crypto.randomUUID();
+    await this.createVersion({
+      id: versionId,
+      agentId: agent.id,
+      versionNumber: 1,
+      ...filtered,
+      changedFields: Object.keys(filtered),
+      changeMessage: "Initial version"
+    });
+    return structuredClone(entity);
+  }
+  async update(input) {
+    const { id, ...updates } = input;
+    const entityUpdates = {};
+    const entityFields = /* @__PURE__ */ new Set(["authorId", "metadata", "activeVersionId", "status"]);
+    for (const [key, value] of Object.entries(updates)) {
+      if (entityFields.has(key)) {
+        entityUpdates[key] = value;
+      }
+    }
+    return this.helpers.updateEntity(id, entityUpdates);
+  }
+  async delete(id) {
+    await this.helpers.deleteEntity(id);
+  }
+  async list(args) {
+    const { page, perPage, orderBy, authorId, metadata, status } = args || {};
+    const result = await this.helpers.listEntities({
+      page,
+      perPage,
+      orderBy,
+      listKey: "agents",
+      filters: { authorId, metadata, status }
+    });
+    return result;
+  }
+  async createVersion(input) {
+    const { id, agentId, versionNumber, changedFields, changeMessage, ...snapshotFields } = input;
+    const filtered = stripUnusedFields(snapshotFields);
+    return this.helpers.createVersion({
+      id,
+      agentId,
+      versionNumber,
+      changedFields,
+      changeMessage,
+      ...filtered
+    });
+  }
+  async getVersion(id) {
+    return this.helpers.getVersion(id);
+  }
+  async getVersionByNumber(agentId, versionNumber) {
+    return this.helpers.getVersionByNumber(agentId, versionNumber);
+  }
+  async getLatestVersion(agentId) {
+    return this.helpers.getLatestVersion(agentId);
+  }
+  async listVersions(input) {
+    const result = await this.helpers.listVersions(input, "agentId");
+    return result;
+  }
+  async deleteVersion(id) {
+    await this.helpers.deleteVersion(id);
+  }
+  async deleteVersionsByParentId(entityId) {
+    await this.helpers.deleteVersionsByParentId(entityId);
+  }
+  async countVersions(agentId) {
+    return this.helpers.countVersions(agentId);
+  }
+};
+
+// src/storage/domains/mcp-clients/filesystem.ts
+var FilesystemMCPClientsStorage = class extends MCPClientsStorage {
+  helpers;
+  constructor({ db }) {
+    super();
+    this.helpers = new FilesystemVersionedHelpers({
+      db,
+      entitiesFile: "mcp-clients.json",
+      parentIdField: "mcpClientId",
+      name: "FilesystemMCPClientsStorage",
+      versionMetadataFields: ["id", "mcpClientId", "versionNumber", "changedFields", "changeMessage", "createdAt"]
+    });
+  }
+  async init() {
+    await this.helpers.db.init();
+  }
+  async dangerouslyClearAll() {
+    await this.helpers.dangerouslyClearAll();
+  }
+  async getById(id) {
+    return this.helpers.getById(id);
+  }
+  async create(input) {
+    const { mcpClient } = input;
+    const now = /* @__PURE__ */ new Date();
+    const entity = {
+      id: mcpClient.id,
+      status: "draft",
+      activeVersionId: void 0,
+      authorId: mcpClient.authorId,
+      metadata: mcpClient.metadata,
+      createdAt: now,
+      updatedAt: now
+    };
+    await this.helpers.createEntity(mcpClient.id, entity);
+    const { id: _id, authorId: _authorId, metadata: _metadata, ...snapshotConfig } = mcpClient;
+    const versionId = crypto.randomUUID();
+    await this.createVersion({
+      id: versionId,
+      mcpClientId: mcpClient.id,
+      versionNumber: 1,
+      ...snapshotConfig,
+      changedFields: Object.keys(snapshotConfig),
+      changeMessage: "Initial version"
+    });
+    return structuredClone(entity);
+  }
+  async update(input) {
+    const { id, ...updates } = input;
+    return this.helpers.updateEntity(id, updates);
+  }
+  async delete(id) {
+    await this.helpers.deleteEntity(id);
+  }
+  async list(args) {
+    const { page, perPage, orderBy, authorId, metadata, status } = args || {};
+    const result = await this.helpers.listEntities({
+      page,
+      perPage,
+      orderBy,
+      listKey: "mcpClients",
+      filters: { authorId, metadata, status }
+    });
+    return result;
+  }
+  async createVersion(input) {
+    return this.helpers.createVersion(input);
+  }
+  async getVersion(id) {
+    return this.helpers.getVersion(id);
+  }
+  async getVersionByNumber(mcpClientId, versionNumber) {
+    return this.helpers.getVersionByNumber(mcpClientId, versionNumber);
+  }
+  async getLatestVersion(mcpClientId) {
+    return this.helpers.getLatestVersion(mcpClientId);
+  }
+  async listVersions(input) {
+    const result = await this.helpers.listVersions(input, "mcpClientId");
+    return result;
+  }
+  async deleteVersion(id) {
+    await this.helpers.deleteVersion(id);
+  }
+  async deleteVersionsByParentId(entityId) {
+    await this.helpers.deleteVersionsByParentId(entityId);
+  }
+  async countVersions(mcpClientId) {
+    return this.helpers.countVersions(mcpClientId);
+  }
+};
+
+// src/storage/domains/mcp-servers/filesystem.ts
+var FilesystemMCPServersStorage = class extends MCPServersStorage {
+  helpers;
+  constructor({ db }) {
+    super();
+    this.helpers = new FilesystemVersionedHelpers({
+      db,
+      entitiesFile: "mcp-servers.json",
+      parentIdField: "mcpServerId",
+      name: "FilesystemMCPServersStorage",
+      versionMetadataFields: ["id", "mcpServerId", "versionNumber", "changedFields", "changeMessage", "createdAt"]
+    });
+  }
+  async init() {
+    await this.helpers.db.init();
+  }
+  async dangerouslyClearAll() {
+    await this.helpers.dangerouslyClearAll();
+  }
+  async getById(id) {
+    return this.helpers.getById(id);
+  }
+  async create(input) {
+    const { mcpServer } = input;
+    const now = /* @__PURE__ */ new Date();
+    const entity = {
+      id: mcpServer.id,
+      status: "draft",
+      activeVersionId: void 0,
+      authorId: mcpServer.authorId,
+      metadata: mcpServer.metadata,
+      createdAt: now,
+      updatedAt: now
+    };
+    await this.helpers.createEntity(mcpServer.id, entity);
+    const { id: _id, authorId: _authorId, metadata: _metadata, ...snapshotConfig } = mcpServer;
+    const versionId = crypto.randomUUID();
+    await this.createVersion({
+      id: versionId,
+      mcpServerId: mcpServer.id,
+      versionNumber: 1,
+      ...snapshotConfig,
+      changedFields: Object.keys(snapshotConfig),
+      changeMessage: "Initial version"
+    });
+    return structuredClone(entity);
+  }
+  async update(input) {
+    const { id, ...updates } = input;
+    return this.helpers.updateEntity(id, updates);
+  }
+  async delete(id) {
+    await this.helpers.deleteEntity(id);
+  }
+  async list(args) {
+    const { page, perPage, orderBy, authorId, metadata, status } = args || {};
+    const result = await this.helpers.listEntities({
+      page,
+      perPage,
+      orderBy,
+      listKey: "mcpServers",
+      filters: { authorId, metadata, status }
+    });
+    return result;
+  }
+  async createVersion(input) {
+    return this.helpers.createVersion(input);
+  }
+  async getVersion(id) {
+    return this.helpers.getVersion(id);
+  }
+  async getVersionByNumber(mcpServerId, versionNumber) {
+    return this.helpers.getVersionByNumber(mcpServerId, versionNumber);
+  }
+  async getLatestVersion(mcpServerId) {
+    return this.helpers.getLatestVersion(mcpServerId);
+  }
+  async listVersions(input) {
+    const result = await this.helpers.listVersions(input, "mcpServerId");
+    return result;
+  }
+  async deleteVersion(id) {
+    await this.helpers.deleteVersion(id);
+  }
+  async deleteVersionsByParentId(entityId) {
+    await this.helpers.deleteVersionsByParentId(entityId);
+  }
+  async countVersions(mcpServerId) {
+    return this.helpers.countVersions(mcpServerId);
+  }
+};
+
+// src/storage/domains/prompt-blocks/filesystem.ts
+var FilesystemPromptBlocksStorage = class extends PromptBlocksStorage {
+  helpers;
+  constructor({ db }) {
+    super();
+    this.helpers = new FilesystemVersionedHelpers({
+      db,
+      entitiesFile: "prompt-blocks.json",
+      parentIdField: "blockId",
+      name: "FilesystemPromptBlocksStorage",
+      versionMetadataFields: ["id", "blockId", "versionNumber", "changedFields", "changeMessage", "createdAt"]
+    });
+  }
+  async init() {
+    await this.helpers.db.init();
+  }
+  async dangerouslyClearAll() {
+    await this.helpers.dangerouslyClearAll();
+  }
+  async getById(id) {
+    return this.helpers.getById(id);
+  }
+  async create(input) {
+    const { promptBlock } = input;
+    const now = /* @__PURE__ */ new Date();
+    const entity = {
+      id: promptBlock.id,
+      status: "draft",
+      activeVersionId: void 0,
+      authorId: promptBlock.authorId,
+      metadata: promptBlock.metadata,
+      createdAt: now,
+      updatedAt: now
+    };
+    await this.helpers.createEntity(promptBlock.id, entity);
+    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 structuredClone(entity);
+  }
+  async update(input) {
+    const { id, ...updates } = input;
+    return this.helpers.updateEntity(id, updates);
+  }
+  async delete(id) {
+    await this.helpers.deleteEntity(id);
+  }
+  async list(args) {
+    const { page, perPage, orderBy, authorId, metadata, status } = args || {};
+    const result = await this.helpers.listEntities({
+      page,
+      perPage,
+      orderBy,
+      listKey: "promptBlocks",
+      filters: { authorId, metadata, status }
+    });
+    return result;
+  }
+  async createVersion(input) {
+    return this.helpers.createVersion(input);
+  }
+  async getVersion(id) {
+    return this.helpers.getVersion(id);
+  }
+  async getVersionByNumber(blockId, versionNumber) {
+    return this.helpers.getVersionByNumber(blockId, versionNumber);
+  }
+  async getLatestVersion(blockId) {
+    return this.helpers.getLatestVersion(blockId);
+  }
+  async listVersions(input) {
+    const result = await this.helpers.listVersions(input, "blockId");
+    return result;
+  }
+  async deleteVersion(id) {
+    await this.helpers.deleteVersion(id);
+  }
+  async deleteVersionsByParentId(entityId) {
+    await this.helpers.deleteVersionsByParentId(entityId);
+  }
+  async countVersions(blockId) {
+    return this.helpers.countVersions(blockId);
+  }
+};
+
+// src/storage/domains/scorer-definitions/filesystem.ts
+var FilesystemScorerDefinitionsStorage = class extends ScorerDefinitionsStorage {
+  helpers;
+  constructor({ db }) {
+    super();
+    this.helpers = new FilesystemVersionedHelpers({
+      db,
+      entitiesFile: "scorer-definitions.json",
+      parentIdField: "scorerDefinitionId",
+      name: "FilesystemScorerDefinitionsStorage",
+      versionMetadataFields: [
+        "id",
+        "scorerDefinitionId",
+        "versionNumber",
+        "changedFields",
+        "changeMessage",
+        "createdAt"
+      ]
+    });
+  }
+  async init() {
+    await this.helpers.db.init();
+  }
+  async dangerouslyClearAll() {
+    await this.helpers.dangerouslyClearAll();
+  }
+  async getById(id) {
+    return this.helpers.getById(id);
+  }
+  async create(input) {
+    const { scorerDefinition } = input;
+    const now = /* @__PURE__ */ new Date();
+    const entity = {
+      id: scorerDefinition.id,
+      status: "draft",
+      activeVersionId: void 0,
+      authorId: scorerDefinition.authorId,
+      metadata: scorerDefinition.metadata,
+      createdAt: now,
+      updatedAt: now
+    };
+    await this.helpers.createEntity(scorerDefinition.id, entity);
+    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 structuredClone(entity);
+  }
+  async update(input) {
+    const { id, ...updates } = input;
+    return this.helpers.updateEntity(id, updates);
+  }
+  async delete(id) {
+    await this.helpers.deleteEntity(id);
+  }
+  async list(args) {
+    const { page, perPage, orderBy, authorId, metadata, status } = args || {};
+    const result = await this.helpers.listEntities({
+      page,
+      perPage,
+      orderBy,
+      listKey: "scorerDefinitions",
+      filters: { authorId, metadata, status }
+    });
+    return result;
+  }
+  async createVersion(input) {
+    return this.helpers.createVersion(input);
+  }
+  async getVersion(id) {
+    return this.helpers.getVersion(id);
+  }
+  async getVersionByNumber(scorerDefinitionId, versionNumber) {
+    return this.helpers.getVersionByNumber(scorerDefinitionId, versionNumber);
+  }
+  async getLatestVersion(scorerDefinitionId) {
+    return this.helpers.getLatestVersion(scorerDefinitionId);
+  }
+  async listVersions(input) {
+    const result = await this.helpers.listVersions(input, "scorerDefinitionId");
+    return result;
+  }
+  async deleteVersion(id) {
+    await this.helpers.deleteVersion(id);
+  }
+  async deleteVersionsByParentId(entityId) {
+    await this.helpers.deleteVersionsByParentId(entityId);
+  }
+  async countVersions(scorerDefinitionId) {
+    return this.helpers.countVersions(scorerDefinitionId);
+  }
+};
+
+// src/storage/domains/skills/filesystem.ts
+var FilesystemSkillsStorage = class extends SkillsStorage {
+  helpers;
+  constructor({ db }) {
+    super();
+    this.helpers = new FilesystemVersionedHelpers({
+      db,
+      entitiesFile: "skills.json",
+      parentIdField: "skillId",
+      name: "FilesystemSkillsStorage",
+      versionMetadataFields: ["id", "skillId", "versionNumber", "changedFields", "changeMessage", "createdAt"]
+    });
+  }
+  async init() {
+    await this.helpers.db.init();
+  }
+  async dangerouslyClearAll() {
+    await this.helpers.dangerouslyClearAll();
+  }
+  async getById(id) {
+    return this.helpers.getById(id);
+  }
+  async create(input) {
+    const { skill } = input;
+    const now = /* @__PURE__ */ new Date();
+    const entity = {
+      id: skill.id,
+      status: "draft",
+      activeVersionId: void 0,
+      authorId: skill.authorId,
+      createdAt: now,
+      updatedAt: now
+    };
+    await this.helpers.createEntity(skill.id, entity);
+    const { id: _id, authorId: _authorId, ...snapshotConfig } = skill;
+    const versionId = crypto.randomUUID();
+    await this.createVersion({
+      id: versionId,
+      skillId: skill.id,
+      versionNumber: 1,
+      ...snapshotConfig,
+      changedFields: Object.keys(snapshotConfig),
+      changeMessage: "Initial version"
+    });
+    return structuredClone(entity);
+  }
+  async update(input) {
+    const { id, ...updates } = input;
+    const existing = await this.helpers.getById(id);
+    if (!existing) {
+      throw new Error(`FilesystemSkillsStorage: skill with id ${id} not found`);
+    }
+    const { authorId, activeVersionId, status, ...configFields } = updates;
+    const configFieldNames = [
+      "name",
+      "description",
+      "instructions",
+      "license",
+      "compatibility",
+      "source",
+      "references",
+      "scripts",
+      "assets",
+      "metadata",
+      "tree"
+    ];
+    const hasConfigUpdate = configFieldNames.some((field) => field in configFields);
+    if (hasConfigUpdate) {
+      const latestVersion = await this.getLatestVersion(id);
+      if (!latestVersion) {
+        throw new Error(`No versions found for skill ${id}`);
+      }
+      const {
+        id: _versionId,
+        skillId: _skillId,
+        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,
+          skillId: id,
+          versionNumber: newVersionNumber,
+          ...newConfig,
+          changedFields,
+          changeMessage: `Updated ${changedFields.join(", ")}`
+        });
+      }
+    }
+    const entityUpdates = {
+      ...authorId !== void 0 && { authorId },
+      ...activeVersionId !== void 0 && { activeVersionId },
+      ...status !== void 0 && { status }
+    };
+    if (activeVersionId !== void 0 && status === void 0) {
+      entityUpdates.status = "published";
+    }
+    return await this.helpers.updateEntity(id, entityUpdates);
+  }
+  async delete(id) {
+    await this.helpers.deleteEntity(id);
+  }
+  async list(args) {
+    const { page, perPage, orderBy, authorId, metadata } = args || {};
+    const result = await this.helpers.listEntities({
+      page,
+      perPage,
+      orderBy,
+      listKey: "skills",
+      filters: { authorId, metadata }
+    });
+    return result;
+  }
+  async createVersion(input) {
+    return this.helpers.createVersion(input);
+  }
+  async getVersion(id) {
+    return this.helpers.getVersion(id);
+  }
+  async getVersionByNumber(skillId, versionNumber) {
+    return this.helpers.getVersionByNumber(skillId, versionNumber);
+  }
+  async getLatestVersion(skillId) {
+    return this.helpers.getLatestVersion(skillId);
+  }
+  async listVersions(input) {
+    const result = await this.helpers.listVersions(input, "skillId");
+    return result;
+  }
+  async deleteVersion(id) {
+    await this.helpers.deleteVersion(id);
+  }
+  async deleteVersionsByParentId(entityId) {
+    await this.helpers.deleteVersionsByParentId(entityId);
+  }
+  async countVersions(skillId) {
+    return this.helpers.countVersions(skillId);
+  }
+};
+
+// src/storage/domains/workspaces/filesystem.ts
+var FilesystemWorkspacesStorage = class extends WorkspacesStorage {
+  helpers;
+  constructor({ db }) {
+    super();
+    this.helpers = new FilesystemVersionedHelpers({
+      db,
+      entitiesFile: "workspaces.json",
+      parentIdField: "workspaceId",
+      name: "FilesystemWorkspacesStorage",
+      versionMetadataFields: ["id", "workspaceId", "versionNumber", "changedFields", "changeMessage", "createdAt"]
+    });
+  }
+  async init() {
+    await this.helpers.db.init();
+  }
+  async dangerouslyClearAll() {
+    await this.helpers.dangerouslyClearAll();
+  }
+  async getById(id) {
+    return this.helpers.getById(id);
+  }
+  async create(input) {
+    const { workspace } = input;
+    const now = /* @__PURE__ */ new Date();
+    const entity = {
+      id: workspace.id,
+      status: "draft",
+      activeVersionId: void 0,
+      authorId: workspace.authorId,
+      metadata: workspace.metadata,
+      createdAt: now,
+      updatedAt: now
+    };
+    await this.helpers.createEntity(workspace.id, entity);
+    const { id: _id, authorId: _authorId, metadata: _metadata, ...snapshotConfig } = workspace;
+    const versionId = crypto.randomUUID();
+    await this.createVersion({
+      id: versionId,
+      workspaceId: workspace.id,
+      versionNumber: 1,
+      ...snapshotConfig,
+      changedFields: Object.keys(snapshotConfig),
+      changeMessage: "Initial version"
+    });
+    return structuredClone(entity);
+  }
+  async update(input) {
+    const { id, ...updates } = input;
+    return this.helpers.updateEntity(id, updates);
+  }
+  async delete(id) {
+    await this.helpers.deleteEntity(id);
+  }
+  async list(args) {
+    const { page, perPage, orderBy, authorId, metadata } = args || {};
+    const result = await this.helpers.listEntities({
+      page,
+      perPage,
+      orderBy,
+      listKey: "workspaces",
+      filters: { authorId, metadata }
+    });
+    return result;
+  }
+  async createVersion(input) {
+    return this.helpers.createVersion(input);
+  }
+  async getVersion(id) {
+    return this.helpers.getVersion(id);
+  }
+  async getVersionByNumber(workspaceId, versionNumber) {
+    return this.helpers.getVersionByNumber(workspaceId, versionNumber);
+  }
+  async getLatestVersion(workspaceId) {
+    return this.helpers.getLatestVersion(workspaceId);
+  }
+  async listVersions(input) {
+    const result = await this.helpers.listVersions(input, "workspaceId");
+    return result;
+  }
+  async deleteVersion(id) {
+    await this.helpers.deleteVersion(id);
+  }
+  async deleteVersionsByParentId(entityId) {
+    await this.helpers.deleteVersionsByParentId(entityId);
+  }
+  async countVersions(workspaceId) {
+    return this.helpers.countVersions(workspaceId);
+  }
+};
+var FilesystemDB = class {
+  dir;
+  /** In-memory cache of parsed domain data, keyed by filename */
+  cache = /* @__PURE__ */ new Map();
+  initialized = false;
+  constructor(dir) {
+    this.dir = dir;
+  }
+  /**
+   * Initialize the storage directory. Called once; subsequent calls are no-ops.
+   */
+  async init() {
+    if (this.initialized) return;
+    this.ensureDir();
+    this.initialized = true;
+  }
+  /**
+   * Ensure the storage directory and skills subdirectory exist.
+   */
+  ensureDir() {
+    if (!fs.existsSync(this.dir)) {
+      fs.mkdirSync(this.dir, { recursive: true });
+    }
+    const skillsDir = path.join(this.dir, "skills");
+    if (!fs.existsSync(skillsDir)) {
+      fs.mkdirSync(skillsDir, { recursive: true });
+    }
+  }
+  // ==========================================================================
+  // Domain-level JSON operations
+  // ==========================================================================
+  /**
+   * Read a domain JSON file and return its entity map.
+   * Uses in-memory cache; reads from disk on first access.
+   */
+  readDomain(filename) {
+    if (this.cache.has(filename)) {
+      return this.cache.get(filename);
+    }
+    const filePath = path.join(this.dir, filename);
+    let data = {};
+    if (fs.existsSync(filePath)) {
+      try {
+        const raw = fs.readFileSync(filePath, "utf-8");
+        data = JSON.parse(raw, dateReviver);
+      } catch {
+        data = {};
+      }
+    }
+    this.cache.set(filename, data);
+    return data;
+  }
+  /**
+   * Write a domain's full entity map to its JSON file.
+   * Uses atomic write (write to .tmp, then rename) to prevent corruption.
+   */
+  writeDomain(filename, data) {
+    this.cache.set(filename, data);
+    const filePath = path.join(this.dir, filename);
+    const tmpPath = filePath + ".tmp";
+    const parentDir = path.dirname(filePath);
+    if (!fs.existsSync(parentDir)) {
+      fs.mkdirSync(parentDir, { recursive: true });
+    }
+    fs.writeFileSync(tmpPath, JSON.stringify(data, null, 2), "utf-8");
+    fs.renameSync(tmpPath, filePath);
+  }
+  /**
+   * Clear all data from a domain JSON file.
+   */
+  clearDomain(filename) {
+    this.writeDomain(filename, {});
+  }
+  /**
+   * Invalidate the in-memory cache for a domain, forcing a re-read from disk on next access.
+   */
+  invalidateCache(filename) {
+    if (filename) {
+      this.cache.delete(filename);
+    } else {
+      this.cache.clear();
+    }
+  }
+  // ==========================================================================
+  // Entity-level convenience methods (used by FilesystemVersionedHelpers)
+  // ==========================================================================
+  /**
+   * Get a single entity by ID from a domain JSON file.
+   */
+  get(filename, id) {
+    const data = this.readDomain(filename);
+    return data[id] ?? null;
+  }
+  /**
+   * Get all entities from a domain JSON file as an array.
+   */
+  getAll(filename) {
+    const data = this.readDomain(filename);
+    return Object.values(data);
+  }
+  /**
+   * Set (create or update) an entity in a domain JSON file.
+   */
+  set(filename, id, entity) {
+    const data = this.readDomain(filename);
+    data[id] = entity;
+    this.writeDomain(filename, data);
+  }
+  /**
+   * Remove an entity by ID from a domain JSON file. No-op if not found.
+   */
+  remove(filename, id) {
+    const data = this.readDomain(filename);
+    if (id in data) {
+      delete data[id];
+      this.writeDomain(filename, data);
+    }
+  }
+  // =========================================================================
+  // Skills directory operations (real file tree, not JSON)
+  // =========================================================================
+  /**
+   * Get the path to a skill's directory.
+   */
+  skillDir(skillName) {
+    const skillsBase = path.join(this.dir, "skills");
+    const dir = path.resolve(skillsBase, skillName);
+    if (!dir.startsWith(skillsBase + path.sep) && dir !== skillsBase) {
+      throw new Error(`Path traversal detected: skill name "${skillName}" escapes skills directory`);
+    }
+    return dir;
+  }
+  /**
+   * Resolve a file path within a skill directory, throwing if it escapes.
+   */
+  safeSkillPath(skillName, relativePath) {
+    const base = this.skillDir(skillName);
+    const resolved = path.resolve(base, relativePath);
+    if (!resolved.startsWith(base + path.sep) && resolved !== base) {
+      throw new Error(`Path traversal detected: "${relativePath}" escapes skill directory`);
+    }
+    return resolved;
+  }
+  /**
+   * List all files in a skill's directory, returning relative paths.
+   */
+  listSkillFiles(skillName) {
+    const dir = this.skillDir(skillName);
+    if (!fs.existsSync(dir)) return [];
+    return walkDir(dir).map((abs) => path.relative(dir, abs).split(path.sep).join("/"));
+  }
+  /**
+   * Read a file from a skill's directory.
+   */
+  readSkillFile(skillName, relativePath) {
+    const filePath = this.safeSkillPath(skillName, relativePath);
+    if (!fs.existsSync(filePath)) return null;
+    try {
+      return fs.readFileSync(filePath);
+    } catch {
+      return null;
+    }
+  }
+  /**
+   * Write a file to a skill's directory.
+   */
+  writeSkillFile(skillName, relativePath, content) {
+    const filePath = this.safeSkillPath(skillName, relativePath);
+    const parentDir = path.dirname(filePath);
+    if (!fs.existsSync(parentDir)) {
+      fs.mkdirSync(parentDir, { recursive: true });
+    }
+    fs.writeFileSync(filePath, content);
+  }
+  /**
+   * Delete a skill's entire directory.
+   */
+  deleteSkillDir(skillName) {
+    const dir = this.skillDir(skillName);
+    if (fs.existsSync(dir)) {
+      fs.rmSync(dir, { recursive: true, force: true });
+    }
+  }
+};
+function dateReviver(_key, value) {
+  if (typeof value === "string" && /^\d{4}-\d{2}-\d{2}T\d{2}:\d{2}:\d{2}/.test(value)) {
+    const d = new Date(value);
+    if (!isNaN(d.getTime())) return d;
+  }
+  return value;
+}
+function walkDir(dir) {
+  const results = [];
+  for (const entry of fs.readdirSync(dir)) {
+    const fullPath = path.join(dir, entry);
+    const stat = fs.statSync(fullPath);
+    if (stat.isDirectory()) {
+      results.push(...walkDir(fullPath));
+    } else {
+      results.push(fullPath);
+    }
+  }
+  return results;
+}
+
+// src/storage/filesystem.ts
+var FilesystemStore = class extends MastraCompositeStore {
+  #db;
+  #dir;
+  constructor(config = {}) {
+    const dir = path.resolve(config.dir ?? ".mastra-storage");
+    super({ id: "filesystem", name: "FilesystemStore" });
+    this.#dir = dir;
+    this.#db = new FilesystemDB(dir);
+    this.stores = {
+      agents: new FilesystemAgentsStorage({ db: this.#db }),
+      promptBlocks: new FilesystemPromptBlocksStorage({ db: this.#db }),
+      scorerDefinitions: new FilesystemScorerDefinitionsStorage({ db: this.#db }),
+      mcpClients: new FilesystemMCPClientsStorage({ db: this.#db }),
+      mcpServers: new FilesystemMCPServersStorage({ db: this.#db }),
+      workspaces: new FilesystemWorkspacesStorage({ db: this.#db }),
+      skills: new FilesystemSkillsStorage({ db: this.#db })
+    };
+  }
+  /**
+   * The absolute path to the storage directory.
+   */
+  get dir() {
+    return this.#dir;
+  }
+};
 
 // src/storage/domains/operations/base.ts
 var StoreOperations = class extends chunkRO47SMI7_cjs.MastraBase {
@@ -5497,7 +7021,7 @@ var StoreOperationsInMemory = class extends StoreOperations {
   async insert({ tableName, record }) {
     const table = this.data[tableName];
     let key = record.id;
-    if ([chunk3ZBLD2Y4_cjs.TABLE_WORKFLOW_SNAPSHOT].includes(tableName) && !record.id && record.run_id) {
+    if ([chunkHH76UOJL_cjs.TABLE_WORKFLOW_SNAPSHOT].includes(tableName) && !record.id && record.run_id) {
       key = record.workflow_name ? `${record.workflow_name}-${record.run_id}` : record.run_id;
       record.id = key;
     } else if (!record.id) {
@@ -5510,7 +7034,7 @@ var StoreOperationsInMemory = class extends StoreOperations {
     const table = this.data[tableName];
     for (const record of records) {
       let key = record.id;
-      if ([chunk3ZBLD2Y4_cjs.TABLE_WORKFLOW_SNAPSHOT].includes(tableName) && !record.id && record.run_id) {
+      if ([chunkHH76UOJL_cjs.TABLE_WORKFLOW_SNAPSHOT].includes(tableName) && !record.id && record.run_id) {
         key = record.run_id;
         record.id = key;
       } else if (!record.id) {
@@ -5557,8 +7081,20 @@ exports.AgentsStorage = AgentsStorage;
 exports.BlobStore = BlobStore;
 exports.DatasetsInMemory = DatasetsInMemory;
 exports.DatasetsStorage = DatasetsStorage;
+exports.EDITOR_DOMAINS = EDITOR_DOMAINS;
 exports.ExperimentsInMemory = ExperimentsInMemory;
 exports.ExperimentsStorage = ExperimentsStorage;
+exports.FilesystemAgentsStorage = FilesystemAgentsStorage;
+exports.FilesystemDB = FilesystemDB;
+exports.FilesystemMCPClientsStorage = FilesystemMCPClientsStorage;
+exports.FilesystemMCPServersStorage = FilesystemMCPServersStorage;
+exports.FilesystemPromptBlocksStorage = FilesystemPromptBlocksStorage;
+exports.FilesystemScorerDefinitionsStorage = FilesystemScorerDefinitionsStorage;
+exports.FilesystemSkillsStorage = FilesystemSkillsStorage;
+exports.FilesystemStore = FilesystemStore;
+exports.FilesystemVersionedHelpers = FilesystemVersionedHelpers;
+exports.FilesystemWorkspacesStorage = FilesystemWorkspacesStorage;
+exports.GitHistory = GitHistory;
 exports.InMemoryAgentsStorage = InMemoryAgentsStorage;
 exports.InMemoryBlobStore = InMemoryBlobStore;
 exports.InMemoryDB = InMemoryDB;
@@ -5610,5 +7146,5 @@ exports.safelyParseJSON = safelyParseJSON;
 exports.serializeDate = serializeDate;
 exports.transformRow = transformRow;
 exports.transformScoreRow = transformScoreRow;
-//# sourceMappingURL=chunk-ZBESCKPX.cjs.map
-//# sourceMappingURL=chunk-ZBESCKPX.cjs.map
+//# sourceMappingURL=chunk-7AHCLTZZ.cjs.map
+//# sourceMappingURL=chunk-7AHCLTZZ.cjs.map