toon-memory 1.3.0 → 1.5.0

package/README.md

@@ -22,13 +22,16 @@ AI agents forget everything between sessions. toon-memory fixes this by providin
 
 ## Features
 
-- **5 MCP tools** — `memory_remember`, `memory_recall`, `memory_forget`, `memory_stats`, `memory_summary`
+- **8 MCP tools** — `memory_remember`, `memory_recall`, `memory_forget`, `memory_stats`, `memory_summary`, `memory_archive`, `memory_encrypt`, `memory_decrypt`
 - **7 agents supported** — OpenCode, VS Code/Copilot, Claude Code, Cursor, Windsurf, Cline, Continue
 - **TOON format** — 40% fewer tokens than JSON, better LLM comprehension
 - **Per-project memory** — each project gets its own memory file
 - **Zero config** — just install and use
 - **Auto gitignore** — automatically adds `.opencode/memory/` to `.gitignore`
 - **Date filtering** — search memory by date range
+- **Auto-archive** — old entries (>30 days) moved to archive automatically
+- **Encryption** — AES-256-GCM encryption for sensitive data
+- **Watch mode** — auto-backup every N minutes
 
 ---
 
@@ -89,6 +92,9 @@ memory_remember   # Save important decisions
 | `memory_forget` | Remove an entry by key or id |
 | `memory_stats` | View memory state |
 | `memory_summary` | Save/retrieve file summaries |
+| `memory_archive` | Archive old entries (>30 days) |
+| `memory_encrypt` | Enable AES-256-GCM encryption |
+| `memory_decrypt` | Disable encryption |
 
 ### Date Filtering
 
@@ -103,6 +109,33 @@ memory_recall({
 })
 ```
 
+### Auto-Archive
+
+Entries older than 30 days are automatically archived to keep memory clean:
+
+```typescript
+// Manually trigger archiving
+memory_archive()
+// 📦 Archivadas 5 entradas antiguas
+// 📋 Quedan 42 entradas activas
+```
+
+### Encryption
+
+Enable AES-256-GCM encryption for sensitive data:
+
+```typescript
+// Enable encryption
+memory_encrypt()
+// 🔐 Encriptación habilitada
+// ⚠️ Guarda esta clave (no se puede recuperar):
+// a1b2c3d4...
+
+// Disable encryption
+memory_decrypt({ key: "a1b2c3d4..." })
+// 🔓 Encriptación deshabilitada
+```
+
 ---
 
 ## How It Works
@@ -136,6 +169,7 @@ npx toon-memory status       # Check installation status
 npx toon-memory stats        # View memory statistics
 npx toon-memory export       # Export memory to JSON
 npx toon-memory import <file> # Import memory from JSON
+npx toon-memory watch [mins] # Auto-backup every N minutes (default: 5)
 npx toon-memory upgrade      # Update to latest version
 npx toon-memory uninstall    # Remove from all agents
 ```

package/dist/cli/setup.js

@@ -335,6 +335,46 @@ ${newLines}
   console.log(`Skipped ${importData.entries.length - newEntries.length} duplicates
 `);
 }
+function watch() {
+  console.log("\n\u{1F9E0} toon-memory watch\n");
+  const memoryFile = join(projectRoot, ".opencode", "memory", "data.toon");
+  const backupDir = join(projectRoot, ".opencode", "memory", "backups");
+  if (!existsSync(memoryFile)) {
+    console.log("Memory not initialized. Run 'npx toon-memory init' first.\n");
+    return;
+  }
+  if (!existsSync(backupDir)) mkdirSync(backupDir, { recursive: true });
+  const intervalMinutes = parseInt(args[1]) || 5;
+  console.log(`Watching memory file every ${intervalMinutes} minutes...`);
+  console.log(`Press Ctrl+C to stop
+`);
+  let lastContent = readFileSync(memoryFile, "utf-8");
+  let backupCount = 0;
+  const backup = () => {
+    const currentContent = readFileSync(memoryFile, "utf-8");
+    if (currentContent !== lastContent) {
+      const timestamp = (/* @__PURE__ */ new Date()).toISOString().replace(/[:.]/g, "-");
+      const backupFile = join(backupDir, `backup-${timestamp}.toon`);
+      writeFileSync(backupFile, currentContent);
+      backupCount++;
+      console.log(`\u{1F4E6} Backup #${backupCount} created: ${timestamp}`);
+      lastContent = currentContent;
+    }
+  };
+  backup();
+  const interval = setInterval(backup, intervalMinutes * 60 * 1e3);
+  process.on("SIGINT", () => {
+    clearInterval(interval);
+    console.log(`
+\u2705 Watch stopped. ${backupCount} backups created.
+`);
+    process.exit(0);
+  });
+  process.on("SIGTERM", () => {
+    clearInterval(interval);
+    process.exit(0);
+  });
+}
 const args = process.argv.slice(2);
 if (args[0] === "uninstall") {
   uninstall();
@@ -364,6 +404,10 @@ if (args[0] === "import") {
   importMemory();
   process.exit(0);
 }
+if (args[0] === "watch") {
+  watch();
+  process.exit(0);
+}
 const agents = detectAgents();
 console.log("\n\u{1F9E0} toon-memory installer\n");
 console.log("Supported agents:");

package/mcp/server.js

@@ -27642,27 +27642,138 @@ var StdioServerTransport = class {
 import { readFileSync, writeFileSync, existsSync, mkdirSync } from "fs";
 import { dirname, join } from "path";
 import { fileURLToPath } from "url";
-import { randomBytes } from "crypto";
+import { randomBytes, createCipheriv, createDecipheriv } from "crypto";
 var __dirname = dirname(fileURLToPath(import.meta.url));
 var MEMORY_DIR = join(process.cwd(), ".opencode", "memory");
 var MEMORY_FILE = join(MEMORY_DIR, "data.toon");
-function ensureMemoryFile() {
+var ARCHIVE_FILE = join(MEMORY_DIR, "archive.toon");
+var CONFIG_FILE = join(MEMORY_DIR, "config.json");
+var ARCHIVE_DAYS = 30;
+var ALGORITHM = "aes-256-gcm";
+function loadConfig() {
+  if (!existsSync(CONFIG_FILE)) {
+    return { encrypted: false };
+  }
+  try {
+    return JSON.parse(readFileSync(CONFIG_FILE, "utf-8"));
+  } catch {
+    return { encrypted: false };
+  }
+}
+function saveConfig(config2) {
+  ensureMemoryDir();
+  writeFileSync(CONFIG_FILE, JSON.stringify(config2, null, 2));
+}
+function ensureMemoryDir() {
   if (!existsSync(MEMORY_DIR)) mkdirSync(MEMORY_DIR, { recursive: true });
+}
+function ensureMemoryFile() {
+  ensureMemoryDir();
   if (!existsSync(MEMORY_FILE)) {
     writeFileSync(MEMORY_FILE, "version: 1\nentries[0|]{id|category|key|content|file|tags|date}:\n");
   }
 }
+function encrypt(text, key) {
+  const keyBuffer = Buffer.from(key, "hex");
+  const iv = randomBytes(16);
+  const cipher = createCipheriv(ALGORITHM, keyBuffer, iv);
+  let encrypted = cipher.update(text, "utf8", "hex");
+  encrypted += cipher.final("hex");
+  const authTag = cipher.getAuthTag();
+  return `${iv.toString("hex")}:${authTag.toString("hex")}:${encrypted}`;
+}
+function decrypt(encryptedData, key) {
+  const keyBuffer = Buffer.from(key, "hex");
+  const [ivHex, authTagHex, encrypted] = encryptedData.split(":");
+  const iv = Buffer.from(ivHex, "hex");
+  const authTag = Buffer.from(authTagHex, "hex");
+  const decipher = createDecipheriv(ALGORITHM, keyBuffer, iv);
+  decipher.setAuthTag(authTag);
+  let decrypted = decipher.update(encrypted, "hex", "utf8");
+  decrypted += decipher.final("utf8");
+  return decrypted;
+}
+function generateKey() {
+  return randomBytes(32).toString("hex");
+}
 function readMemory() {
   ensureMemoryFile();
-  return readFileSync(MEMORY_FILE, "utf-8");
+  const config2 = loadConfig();
+  const data = readFileSync(MEMORY_FILE, "utf-8");
+  if (config2.encrypted && config2.key) {
+    try {
+      return decrypt(data, config2.key);
+    } catch {
+      return data;
+    }
+  }
+  return data;
 }
 function writeMemory(content) {
   ensureMemoryFile();
-  writeFileSync(MEMORY_FILE, content);
+  const config2 = loadConfig();
+  if (config2.encrypted && config2.key) {
+    const encrypted = encrypt(content, config2.key);
+    writeFileSync(MEMORY_FILE, encrypted);
+  } else {
+    writeFileSync(MEMORY_FILE, content);
+  }
 }
 function generateId() {
   return randomBytes(4).toString("hex");
 }
+function archiveOldEntries() {
+  const data = readMemory();
+  const lines = data.split("\n");
+  const headerIdx = lines.findIndex((l) => l.startsWith("entries["));
+  if (headerIdx === -1) return { archived: 0, kept: 0 };
+  const today = /* @__PURE__ */ new Date();
+  const cutoff = new Date(today);
+  cutoff.setDate(cutoff.getDate() - ARCHIVE_DAYS);
+  const cutoffStr = cutoff.toISOString().split("T")[0];
+  const entryLines = lines.slice(headerIdx + 1).filter((l) => l.trim().length > 0);
+  const toArchive = [];
+  const toKeep = [];
+  for (const line of entryLines) {
+    const parts = line.trim().split("|");
+    if (parts.length >= 7) {
+      const date5 = parts[6];
+      if (date5 < cutoffStr) {
+        toArchive.push(line.trim());
+      } else {
+        toKeep.push(line.trim());
+      }
+    } else {
+      toKeep.push(line.trim());
+    }
+  }
+  if (toArchive.length === 0) return { archived: 0, kept: toKeep.length };
+  let archiveContent = "";
+  if (existsSync(ARCHIVE_FILE)) {
+    archiveContent = readFileSync(ARCHIVE_FILE, "utf-8");
+  } else {
+    archiveContent = `version: 1
+archived:
+`;
+  }
+  const archiveLines = archiveContent.split("\n");
+  let archiveHeaderIdx = archiveLines.findIndex((l) => l.startsWith("archived["));
+  if (archiveHeaderIdx === -1) {
+    archiveLines.push(`archived[0|]{id|category|key|content|file|tags|date}:`);
+    archiveHeaderIdx = archiveLines.length - 1;
+  }
+  const archiveMatch = archiveLines[archiveHeaderIdx].match(/archived\[(\d+)\|/);
+  const archiveCount = archiveMatch ? parseInt(archiveMatch[1]) : 0;
+  for (const entry of toArchive) {
+    archiveLines.splice(archiveHeaderIdx + 1, 0, `  ${entry}`);
+  }
+  archiveLines[archiveHeaderIdx] = archiveLines[archiveHeaderIdx].replace(/archived\[\d+\|/, `[${archiveCount + toArchive.length}|`);
+  writeFileSync(ARCHIVE_FILE, archiveLines.join("\n"));
+  lines[headerIdx] = lines[headerIdx].replace(/entries\[\d+\|/, `[${toKeep.length}|`);
+  lines.splice(headerIdx + 1, entryLines.length, ...toKeep.map((l) => `  ${l}`));
+  writeMemory(lines.join("\n"));
+  return { archived: toArchive.length, kept: toKeep.length };
+}
 var server = new McpServer(
   { name: "toon-memory", version: "1.1.0" },
   { capabilities: { tools: { listChanged: true } } }
@@ -27853,6 +27964,81 @@ server.registerTool(
     };
   }
 );
+server.registerTool(
+  "memory_archive",
+  {
+    title: "Archive Old Entries",
+    description: "Mover entradas antiguas (>30 d\xEDas) a archive.toon para mantener la memoria limpia.",
+    inputSchema: {}
+  },
+  async () => {
+    const result = archiveOldEntries();
+    if (result.archived === 0) {
+      return { content: [{ type: "text", text: "No hay entradas antiguas para archivar" }] };
+    }
+    return {
+      content: [{
+        type: "text",
+        text: `\u{1F4E6} Archivadas ${result.archived} entradas antiguas
+\u{1F4CB} Quedan ${result.kept} entradas activas`
+      }]
+    };
+  }
+);
+server.registerTool(
+  "memory_encrypt",
+  {
+    title: "Enable Encryption",
+    description: "Habilita encriptaci\xF3n AES-256-GCM para la memoria. La clave se genera autom\xE1ticamente.",
+    inputSchema: {}
+  },
+  async () => {
+    const config2 = loadConfig();
+    if (config2.encrypted) {
+      return { content: [{ type: "text", text: "La encriptaci\xF3n ya est\xE1 habilitada" }] };
+    }
+    const key = generateKey();
+    const data = readFileSync(MEMORY_FILE, "utf-8");
+    const encrypted = encrypt(data, key);
+    writeFileSync(MEMORY_FILE, encrypted);
+    saveConfig({ encrypted: true, key });
+    return {
+      content: [{
+        type: "text",
+        text: `\u{1F510} Encriptaci\xF3n habilitada
+\u26A0\uFE0F Guarda esta clave (no se puede recuperar):
+${key}`
+      }]
+    };
+  }
+);
+server.registerTool(
+  "memory_decrypt",
+  {
+    title: "Disable Encryption",
+    description: "Deshabilita la encriptaci\xF3n y decodifica la memoria.",
+    inputSchema: {
+      key: external_exports.string().describe("Clave de encriptaci\xF3n")
+    }
+  },
+  async ({ key }) => {
+    const config2 = loadConfig();
+    if (!config2.encrypted) {
+      return { content: [{ type: "text", text: "La encriptaci\xF3n no est\xE1 habilitada" }] };
+    }
+    try {
+      const data = readFileSync(MEMORY_FILE, "utf-8");
+      const decrypted = decrypt(data, key);
+      writeFileSync(MEMORY_FILE, decrypted);
+      saveConfig({ encrypted: false });
+      return {
+        content: [{ type: "text", text: "\u{1F513} Encriptaci\xF3n deshabilitada" }]
+      };
+    } catch {
+      return { content: [{ type: "text", text: "\u274C Clave incorrecta o datos corruptos" }] };
+    }
+  }
+);
 var transport = new StdioServerTransport();
 await server.connect(transport);
 /*! Bundled license information:

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "toon-memory",
-  "version": "1.3.0",
+  "version": "1.5.0",
   "description": "Persistent memory system for AI coding agents using TOON format (40% fewer tokens than JSON)",
   "type": "module",
   "bin": {

package/src/cli/setup.ts

@@ -446,6 +446,59 @@ function importMemory(): void {
   console.log(`Skipped ${importData.entries.length - newEntries.length} duplicates\n`)
 }
 
+// Watch mode - backup memory every N minutes
+function watch(): void {
+  console.log("\n🧠 toon-memory watch\n")
+  
+  const memoryFile = join(projectRoot, ".opencode", "memory", "data.toon")
+  const backupDir = join(projectRoot, ".opencode", "memory", "backups")
+  
+  if (!existsSync(memoryFile)) {
+    console.log("Memory not initialized. Run 'npx toon-memory init' first.\n")
+    return
+  }
+  
+  if (!existsSync(backupDir)) mkdirSync(backupDir, { recursive: true })
+  
+  const intervalMinutes = parseInt(args[1]) || 5
+  console.log(`Watching memory file every ${intervalMinutes} minutes...`)
+  console.log(`Press Ctrl+C to stop\n`)
+  
+  let lastContent = readFileSync(memoryFile, "utf-8")
+  let backupCount = 0
+  
+  const backup = () => {
+    const currentContent = readFileSync(memoryFile, "utf-8")
+    
+    if (currentContent !== lastContent) {
+      const timestamp = new Date().toISOString().replace(/[:.]/g, "-")
+      const backupFile = join(backupDir, `backup-${timestamp}.toon`)
+      writeFileSync(backupFile, currentContent)
+      backupCount++
+      console.log(`📦 Backup #${backupCount} created: ${timestamp}`)
+      lastContent = currentContent
+    }
+  }
+  
+  // Initial backup
+  backup()
+  
+  // Set interval
+  const interval = setInterval(backup, intervalMinutes * 60 * 1000)
+  
+  // Handle Ctrl+C
+  process.on("SIGINT", () => {
+    clearInterval(interval)
+    console.log(`\n✅ Watch stopped. ${backupCount} backups created.\n`)
+    process.exit(0)
+  })
+  
+  process.on("SIGTERM", () => {
+    clearInterval(interval)
+    process.exit(0)
+  })
+}
+
 // Main
 const args = process.argv.slice(2)
 
@@ -484,6 +537,11 @@ if (args[0] === "import") {
   process.exit(0)
 }
 
+if (args[0] === "watch") {
+  watch()
+  process.exit(0)
+}
+
 const agents = detectAgents()
 console.log("\n🧠 toon-memory installer\n")
 

package/src/mcp/server.ts

@@ -4,33 +4,178 @@ import { z } from "zod"
 import { readFileSync, writeFileSync, existsSync, mkdirSync } from "fs"
 import { dirname, join } from "path"
 import { fileURLToPath } from "url"
-import { randomBytes } from "crypto"
+import { randomBytes, createCipheriv, createDecipheriv } from "crypto"
 
 const __dirname = dirname(fileURLToPath(import.meta.url))
 const MEMORY_DIR = join(process.cwd(), ".opencode", "memory")
 const MEMORY_FILE = join(MEMORY_DIR, "data.toon")
+const ARCHIVE_FILE = join(MEMORY_DIR, "archive.toon")
+const CONFIG_FILE = join(MEMORY_DIR, "config.json")
+const MAX_ENTRIES = 100
+const ARCHIVE_DAYS = 30
+const ALGORITHM = "aes-256-gcm"
+
+interface MemoryConfig {
+  encrypted: boolean
+  key?: string
+}
 
-function ensureMemoryFile() {
+function loadConfig(): MemoryConfig {
+  if (!existsSync(CONFIG_FILE)) {
+    return { encrypted: false }
+  }
+  try {
+    return JSON.parse(readFileSync(CONFIG_FILE, "utf-8"))
+  } catch {
+    return { encrypted: false }
+  }
+}
+
+function saveConfig(config: MemoryConfig): void {
+  ensureMemoryDir()
+  writeFileSync(CONFIG_FILE, JSON.stringify(config, null, 2))
+}
+
+function ensureMemoryDir() {
   if (!existsSync(MEMORY_DIR)) mkdirSync(MEMORY_DIR, { recursive: true })
+}
+
+function ensureMemoryFile() {
+  ensureMemoryDir()
   if (!existsSync(MEMORY_FILE)) {
     writeFileSync(MEMORY_FILE, "version: 1\nentries[0|]{id|category|key|content|file|tags|date}:\n")
   }
 }
 
-function readMemory() {
+function encrypt(text: string, key: string): string {
+  const keyBuffer = Buffer.from(key, "hex")
+  const iv = randomBytes(16)
+  const cipher = createCipheriv(ALGORITHM, keyBuffer, iv)
+  
+  let encrypted = cipher.update(text, "utf8", "hex")
+  encrypted += cipher.final("hex")
+  
+  const authTag = cipher.getAuthTag()
+  
+  return `${iv.toString("hex")}:${authTag.toString("hex")}:${encrypted}`
+}
+
+function decrypt(encryptedData: string, key: string): string {
+  const keyBuffer = Buffer.from(key, "hex")
+  const [ivHex, authTagHex, encrypted] = encryptedData.split(":")
+  
+  const iv = Buffer.from(ivHex, "hex")
+  const authTag = Buffer.from(authTagHex, "hex")
+  const decipher = createDecipheriv(ALGORITHM, keyBuffer, iv)
+  decipher.setAuthTag(authTag)
+  
+  let decrypted = decipher.update(encrypted, "hex", "utf8")
+  decrypted += decipher.final("utf8")
+  
+  return decrypted
+}
+
+function generateKey(): string {
+  return randomBytes(32).toString("hex")
+}
+
+function readMemory(): string {
   ensureMemoryFile()
-  return readFileSync(MEMORY_FILE, "utf-8")
+  const config = loadConfig()
+  const data = readFileSync(MEMORY_FILE, "utf-8")
+  
+  if (config.encrypted && config.key) {
+    try {
+      return decrypt(data, config.key)
+    } catch {
+      return data
+    }
+  }
+  
+  return data
 }
 
-function writeMemory(content: string) {
+function writeMemory(content: string): void {
   ensureMemoryFile()
-  writeFileSync(MEMORY_FILE, content)
+  const config = loadConfig()
+  
+  if (config.encrypted && config.key) {
+    const encrypted = encrypt(content, config.key)
+    writeFileSync(MEMORY_FILE, encrypted)
+  } else {
+    writeFileSync(MEMORY_FILE, content)
+  }
 }
 
 function generateId(): string {
   return randomBytes(4).toString("hex")
 }
 
+function archiveOldEntries(): { archived: number; kept: number } {
+  const data = readMemory()
+  const lines = data.split("\n")
+  const headerIdx = lines.findIndex((l) => l.startsWith("entries["))
+  
+  if (headerIdx === -1) return { archived: 0, kept: 0 }
+  
+  const today = new Date()
+  const cutoff = new Date(today)
+  cutoff.setDate(cutoff.getDate() - ARCHIVE_DAYS)
+  const cutoffStr = cutoff.toISOString().split("T")[0]
+  
+  const entryLines = lines.slice(headerIdx + 1).filter((l) => l.trim().length > 0)
+  const toArchive: string[] = []
+  const toKeep: string[] = []
+  
+  for (const line of entryLines) {
+    const parts = line.trim().split("|")
+    if (parts.length >= 7) {
+      const date = parts[6]
+      if (date < cutoffStr) {
+        toArchive.push(line.trim())
+      } else {
+        toKeep.push(line.trim())
+      }
+    } else {
+      toKeep.push(line.trim())
+    }
+  }
+  
+  if (toArchive.length === 0) return { archived: 0, kept: toKeep.length }
+  
+  // Write archived entries
+  let archiveContent = ""
+  if (existsSync(ARCHIVE_FILE)) {
+    archiveContent = readFileSync(ARCHIVE_FILE, "utf-8")
+  } else {
+    archiveContent = `version: 1\narchived:\n`
+  }
+  
+  const archiveLines = archiveContent.split("\n")
+  let archiveHeaderIdx = archiveLines.findIndex((l) => l.startsWith("archived["))
+  if (archiveHeaderIdx === -1) {
+    archiveLines.push(`archived[0|]{id|category|key|content|file|tags|date}:`)
+    archiveHeaderIdx = archiveLines.length - 1
+  }
+  
+  const archiveMatch = archiveLines[archiveHeaderIdx].match(/archived\[(\d+)\|/)
+  const archiveCount = archiveMatch ? parseInt(archiveMatch[1]) : 0
+  
+  for (const entry of toArchive) {
+    archiveLines.splice(archiveHeaderIdx + 1, 0, `  ${entry}`)
+  }
+  archiveLines[archiveHeaderIdx] = archiveLines[archiveHeaderIdx].replace(/archived\[\d+\|/, `[${archiveCount + toArchive.length}|`)
+  
+  writeFileSync(ARCHIVE_FILE, archiveLines.join("\n"))
+  
+  // Update main file
+  lines[headerIdx] = lines[headerIdx].replace(/entries\[\d+\|/, `[${toKeep.length}|`)
+  lines.splice(headerIdx + 1, entryLines.length, ...toKeep.map((l) => `  ${l}`))
+  writeMemory(lines.join("\n"))
+  
+  return { archived: toArchive.length, kept: toKeep.length }
+}
+
 const server = new McpServer(
   { name: "toon-memory", version: "1.1.0" },
   { capabilities: { tools: { listChanged: true } } }
@@ -251,5 +396,91 @@ server.registerTool(
   }
 )
 
+server.registerTool(
+  "memory_archive",
+  {
+    title: "Archive Old Entries",
+    description: "Mover entradas antiguas (>30 días) a archive.toon para mantener la memoria limpia.",
+    inputSchema: {},
+  },
+  async () => {
+    const result = archiveOldEntries()
+    
+    if (result.archived === 0) {
+      return { content: [{ type: "text" as const, text: "No hay entradas antiguas para archivar" }] }
+    }
+    
+    return {
+      content: [{ 
+        type: "text" as const, 
+        text: `📦 Archivadas ${result.archived} entradas antiguas\n📋 Quedan ${result.kept} entradas activas` 
+      }],
+    }
+  }
+)
+
+server.registerTool(
+  "memory_encrypt",
+  {
+    title: "Enable Encryption",
+    description: "Habilita encriptación AES-256-GCM para la memoria. La clave se genera automáticamente.",
+    inputSchema: {},
+  },
+  async () => {
+    const config = loadConfig()
+    
+    if (config.encrypted) {
+      return { content: [{ type: "text" as const, text: "La encriptación ya está habilitada" }] }
+    }
+    
+    const key = generateKey()
+    const data = readFileSync(MEMORY_FILE, "utf-8")
+    
+    const encrypted = encrypt(data, key)
+    writeFileSync(MEMORY_FILE, encrypted)
+    
+    saveConfig({ encrypted: true, key })
+    
+    return {
+      content: [{ 
+        type: "text" as const, 
+        text: `🔐 Encriptación habilitada\n⚠️ Guarda esta clave (no se puede recuperar):\n${key}` 
+      }],
+    }
+  }
+)
+
+server.registerTool(
+  "memory_decrypt",
+  {
+    title: "Disable Encryption",
+    description: "Deshabilita la encriptación y decodifica la memoria.",
+    inputSchema: {
+      key: z.string().describe("Clave de encriptación"),
+    },
+  },
+  async ({ key }) => {
+    const config = loadConfig()
+    
+    if (!config.encrypted) {
+      return { content: [{ type: "text" as const, text: "La encriptación no está habilitada" }] }
+    }
+    
+    try {
+      const data = readFileSync(MEMORY_FILE, "utf-8")
+      const decrypted = decrypt(data, key)
+      
+      writeFileSync(MEMORY_FILE, decrypted)
+      saveConfig({ encrypted: false })
+      
+      return {
+        content: [{ type: "text" as const, text: "🔓 Encriptación deshabilitada" }],
+      }
+    } catch {
+      return { content: [{ type: "text" as const, text: "❌ Clave incorrecta o datos corruptos" }] }
+    }
+  }
+)
+
 const transport = new StdioServerTransport()
 await server.connect(transport)