toon-memory 1.7.0 → 2.0.0

package/mcp/server.js

@@ -16506,8 +16506,8 @@ var require_resolve = /* @__PURE__ */ __commonJSMin(((exports) => {
     }
     return count;
   }
-  function getFullPath(resolver, id = "", normalize) {
-    if (normalize !== false) id = normalizeId(id);
+  function getFullPath(resolver, id = "", normalize2) {
+    if (normalize2 !== false) id = normalizeId(id);
     return _getFullPath(resolver, resolver.parse(id));
   }
   exports.getFullPath = getFullPath;
@@ -17602,7 +17602,7 @@ var require_schemes = /* @__PURE__ */ __commonJSMin(((exports, module) => {
 var require_fast_uri = /* @__PURE__ */ __commonJSMin(((exports, module) => {
   const { normalizeIPv6, removeDotSegments, recomposeAuthority, normalizeComponentEncoding, isIPv4, nonSimpleDomain } = require_utils();
   const { SCHEMES, getSchemeHandler } = require_schemes();
-  function normalize(uri, options) {
+  function normalize2(uri, options) {
     if (typeof uri === "string") uri = serialize(parse3(uri, options), options);
     else if (typeof uri === "object") uri = parse3(serialize(uri, options), options);
     return uri;
@@ -17780,7 +17780,7 @@ var require_fast_uri = /* @__PURE__ */ __commonJSMin(((exports, module) => {
   }
   const fastUri = {
     SCHEMES,
-    normalize,
+    normalize: normalize2,
     resolve,
     resolveComponent,
     equal,
@@ -27644,10 +27644,11 @@ import { dirname, join } from "path";
 import { fileURLToPath } from "url";
 import { randomBytes, createCipheriv, createDecipheriv } from "crypto";
 var __dirname = dirname(fileURLToPath(import.meta.url));
-var MEMORY_DIR = join(process.cwd(), ".opencode", "memory");
+var MEMORY_DIR = join(process.cwd(), ".toon-memory", "memory");
 var MEMORY_FILE = join(MEMORY_DIR, "data.toon");
 var ARCHIVE_FILE = join(MEMORY_DIR, "archive.toon");
 var CONFIG_FILE = join(MEMORY_DIR, "config.json");
+var MAX_ENTRIES = 100;
 var ARCHIVE_DAYS = 30;
 var ALGORITHM = "aes-256-gcm";
 function loadConfig() {
@@ -27673,7 +27674,7 @@ function ensureMemoryDir() {
 function ensureMemoryFile() {
   ensureMemoryDir();
   if (!existsSync(MEMORY_FILE)) {
-    writeFileSync(MEMORY_FILE, "version: 1\nentries[0|]{id|category|key|content|file|tags|date}:\n");
+    writeFileSync(MEMORY_FILE, "version: 1\nentries[0|]{id|category|key|content|file|tags|date|ttl}:\n");
   }
 }
 function encrypt(text, key) {
@@ -27726,6 +27727,96 @@ function writeMemory(content) {
 function generateId() {
   return randomBytes(4).toString("hex");
 }
+function parseTTL(ttl) {
+  if (!ttl || !ttl.trim()) return "";
+  const trimmed = ttl.trim();
+  const dayMatch = trimmed.match(/^(\d+)d$/);
+  if (dayMatch) {
+    const days = parseInt(dayMatch[1]);
+    const d = /* @__PURE__ */ new Date();
+    d.setDate(d.getDate() + days);
+    return d.toISOString().split("T")[0];
+  }
+  if (/^\d{4}-\d{2}-\d{2}$/.test(trimmed)) return trimmed;
+  return "";
+}
+function isExpired(ttl) {
+  if (!ttl) return false;
+  const ttlDate = parseTTL(ttl) || ttl;
+  const today = (/* @__PURE__ */ new Date()).toISOString().split("T")[0];
+  return ttlDate <= today;
+}
+var TAG_VOCABULARY = {
+  "redis": ["redis", "cache", "caching", "memcached"],
+  "auth": ["auth", "authentication", "authorization", "login", "token", "jwt", "session", "oauth"],
+  "api": ["api", "endpoint", "rest", "graphql", "route", "router", "controller"],
+  "db": ["database", "db", "sql", "postgres", "mysql", "mongo", "query", "migration", "schema"],
+  "security": ["security", "encrypt", "decrypt", "vulnerability", "xss", "csrf", "cors", "sanitiz"],
+  "test": ["test", "testing", "vitest", "jest", "spec", "mock", "assert", "coverage"],
+  "deploy": ["deploy", "docker", "ci/cd", "github actions", "pipeline", "kubernetes", "k8s"],
+  "config": ["config", "configuration", "settings", "env", "environment", "dotenv"],
+  "performance": ["performance", "optimize", "benchmark", "latency", "throughput", "cache"],
+  "refactor": ["refactor", "cleanup", "restructure", "reorganize", "rework"],
+  "error": ["error", "exception", "throw", "catch", "handling", "retry", "fallback"],
+  "logging": ["log", "logging", "logger", "debug", "trace", "monitor", "observability"],
+  "types": ["typescript", "types", "type", "interface", "generic", "enum", "zod", "schema"],
+  "async": ["async", "await", "promise", "concurrent", "parallel", "worker", "queue"],
+  "state": ["state", "store", "redux", "context", "reducer", "action", "observable"],
+  "ui": ["ui", "component", "render", "dom", "css", "style", "layout", "responsive"],
+  "storage": ["storage", "file", "filesystem", "s3", "blob", "upload", "download"],
+  "email": ["email", "mail", "smtp", "sendgrid", "newsletter", "notification"],
+  "payment": ["payment", "stripe", "billing", "invoice", "checkout", "subscription"],
+  "webhook": ["webhook", "callback", "event", "listener", "hook"]
+};
+function inferTags(content, key) {
+  const text = `${key} ${content}`.toLowerCase();
+  const matched = [];
+  for (const [tag, keywords] of Object.entries(TAG_VOCABULARY)) {
+    if (keywords.some((kw) => text.includes(kw))) {
+      matched.push(tag);
+    }
+  }
+  return matched.join(";");
+}
+function parseRelativeDate(since) {
+  const trimmed = since.trim();
+  const hourMatch = trimmed.match(/^(\d+)h$/);
+  if (hourMatch) {
+    const d = /* @__PURE__ */ new Date();
+    d.setHours(d.getHours() - parseInt(hourMatch[1]));
+    return d.toISOString().split("T")[0];
+  }
+  const dayMatch = trimmed.match(/^(\d+)d$/);
+  if (dayMatch) {
+    const d = /* @__PURE__ */ new Date();
+    d.setDate(d.getDate() - parseInt(dayMatch[1]));
+    return d.toISOString().split("T")[0];
+  }
+  if (/^\d{4}-\d{2}-\d{2}$/.test(trimmed)) return trimmed;
+  const today = (/* @__PURE__ */ new Date()).toISOString().split("T")[0];
+  return today;
+}
+var normalize = (s) => s.toLowerCase().replace(/[-_]/g, " ").replace(/\s+/g, " ").trim();
+function findRelatedEntries(text, excludeKey = "", limit = 3) {
+  const data = readMemory();
+  const lines = data.split("\n").filter((l) => l.startsWith("  ") && l.includes("|") && !l.startsWith("  summaries:"));
+  const queryTokens = normalize(text).split(" ").filter(Boolean);
+  const scored = lines.map((line) => {
+    const trimmed = line.trim();
+    const parts = trimmed.split("|");
+    if (parts.length < 7) return null;
+    const [id, cat, key, content, file2, tags, date5] = parts;
+    if (key === excludeKey) return null;
+    const searchStr = normalize(`${id} ${cat} ${key} ${content} ${file2} ${tags}`);
+    let score = 0;
+    for (const token of queryTokens) {
+      if (searchStr.includes(token)) score++;
+    }
+    if (score === 0) return null;
+    return { id, cat, key, content, file: file2, tags, date: date5, score };
+  }).filter(Boolean).sort((a, b) => b.score - a.score).slice(0, limit);
+  return scored;
+}
 function archiveOldEntries() {
   const data = readMemory();
   const lines = data.split("\n");
@@ -27742,7 +27833,10 @@ function archiveOldEntries() {
     const parts = line.trim().split("|");
     if (parts.length >= 7) {
       const date5 = parts[6];
-      if (date5 < cutoffStr) {
+      const ttl = parts[7] || "";
+      const isOld = date5 < cutoffStr;
+      const isTtlExpired = ttl && isExpired(ttl);
+      if (isOld || isTtlExpired) {
         toArchive.push(line.trim());
       } else {
         toKeep.push(line.trim());
@@ -27779,8 +27873,58 @@ archived:
   return { archived: toArchive.length, kept: toKeep.length };
 }
 var server = new McpServer(
-  { name: "toon-memory", version: "1.1.0" },
-  { capabilities: { tools: { listChanged: true } } }
+  { name: "toon-memory", version: "2.0.0" },
+  { capabilities: { tools: { listChanged: true }, resources: { listChanged: true } } }
+);
+server.registerResource(
+  "memory-entries",
+  "toon://memory/entries",
+  { title: "Memory Entries", mimeType: "text/plain" },
+  async (uri) => {
+    const data = readMemory();
+    return { contents: [{ uri: uri.href, text: data }] };
+  }
+);
+server.registerResource(
+  "memory-stats",
+  "toon://memory/stats",
+  { title: "Memory Stats", mimeType: "text/plain" },
+  async (uri) => {
+    const data = readMemory();
+    const lines = data.split("\n").filter((l) => l.startsWith("  ") && l.includes("|") && !l.startsWith("  summaries:"));
+    const entries = lines.map((l) => {
+      const parts = l.trim().split("|");
+      return { category: parts[1] || "unknown", ttl: parts[7] || "" };
+    });
+    const byCategory = {};
+    for (const e of entries) {
+      byCategory[e.category] = (byCategory[e.category] || 0) + 1;
+    }
+    const withTtl = entries.filter((e) => e.ttl).length;
+    const expired = entries.filter((e) => e.ttl && isExpired(e.ttl)).length;
+    const text = [
+      `Entradas totales: ${entries.length}`,
+      `TTL: ${withTtl} con expiraci\xF3n, ${expired} expiradas`,
+      "Por categor\xEDa:",
+      ...Object.entries(byCategory).map(([k, v]) => `  ${k}: ${v}`)
+    ].join("\n");
+    return { contents: [{ uri: uri.href, text }] };
+  }
+);
+server.registerResource(
+  "memory-summaries",
+  "toon://memory/summaries",
+  { title: "Memory Summaries", mimeType: "text/plain" },
+  async (uri) => {
+    const data = readMemory();
+    const lines = data.split("\n");
+    const summaryIdx = lines.findIndex((l) => l.trim().startsWith("summaries:"));
+    if (summaryIdx === -1) {
+      return { contents: [{ uri: uri.href, text: "No hay res\xFAmenes guardados" }] };
+    }
+    const summaryText = lines.slice(summaryIdx + 1).filter((l) => l.includes(":")).join("\n");
+    return { contents: [{ uri: uri.href, text: summaryText || "No hay res\xFAmenes guardados" }] };
+  }
 );
 server.registerTool(
   "memory_remember",
@@ -27792,10 +27936,11 @@ server.registerTool(
       key: external_exports.string().describe("T\xEDtulo corto en kebab-case (ej: risk-engine-prioridad)"),
       content: external_exports.string().describe("Contenido detallado del hecho"),
       file: external_exports.string().optional().default("").describe("Archivo o l\xEDnea relacionada (ej: spec.md:145)"),
-      tags: external_exports.string().optional().default("").describe("Tags separados por punto y coma (ej: risk;spec)")
+      tags: external_exports.string().optional().default("").describe("Tags separados por punto y coma (ej: risk;spec)"),
+      ttl: external_exports.string().optional().default("").describe("Time to live (ej: 7d, 2026-07-17). Vac\xEDo = sin expiraci\xF3n")
     }
   },
-  async ({ category, key, content, file: file2, tags }) => {
+  async ({ category, key, content, file: file2, tags, ttl }) => {
     const data = readMemory();
     const newId = generateId();
     const date5 = (/* @__PURE__ */ new Date()).toISOString().split("T")[0];
@@ -27819,8 +27964,11 @@ server.registerTool(
       }
     }
     const entryId = existingIdx !== -1 ? existingId : newId;
-    const newEntry = `${entryId}|${category}|${key}|${content}|${file2 || ""}|${tags || ""}|${date5}`;
+    const resolvedTtl = parseTTL(ttl);
+    const resolvedTags = tags ? tags : inferTags(content, key);
+    const newEntry = `${entryId}|${category}|${key}|${content}|${file2 || ""}|${resolvedTags}|${date5}|${resolvedTtl}`;
     let action = "Guardado";
+    const tagsInferred = !tags && resolvedTags ? true : false;
     if (existingIdx !== -1) {
       lines[existingIdx] = `  ${newEntry}`;
       action = "Actualizado";
@@ -27831,9 +27979,32 @@ server.registerTool(
       lines[headerIdx] = lines[headerIdx].replace(/\[\d+\|/, `[${count + 1}|`);
     }
     writeMemory(lines.join("\n"));
+    const headerMatch = lines[headerIdx].match(/\[(\d+)\|/);
+    const entryCount = headerMatch ? parseInt(headerMatch[1]) : 0;
+    let archiveMsg = "";
+    if (entryCount > MAX_ENTRIES) {
+      const result = archiveOldEntries();
+      if (result.archived > 0) {
+        archiveMsg = `
+\u{1F4E6} Auto-archived ${result.archived} old entries (${result.kept} kept)`;
+      }
+    }
+    const ttlMsg = resolvedTtl ? `
+\u23F0 TTL: ${resolvedTtl}` : "";
+    const inferredMsg = tagsInferred ? `
+\u{1F3F7}\uFE0F Tags inferidos: ${resolvedTags}` : "";
+    const related = findRelatedEntries(`${key} ${content} ${resolvedTags}`, key, 3);
+    let relatedMsg = "";
+    if (related.length > 0) {
+      const items = related.map((r) => `  [${r.cat}] ${r.key} \u2014 ${r.content.slice(0, 80)}`).join("\n");
+      relatedMsg = `
+
+\u{1F517} Entradas relacionadas:
+${items}`;
+    }
     return {
       content: [{ type: "text", text: `\u{1F9E0} ${action}: ${category}/${key} (${entryId})
-${content}` }]
+${content}${ttlMsg}${inferredMsg}${archiveMsg}${relatedMsg}` }]
     };
   }
 );
@@ -27852,17 +28023,18 @@ server.registerTool(
   async ({ query, category, from_date, to_date }) => {
     const data = readMemory();
     const lines = data.split("\n").filter((l) => l.startsWith("  ") && l.includes("|") && !l.startsWith("summaries:"));
-    const normalize = (s) => s.toLowerCase().replace(/[-_]/g, " ").replace(/\s+/g, " ").trim();
-    const queryTokens = normalize(query).split(" ").filter(Boolean);
+    const normalize2 = (s) => s.toLowerCase().replace(/[-_]/g, " ").replace(/\s+/g, " ").trim();
+    const queryTokens = normalize2(query).split(" ").filter(Boolean);
     const results = lines.map((line) => {
       const trimmed = line.trim();
       const parts = trimmed.split("|");
       if (parts.length < 7) return null;
-      const [id, cat, key, content, file2, tags, date5] = parts;
+      const [id, cat, key, content, file2, tags, date5, ttl] = parts;
       if (category && cat !== category) return null;
       if (from_date && date5 < from_date) return null;
       if (to_date && date5 > to_date) return null;
-      const searchStr = normalize(`${id} ${cat} ${key} ${content} ${file2} ${tags}`);
+      if (ttl && isExpired(ttl)) return null;
+      const searchStr = normalize2(`${id} ${cat} ${key} ${content} ${file2} ${tags}`);
       if (!queryTokens.every((token) => searchStr.includes(token))) return null;
       return { id, cat, key, content, file: file2, tags, date: date5 };
     }).filter(Boolean);
@@ -27919,12 +28091,14 @@ server.registerTool(
     const lines = data.split("\n").filter((l) => l.startsWith("  ") && l.includes("|") && !l.startsWith("  summaries:"));
     const entries = lines.map((l) => {
       const parts = l.trim().split("|");
-      return { category: parts[1] || "unknown" };
+      return { category: parts[1] || "unknown", ttl: parts[7] || "" };
     });
     const byCategory = {};
     for (const e of entries) {
       byCategory[e.category] = (byCategory[e.category] || 0) + 1;
     }
+    const withTtl = entries.filter((e) => e.ttl).length;
+    const expired = entries.filter((e) => e.ttl && isExpired(e.ttl)).length;
     const summaryLines = data.split("\n").filter((l) => l.includes(":") && !l.startsWith("  ") && !l.startsWith("version") && !l.startsWith("entries") && !/^\[\d+\|]/.test(l));
     const stats = [
       `Entradas totales: ${entries.length}`,
@@ -27933,15 +28107,90 @@ server.registerTool(
       "Por categor\xEDa:",
       ...Object.entries(byCategory).map(([k, v]) => `  ${k}: ${v}`),
       "",
+      `TTL: ${withTtl} con expiraci\xF3n, ${expired} expiradas`,
+      "",
       `\xDAltimas 5 entradas:`,
       ...lines.slice(-5).map((l) => {
         const parts = l.trim().split("|");
-        return `  [${parts[1]}] ${parts[2]} (${parts[0]})`;
+        const ttlInfo = parts[7] ? ` | TTL: ${parts[7]}` : "";
+        return `  [${parts[1]}] ${parts[2]} (${parts[0]})${ttlInfo}`;
       })
     ];
     return { content: [{ type: "text", text: stats.join("\n") }] };
   }
 );
+server.registerTool(
+  "memory_diff",
+  {
+    title: "Memory Diff",
+    description: "Muestra qu\xE9 cambi\xF3 en la memoria desde una fecha. \xDAtil para saber qu\xE9 se aprendi\xF3 desde la \xFAltima sesi\xF3n.",
+    inputSchema: {
+      since: external_exports.string().describe("Desde cu\xE1ndo mostrar cambios (ej: 24h, 7d, 2026-07-10)"),
+      type: external_exports.enum(["all", "created", "updated"]).optional().default("all").describe("Filtrar por tipo de cambio")
+    }
+  },
+  async ({ since, type }) => {
+    const sinceDate = parseRelativeDate(since);
+    const today = (/* @__PURE__ */ new Date()).toISOString().split("T")[0];
+    const data = readMemory();
+    const lines = data.split("\n").filter((l) => l.startsWith("  ") && l.includes("|") && !l.startsWith("  summaries:"));
+    const results = lines.map((line) => {
+      const trimmed = line.trim();
+      const parts = trimmed.split("|");
+      if (parts.length < 7) return null;
+      const [id, cat, key, content, file2, tags, date5] = parts;
+      if (date5 < sinceDate) return null;
+      const changeType = date5 === today ? "created" : "updated";
+      if (type !== "all" && changeType !== type) return null;
+      return { id, cat, key, content, file: file2, tags, date: date5, changeType };
+    }).filter(Boolean);
+    if (results.length === 0) {
+      return { content: [{ type: "text", text: `No hay cambios desde ${sinceDate}` }] };
+    }
+    const created = results.filter((r) => r.changeType === "created");
+    const updated = results.filter((r) => r.changeType === "updated");
+    const sections = [`\u{1F4CB} Cambios desde ${sinceDate}:`, ""];
+    if (created.length > 0 && (type === "all" || type === "created")) {
+      sections.push(`\u2795 Nuevas (${created.length}):`);
+      for (const r of created) {
+        sections.push(`  [${r.cat}] ${r.key} (${r.id})
+    ${r.content}`);
+      }
+      sections.push("");
+    }
+    if (updated.length > 0 && (type === "all" || type === "updated")) {
+      sections.push(`\u270F\uFE0F  Actualizadas (${updated.length}):`);
+      for (const r of updated) {
+        sections.push(`  [${r.cat}] ${r.key} (${r.id}) \u2014 ${r.date}`);
+      }
+      sections.push("");
+    }
+    return { content: [{ type: "text", text: sections.join("\n") }] };
+  }
+);
+server.registerTool(
+  "memory_suggest",
+  {
+    title: "Suggest Related Memories",
+    description: "Sugiere entradas de memoria relacionadas con un contexto dado. \xDAtil para obtener contexto antes de una tarea.",
+    inputSchema: {
+      context: external_exports.string().describe("Texto o contexto para buscar sugerencias"),
+      limit: external_exports.number().optional().default(5).describe("M\xE1ximo de sugerencias")
+    }
+  },
+  async ({ context, limit }) => {
+    const related = findRelatedEntries(context, "", limit);
+    if (related.length === 0) {
+      return { content: [{ type: "text", text: `No se encontraron entradas relacionadas con "${context}"` }] };
+    }
+    const formatted = related.map((r) => `[${r.cat}] ${r.key} (${r.id})
+  ${r.content}
+  File: ${r.file} | Tags: ${r.tags} | Date: ${r.date}`).join("\n\n");
+    return { content: [{ type: "text", text: `\u{1F50D} Sugerencias para "${context}":
+
+${formatted}` }] };
+  }
+);
 server.registerTool(
   "memory_summary",
   {

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "toon-memory",
-  "version": "1.7.0",
+  "version": "2.0.0",
   "description": "Persistent memory system for AI coding agents using TOON format (40% fewer tokens than JSON)",
   "type": "module",
   "bin": {
@@ -45,6 +45,14 @@
     "windsurf",
     "cline",
     "continue",
+    "codex",
+    "gemini",
+    "zed",
+    "antigravity",
+    "aider",
+    "kilocode",
+    "openclaw",
+    "kiro",
     "ai-agent",
     "memory",
     "toon",

package/skills/toon-memory.md

@@ -6,16 +6,23 @@ A persistent memory system for AI coding agents. It remembers decisions, pattern
 
 ## Supported Agents
 
-| Agent | Config File | Format |
-|-------|-------------|--------|
-| OpenCode | `.opencode/opencode.json` | MCP server |
-| VS Code / Copilot | `.vscode/mcp.json` | MCP server |
-| Claude | `.claude/settings.json` | MCP server |
-| Cursor | `.cursor/mcp.json` | MCP server |
-| Windsurf | `.windsurfrules` | MCP server |
-| Cline | `.cline/mcp.json` | MCP server |
-| Continue | `.continue/config.json` | MCP server |
-| Aider | `.aider.conf.yml` | Manual config |
+| Agent | Config File | Format | Hooks |
+|-------|-------------|--------|-------|
+| OpenCode | `.opencode/opencode.json` | MCP server | — |
+| VS Code / Copilot | `.vscode/mcp.json` | MCP server | — |
+| Claude Code | `.claude/settings.json` | MCP server | SessionStart |
+| Cursor | `.cursor/mcp.json` | MCP server | — |
+| Windsurf | `~/.codeium/windsurf/mcp_config.json` | MCP server | — |
+| Cline | `.cline/mcp.json` | MCP server | — |
+| Continue | `.continue/config.json` | MCP server | — |
+| Codex CLI | `.codex/config.toml` | TOML | SessionStart |
+| Gemini CLI | `.gemini/settings.json` | MCP server | SessionStart |
+| Zed | `~/.config/zed/settings.json` | JSONC | — |
+| Antigravity | `.gemini/config/mcp_config.json` | MCP server | SessionStart |
+| Aider | — | Instructions only | — |
+| KiloCode | `~/.kilocode/mcp_settings.json` | MCP server | — |
+| OpenClaw | `.openclaw.json` | MCP server | — |
+| Kiro | `.kiro/settings/mcp.json` | MCP server | — |
 
 ## Tools
 
@@ -26,6 +33,9 @@ A persistent memory system for AI coding agents. It remembers decisions, pattern
 | `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 |
+| `memory_encrypt` | Enable encryption |
+| `memory_decrypt` | Disable encryption |
 
 ## Installation
 
@@ -37,8 +47,9 @@ npx toon-memory
 
 This will:
 1. Detect installed agents
-2. Ask if you want local or global installation
-3. Configure the MCP server automatically
+2. Let you select which agents to configure
+3. Ask for local or global installation
+4. Configure MCP server, instructions, and hooks automatically
 
 ### Manual installation
 
@@ -71,7 +82,7 @@ Add to your agent's MCP config:
 ### When exploring the project
 
 1. First: `memory_recall(query="what you need to know")`
-2. If no result: use CodeGraph or grep
+2. If no result: use grep or search tools
 3. Only if both fail: read files directly
 
 ### At the END of every session
@@ -91,7 +102,7 @@ Add to your agent's MCP config:
 
 ## File format
 
-Data is stored in `.opencode/memory/data.toon` using TOON (Token-Oriented Object Notation):
+Data is stored in `.toon-memory/memory/data.toon` using TOON (Token-Oriented Object Notation):
 
 ```
 version: 1