mindcache 2.3.0 → 2.4.0

package/dist/cloud/index.mjs

@@ -10,6 +10,157 @@ 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, {
@@ -328,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,
@@ -346,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";
@@ -359,11 +569,28 @@ var MindCache = class {
     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._initPromise = 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;
+        }
+      });
     }
   }
   /**
@@ -443,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
    */
@@ -561,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;
@@ -610,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];
     }
@@ -701,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,
@@ -725,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]) {
@@ -783,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;
@@ -1057,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,
@@ -1084,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",
@@ -1123,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) {
@@ -1131,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,
@@ -1154,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() {
@@ -1173,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, "_");
@@ -1189,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, "_");
@@ -1217,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, "_");
@@ -1292,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);
@@ -1539,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();
@@ -1780,6 +2060,8 @@ var MindCache = class {
           }
           if (attrs.readonly) {
             systemTags.push("readonly");
+          } else {
+            systemTags.push("LLMWrite");
           }
           if (attrs.hardcoded) {
             systemTags.push("protected");
@@ -1787,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 = [];
@@ -1795,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