@lotargo/memory_plugin 1.3.0 → 1.3.1

package/mcp-server/config/config_manager.js

@@ -1,6 +1,6 @@
 import fs from "fs";
 import path from "path";
-import { MEMORY_DIR, ensureDir } from "../memory.js";
+import { MEMORY_DIR, ensureDirSync } from "../memory.js";
 
 const CONFIG_FILE = path.join(MEMORY_DIR, "config.json");
 
@@ -23,7 +23,7 @@ export function getConfig() {
     return cachedConfig;
   }
 
-  ensureDir();
+  ensureDirSync();
 
   if (fs.existsSync(CONFIG_FILE)) {
     try {
@@ -42,7 +42,7 @@ export function getConfig() {
 }
 
 export function saveConfig(newConfig) {
-  ensureDir();
+  ensureDirSync();
   cachedConfig = Object.freeze({ ...DEFAULT_CONFIG, ...newConfig });
   try {
     fs.writeFileSync(CONFIG_FILE, JSON.stringify(cachedConfig, null, 2), "utf-8");

package/mcp-server/index.js

@@ -453,12 +453,13 @@ server.registerTool(
     description:
       "Ingest a document into the RAG knowledge base. " +
       "Accepts local file paths, web URLs, or raw Markdown/text content. " +
+      "For type='file' the file is read from disk and indexed with a code-block wrapper. " +
       "For type='url' the page is fetched and its content is indexed (not just the URL). " +
       "Processes document through 3-tier hierarchy chunking (Big/Medium/Small), " +
       "computes dense vectors, and extracts GraphRAG code symbols.",
     inputSchema: z.object({
-      content: z.string().describe("Raw text content, file path, or web URL"),
-      type: z.enum(["text", "file", "url"]).nullish().transform((v) => v || "text").describe("Input content type: 'text', 'file', or 'url' (url fetches the page content)"),
+      content: z.string().describe("Raw text content, file path, or web URL. For type='file' this can be the file path (reads from disk) or the file content directly"),
+      type: z.enum(["text", "file", "url"]).nullish().transform((v) => v || "text").describe("Input content type: 'text' (raw content), 'file' (reads from disk, wraps in code block), or 'url' (fetches page content)"),
       title: optStr().describe("Document title"),
       path: optStr().describe("Original document file path"),
       generateEmbeddings: defBool(true).describe("Compute dense vector embeddings"),

package/mcp-server/ingest/pipeline.js

@@ -1,4 +1,5 @@
 import { randomUUID } from "node:crypto";
+import { readFile } from "node:fs/promises";
 import { getDatabase, BLOBS_DIR } from "../db/database.js";
 import { saveBlob, deleteBlob } from "../storage/blob_store.js";
 import { normalizeContent, fetchUrlContent } from "./normalizer.js";
@@ -28,6 +29,13 @@ export async function ingestDocument({
     effectiveType = "text";
     effectiveTitle = title || fetched.title;
     effectivePath = path || fetched.finalUrl || content;
+  } else if (type === "file") {
+    const filePath = effectivePath || content;
+    const needsRead = !content || content === filePath;
+    if (needsRead && filePath) {
+      content = await readFile(filePath, "utf-8");
+      effectivePath = filePath;
+    }
   }
 
   const { markdown, title: docTitle, metadata } = normalizeContent({ content, type: effectiveType, path: effectivePath, title: effectiveTitle });

package/mcp-server/memory.js

@@ -1,192 +1,203 @@
-import { readFile, writeFile, mkdir, unlink, readdir } from "fs/promises";
-import { existsSync } from "fs";
-import { join, basename, resolve } from "path";
-import { homedir } from "os";
-
-function resolveMemoryDir() {
-  if (process.env.MEMORY_DIR) return process.env.MEMORY_DIR;
-  if (process.env.OPENCODE_CONFIG_DIR) return join(process.env.OPENCODE_CONFIG_DIR, "memory");
-
-  const legacyDir = join(homedir(), ".config", "opencode", "memory");
-  if (existsSync(legacyDir)) {
-    return legacyDir;
-  }
-
-  if (process.platform === "win32") {
-    const appData = process.env.LOCALAPPDATA || process.env.APPDATA || join(homedir(), "AppData", "Local");
-    return join(appData, "opencode", "memory");
-  }
-
-  const configHome = process.env.XDG_CONFIG_HOME || join(homedir(), ".config");
-  return join(configHome, "opencode", "memory");
-}
-
-export const MEMORY_DIR = resolveMemoryDir();
-export const GLOBAL_KEY = "global";
-
-export async function ensureDir() {
-  if (!existsSync(MEMORY_DIR)) await mkdir(MEMORY_DIR, { recursive: true });
-  const storageDir = join(MEMORY_DIR, "storage");
-  const blobsDir = join(storageDir, "blobs");
-  const modelsDir = join(storageDir, "models");
-  const exportsDir = join(MEMORY_DIR, "exports");
-  if (!existsSync(blobsDir)) await mkdir(blobsDir, { recursive: true });
-  if (!existsSync(modelsDir)) await mkdir(modelsDir, { recursive: true });
-  if (!existsSync(exportsDir)) await mkdir(exportsDir, { recursive: true });
-}
-
-// Canonical absolute path key: forward slashes, lowercase drive letter on win32.
-export function canonicalPath(dir) {
-  let p = resolve(dir || process.cwd());
-  if (process.platform === "win32") {
-    p = p.replace(/\\/g, "/").replace(/^([a-zA-Z]):/, (_, d) => `${d.toLowerCase()}:`);
-  }
-  return p;
-}
-
-// Project store key = full directory path. This removes basename collisions and
-// binds each store to the real project location.
-export function projectKey(worktree, directory) {
-  return canonicalPath(worktree || directory);
-}
-
-// Display label for a project (basename of the resolved directory).
-export function projectName(worktree, directory) {
-  const dir = worktree || directory || process.cwd();
-  return dir ? basename(resolve(dir)) : "default";
-}
-
-export function scopeKey(scope, worktree, directory) {
-  return scope === "global" ? GLOBAL_KEY : projectKey(worktree, directory);
-}
-
-function slugify(key) {
-  return key.replace(/[^a-zA-Z0-9_-]/g, "_");
-}
-
-function memoryPath(key) {
-  return join(MEMORY_DIR, `${slugify(key)}.md`);
-}
-
-export function memoryFileName(key) {
-  return basename(memoryPath(key));
-}
-
-export function storeFilePath(key) {
-  return memoryPath(key);
-}
-
-function parseMeta(content) {
-  const m = content.match(/<!-- path: (.+?) -->/);
-  return { path: m ? m[1].trim() : null };
-}
-
-function isSimpleKey(key) {
-  return /^[a-zA-Z0-9_-]+$/.test(key);
-}
-
-// Lazy migration: when reading a project path store that doesn't exist yet but a
-// legacy <basename>.md store (without path binding) does, claim it under the path.
-async function maybeMigrateLegacy(key) {
-  if (key === GLOBAL_KEY || isSimpleKey(key)) return null;
-  const legacyBasename = basename(key);
-  if (!legacyBasename) return null;
-  const legacyFp = join(MEMORY_DIR, `${legacyBasename}.md`);
-  if (slugify(key) === legacyBasename || !existsSync(legacyFp)) return null;
-  const content = await readFile(legacyFp, "utf-8");
-  if (parseMeta(content).path) return null; // already bound to another project
-  // Collision guard: a different path with the same basename is already bound,
-  // so this legacy store is ambiguous and must not be silently claimed.
-  const files = await readdir(MEMORY_DIR).catch(() => []);
-  for (const f of files) {
-    if (!f.endsWith(".md") || f === `${legacyBasename}.md` || f === `${GLOBAL_KEY}.md`) continue;
-    try {
-      const other = parseMeta(await readFile(join(MEMORY_DIR, f), "utf-8")).path;
-      if (other && basename(other) === legacyBasename) return null;
-    } catch (e) {}
-  }
-  const facts = content.split("\n").filter((l) => l.startsWith("- ["));
-  await writeMemory(key, facts);
-  try {
-    await unlink(legacyFp);
-  } catch (e) {}
-  return facts;
-}
-
-export async function readMemory(key) {
-  const fp = memoryPath(key);
-  if (existsSync(fp)) {
-    const content = await readFile(fp, "utf-8");
-    return content.split("\n").filter((l) => l.startsWith("- ["));
-  }
-  const migrated = await maybeMigrateLegacy(key);
-  return migrated || [];
-}
-
-export async function readMemoryRaw(key) {
-  return (await readMemory(key)).map((e) => e.slice(2));
-}
-
-export async function writeMemory(key, entries) {
-  const lines = [];
-  if (key === GLOBAL_KEY) {
-    lines.push("# Global Memory", "");
-  } else {
-    lines.push(`# Memory: ${basename(key) || key}`, "");
-    if (!isSimpleKey(key)) {
-      lines.push(`<!-- path: ${key} -->`, "");
-    }
-  }
-  const content = lines.join("\n") + "\n" + (entries.length ? entries.join("\n") + "\n" : "");
-  await writeFile(memoryPath(key), content);
-}
-
-export async function listProjectStores() {
-  const stores = [];
-  const files = await readdir(MEMORY_DIR).catch(() => []);
-  for (const f of files) {
-    if (!f.endsWith(".md") || f === `${GLOBAL_KEY}.md`) continue;
-    const fp = join(MEMORY_DIR, f);
-    let content = "";
-    try {
-      content = await readFile(fp, "utf-8");
-    } catch (e) {
-      continue;
-    }
-    const facts = content.split("\n").filter((l) => l.startsWith("- ["));
-    const meta = parseMeta(content);
-    const key = meta.path || f.slice(0, -3);
-    stores.push({
-      key,
-      path: meta.path,
-      basename: basename(meta.path || key) || key,
-      file: f,
-      count: facts.length,
-      legacy: !meta.path,
-    });
-  }
-  stores.sort((a, b) => a.basename.localeCompare(b.basename));
-  return stores;
-}
-
-// Bind an unbound legacy store (e.g. "comfy-meta-viewer") to a directory path.
-export async function migrateLegacyStore(legacyKey, targetDir) {
-  const legacyFp = join(MEMORY_DIR, `${legacyKey.replace(/[^a-zA-Z0-9_-]/g, "_")}.md`);
-  if (!existsSync(legacyFp)) return { ok: false, reason: "not_found", key: legacyKey };
-  const content = await readFile(legacyFp, "utf-8");
-  if (parseMeta(content).path) return { ok: false, reason: "already_bound", key: legacyKey };
-  const targetKey = projectKey(targetDir, null);
-  const facts = content.split("\n").filter((l) => l.startsWith("- ["));
-  await writeMemory(targetKey, facts);
-  try {
-    await unlink(legacyFp);
-  } catch (e) {}
-  return { ok: true, key: targetKey, file: memoryPath(targetKey), facts: facts.length };
-}
-
-export function today() {
-  const d = new Date();
-  const date = `${d.getFullYear()}-${String(d.getMonth() + 1).padStart(2, "0")}-${String(d.getDate()).padStart(2, "0")}`;
-  const time = `${String(d.getHours()).padStart(2, "0")}:${String(d.getMinutes()).padStart(2, "0")}`;
-  return `${date} ${time}`;
-}
+import { readFile, writeFile, mkdir, unlink, readdir } from "fs/promises";
+import { existsSync, mkdirSync } from "fs";
+import { join, basename, resolve } from "path";
+import { homedir } from "os";
+
+function resolveMemoryDir() {
+  if (process.env.MEMORY_DIR) return process.env.MEMORY_DIR;
+  if (process.env.OPENCODE_CONFIG_DIR) return join(process.env.OPENCODE_CONFIG_DIR, "memory");
+
+  const legacyDir = join(homedir(), ".config", "opencode", "memory");
+  if (existsSync(legacyDir)) {
+    return legacyDir;
+  }
+
+  if (process.platform === "win32") {
+    const appData = process.env.LOCALAPPDATA || process.env.APPDATA || join(homedir(), "AppData", "Local");
+    return join(appData, "opencode", "memory");
+  }
+
+  const configHome = process.env.XDG_CONFIG_HOME || join(homedir(), ".config");
+  return join(configHome, "opencode", "memory");
+}
+
+export const MEMORY_DIR = resolveMemoryDir();
+export const GLOBAL_KEY = "global";
+
+export async function ensureDir() {
+  if (!existsSync(MEMORY_DIR)) await mkdir(MEMORY_DIR, { recursive: true });
+  const storageDir = join(MEMORY_DIR, "storage");
+  const blobsDir = join(storageDir, "blobs");
+  const modelsDir = join(storageDir, "models");
+  const exportsDir = join(MEMORY_DIR, "exports");
+  if (!existsSync(blobsDir)) await mkdir(blobsDir, { recursive: true });
+  if (!existsSync(modelsDir)) await mkdir(modelsDir, { recursive: true });
+  if (!existsSync(exportsDir)) await mkdir(exportsDir, { recursive: true });
+}
+
+export function ensureDirSync() {
+  if (!existsSync(MEMORY_DIR)) mkdirSync(MEMORY_DIR, { recursive: true });
+  const storageDir = join(MEMORY_DIR, "storage");
+  const blobsDir = join(storageDir, "blobs");
+  const modelsDir = join(storageDir, "models");
+  const exportsDir = join(MEMORY_DIR, "exports");
+  if (!existsSync(blobsDir)) mkdirSync(blobsDir, { recursive: true });
+  if (!existsSync(modelsDir)) mkdirSync(modelsDir, { recursive: true });
+  if (!existsSync(exportsDir)) mkdirSync(exportsDir, { recursive: true });
+}
+
+// Canonical absolute path key: forward slashes, lowercase drive letter on win32.
+export function canonicalPath(dir) {
+  let p = resolve(dir || process.cwd());
+  if (process.platform === "win32") {
+    p = p.replace(/\\/g, "/").replace(/^([a-zA-Z]):/, (_, d) => `${d.toLowerCase()}:`);
+  }
+  return p;
+}
+
+// Project store key = full directory path. This removes basename collisions and
+// binds each store to the real project location.
+export function projectKey(worktree, directory) {
+  return canonicalPath(worktree || directory);
+}
+
+// Display label for a project (basename of the resolved directory).
+export function projectName(worktree, directory) {
+  const dir = worktree || directory || process.cwd();
+  return dir ? basename(resolve(dir)) : "default";
+}
+
+export function scopeKey(scope, worktree, directory) {
+  return scope === "global" ? GLOBAL_KEY : projectKey(worktree, directory);
+}
+
+function slugify(key) {
+  return key.replace(/[^a-zA-Z0-9_-]/g, "_");
+}
+
+function memoryPath(key) {
+  return join(MEMORY_DIR, `${slugify(key)}.md`);
+}
+
+export function memoryFileName(key) {
+  return basename(memoryPath(key));
+}
+
+export function storeFilePath(key) {
+  return memoryPath(key);
+}
+
+function parseMeta(content) {
+  const m = content.match(/<!-- path: (.+?) -->/);
+  return { path: m ? m[1].trim() : null };
+}
+
+function isSimpleKey(key) {
+  return /^[a-zA-Z0-9_-]+$/.test(key);
+}
+
+// Lazy migration: when reading a project path store that doesn't exist yet but a
+// legacy <basename>.md store (without path binding) does, claim it under the path.
+async function maybeMigrateLegacy(key) {
+  if (key === GLOBAL_KEY || isSimpleKey(key)) return null;
+  const legacyBasename = basename(key);
+  if (!legacyBasename) return null;
+  const legacyFp = join(MEMORY_DIR, `${legacyBasename}.md`);
+  if (slugify(key) === legacyBasename || !existsSync(legacyFp)) return null;
+  const content = await readFile(legacyFp, "utf-8");
+  if (parseMeta(content).path) return null; // already bound to another project
+  // Collision guard: a different path with the same basename is already bound,
+  // so this legacy store is ambiguous and must not be silently claimed.
+  const files = await readdir(MEMORY_DIR).catch(() => []);
+  for (const f of files) {
+    if (!f.endsWith(".md") || f === `${legacyBasename}.md` || f === `${GLOBAL_KEY}.md`) continue;
+    try {
+      const other = parseMeta(await readFile(join(MEMORY_DIR, f), "utf-8")).path;
+      if (other && basename(other) === legacyBasename) return null;
+    } catch (e) {}
+  }
+  const facts = content.split("\n").filter((l) => l.startsWith("- ["));
+  await writeMemory(key, facts);
+  try {
+    await unlink(legacyFp);
+  } catch (e) {}
+  return facts;
+}
+
+export async function readMemory(key) {
+  const fp = memoryPath(key);
+  if (existsSync(fp)) {
+    const content = await readFile(fp, "utf-8");
+    return content.split("\n").filter((l) => l.startsWith("- ["));
+  }
+  const migrated = await maybeMigrateLegacy(key);
+  return migrated || [];
+}
+
+export async function readMemoryRaw(key) {
+  return (await readMemory(key)).map((e) => e.slice(2));
+}
+
+export async function writeMemory(key, entries) {
+  const lines = [];
+  if (key === GLOBAL_KEY) {
+    lines.push("# Global Memory", "");
+  } else {
+    lines.push(`# Memory: ${basename(key) || key}`, "");
+    if (!isSimpleKey(key)) {
+      lines.push(`<!-- path: ${key} -->`, "");
+    }
+  }
+  const content = lines.join("\n") + "\n" + (entries.length ? entries.join("\n") + "\n" : "");
+  await writeFile(memoryPath(key), content);
+}
+
+export async function listProjectStores() {
+  const stores = [];
+  const files = await readdir(MEMORY_DIR).catch(() => []);
+  for (const f of files) {
+    if (!f.endsWith(".md") || f === `${GLOBAL_KEY}.md`) continue;
+    const fp = join(MEMORY_DIR, f);
+    let content = "";
+    try {
+      content = await readFile(fp, "utf-8");
+    } catch (e) {
+      continue;
+    }
+    const facts = content.split("\n").filter((l) => l.startsWith("- ["));
+    const meta = parseMeta(content);
+    const key = meta.path || f.slice(0, -3);
+    stores.push({
+      key,
+      path: meta.path,
+      basename: basename(meta.path || key) || key,
+      file: f,
+      count: facts.length,
+      legacy: !meta.path,
+    });
+  }
+  stores.sort((a, b) => a.basename.localeCompare(b.basename));
+  return stores;
+}
+
+// Bind an unbound legacy store (e.g. "comfy-meta-viewer") to a directory path.
+export async function migrateLegacyStore(legacyKey, targetDir) {
+  const legacyFp = join(MEMORY_DIR, `${legacyKey.replace(/[^a-zA-Z0-9_-]/g, "_")}.md`);
+  if (!existsSync(legacyFp)) return { ok: false, reason: "not_found", key: legacyKey };
+  const content = await readFile(legacyFp, "utf-8");
+  if (parseMeta(content).path) return { ok: false, reason: "already_bound", key: legacyKey };
+  const targetKey = projectKey(targetDir, null);
+  const facts = content.split("\n").filter((l) => l.startsWith("- ["));
+  await writeMemory(targetKey, facts);
+  try {
+    await unlink(legacyFp);
+  } catch (e) {}
+  return { ok: true, key: targetKey, file: memoryPath(targetKey), facts: facts.length };
+}
+
+export function today() {
+  const d = new Date();
+  const date = `${d.getFullYear()}-${String(d.getMonth() + 1).padStart(2, "0")}-${String(d.getDate()).padStart(2, "0")}`;
+  const time = `${String(d.getHours()).padStart(2, "0")}:${String(d.getMinutes()).padStart(2, "0")}`;
+  return `${date} ${time}`;
+}

package/mcp-server/ml/model_manager.js

@@ -388,10 +388,10 @@ export async function getReranker(modelName = "Xenova/bge-reranker-base", progre
     return rerankerInstance;
   }
 
-  checkAndSelfHealModel(modelName);
+  const cacheDir = ensureValidModelDirectory();
 
   const { pipeline, env } = await import("@huggingface/transformers");
-  env.cacheDir = MODELS_DIR;
+  env.cacheDir = cacheDir;
   env.allowLocalModels = true;
   env.allowRemoteModels = true;
   env.remoteHost = "https://huggingface.co";

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@lotargo/memory_plugin",
-  "version": "1.3.0",
+  "version": "1.3.1",
   "description": "Persistent memory agent for coding AI tools — remembers user preferences and project context across sessions. Works with Antigravity, OpenCode, Claude Code, and Codex.",
   "type": "module",
   "main": "opencode-plugin/index.js",

package/skills/using-memory/SKILL.md

@@ -1,14 +1,15 @@
 ---
 name: using-memory
-description: Comprehensive guide for using the Memory & Hybrid RAG Knowledge Engine tools (remember, recall, forget, update_fact, memory_info, link_knowledge, ingest_document, query_knowledge_base, manage_knowledge_base). Trigger proactively whenever user preferences, project conventions, technology stack choices, or architecture decisions are introduced, or when querying ingested documentation, indexing files/repos, or managing persistent knowledge.
+description: Comprehensive guide for using the Memory, Hybrid RAG Knowledge Engine & MCP Helper tools (remember, recall, forget, update_fact, memory_info, link_knowledge, ingest_document, query_knowledge_base, manage_knowledge_base, list-mcp-tools, mcp-reminder). Trigger proactively whenever user preferences, project conventions, technology stack choices, or architecture decisions are introduced, or when querying ingested documentation, indexing files/repos, managing persistent knowledge, or looking up available MCP tool integrations.
 ---
 
-# Using Memory & Hybrid RAG Knowledge Engine
+# Using Memory, Hybrid RAG Knowledge Engine & MCP Helper Tools
 
-You have access to a persistent dual-layer memory engine supercharged with an **Agent-Driven Knowledge Graph**:
+You have access to a persistent dual-layer memory engine supercharged with an **Agent-Driven Knowledge Graph** and general MCP integration helpers:
 1. **Layer 1: Notebook Store (Key-Value Facts)**: Stores high-signal personal preferences, project conventions, and durable rules in clean Markdown.
 2. **Layer 2: RAG Knowledge Base**: Indexes documentation, repositories, and technical guides for hybrid semantic retrieval.
 3. **Layer 3: Agent-Driven Knowledge Graph**: Connects Notebook facts (Layer 1) to specific Knowledge Base documents, sections, and **exact line ranges** (Layer 2).
+4. **Integration Layer (General MCP Helpers)**: Quickly discovers connected MCP servers and identifies appropriate tools for specific tasks.
 
 ---
 
@@ -28,7 +29,9 @@ You have access to a persistent dual-layer memory engine supercharged with an **
 | User asks to index a documentation URL, file, or repository | `ingest_document` | `content` or `source_path`, `title`, `metadata` |
 | User asks a complex question about indexed docs or code | `query_knowledge_base` | `query`, `limit`, `generateEmbeddings` |
 | Read full raw content of an ambiguous/abstract document | `manage_knowledge_base` | `action: "read_document"`, `docId` |
-| User asks to view database stats, list indexed docs, or export snapshots | `manage_knowledge_base` | `action` ("stats", "list", "read_document", "delete", "export_snapshot") |
+| User asks to view database stats, list indexed docs, or export snapshots | `manage_knowledge_base` | `action` ("stats", "list", "read_document", "delete", "export_snapshot", "import_snapshot") |
+| Discover available MCP servers and their specific purposes | `list-mcp-tools` | — |
+| Ask which MCP tool / server is suitable for a specific task | `mcp-reminder` | `task` (string, e.g., "db migration") |
 
 ---
 
@@ -113,7 +116,7 @@ Use this tool when adding technical documentation, API specs, architectural docu
 
 ### Hybrid Retrieval (`query_knowledge_base`)
 Use this tool BEFORE answering deep architectural or technical questions when indexed documents exist.
-- Performs **Hybrid RRF Fusion** combining SQLite FTS5 BM25 keyword matching with dense ONNX vector semantic search.
+- Performs **Hybrid RRF/RSF Fusion** combining SQLite FTS5 BM25 keyword matching with dense ONNX vector semantic search.
 - Returns candidate sections with breadcrumb paths and defined code symbols (classes, functions, types).
 
 #### Query Formulation Rules (CRITICAL for retrieval quality)
@@ -154,13 +157,28 @@ In such cases, use the **Full Raw Document Reading** mechanism:
 - Use `action: "list"` to see all ingested documents.
 - Use `action: "read_document"` with `docId` to read the complete raw text content of any document.
 - Use `action: "delete"` with `docId` to remove an outdated document and purge its CAS blob.
+- Use `action: "export_snapshot"` with `snapshotPath` to export a JSON backup of the RAG base.
+- Use `action: "import_snapshot"` with `snapshotPath` to import and merge a JSON backup into the current database.
 
 ---
 
-## 4. Core Directives for AI Agents
+## 4. General MCP Helpers (`list-mcp-tools`, `mcp-reminder`)
+
+### Discovering Connected MCP Servers (`list-mcp-tools`)
+When working in multi-server environments (e.g., OpenCode, Claude Code), you might have several auxiliary servers installed (for database, UI design, browser automation, etc.).
+- Use `list-mcp-tools` to immediately view all registered servers and their descriptions. This avoids guessing what other capabilities are available in the current workspace.
+
+### Contextual Tool Reminders (`mcp-reminder`)
+- If you are unsure which tool/server is best suited for the task at hand (e.g., how to do browser testing, or run a database migration), run `mcp-reminder(task: "your current task definition")`.
+- It analyzes your task and suggests appropriate servers (like `playwright` for testing, `supabase` for DB, or `stitch` for UI design).
+
+---
+
+## 5. Core Directives for AI Agents
 
 1. **Read Memories First (MANDATORY)**: At the very start of any session or conversation, your VERY FIRST STEP MUST BE to execute `recall` to load all saved facts, user context, and project guidelines BEFORE performing any other task or code analysis.
 2. **Be Proactive**: When the user mentions a durable preference, personal fact, or constraint, save it immediately using `remember`. Do not wait for explicit user commands.
-3. **Check Knowledge Base First**: If a user asks how a specific module, API, or project architecture works, call `query_knowledge_base` using concept-dense search phrases.
+3. **Check Knowledge Base First**: If a query is related to specialized documentation, APIs, or project architectures, call `query_knowledge_base` using concept-dense search phrases.
 4. **Inspect Ambiguous Docs Directly**: If querying produces low relevance scores on abstractly-named documents, call `manage_knowledge_base(action: "read_document")` to inspect the full text directly.
 5. **Keep Memory Clean**: If a preference changes, call `update_fact` to edit it in place, or `remember` with `supersedes` to keep a version trail. Use `keep: true` for facts that must survive an accidental `forget`, and give ephemeral facts a `ttl` so stale ones surface as `[EXPIRED]`.
+6. **Leverage MCP Servers**: Proactively list available tools using `list-mcp-tools` and query `mcp-reminder` if unsure of which platform tool can help you automate tasks.