mindcache 2.2.0 → 2.4.0

package/dist/cloud/index.mjs

@@ -10,21 +10,173 @@ var __export = (target, all) => {
     __defProp(target, name, { get: all[name], enumerable: true });
 };
 
+// src/local/IndexedDBAdapter.ts
+var IndexedDBAdapter_exports = {};
+__export(IndexedDBAdapter_exports, {
+  IndexedDBAdapter: () => IndexedDBAdapter
+});
+var IndexedDBAdapter;
+var init_IndexedDBAdapter = __esm({
+  "src/local/IndexedDBAdapter.ts"() {
+    IndexedDBAdapter = class {
+      constructor(config = {}) {
+        this.config = config;
+        this.dbName = config.dbName || "mindcache_db";
+        this.storeName = config.storeName || "mindcache_store";
+        this.key = config.key || "mindcache_data";
+      }
+      mindcache = null;
+      unsubscribe = null;
+      saveTimeout = null;
+      db = null;
+      dbName;
+      storeName;
+      key;
+      async attach(mc) {
+        if (this.mindcache) {
+          this.detach();
+        }
+        this.mindcache = mc;
+        await this.initDB();
+        await this.load();
+        const listener = () => {
+          if (this.mindcache && !this.mindcache.isRemoteUpdate()) {
+            this.scheduleSave();
+          }
+        };
+        mc.subscribeToAll(listener);
+        this.unsubscribe = () => mc.unsubscribeFromAll(listener);
+        console.log("\u{1F5C4}\uFE0F IndexedDBAdapter: Attached to MindCache instance");
+      }
+      detach() {
+        if (this.unsubscribe) {
+          this.unsubscribe();
+          this.unsubscribe = null;
+        }
+        if (this.saveTimeout) {
+          clearTimeout(this.saveTimeout);
+          this.saveTimeout = null;
+        }
+        this.mindcache = null;
+        if (this.db) {
+          this.db.close();
+          this.db = null;
+        }
+      }
+      initDB() {
+        return new Promise((resolve, reject) => {
+          const request = indexedDB.open(this.dbName);
+          request.onerror = () => {
+            console.error("MindCache: IndexedDB error:", request.error);
+            reject(request.error);
+          };
+          request.onsuccess = () => {
+            const db = request.result;
+            if (!db.objectStoreNames.contains(this.storeName)) {
+              const currentVersion = db.version;
+              db.close();
+              const upgradeRequest = indexedDB.open(this.dbName, currentVersion + 1);
+              upgradeRequest.onerror = () => {
+                console.error("MindCache: IndexedDB upgrade error:", upgradeRequest.error);
+                reject(upgradeRequest.error);
+              };
+              upgradeRequest.onupgradeneeded = () => {
+                const upgradeDb = upgradeRequest.result;
+                if (!upgradeDb.objectStoreNames.contains(this.storeName)) {
+                  upgradeDb.createObjectStore(this.storeName);
+                }
+              };
+              upgradeRequest.onsuccess = () => {
+                this.db = upgradeRequest.result;
+                resolve();
+              };
+            } else {
+              this.db = db;
+              resolve();
+            }
+          };
+          request.onupgradeneeded = () => {
+            const db = request.result;
+            if (!db.objectStoreNames.contains(this.storeName)) {
+              db.createObjectStore(this.storeName);
+            }
+          };
+        });
+      }
+      load() {
+        if (!this.db || !this.mindcache) {
+          return Promise.resolve();
+        }
+        return new Promise((resolve) => {
+          try {
+            const transaction = this.db.transaction([this.storeName], "readonly");
+            const store = transaction.objectStore(this.storeName);
+            const request = store.get(this.key);
+            request.onsuccess = () => {
+              if (request.result) {
+                this.mindcache.deserialize(request.result);
+                console.log("\u{1F5C4}\uFE0F IndexedDBAdapter: Loaded data from IndexedDB");
+              }
+              resolve();
+            };
+            request.onerror = () => {
+              console.error("MindCache: Failed to load from IndexedDB:", request.error);
+              resolve();
+            };
+          } catch (error) {
+            console.error("MindCache: Error accessing IndexedDB for load:", error);
+            resolve();
+          }
+        });
+      }
+      scheduleSave() {
+        if (this.saveTimeout) {
+          clearTimeout(this.saveTimeout);
+        }
+        this.saveTimeout = setTimeout(() => {
+          this.save();
+          this.saveTimeout = null;
+        }, this.config.debounceMs ?? 1e3);
+      }
+      save() {
+        if (!this.db || !this.mindcache) {
+          return;
+        }
+        try {
+          const data = this.mindcache.serialize();
+          const transaction = this.db.transaction([this.storeName], "readwrite");
+          const store = transaction.objectStore(this.storeName);
+          const request = store.put(data, this.key);
+          request.onsuccess = () => {
+            console.log("\u{1F5C4}\uFE0F IndexedDBAdapter: Saved to IndexedDB");
+          };
+          request.onerror = () => {
+            console.error("MindCache: Failed to save to IndexedDB:", request.error);
+          };
+        } catch (error) {
+          console.error("MindCache: Error accessing IndexedDB for save:", error);
+        }
+      }
+    };
+  }
+});
+
 // src/cloud/CloudAdapter.ts
 var CloudAdapter_exports = {};
 __export(CloudAdapter_exports, {
   CloudAdapter: () => CloudAdapter
 });
-var DEFAULT_BASE_URL, RECONNECT_DELAY, MAX_RECONNECT_DELAY, CloudAdapter;
+var RECONNECT_DELAY, MAX_RECONNECT_DELAY, CloudAdapter;
 var init_CloudAdapter = __esm({
   "src/cloud/CloudAdapter.ts"() {
-    DEFAULT_BASE_URL = "wss://api.mindcache.io";
     RECONNECT_DELAY = 1e3;
     MAX_RECONNECT_DELAY = 3e4;
     CloudAdapter = class {
       constructor(config) {
         this.config = config;
-        this.config.baseUrl = config.baseUrl || DEFAULT_BASE_URL;
+        if (!config.baseUrl) {
+          throw new Error("MindCache Cloud: baseUrl is required. Please provide the cloud API URL in your configuration.");
+        }
       }
       ws = null;
       queue = [];
@@ -85,6 +237,40 @@ var init_CloudAdapter = __esm({
         }
         this.mindcache = null;
       }
+      /**
+       * Fetch a short-lived WebSocket token from the API using the API key.
+       * This keeps the API key secure by only using it for a single HTTPS request,
+       * then using the short-lived token for the WebSocket connection.
+       *
+       * Supports two key formats:
+       * - API keys: mc_live_xxx or mc_test_xxx → Bearer token
+       * - Delegate keys: del_xxx:sec_xxx → ApiKey format
+       */
+      async fetchTokenWithApiKey() {
+        if (!this.config.apiKey) {
+          throw new Error("API key is required to fetch token");
+        }
+        const httpBaseUrl = this.config.baseUrl.replace("wss://", "https://").replace("ws://", "http://");
+        const isDelegate = this.config.apiKey.startsWith("del_") && this.config.apiKey.includes(":");
+        const authHeader = isDelegate ? `ApiKey ${this.config.apiKey}` : `Bearer ${this.config.apiKey}`;
+        const response = await fetch(`${httpBaseUrl}/api/ws-token`, {
+          method: "POST",
+          headers: {
+            "Content-Type": "application/json",
+            "Authorization": authHeader
+          },
+          body: JSON.stringify({
+            instanceId: this.config.instanceId,
+            permission: "write"
+          })
+        });
+        if (!response.ok) {
+          const error = await response.json().catch(() => ({ error: "Failed to get token" }));
+          throw new Error(error.error || `Failed to get WebSocket token: ${response.status}`);
+        }
+        const data = await response.json();
+        return data.token;
+      }
       /**
        * Connect to the cloud service
        */
@@ -94,13 +280,19 @@ var init_CloudAdapter = __esm({
         }
         this._state = "connecting";
         try {
-          if (this.config.tokenProvider && !this.token) {
-            this.token = await this.config.tokenProvider();
+          if (!this.token) {
+            if (this.config.tokenProvider) {
+              this.token = await this.config.tokenProvider();
+            } else if (this.config.apiKey) {
+              this.token = await this.fetchTokenWithApiKey();
+            }
           }
           let url = `${this.config.baseUrl}/sync/${this.config.instanceId}`;
           if (this.token) {
             url += `?token=${encodeURIComponent(this.token)}`;
             this.token = null;
+          } else {
+            throw new Error("MindCache Cloud: No authentication method available. Provide apiKey or tokenProvider.");
           }
           this.ws = new WebSocket(url);
           this.setupWebSocket();
@@ -162,12 +354,6 @@ var init_CloudAdapter = __esm({
           return;
         }
         this.ws.onopen = () => {
-          if (this.config.apiKey) {
-            this.ws.send(JSON.stringify({
-              type: "auth",
-              apiKey: this.config.apiKey
-            }));
-          }
         };
         this.ws.onmessage = (event) => {
           try {
@@ -175,6 +361,7 @@ var init_CloudAdapter = __esm({
             this.handleMessage(msg);
           } catch (error) {
             console.error("MindCache Cloud: Failed to parse message:", error);
+            console.error("Raw message:", typeof event.data === "string" ? event.data.slice(0, 200) : event.data);
           }
         };
         this.ws.onclose = () => {
@@ -182,10 +369,12 @@ var init_CloudAdapter = __esm({
           this.emit("disconnected");
           this.scheduleReconnect();
         };
-        this.ws.onerror = (error) => {
+        this.ws.onerror = () => {
           this._state = "error";
-          this.emit("error", new Error("WebSocket error"));
-          console.error("MindCache Cloud: WebSocket error:", error);
+          const url = `${this.config.baseUrl}/sync/${this.config.instanceId}`;
+          console.error(`MindCache Cloud: WebSocket error connecting to ${url}`);
+          console.error("Check that the instance ID and API key are correct, and that the server is reachable.");
+          this.emit("error", new Error(`WebSocket connection failed to ${url}`));
         };
       }
       handleMessage(msg) {
@@ -262,15 +451,6 @@ var init_CloudAdapter = __esm({
         this.reconnectTimeout = setTimeout(async () => {
           this.reconnectTimeout = null;
           this.reconnectAttempts++;
-          if (this.config.tokenProvider) {
-            try {
-              this.token = await this.config.tokenProvider();
-            } catch (error) {
-              console.error("MindCache Cloud: Failed to get token for reconnect:", error);
-              this.emit("error", error);
-              return;
-            }
-          }
           this.connect();
         }, delay);
       }
@@ -299,8 +479,8 @@ var init_CloudAdapter = __esm({
 var DEFAULT_KEY_ATTRIBUTES = {
   type: "text",
   contentTags: [],
-  systemTags: ["prompt"],
-  // visible by default
+  systemTags: ["SystemPrompt", "LLMWrite"],
+  // visible in system prompt and writable by LLM by default
   zIndex: 0,
   // Legacy - derived from systemTags
   readonly: false,
@@ -317,6 +497,65 @@ var MindCache = class {
   globalListeners = [];
   // Internal flag to prevent sync loops when receiving remote updates
   _isRemoteUpdate = false;
+  /**
+   * Normalize system tags: migrate old tags to new ones
+   * - 'prompt' → 'SystemPrompt'
+   * - 'readonly' → remove 'LLMWrite' (or add if not readonly)
+   */
+  normalizeSystemTags(tags) {
+    const normalized = [];
+    let hasSystemPrompt = false;
+    let hasLLMRead = false;
+    let hasLLMWrite = false;
+    let hasReadonly = false;
+    for (const tag of tags) {
+      if (tag === "SystemPrompt" || tag === "prompt") {
+        hasSystemPrompt = true;
+      } else if (tag === "LLMRead") {
+        hasLLMRead = true;
+      } else if (tag === "LLMWrite") {
+        hasLLMWrite = true;
+      } else if (tag === "readonly") {
+        hasReadonly = true;
+      } else if (tag === "protected") {
+        normalized.push(tag);
+      } else if (tag === "ApplyTemplate" || tag === "template") {
+        normalized.push("ApplyTemplate");
+      }
+    }
+    if (hasSystemPrompt) {
+      normalized.push("SystemPrompt");
+    }
+    if (hasLLMRead) {
+      normalized.push("LLMRead");
+    }
+    if (hasReadonly) {
+      normalized.push("readonly");
+    } else if (hasLLMWrite) {
+      normalized.push("LLMWrite");
+    } else {
+      normalized.push("LLMWrite");
+    }
+    return normalized;
+  }
+  /**
+   * Check if key should be visible in system prompt
+   */
+  hasSystemPrompt(tags) {
+    return tags.includes("SystemPrompt") || tags.includes("prompt");
+  }
+  /**
+   * Check if key can be read by LLM (has LLMRead or SystemPrompt)
+   */
+  hasLLMRead(tags) {
+    return tags.includes("LLMRead") || tags.includes("SystemPrompt") || tags.includes("prompt");
+  }
+  /**
+   * Check if key can be written by LLM (has LLMWrite and not readonly)
+   */
+  hasLLMWrite(tags) {
+    return tags.includes("LLMWrite") && !tags.includes("readonly");
+  }
   // Cloud sync state
   _cloudAdapter = null;
   _connectionState = "disconnected";
@@ -325,15 +564,33 @@ var MindCache = class {
   _cloudConfig = null;
   // Access level for system operations
   _accessLevel = "user";
+  _initPromise = null;
   constructor(options) {
     if (options?.accessLevel) {
       this._accessLevel = options.accessLevel;
     }
+    if (options?.cloud && options?.indexedDB) {
+      throw new Error(
+        "MindCache: Cannot use both cloud and indexedDB together. Choose one persistence method to avoid data conflicts. Use cloud for real-time sync, or indexedDB for local-only persistence."
+      );
+    }
+    const initPromises = [];
     if (options?.cloud) {
       this._cloudConfig = options.cloud;
       this._isLoaded = false;
       this._connectionState = "disconnected";
-      this._initCloud();
+      initPromises.push(this._initCloud());
+    }
+    if (options?.indexedDB) {
+      this._isLoaded = false;
+      initPromises.push(this._initIndexedDB(options.indexedDB));
+    }
+    if (initPromises.length > 0) {
+      this._initPromise = Promise.all(initPromises).then(() => {
+        if (!this._cloudConfig) {
+          this._isLoaded = true;
+        }
+      });
     }
   }
   /**
@@ -353,9 +610,11 @@ var MindCache = class {
       return;
     }
     try {
-      const { CloudAdapter: CloudAdapter2 } = await Promise.resolve().then(() => (init_CloudAdapter(), CloudAdapter_exports));
-      const configUrl = this._cloudConfig.baseUrl || "https://api.mindcache.io";
-      const baseUrl = configUrl.replace("https://", "wss://").replace("http://", "ws://");
+      const CloudAdapter2 = await this._getCloudAdapterClass();
+      if (!this._cloudConfig.baseUrl) {
+        throw new Error("MindCache Cloud: baseUrl is required. Please provide the cloud API URL in your configuration.");
+      }
+      const baseUrl = this._cloudConfig.baseUrl.replace("https://", "wss://").replace("http://", "ws://");
       const adapter = new CloudAdapter2({
         instanceId: this._cloudConfig.instanceId,
         projectId: this._cloudConfig.projectId || "default",
@@ -411,6 +670,19 @@ var MindCache = class {
       this._isLoaded = true;
     }
   }
+  async _initIndexedDB(config) {
+    try {
+      const IndexedDBAdapter2 = await this._getIndexedDBAdapterClass();
+      const adapter = new IndexedDBAdapter2(config);
+      await adapter.attach(this);
+    } catch (error) {
+      console.error("MindCache: Failed to initialize IndexedDB:", error);
+    }
+  }
+  async _getIndexedDBAdapterClass() {
+    const { IndexedDBAdapter: IndexedDBAdapter2 } = await Promise.resolve().then(() => (init_IndexedDBAdapter(), IndexedDBAdapter_exports));
+    return IndexedDBAdapter2;
+  }
   /**
    * Get the current cloud connection state
    */
@@ -423,12 +695,46 @@ var MindCache = class {
   get isLoaded() {
     return this._isLoaded;
   }
+  /**
+   * Protected method to load CloudAdapter class.
+   * Can be overridden/mocked for testing.
+   */
+  async _getCloudAdapterClass() {
+    const { CloudAdapter: CloudAdapter2 } = await Promise.resolve().then(() => (init_CloudAdapter(), CloudAdapter_exports));
+    return CloudAdapter2;
+  }
   /**
    * Check if this instance is connected to cloud
    */
   get isCloud() {
     return this._cloudConfig !== null;
   }
+  /**
+   * Wait for initial sync to complete (or resolve immediately if already synced/local).
+   * Useful for scripts or linear execution flows.
+   */
+  async waitForSync() {
+    if (this._isLoaded) {
+      return;
+    }
+    if (this._initPromise) {
+      await this._initPromise;
+    }
+    if (this._isLoaded) {
+      return;
+    }
+    return new Promise((resolve) => {
+      if (!this._cloudAdapter) {
+        resolve();
+        return;
+      }
+      const handler = () => {
+        this._cloudAdapter?.off("synced", handler);
+        resolve();
+      };
+      this._cloudAdapter.on("synced", handler);
+    });
+  }
   /**
    * Disconnect from cloud (if connected)
    */
@@ -495,7 +801,7 @@ var MindCache = class {
     if (!entry) {
       return void 0;
     }
-    if (entry.attributes.template) {
+    if (entry.attributes.systemTags?.includes("ApplyTemplate") || entry.attributes.systemTags?.includes("template") || entry.attributes.template) {
       const processingStack = _processingStack || /* @__PURE__ */ new Set();
       if (processingStack.has(key)) {
         return entry.value;
@@ -544,77 +850,87 @@ var MindCache = class {
       ...DEFAULT_KEY_ATTRIBUTES,
       contentTags: [],
       // Fresh array
-      systemTags: ["prompt"],
+      systemTags: ["SystemPrompt", "LLMWrite"],
       // Fresh array with default
       tags: [],
       // Fresh array
       zIndex: 0
     };
     const finalAttributes = attributes ? { ...baseAttributes, ...attributes } : baseAttributes;
+    let systemTags = this.normalizeSystemTags(finalAttributes.systemTags || []);
     if (attributes) {
-      let systemTags2 = [...finalAttributes.systemTags || []];
       if ("readonly" in attributes) {
-        if (attributes.readonly && !systemTags2.includes("readonly")) {
-          systemTags2.push("readonly");
-        } else if (!attributes.readonly && !wasHardcoded) {
-          systemTags2 = systemTags2.filter((t) => t !== "readonly");
+        if (attributes.readonly) {
+          systemTags = systemTags.filter((t) => t !== "LLMWrite");
+          if (!systemTags.includes("readonly")) {
+            systemTags.push("readonly");
+          }
+        } else if (!wasHardcoded) {
+          if (!systemTags.includes("LLMWrite")) {
+            systemTags.push("LLMWrite");
+          }
+          systemTags = systemTags.filter((t) => t !== "readonly");
         }
       }
       if ("visible" in attributes) {
-        if (attributes.visible && !systemTags2.includes("prompt")) {
-          systemTags2.push("prompt");
-        } else if (!attributes.visible) {
-          systemTags2 = systemTags2.filter((t) => t !== "prompt");
+        if (attributes.visible) {
+          if (!systemTags.includes("SystemPrompt")) {
+            systemTags.push("SystemPrompt");
+          }
+          systemTags = systemTags.filter((t) => t !== "prompt");
+        } else {
+          systemTags = systemTags.filter((t) => t !== "SystemPrompt" && t !== "prompt");
         }
       }
+      if ("systemTags" in attributes && Array.isArray(attributes.systemTags)) {
+        systemTags = this.normalizeSystemTags(attributes.systemTags);
+      }
       if ("hardcoded" in attributes) {
-        if (attributes.hardcoded && !systemTags2.includes("protected")) {
-          systemTags2.push("protected");
+        if (attributes.hardcoded && !systemTags.includes("protected")) {
+          systemTags.push("protected");
         } else if (!attributes.hardcoded && !wasHardcoded) {
-          systemTags2 = systemTags2.filter((t) => t !== "protected");
+          systemTags = systemTags.filter((t) => t !== "protected");
         }
-        if (wasHardcoded && !systemTags2.includes("protected")) {
-          systemTags2.push("protected");
+        if (wasHardcoded && !systemTags.includes("protected")) {
+          systemTags.push("protected");
         }
       } else if (wasHardcoded) {
-        if (!systemTags2.includes("protected")) {
-          systemTags2.push("protected");
+        if (!systemTags.includes("protected")) {
+          systemTags.push("protected");
         }
       }
       if ("template" in attributes) {
-        if (attributes.template && !wasHardcoded && !systemTags2.includes("template")) {
-          systemTags2.push("template");
+        if (attributes.template && !wasHardcoded && !systemTags.includes("ApplyTemplate") && !systemTags.includes("template")) {
+          systemTags.push("ApplyTemplate");
         } else if (!attributes.template || wasHardcoded) {
-          systemTags2 = systemTags2.filter((t) => t !== "template");
+          systemTags = systemTags.filter((t) => t !== "ApplyTemplate" && t !== "template");
         }
       }
-      finalAttributes.systemTags = systemTags2;
     } else if (wasHardcoded) {
-      let systemTags2 = [...finalAttributes.systemTags || []];
-      if (!systemTags2.includes("protected")) {
-        systemTags2.push("protected");
+      if (!systemTags.includes("protected")) {
+        systemTags.push("protected");
       }
-      if (!systemTags2.includes("readonly")) {
-        systemTags2.push("readonly");
+      systemTags = systemTags.filter((t) => t !== "LLMWrite");
+      if (!systemTags.includes("readonly")) {
+        systemTags.push("readonly");
       }
-      systemTags2 = systemTags2.filter((t) => t !== "template");
-      finalAttributes.systemTags = systemTags2;
+      systemTags = systemTags.filter((t) => t !== "template");
     }
-    let systemTags = finalAttributes.systemTags || [];
     if (wasHardcoded && !systemTags.includes("protected")) {
-      systemTags = [...systemTags, "protected"];
+      systemTags.push("protected");
     }
     if (systemTags.includes("protected")) {
+      systemTags = systemTags.filter((t) => t !== "LLMWrite");
       if (!systemTags.includes("readonly")) {
-        systemTags = [...systemTags, "readonly"];
+        systemTags.push("readonly");
       }
       systemTags = systemTags.filter((t) => t !== "template");
-      finalAttributes.systemTags = systemTags;
     }
-    finalAttributes.readonly = systemTags.includes("readonly");
-    finalAttributes.visible = systemTags.includes("prompt");
+    finalAttributes.systemTags = systemTags;
+    finalAttributes.readonly = systemTags.includes("readonly") || !systemTags.includes("LLMWrite");
+    finalAttributes.visible = this.hasSystemPrompt(systemTags);
     finalAttributes.hardcoded = wasHardcoded || systemTags.includes("protected");
-    finalAttributes.template = systemTags.includes("template");
+    finalAttributes.template = systemTags.includes("ApplyTemplate") || systemTags.includes("template");
     if (attributes && "tags" in attributes && attributes.tags) {
       finalAttributes.contentTags = [...attributes.tags];
     }
@@ -635,21 +951,25 @@ var MindCache = class {
       return;
     }
     this._isRemoteUpdate = true;
-    const systemTags = attributes.systemTags || [];
-    if (!attributes.systemTags) {
+    let systemTags = attributes.systemTags || [];
+    if (!attributes.systemTags || systemTags.length === 0) {
+      systemTags = [];
       if (attributes.visible !== false) {
         systemTags.push("prompt");
       }
       if (attributes.readonly) {
         systemTags.push("readonly");
+      } else {
+        systemTags.push("LLMWrite");
       }
       if (attributes.hardcoded) {
         systemTags.push("protected");
       }
       if (attributes.template) {
-        systemTags.push("template");
+        systemTags.push("ApplyTemplate");
       }
     }
+    systemTags = this.normalizeSystemTags(systemTags);
     const contentTags = attributes.contentTags || attributes.tags || [];
     this.stm[key] = {
       value,
@@ -659,10 +979,11 @@ var MindCache = class {
         systemTags,
         zIndex: attributes.zIndex ?? 0,
         tags: contentTags,
-        readonly: systemTags.includes("readonly"),
-        visible: systemTags.includes("prompt"),
+        // Sync legacy attributes FROM normalized systemTags
+        readonly: systemTags.includes("readonly") || !systemTags.includes("LLMWrite"),
+        visible: this.hasSystemPrompt(systemTags),
         hardcoded: systemTags.includes("protected"),
-        template: systemTags.includes("template")
+        template: systemTags.includes("ApplyTemplate") || systemTags.includes("template")
       }
     };
     if (this.listeners[key]) {
@@ -717,39 +1038,55 @@ var MindCache = class {
       }
     }
     entry.attributes = { ...entry.attributes, ...allowedAttributes };
-    if ("readonly" in attributes || "visible" in attributes || "template" in attributes) {
-      let newSystemTags = [];
-      if (entry.attributes.readonly) {
-        newSystemTags.push("readonly");
-      }
-      if (entry.attributes.visible) {
-        newSystemTags.push("prompt");
-      }
-      if (entry.attributes.template) {
-        newSystemTags.push("template");
-      }
-      if (wasHardcoded || entry.attributes.hardcoded) {
-        newSystemTags.push("protected");
+    if ("readonly" in attributes || "visible" in attributes || "template" in attributes || "systemTags" in attributes) {
+      let newSystemTags = entry.attributes.systemTags || [];
+      if ("systemTags" in attributes && Array.isArray(attributes.systemTags)) {
+        newSystemTags = this.normalizeSystemTags(attributes.systemTags);
+      } else {
+        newSystemTags = [];
+        if (!entry.attributes.readonly) {
+          newSystemTags.push("LLMWrite");
+        } else {
+          newSystemTags.push("readonly");
+        }
+        if (entry.attributes.visible) {
+          newSystemTags.push("SystemPrompt");
+        }
+        if (entry.attributes.template) {
+          newSystemTags.push("ApplyTemplate");
+        }
+        if (wasHardcoded || entry.attributes.hardcoded) {
+          newSystemTags.push("protected");
+        }
+        newSystemTags = this.normalizeSystemTags(newSystemTags);
       }
       if (newSystemTags.includes("protected")) {
+        newSystemTags = newSystemTags.filter((t) => t !== "LLMWrite");
         if (!newSystemTags.includes("readonly")) {
           newSystemTags.push("readonly");
         }
-        newSystemTags = newSystemTags.filter((t) => t !== "template");
+        newSystemTags = newSystemTags.filter((t) => t !== "ApplyTemplate" && t !== "template");
         entry.attributes.readonly = true;
         entry.attributes.template = false;
       }
       entry.attributes.systemTags = newSystemTags;
+      entry.attributes.readonly = newSystemTags.includes("readonly") || !newSystemTags.includes("LLMWrite");
+      entry.attributes.visible = this.hasSystemPrompt(newSystemTags);
+      entry.attributes.template = newSystemTags.includes("ApplyTemplate") || newSystemTags.includes("template");
     } else if (wasHardcoded) {
-      let systemTags = [...entry.attributes.systemTags || []];
+      let systemTags = this.normalizeSystemTags(entry.attributes.systemTags || []);
       if (!systemTags.includes("protected")) {
         systemTags.push("protected");
       }
+      systemTags = systemTags.filter((t) => t !== "LLMWrite");
       if (!systemTags.includes("readonly")) {
         systemTags.push("readonly");
       }
-      systemTags = systemTags.filter((t) => t !== "template");
+      systemTags = systemTags.filter((t) => t !== "ApplyTemplate" && t !== "template");
       entry.attributes.systemTags = systemTags;
+      entry.attributes.readonly = true;
+      entry.attributes.visible = this.hasSystemPrompt(systemTags);
+      entry.attributes.template = false;
     }
     if (wasHardcoded) {
       entry.attributes.hardcoded = true;
@@ -991,8 +1328,9 @@ var MindCache = class {
     const sortedKeys = this.getSortedKeys();
     sortedKeys.forEach((key) => {
       const entry = this.stm[key];
-      if (entry.attributes.visible) {
-        const processedValue = entry.attributes.template ? this.get_value(key) : entry.value;
+      if (this.hasLLMRead(entry.attributes.systemTags) || entry.attributes.visible) {
+        const hasTemplate = entry.attributes.systemTags?.includes("ApplyTemplate") || entry.attributes.systemTags?.includes("template") || entry.attributes.template;
+        const processedValue = hasTemplate ? this.get_value(key) : entry.value;
         apiData.push({
           key,
           value: processedValue,
@@ -1018,7 +1356,7 @@ var MindCache = class {
     const sortedKeys = this.getSortedKeys();
     sortedKeys.forEach((key) => {
       const entry = this.stm[key];
-      if (entry.attributes.visible && entry.attributes.type === "image" && entry.attributes.contentType) {
+      if ((this.hasLLMRead(entry.attributes.systemTags) || entry.attributes.visible) && entry.attributes.type === "image" && entry.attributes.contentType) {
         const dataUrl = this.createDataUrl(entry.value, entry.attributes.contentType);
         imageParts.push({
           type: "file",
@@ -1057,6 +1395,7 @@ var MindCache = class {
   }
   deserialize(data) {
     if (typeof data === "object" && data !== null) {
+      this._isRemoteUpdate = true;
       this.clear();
       Object.entries(data).forEach(([key, entry]) => {
         if (entry && typeof entry === "object" && "value" in entry && "attributes" in entry) {
@@ -1065,21 +1404,24 @@ var MindCache = class {
             return;
           }
           let systemTags = attrs.systemTags || [];
-          if (!attrs.systemTags) {
+          if (!attrs.systemTags || systemTags.length === 0) {
             systemTags = [];
             if (attrs.visible !== false) {
               systemTags.push("prompt");
             }
             if (attrs.readonly) {
               systemTags.push("readonly");
+            } else {
+              systemTags.push("LLMWrite");
             }
             if (attrs.hardcoded) {
               systemTags.push("protected");
             }
             if (attrs.template) {
-              systemTags.push("template");
+              systemTags.push("ApplyTemplate");
             }
           }
+          systemTags = this.normalizeSystemTags(systemTags);
           const contentTags = attrs.contentTags || attrs.tags || [];
           this.stm[key] = {
             value: entry.value,
@@ -1088,17 +1430,18 @@ var MindCache = class {
               contentTags,
               systemTags,
               zIndex: attrs.zIndex ?? 0,
-              // Sync legacy attributes
+              // Sync legacy attributes FROM normalized systemTags
               tags: contentTags,
-              readonly: systemTags.includes("readonly"),
-              visible: systemTags.includes("prompt"),
+              readonly: systemTags.includes("readonly") || !systemTags.includes("LLMWrite"),
+              visible: this.hasSystemPrompt(systemTags),
               hardcoded: systemTags.includes("protected"),
-              template: systemTags.includes("template")
+              template: systemTags.includes("ApplyTemplate") || systemTags.includes("template")
             }
           };
         }
       });
       this.notifyGlobalListeners();
+      this._isRemoteUpdate = false;
     }
   }
   get_system_prompt() {
@@ -1107,13 +1450,14 @@ var MindCache = class {
     const sortedKeys = this.getSortedKeys();
     sortedKeys.forEach((key) => {
       const entry = this.stm[key];
-      if (entry.attributes.visible) {
+      if (this.hasLLMRead(entry.attributes.systemTags) || entry.attributes.visible) {
         if (entry.attributes.type === "image") {
           promptLines.push(`image ${key} available`);
           return;
         }
         if (entry.attributes.type === "file") {
-          if (entry.attributes.readonly) {
+          const canWrite2 = this.hasLLMWrite(entry.attributes.systemTags) || !entry.attributes.readonly && !entry.attributes.systemTags.includes("readonly");
+          if (!canWrite2) {
             promptLines.push(`${key}: [${entry.attributes.type.toUpperCase()}] - ${entry.attributes.contentType || "unknown format"}`);
           } else {
             const sanitizedKey = key.replace(/[^a-zA-Z0-9_-]/g, "_");
@@ -1123,7 +1467,8 @@ var MindCache = class {
         }
         const value = this.get_value(key);
         const formattedValue = typeof value === "object" && value !== null ? JSON.stringify(value) : String(value);
-        if (entry.attributes.readonly) {
+        const canWrite = this.hasLLMWrite(entry.attributes.systemTags) || !entry.attributes.readonly && !entry.attributes.systemTags.includes("readonly");
+        if (!canWrite) {
           promptLines.push(`${key}: ${formattedValue}`);
         } else {
           const sanitizedKey = key.replace(/[^a-zA-Z0-9_-]/g, "_");
@@ -1151,7 +1496,7 @@ var MindCache = class {
     const sortedKeys = this.getSortedKeys();
     const writableKeys = sortedKeys.filter((key) => {
       const entry = this.stm[key];
-      return !entry.attributes.readonly;
+      return this.hasLLMWrite(entry.attributes.systemTags) || !entry.attributes.readonly && !entry.attributes.systemTags.includes("readonly");
     });
     writableKeys.forEach((key) => {
       const sanitizedKey = key.replace(/[^a-zA-Z0-9_-]/g, "_");
@@ -1226,7 +1571,8 @@ var MindCache = class {
       return null;
     }
     const entry = this.stm[originalKey];
-    if (entry && entry.attributes.readonly) {
+    const canWrite = entry && (this.hasLLMWrite(entry.attributes.systemTags) || !entry.attributes.readonly && !entry.attributes.systemTags.includes("readonly"));
+    if (!canWrite) {
       return null;
     }
     this.set_value(originalKey, value);
@@ -1473,7 +1819,7 @@ var MindCache = class {
     entry.attributes.readonly = tags.includes("readonly");
     entry.attributes.visible = tags.includes("prompt");
     entry.attributes.hardcoded = tags.includes("protected");
-    entry.attributes.template = tags.includes("template");
+    entry.attributes.template = tags.includes("ApplyTemplate") || tags.includes("template");
   }
   toMarkdown() {
     const now = /* @__PURE__ */ new Date();
@@ -1714,6 +2060,8 @@ var MindCache = class {
           }
           if (attrs.readonly) {
             systemTags.push("readonly");
+          } else {
+            systemTags.push("LLMWrite");
           }
           if (attrs.hardcoded) {
             systemTags.push("protected");
@@ -1721,7 +2069,9 @@ var MindCache = class {
           if (attrs.template) {
             systemTags.push("template");
           }
-          attrs.systemTags = systemTags;
+          attrs.systemTags = this.normalizeSystemTags(systemTags);
+        } else {
+          attrs.systemTags = this.normalizeSystemTags(attrs.systemTags);
         }
         if (!attrs.contentTags) {
           attrs.contentTags = [];
@@ -1729,6 +2079,11 @@ var MindCache = class {
         if (!attrs.tags) {
           attrs.tags = [...attrs.contentTags];
         }
+        const normalizedTags = attrs.systemTags || [];
+        attrs.readonly = normalizedTags.includes("readonly") || !normalizedTags.includes("LLMWrite");
+        attrs.visible = this.hasSystemPrompt(normalizedTags);
+        attrs.hardcoded = normalizedTags.includes("protected");
+        attrs.template = normalizedTags.includes("ApplyTemplate") || normalizedTags.includes("template");
         this.stm[key] = {
           value: entry.value,
           attributes: attrs