@lotargo/memory_plugin 1.2.7 → 1.2.9

package/mcp-server/cli.js

@@ -5,7 +5,7 @@ import { getConfig, updateConfig, resetConfig } from "./config/config_manager.js
 import { hybridQuery } from "./retrieval/retriever.js";
 import { getDatabase } from "./db/database.js";
 import { deleteDocument } from "./ingest/pipeline.js";
-import { readMemoryRaw, readMemory, writeMemory, GLOBAL_KEY, projectName } from "./memory.js";
+import { readMemoryRaw, readMemory, writeMemory, GLOBAL_KEY, projectName, projectKey, listProjectStores, migrateLegacyStore, memoryFileName } from "./memory.js";
 import { getCorpusCacheSize, clearCorpusCache } from "./benchmarks/fetch_real_corpus.js";
 import { SMOKE_DOC_IDS } from "./benchmarks/quality_evaluator.js";
 import { getModelStorageInfo, deleteModelCache, listAllCachedModels } from "./ml/model_manager.js";
@@ -97,9 +97,9 @@ async function getQuickStats() {
 
   let factCount = 0;
   try {
-    const projName = projectName(null, null);
+    const projKey = projectKey(null, null);
     const globalF = await readMemoryRaw(GLOBAL_KEY);
-    const projF = await readMemoryRaw(projName);
+    const projF = await readMemoryRaw(projKey);
     factCount = (globalF ? globalF.length : 0) + (projF ? projF.length : 0);
   } catch (e) {}
 
@@ -368,7 +368,7 @@ console.log(`\x1b[36m └──${"─".repeat(PANEL_WIDTH - 4)}┘\x1b[0m\n`);
       } else if (key.name === "return") {
         cleanup();
         resolve({ action: "select", index: activeIndex, value: allItems[activeIndex].value });
-      } else if (key.name === "backspace" || key.name === "escape") {
+      } else if (key.name === "backspace" || key.name === "escape" || key.name === "delete") {
         cleanup();
         resolve({ action: "back" });
       }
@@ -440,7 +440,7 @@ function selectSimpleMenu({ title, subtitle = "", items, initialIndex = 0 }) {
       } else if (key.name === "return") {
         cleanup();
         resolve({ action: "select", index, value: items[index].value });
-      } else if (key.name === "backspace" || key.name === "escape") {
+      } else if (key.name === "backspace" || key.name === "escape" || key.name === "delete") {
         cleanup();
         resolve({ action: "back" });
       }
@@ -517,7 +517,7 @@ function adjustAlphaMenu(initialAlpha) {
       } else if (key.name === "return") {
         cleanup();
         resolve({ action: "save", value: alpha });
-      } else if (key.name === "backspace" || key.name === "escape") {
+      } else if (key.name === "backspace" || key.name === "escape" || key.name === "delete") {
         cleanup();
         resolve({ action: "cancel" });
       }
@@ -566,7 +566,7 @@ function readTextInput(promptText, defaultValue = "") {
       if (key.name === "return") {
         cleanup();
         resolve({ action: "submit", value: text.trim() });
-      } else if (key.name === "backspace") {
+      } else if (key.name === "backspace" || key.name === "delete") {
         if (text.length > 0) {
           text = text.slice(0, -1);
           render();
@@ -610,7 +610,7 @@ function waitForEnter() {
         cleanup();
         process.exit(0);
       }
-      if (key.name === "return" || key.name === "backspace" || key.name === "escape" || key.name === "space") {
+      if (key.name === "return" || key.name === "backspace" || key.name === "escape" || key.name === "delete" || key.name === "space") {
         cleanup();
         resolve();
       }
@@ -1014,10 +1014,75 @@ export async function runCli() {
       case "notebook": {
         let nbRunning = true;
         while (nbRunning) {
-          const projName = projectName(null, null);
+          const projKey = projectKey(null, null);
+          const projLabel = projectName(null, null);
+
+          async function browseFacts(key, title) {
+            let factRunning = true;
+            while (factRunning) {
+              const rawEntries = await readMemory(key);
+              const factList = await readMemoryRaw(key);
+
+              if (!factList || factList.length === 0) {
+                console.clear();
+                const line = "─".repeat(PANEL_WIDTH - 2);
+                console.log(`\x1b[36m╭${line}╮\x1b[0m`);
+                console.log(`\x1b[36m│\x1b[0m  \x1b[1m\x1b[37mNOTEBOOK FACTS: STORE EMPTY\x1b[0m${" ".repeat(PANEL_WIDTH - 30)}\x1b[36m│\x1b[0m`);
+                console.log(`\x1b[36m╰${line}╯\x1b[0m`);
+                console.log(`\n  [*] Notebook store [${key}] has no saved facts.\n`);
+                await waitForEnter();
+                return;
+              }
+
+              const file = memoryFileName(key);
+              const factItems = factList.map((fact, idx) => ({
+                label: `${idx + 1}. ${fact}`,
+                value: idx,
+                info: `Select to delete this fact from ${file}`,
+              }));
+              factItems.push({ label: "< Back", value: "back" });
+
+              const factRes = await selectSimpleMenu({
+                title: `NOTEBOOK FACTS [${title}]`,
+                subtitle: `Total facts: ${factList.length}`,
+                items: factItems,
+              });
+
+              if (factRes.action === "back" || factRes.value === "back") {
+                return;
+              }
+
+              const selectedIdx = factRes.value;
+              const selectedFact = factList[selectedIdx];
+
+              const actionRes = await selectSimpleMenu({
+                title: `FACT ACTION`,
+                subtitle: `Fact: "${selectedFact}"`,
+                items: [
+                  { label: "[DELETE] Delete this fact from store", value: "delete", info: "Remove fact permanently" },
+                  { label: "< Cancel / Back", value: "cancel" },
+                ],
+              });
+
+              if (actionRes.action === "back" || actionRes.value === "cancel") {
+                return;
+              }
+
+              if (actionRes.action === "select" && actionRes.value === "delete") {
+                const updated = [...rawEntries];
+                updated.splice(selectedIdx, 1);
+                await writeMemory(key, updated);
+                console.clear();
+                console.log("\n  [OK] Fact deleted successfully.\n");
+                await waitForEnter();
+              }
+            }
+          }
+
           const scopeItems = [
             { label: "Global Memory", value: "global", badge: "global.md", info: "User facts stored across all projects" },
-            { label: `Project Memory (${projName})`, value: "project", badge: `${projName}.md`, info: `Facts specific to project ${projName}` },
+            { label: `Project Memory (${projLabel})`, value: "project", badge: memoryFileName(projKey), info: `Facts bound to ${projKey}` },
+            { label: "Project Stores (All Projects)", value: "projects", info: "List & browse every project memory store; bind legacy stores" },
             { label: "< Back to Main Menu", value: "back" },
           ];
           const scopeRes = await selectSimpleMenu({
@@ -1031,63 +1096,87 @@ export async function runCli() {
             break;
           }
 
-          const key = scopeRes.value === "global" ? GLOBAL_KEY : projName;
-          let factRunning = true;
-          while (factRunning) {
-            const rawEntries = await readMemory(key);
-            const factList = await readMemoryRaw(key);
-
-            if (!factList || factList.length === 0) {
-              console.clear();
-              const line = "─".repeat(PANEL_WIDTH - 2);
-              console.log(`\x1b[36m╭${line}╮\x1b[0m`);
-              console.log(`\x1b[36m│\x1b[0m  \x1b[1m\x1b[37mNOTEBOOK FACTS: STORE EMPTY\x1b[0m${" ".repeat(PANEL_WIDTH - 30)}\x1b[36m│\x1b[0m`);
-              console.log(`\x1b[36m╰${line}╯\x1b[0m`);
-              console.log(`\n  [*] Notebook store [${key}] has no saved facts.\n`);
-              await waitForEnter();
-              factRunning = false;
-              break;
-            }
-
-            const factItems = factList.map((fact, idx) => ({
-              label: `${idx + 1}. ${fact}`,
-              value: idx,
-              info: `Select to delete this fact from ${key}.md`,
-            }));
-            factItems.push({ label: "< Back", value: "back" });
-
-            const factRes = await selectSimpleMenu({
-              title: `NOTEBOOK FACTS [${key.toUpperCase()}]`,
-              subtitle: `Total facts: ${factList.length}`,
-              items: factItems,
-            });
-
-            if (factRes.action === "back" || factRes.value === "back") {
-              factRunning = false;
-              break;
-            }
-
-            const selectedIdx = factRes.value;
-            const selectedFact = factList[selectedIdx];
+          if (scopeRes.value === "projects") {
+            let stores = await listProjectStores();
+            let storeRunning = true;
+            while (storeRunning) {
+              if (!stores.length) {
+                console.clear();
+                const line = "─".repeat(PANEL_WIDTH - 2);
+                console.log(`\x1b[36m╭${line}╮\x1b[0m`);
+                console.log(`\x1b[36m│\x1b[0m  \x1b[1m\x1b[37mPROJECT STORES: NONE FOUND\x1b[0m${" ".repeat(PANEL_WIDTH - 32)}\x1b[36m│\x1b[0m`);
+                console.log(`\x1b[36m╰${line}╯\x1b[0m`);
+                console.log("\n  [*] No project memory stores found.\n");
+                await waitForEnter();
+                storeRunning = false;
+                break;
+              }
+              const storeItems = stores.map((s) => ({
+                label: `${s.basename} (${s.count})`,
+                badge: s.file,
+                hint: s.legacy ? "LEGACY" : "BOUND",
+                info: s.path ? `Bound to: ${s.path}` : `Unbound legacy store. View facts or bind to current dir: ${projKey}`,
+                value: s,
+              }));
+              storeItems.push({ label: "< Back", value: "back" });
+
+              const storeRes = await selectSimpleMenu({
+                title: "PROJECT MEMORY STORES",
+                subtitle: `Total stores: ${stores.length}`,
+                items: storeItems,
+              });
 
-            const actionRes = await selectSimpleMenu({
-              title: `FACT ACTION`,
-              subtitle: `Fact: "${selectedFact}"`,
-              items: [
-                { label: "[DELETE] Delete this fact from store", value: "delete", info: "Remove fact permanently" },
-                { label: "< Cancel / Back", value: "cancel" },
-              ],
-            });
+              if (storeRes.action === "back" || storeRes.value === "back") {
+                storeRunning = false;
+                break;
+              }
 
-            if (actionRes.action === "select" && actionRes.value === "delete") {
-              const updated = [...rawEntries];
-              updated.splice(selectedIdx, 1);
-              await writeMemory(key, updated);
-              console.clear();
-              console.log("\n  [OK] Fact deleted successfully.\n");
-              await waitForEnter();
+              const store = storeRes.value;
+              let actionRunning = true;
+              while (actionRunning) {
+                const actionItems = [
+                  { label: "View facts", value: "view", info: `Browse ${store.count} fact(s) in ${store.file}` },
+                ];
+                if (store.legacy) {
+                  actionItems.push({
+                    label: "[MIGRATE] Bind to current directory",
+                    value: "migrate",
+                    info: `Rebind '${store.basename}' store from unbound legacy to ${projKey}`,
+                  });
+                }
+                actionItems.push({ label: "< Cancel / Back", value: "cancel" });
+
+                const actRes = await selectSimpleMenu({
+                  title: `STORE: ${store.basename}`,
+                  subtitle: store.path || "Unbound legacy store",
+                  items: actionItems,
+                });
+
+                if (actRes.action === "back" || actRes.value === "cancel") {
+                  actionRunning = false;
+                  break;
+                }
+                if (actRes.value === "view") {
+                  await browseFacts(store.key, store.basename);
+                } else if (actRes.value === "migrate") {
+                  const mig = await migrateLegacyStore(store.key, projKey);
+                  console.clear();
+                  if (mig.ok) {
+                    console.log(`\n  [OK] Legacy store '${store.basename}' bound to ${mig.key} (${mig.facts} fact(s)) [${mig.file}]\n`);
+                  } else {
+                    console.log(`\n  [*] Could not migrate: ${mig.reason}\n`);
+                  }
+                  await waitForEnter();
+                  stores = await listProjectStores();
+                  actionRunning = false;
+                  break;
+                }
+              }
             }
+            continue;
           }
+
+          await browseFacts(scopeRes.value === "global" ? GLOBAL_KEY : projKey, scopeRes.value === "global" ? "GLOBAL" : projLabel);
         }
         break;
       }

package/mcp-server/index.js

@@ -2,7 +2,7 @@
 import { McpServer } from "@modelcontextprotocol/sdk/server/mcp.js";
 import { StdioServerTransport } from "@modelcontextprotocol/sdk/server/stdio.js";
 import * as z from "zod/v4";
-import { ensureDir, readMemory, readMemoryRaw, writeMemory, today, MEMORY_DIR, GLOBAL_KEY, scopeKey, projectName } from "./memory.js";
+import { ensureDir, readMemory, readMemoryRaw, writeMemory, today, MEMORY_DIR, GLOBAL_KEY, scopeKey, projectKey, projectName, canonicalPath, listProjectStores } from "./memory.js";
 
 const cliArgs = process.argv.slice(2);
 
@@ -92,13 +92,16 @@ server.registerTool(
 server.registerTool(
   "recall",
   {
-    description: "Show saved facts with any Agent-linked Knowledge Base documents/lines. scope: 'project', 'global', or 'all' (default)",
+    description:
+      "Show saved facts with any Agent-linked Knowledge Base documents/lines. " +
+      "scope: 'project', 'global', 'all' (default), or 'list_projects'. " +
+      "Use project: '<directory path>' with scope 'project'/'all' to read facts of a specific project from any working directory.",
     inputSchema: z.object({
-      scope: z.string().default("all").describe("'project', 'global', or 'all'"),
+      scope: z.string().default("all").describe("'project', 'global', 'all', or 'list_projects'"),
+      project: z.string().optional().describe("Directory path of the project to read facts from (e.g. 'F:/projects/plugins/memory')"),
     }),
   },
-  async ({ scope }) => {
-    const project = projectName(null, null);
+  async ({ scope, project }) => {
     const { getLinksForFact } = await import("./graph/knowledge_linker.js");
     const results = [];
 
@@ -119,6 +122,26 @@ server.registerTool(
       return line;
     };
 
+    if (scope === "list_projects") {
+      const stores = await listProjectStores();
+      if (!stores.length) {
+        return { content: [{ type: "text", text: "No project memory stores found." }] };
+      }
+      const lines = stores.map(
+        (s, i) => `${i + 1}. ${s.basename} — ${s.count} fact(s) [${s.file}]${s.path ? ` (bound to ${s.path})` : " (unbound legacy store)"}`
+      );
+      return {
+        content: [
+          {
+            type: "text",
+            text: `Project Memory Stores:\n${lines.join("\n")}\n\nUse recall(scope: "project", project: "<path>") to read a specific store.`,
+          },
+        ],
+      };
+    }
+
+    const target = project ? canonicalPath(project) : projectKey(null, null);
+    const label = project ? target : projectName();
     if (scope !== "project") {
       const global = await readMemoryRaw(GLOBAL_KEY);
       if (global.length) {
@@ -127,11 +150,11 @@ server.registerTool(
       }
     }
     if (scope !== "global") {
-      const local = await readMemoryRaw(project);
+      const local = await readMemoryRaw(target);
       if (local.length) {
         if (results.length) results.push("");
-        results.push(`--- ${project} ---`);
-        local.forEach((e, i) => results.push(`${i + 1}. ${formatFactWithLinks(e, project)}`));
+        results.push(`--- Project: ${label} ---`);
+        local.forEach((e, i) => results.push(`${i + 1}. ${formatFactWithLinks(e, target)}`));
       }
     }
     const text = results.length ? results.join("\n") : "Memory is empty.";

package/mcp-server/memory.js

@@ -1,72 +1,188 @@
-import { readFile, writeFile, mkdir } from "fs/promises";
-import { existsSync } from "fs";
-import { join, basename } 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 projectName(worktree, directory) {
-  const dir = worktree || directory || process.cwd();
-  return dir ? basename(dir) : "default";
-}
-
-export function scopeKey(scope, worktree, directory) {
-  return scope === "global" ? GLOBAL_KEY : projectName(worktree, directory);
-}
-
-function memoryPath(key) {
-  return join(MEMORY_DIR, `${key.replace(/[^a-zA-Z0-9_-]/g, "_")}.md`);
-}
-
-export async function readMemory(key) {
-  const fp = memoryPath(key);
-  if (!existsSync(fp)) return [];
-  const content = await readFile(fp, "utf-8");
-  return content.split("\n").filter((l) => l.startsWith("- ["));
-}
-
-export async function readMemoryRaw(key) {
-  return (await readMemory(key)).map((e) => e.slice(2));
-}
-
-export async function writeMemory(key, entries) {
-  const header = `# ${key === GLOBAL_KEY ? "Global Memory" : `Memory: ${key}`}\n\n`;
-  await writeFile(memoryPath(key), header + entries.join("\n") + "\n");
-}
-
-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 } 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));
+}
+
+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/prompt_manager.js

@@ -1,7 +1,8 @@
-import { readFile, writeFile, mkdir, unlink } from "fs/promises";
+import { readFile, writeFile, mkdir, unlink, rename, copyFile } from "fs/promises";
 import { existsSync } from "fs";
 import { join } from "path";
 import { homedir } from "os";
+import { createHash } from "crypto";
 
 const START_MARKER = "<!-- START MEMORY AGENT PROMPT -->";
 const END_MARKER = "<!-- END MEMORY AGENT PROMPT -->";
@@ -13,24 +14,90 @@ export const PROMPT_BLOCK = `${START_MARKER}
 3. SIGNAL FILTER: Save only high-signal facts (name, language, roles, constraints, tech stack preferences, architecture decisions, conventions). Translate facts into clear, concise English when saving. Do NOT save transient details or one-off conversation turns.
 ${END_MARKER}`;
 
+// Plugin-owned files live here so we never destroy user-owned config content.
+const AGENT_CONFIG_DIR = join(homedir(), ".config", "memory-agent");
+export const PROMPT_FILE = join(AGENT_CONFIG_DIR, "prompt.md");
+const BACKUP_DIR = join(AGENT_CONFIG_DIR, "backups");
+const STATE_FILE = join(AGENT_CONFIG_DIR, "prompt-state.json");
+
+function sha256(content) {
+  return createHash("sha256").update(content).digest("hex");
+}
+
+async function atomicWrite(filePath, content) {
+  const tmp = `${filePath}.memory-tmp-${process.pid}`;
+  await writeFile(tmp, content, "utf-8");
+  await rename(tmp, filePath);
+}
+
+async function backupFile(filePath) {
+  await mkdir(BACKUP_DIR, { recursive: true });
+  const name = filePath.split(/[\\/]/).pop() || "config";
+  const stamp = new Date().toISOString().replace(/[:.]/g, "-");
+  const dest = join(BACKUP_DIR, `${name}.${stamp}.bak`);
+  await copyFile(filePath, dest);
+  return dest;
+}
+
+async function loadState() {
+  try {
+    return JSON.parse(await readFile(STATE_FILE, "utf-8"));
+  } catch {
+    return {};
+  }
+}
+
+async function saveState(state) {
+  await mkdir(AGENT_CONFIG_DIR, { recursive: true });
+  await atomicWrite(STATE_FILE, JSON.stringify(state, null, 2) + "\n");
+}
+
 export function getGlobalPromptTargets() {
   const home = homedir();
   return [
     {
       name: "Antigravity",
       filePath: join(home, ".gemini", "config", "AGENTS.md"),
+      // Antigravity resolves `@` imports only in GEMINI.md, not reliably in AGENTS.md
+      includeSupported: false,
     },
     {
       name: "Codex",
       filePath: join(home, ".codex", "AGENTS.md"),
+      // AGENTS.md standard has no import syntax
+      includeSupported: false,
     },
     {
       name: "Claude Code",
       filePath: join(home, ".claude", "CLAUDE.md"),
+      // @path imports are supported and trusted in user-scope CLAUDE.md
+      includeSupported: true,
     },
   ];
 }
 
+// Ensure the plugin-owned prompt file exists and is up to date with PROMPT_BLOCK.
+// This file is referenced via `@` includes; updating it never touches user configs.
+export async function syncPromptFile() {
+  await mkdir(AGENT_CONFIG_DIR, { recursive: true });
+  const expected = `${PROMPT_BLOCK}\n`;
+  const current = existsSync(PROMPT_FILE) ? await readFile(PROMPT_FILE, "utf-8") : "";
+  if (current !== expected) {
+    await atomicWrite(PROMPT_FILE, expected);
+  }
+  return PROMPT_FILE;
+}
+
+function toIncludePath(filePath) {
+  return filePath.replace(/\\/g, "/");
+}
+
+function buildIncludeBlock(promptFile) {
+  return `${START_MARKER}
+@${toIncludePath(promptFile)}
+${END_MARKER}`;
+}
+
 function stripPromptBlock(content) {
   const startIndex = content.indexOf(START_MARKER);
   const endIndex = content.indexOf(END_MARKER);
@@ -44,7 +111,9 @@ function stripPromptBlock(content) {
 }
 
 export async function enableGlobalPrompt() {
+  const promptFile = await syncPromptFile();
   const targets = getGlobalPromptTargets();
+  const state = await loadState();
   const results = [];
 
   for (const target of targets) {
@@ -54,26 +123,48 @@ export async function enableGlobalPrompt() {
         await mkdir(parentDir, { recursive: true });
       }
 
-      let existing = "";
-      if (existsSync(target.filePath)) {
-        existing = await readFile(target.filePath, "utf-8");
+      const existed = existsSync(target.filePath);
+      const existing = existed ? await readFile(target.filePath, "utf-8") : "";
+      const clean = stripPromptBlock(existing);
+
+      const block = target.includeSupported
+        ? buildIncludeBlock(promptFile)
+        : PROMPT_BLOCK;
+      const updated = clean ? `${clean}\n\n${block}\n` : `${block}\n`;
+
+      const key = target.filePath;
+      const prev = state[key];
+
+      if (existed && existing === updated) {
+        results.push({ name: target.name, filePath: target.filePath, status: "up_to_date" });
+        continue;
       }
 
-      const clean = stripPromptBlock(existing);
-      const updated = clean ? `${clean}\n\n${PROMPT_BLOCK}\n` : `${PROMPT_BLOCK}\n`;
+      // Hash guard: if the user modified the file since we last wrote it,
+      // back it up before overwriting their edits.
+      if (existed && prev && prev.hash && prev.hash !== sha256(existing)) {
+        await backupFile(target.filePath);
+      }
 
-      await writeFile(target.filePath, updated, "utf-8");
-      results.push({ name: target.name, filePath: target.filePath, status: "enabled" });
+      await atomicWrite(target.filePath, updated);
+      state[key] = { hash: sha256(updated), existedBefore: existed };
+      results.push({
+        name: target.name,
+        filePath: target.filePath,
+        status: existed ? "enabled" : "created_new_file",
+      });
     } catch (err) {
       results.push({ name: target.name, filePath: target.filePath, status: "failed", error: err.message });
     }
   }
 
+  await saveState(state);
   return results;
 }
 
 export async function disableGlobalPrompt() {
   const targets = getGlobalPromptTargets();
+  const state = await loadState();
   const results = [];
 
   for (const target of targets) {
@@ -84,20 +175,36 @@ export async function disableGlobalPrompt() {
       }
 
       const existing = await readFile(target.filePath, "utf-8");
+      if (!existing.includes(START_MARKER)) {
+        results.push({ name: target.name, filePath: target.filePath, status: "skipped" });
+        continue;
+      }
+
       const clean = stripPromptBlock(existing);
+      const key = target.filePath;
+      const prev = state[key];
 
       if (clean.length === 0) {
-        await unlink(target.filePath);
-        results.push({ name: target.name, filePath: target.filePath, status: "removed_file" });
+        // Only delete the file if we created it; otherwise leave the user's file in place.
+        if (prev && prev.existedBefore === false) {
+          await unlink(target.filePath);
+          results.push({ name: target.name, filePath: target.filePath, status: "removed_file" });
+        } else {
+          await atomicWrite(target.filePath, "");
+          results.push({ name: target.name, filePath: target.filePath, status: "disabled" });
+        }
       } else {
-        await writeFile(target.filePath, clean + "\n", "utf-8");
+        await atomicWrite(target.filePath, clean + "\n");
         results.push({ name: target.name, filePath: target.filePath, status: "disabled" });
       }
+
+      delete state[key];
     } catch (err) {
       results.push({ name: target.name, filePath: target.filePath, status: "failed", error: err.message });
     }
   }
 
+  await saveState(state);
   return results;
 }
 

package/mcp-server/retrieval/retriever.js

@@ -203,10 +203,17 @@ export async function hybridQuery({
   rerankerModel = null,
   rerankerEnabled = null,
   instruction = null,
+  generateEmbeddings = true,
 }) {
   const db = customDb || getDatabase();
   const activeConfig = getConfig();
 
+  // If embeddings are disabled (e.g. fast/offline test mode or model not cached),
+  // fall back to pure lexical search instead of attempting to load the model.
+  if (generateEmbeddings === false) {
+    fusionAlgorithm = "lexical_only";
+  }
+
   const algo = fusionAlgorithm || activeConfig.fusionAlgorithm || "rsf";
   const alphaWeight = alpha !== null && alpha !== undefined ? alpha : (activeConfig.alpha ?? 0.5);
   const embModel = embeddingModel || activeConfig.embeddingModel || "Xenova/multilingual-e5-small";

package/mcp-server/setup.js

@@ -176,6 +176,12 @@ export async function runSetup() {
     promptResults.forEach((r) => {
       if (r.status === "enabled") {
         console.log(`  [OK] ${r.name}: enabled global prompt instruction in ${r.filePath}`);
+      } else if (r.status === "created_new_file") {
+        console.log(`  [OK] ${r.name}: created ${r.filePath} with global prompt instruction`);
+      } else if (r.status === "up_to_date") {
+        console.log(`  [OK] ${r.name}: global prompt already up to date (${r.filePath})`);
+      } else if (r.status === "failed") {
+        console.log(`  [WARN] ${r.name}: failed to enable global prompt (${r.error})`);
       }
     });
   } catch (err) {

package/opencode-plugin/index.js

@@ -1,6 +1,6 @@
-const { readFile, writeFile, mkdir, cp, readdir } = await import("fs/promises");
+const { readFile, writeFile, mkdir, cp, readdir, unlink } = await import("fs/promises");
 const { existsSync } = await import("fs");
-const { join, basename, dirname } = await import("path");
+const { join, basename, dirname, resolve } = await import("path");
 const { homedir } = await import("os");
 const { fileURLToPath } = await import("url");
 
@@ -28,24 +28,86 @@ async function ensureDir() {
   } catch (e) {}
 }
 
+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;
+}
+
+// Display label for a project (basename of the resolved directory).
 function projectName(worktree, directory) {
   const dir = worktree || directory;
-  return dir ? basename(dir) : "default";
+  return dir ? basename(resolve(dir)) : "default";
+}
+
+// Project store key = full directory path (removes basename collisions).
+function projectKey(worktree, directory) {
+  return canonicalPath(worktree || directory);
 }
 
 function scopeKey(scope, worktree, directory) {
-  return scope === "global" ? GLOBAL_KEY : projectName(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, `${key.replace(/[^a-zA-Z0-9_-]/g, "_")}.md`);
+  return join(MEMORY_DIR, `${slugify(key)}.md`);
+}
+
+function memoryFileName(key) {
+  return basename(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;
 }
 
 async function readMemory(key) {
   const fp = memoryPath(key);
-  if (!existsSync(fp)) return [];
-  const content = await readFile(fp, "utf-8");
-  return content.split("\n").filter((l) => l.startsWith("- ["));
+  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 || [];
 }
 
 async function readMemoryRaw(key) {
@@ -53,8 +115,58 @@ async function readMemoryRaw(key) {
 }
 
 async function writeMemory(key, entries) {
-  const header = `# ${key === GLOBAL_KEY ? "Global Memory" : `Memory: ${key}`}\n\n`;
-  await writeFile(memoryPath(key), header + entries.join("\n") + "\n");
+  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);
+}
+
+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;
+    let content = "";
+    try {
+      content = await readFile(join(MEMORY_DIR, f), "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;
+}
+
+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 };
 }
 
 function today() {
@@ -128,7 +240,7 @@ const MCP_SERVERS = [
 
 export const MemoryPlugin = async ({ directory, worktree, client }) => {
   await ensureDir();
-  const projectKey = projectName(worktree, directory);
+  const projectKey = scopeKey("project", worktree, directory);
 
   return {
     "experimental.chat.messages.transform": async (_input, output) => {
@@ -231,16 +343,19 @@ export const MemoryPlugin = async ({ directory, worktree, client }) => {
         },
       },
       "recall": {
-        description: "Show saved facts with any Agent-linked Knowledge Base documents/lines. scope: 'project', 'global', or 'all' (default)",
+        description:
+          "Show saved facts with any Agent-linked Knowledge Base documents/lines. " +
+          "scope: 'project', 'global', 'all' (default), or 'list_projects'. " +
+          "Use project: '<directory path>' to read facts of a specific project from any working directory.",
         args: {
           scope: {
             type: "string",
-            description: "project, global или all (по умолчанию)",
+            description: "project, global, all (по умолчанию) или list_projects",
             default: "all",
           },
+          project: { type: "string", description: "Directory path of the project to read facts from (e.g. 'F:/projects/plugins/memory')" },
         },
-        async execute({ scope }, { worktree, directory }) {
-          const project = projectName(worktree, directory);
+        async execute({ scope, project }, { worktree, directory }) {
           const results = [];
 
           let getLinksForFact;
@@ -268,6 +383,19 @@ export const MemoryPlugin = async ({ directory, worktree, client }) => {
             return line;
           };
 
+          if (scope === "list_projects") {
+            return listProjectStores().then((stores) => {
+              if (!stores.length) return "No project memory stores found.";
+              const lines = stores.map(
+                (s, i) => `${i + 1}. ${s.basename} — ${s.count} fact(s) [${s.file}]${s.path ? ` (bound to ${s.path})` : " (unbound legacy store)"}`
+              );
+              return `Project Memory Stores:\n${lines.join("\n")}\n\nUse recall(scope: "project", project: "<path>") to read a specific store.`;
+            });
+          }
+
+          const target = project ? canonicalPath(project) : projectKey(worktree, directory);
+          const label = project ? target : projectName(worktree, directory);
+
           if (scope !== "project") {
             const global = await readMemoryRaw(GLOBAL_KEY);
             if (global.length) {
@@ -276,11 +404,11 @@ export const MemoryPlugin = async ({ directory, worktree, client }) => {
             }
           }
           if (scope !== "global") {
-            const local = await readMemoryRaw(project);
+            const local = await readMemoryRaw(target);
             if (local.length) {
               if (results.length) results.push("");
-              results.push(`--- ${project} ---`);
-              local.forEach((e, i) => results.push(`${i + 1}. ${formatFactWithLinks(e, project)}`));
+              results.push(`--- Project: ${label} ---`);
+              local.forEach((e, i) => results.push(`${i + 1}. ${formatFactWithLinks(e, target)}`));
             }
           }
           return results.length ? results.join("\n") : "Memory is empty.";

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@lotargo/memory_plugin",
-  "version": "1.2.7",
+  "version": "1.2.9",
   "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",