local-agentic-ai-mem 0.1.0

package/README.md

@@ -0,0 +1,74 @@
+# agentic-memory
+
+Local-first memory for Claude Code. Your code and your memory never leave your machine.
+
+```bash
+npx local-agentic-ai-mem install
+```
+
+That is the whole setup. No account, no API key, no server.
+
+## What it does
+
+Claude Code forgets everything when the terminal closes. This remembers the
+part that matters — what you decided, what you tried that did not work, and
+what someone told you that is not written down anywhere in the code.
+
+It runs as hooks, not as a tool you have to remember to call:
+
+- **SessionStart** injects what is known to be true about the project
+- **UserPromptSubmit** surfaces relevant past work as you type
+- **Stop** records what the session concluded, or records nothing if it
+  concluded nothing
+
+An MCP server is registered too, but only as an escape hatch: `recall_memory`
+for an explicit lookup, `save_memory` for something you want kept. The project
+facts are also exposed as an MCP resource, so a client can attach them without
+the model deciding to ask.
+
+## What it stores
+
+Not everything. A turn that changed no files and concluded nothing is
+discarded rather than saved — on a real corpus that was about 16% of all
+turns, and keeping them measurably made recall worse.
+
+What survives is graded:
+
+| | |
+|---|---|
+| **Tier 1** | 20–40 facts per project, injected whole every session |
+| **Tier 2** | decisions anchored to files or a commit, searchable |
+| **Tier 3** | raw turns, which decay and get archived |
+
+Memories that reach a remote are ranked higher than ones that only ever
+existed locally. A memory restated later, or explicitly replaced, is marked
+superseded rather than deleted — a file changing does not mean the decision
+behind it was wrong.
+
+## Where it lives
+
+By default `~/.agentic-memory/memory.db`, a single SQLite file.
+
+```bash
+npx local-agentic-ai-mem install --project
+```
+
+stores it in `./.agentic-memory/` instead, so committing it means your memory
+travels through git — to your other machines, and to anyone else on the repo.
+Secrets are redacted before anything is written, which is what makes that safe.
+
+## Commands
+
+```
+install [--project]   install hooks + MCP
+mcp                   run the MCP server on stdio
+import <dump.sql>     import an existing MemoryOS database
+status                what is stored
+purge-legacy          remove an old MemoryOS install
+```
+
+## Privacy
+
+There is no server to send anything to. Embeddings are computed locally with
+bge-small-en-v1.5 on CPU. The only network access this package ever makes is
+downloading that model, once.

package/dist/commands/import.js

@@ -0,0 +1,232 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.importDump = importDump;
+/**
+ * Import a MemoryOS pg_dump into the local database.
+ *
+ * Five months of captured work is worth keeping, but not verbatim: everything
+ * is re-composed, re-tiered and re-embedded on the way in, so what lands is
+ * the curated corpus rather than the raw one.
+ */
+const fs_1 = require("fs");
+const db_1 = require("../db");
+const compose_1 = require("../lib/compose");
+const tiers_1 = require("../lib/tiers");
+const redact_1 = require("../lib/redact");
+const embed_1 = require("../lib/embed");
+const maintain_1 = require("../lib/maintain");
+const COLS = [
+    "id", "user_id", "project_id", "prompt", "started_at", "duration_ms",
+    "tool_calls", "files_touched", "git_commit", "embedding_bge", "embed_model",
+    "client_id", "tokens_input", "tokens_output", "tokens_cache_create",
+    "tokens_cache_read", "relevance_score", "last_recalled", "recall_count",
+    "consolidated", "archived_at", "decisions",
+];
+function splitTuple(t) {
+    const s = t.trim().replace(/^\(/, "").replace(/\)$/, "");
+    const out = [];
+    let i = 0;
+    while (i < s.length) {
+        while (i < s.length && (s[i] === " " || s[i] === ","))
+            i++;
+        if (i >= s.length)
+            break;
+        if (s[i] === "'") {
+            let j = i + 1, buf = "";
+            while (j < s.length) {
+                if (s[j] === "'") {
+                    if (s[j + 1] === "'") {
+                        buf += "'";
+                        j += 2;
+                        continue;
+                    }
+                    break;
+                }
+                buf += s[j];
+                j++;
+            }
+            out.push(buf);
+            i = j + 1;
+        }
+        else {
+            let j = i, depth = 0;
+            while (j < s.length) {
+                if ("[{(".includes(s[j]))
+                    depth++;
+                else if ("]})".includes(s[j]))
+                    depth--;
+                else if (s[j] === "," && depth === 0)
+                    break;
+                j++;
+            }
+            out.push(s.slice(i, j).trim());
+            i = j;
+        }
+    }
+    return out;
+}
+function pgArray(v) {
+    if (!v || v === "NULL" || v === "{}")
+        return [];
+    const inner = v.replace(/^\{/, "").replace(/\}$/, "");
+    const out = [];
+    let cur = "", inQ = false;
+    for (let i = 0; i < inner.length; i++) {
+        const c = inner[i];
+        if (inQ) {
+            if (c === "\\") {
+                cur += inner[++i];
+                continue;
+            }
+            if (c === '"') {
+                inQ = false;
+                continue;
+            }
+            cur += c;
+        }
+        else if (c === '"')
+            inQ = true;
+        else if (c === ",") {
+            out.push(cur);
+            cur = "";
+        }
+        else
+            cur += c;
+    }
+    if (cur)
+        out.push(cur);
+    return out.map((x) => x.trim()).filter(Boolean);
+}
+function parse(path) {
+    const text = (0, fs_1.readFileSync)(path, "utf8");
+    const atoms = [];
+    const slugs = new Map();
+    let table = null;
+    let buf = null;
+    for (const line of text.split("\n")) {
+        if (buf === null && line.startsWith("INSERT INTO")) {
+            const m = line.match(/INSERT INTO "public"\."(\w+)"/);
+            table = m ? m[1] : null;
+            continue;
+        }
+        if (table === "projects" && buf === null && line.startsWith("(")) {
+            const f = splitTuple(line.trim().replace(/[,;]$/, ""));
+            if (f.length > 4)
+                slugs.set(f[0], f[4] || f[3]);
+            continue;
+        }
+        if (table !== "atoms" && buf === null)
+            continue;
+        if (buf === null) {
+            if (!line.startsWith("("))
+                continue;
+            buf = "";
+        }
+        buf += line + "\n";
+        let inQ = false;
+        for (let i = 0; i < buf.length; i++) {
+            if (buf[i] === "'") {
+                if (inQ && buf[i + 1] === "'") {
+                    i++;
+                    continue;
+                }
+                inQ = !inQ;
+            }
+        }
+        if (inQ)
+            continue;
+        const f = splitTuple(buf.trim().replace(/[,;]$/, ""));
+        buf = null;
+        if (f.length !== COLS.length)
+            continue;
+        if (f[20] !== "NULL")
+            continue; // already archived upstream
+        atoms.push({
+            projectId: f[2],
+            prompt: f[3] ?? "",
+            decisions: pgArray(f[21]),
+            files: pgArray(f[7]),
+            toolCalls: f[6],
+            gitCommit: f[8] === "NULL" ? null : f[8],
+            startedAt: f[4],
+        });
+    }
+    return { atoms, slugs };
+}
+async function importDump(path) {
+    if (!path) {
+        console.error("  usage: agentic-memory import <memoryos-dump.sql>");
+        process.exit(1);
+    }
+    console.log(`\n  Reading ${path}…`);
+    const { atoms, slugs } = parse(path);
+    console.log(`  ${atoms.length} atoms found`);
+    // Compose first, so nothing that fails the bar is embedded at all.
+    const keep = [];
+    let dropped = 0;
+    for (const a of atoms) {
+        const composed = (0, compose_1.composeAtomContent)({
+            prompt: a.prompt,
+            decisions: a.decisions,
+            files_touched: a.files,
+            tool_calls: a.toolCalls,
+            git_commit: a.gitCommit,
+        });
+        if (!composed) {
+            dropped++;
+            continue;
+        }
+        keep.push({ src: a, content: (0, redact_1.redact)(composed.content), decisions: composed.decisions.map(redact_1.redact) });
+    }
+    console.log(`  ${keep.length} worth keeping, ${dropped} discarded as non-durable\n`);
+    (0, db_1.db)(process.cwd());
+    const projectIds = new Map();
+    for (const k of keep) {
+        if (projectIds.has(k.src.projectId))
+            continue;
+        const slug = slugs.get(k.src.projectId) ?? k.src.projectId.slice(0, 8);
+        projectIds.set(k.src.projectId, (0, db_1.upsertProject)(slug));
+    }
+    const t0 = Date.now();
+    const report = (n, total) => {
+        const rate = n / Math.max((Date.now() - t0) / 1000, 0.001);
+        process.stderr.write(`\r  embedding ${n}/${total} (${rate.toFixed(1)}/s)   `);
+    };
+    const contentVecs = await (0, embed_1.embedMany)(keep.map((k) => (0, compose_1.indexText)((0, redact_1.redact)(k.src.prompt), k.content)), (n) => report(n, keep.length * 2));
+    const promptVecs = await (0, embed_1.embedMany)(keep.map((k) => (0, redact_1.redact)(k.src.prompt)), (n) => report(keep.length + n, keep.length * 2));
+    process.stderr.write("\n");
+    keep.forEach((k, i) => {
+        const atom = {
+            id: String(i),
+            project_id: k.src.projectId,
+            prompt: k.src.prompt,
+            content: k.content,
+            decisions: k.decisions,
+            files_touched: k.src.files,
+            tool_calls: k.src.toolCalls,
+            git_commit: k.src.gitCommit,
+            started_at: k.src.startedAt,
+        };
+        (0, db_1.insertMemory)({
+            projectId: projectIds.get(k.src.projectId),
+            prompt: (0, redact_1.redact)(k.src.prompt),
+            content: k.content,
+            decisions: k.decisions,
+            files: k.src.files,
+            toolCalls: [],
+            gitCommit: k.src.gitCommit,
+            anchorSha: k.src.gitCommit,
+            confidence: (0, tiers_1.gradeConfidence)({ git_commit: k.src.gitCommit }),
+            tier: (0, tiers_1.assignTier)(atom),
+            startedAt: k.src.startedAt,
+            sessionId: null,
+            vec: contentVecs[i],
+            promptVec: promptVecs[i],
+        });
+    });
+    console.log(`  imported ${keep.length}`);
+    const m = (0, maintain_1.maintain)(true);
+    if (m)
+        console.log(`  superseded ${m.superseded}, tier 2 ${m.tier2}, project facts ${m.facts}`);
+    console.log("");
+}

package/dist/commands/install.js

@@ -0,0 +1,112 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.installHooks = installHooks;
+exports.registerSettings = registerSettings;
+exports.install = install;
+/**
+ * Install: write hooks, register the MCP server, create the database.
+ *
+ * One command, no account, no API key, nothing to sign up for. The hooks are
+ * the primary surface — they push context in without the model choosing to
+ * ask — so registering them correctly matters more than the MCP entry.
+ */
+const fs_1 = require("fs");
+const os_1 = require("os");
+const path_1 = require("path");
+const db_1 = require("../db");
+const uninstall_legacy_1 = require("./uninstall-legacy");
+const HOOK_EVENTS = {
+    SessionStart: "session-start.mjs",
+    UserPromptSubmit: "user-prompt-submit.mjs",
+    PostToolUse: "post-tool-use.mjs",
+    Stop: "stop.mjs",
+};
+function templatesDir() {
+    for (const c of [(0, path_1.resolve)(__dirname, "..", "templates"), (0, path_1.resolve)(__dirname, "..", "..", "templates")]) {
+        if ((0, fs_1.existsSync)((0, path_1.join)(c, "hooks", "stop.mjs")))
+            return c;
+    }
+    throw new Error("agentic-memory templates not found");
+}
+function installHooks(home = (0, os_1.homedir)()) {
+    const hooksDir = (0, path_1.join)(home, ".claude", "hooks", "agentic-memory");
+    (0, fs_1.mkdirSync)(hooksDir, { recursive: true });
+    const tpl = (0, path_1.join)(templatesDir(), "hooks");
+    // The hooks run from ~/.claude/hooks/, outside any node_modules tree, so a
+    // bare specifier would not resolve. Stamp in the absolute package root.
+    const root = (0, path_1.resolve)(__dirname, "..", "..");
+    const written = [];
+    for (const f of (0, fs_1.readdirSync)(tpl)) {
+        const dest = (0, path_1.join)(hooksDir, f);
+        const src = (0, fs_1.readFileSync)((0, path_1.join)(tpl, f), "utf8").replace(/__AGENTIC_MEMORY_ROOT__/g, root);
+        (0, fs_1.writeFileSync)(dest, src);
+        (0, fs_1.chmodSync)(dest, 0o755);
+        written.push(dest);
+    }
+    return written;
+}
+/** Merge our entries into settings.json without disturbing anything else. */
+function registerSettings(home = (0, os_1.homedir)()) {
+    const path = (0, path_1.join)(home, ".claude", "settings.json");
+    (0, fs_1.mkdirSync)((0, path_1.join)(home, ".claude"), { recursive: true });
+    let settings = {};
+    if ((0, fs_1.existsSync)(path)) {
+        try {
+            settings = JSON.parse((0, fs_1.readFileSync)(path, "utf8"));
+        }
+        catch {
+            settings = {};
+        }
+    }
+    const hooksDir = (0, path_1.join)(home, ".claude", "hooks", "agentic-memory");
+    settings.hooks ??= {};
+    for (const [event, file] of Object.entries(HOOK_EVENTS)) {
+        const command = `node ${(0, path_1.join)(hooksDir, file)}`;
+        settings.hooks[event] ??= [];
+        const groups = settings.hooks[event];
+        const already = groups.some((g) => (g?.hooks ?? []).some((h) => h?.command === command));
+        if (!already)
+            groups.push({ hooks: [{ type: "command", command }] });
+    }
+    settings.mcpServers ??= {};
+    settings.mcpServers["agentic-memory"] = {
+        command: "npx",
+        args: ["-y", "local-agentic-ai-mem", "mcp"],
+    };
+    (0, fs_1.writeFileSync)(path, JSON.stringify(settings, null, 2) + "\n");
+}
+function install(opts = {}) {
+    console.log("\n  agentic-memory — local-first memory for Claude Code\n");
+    if (!opts.keepLegacy) {
+        const legacy = (0, uninstall_legacy_1.removeLegacyInstall)();
+        const touched = legacy.hooksRemoved.length + (legacy.mcpRemoved ? 1 : 0) + legacy.settingsCleaned;
+        if (touched > 0) {
+            console.log(`  Removed previous MemoryOS install:`);
+            if (legacy.hooksRemoved.length)
+                console.log(`    hooks            ${legacy.hooksRemoved.length}`);
+            if (legacy.mcpRemoved)
+                console.log(`    MCP shim         removed`);
+            if (legacy.credentialRemoved)
+                console.log(`    credential file  removed`);
+            if (legacy.settingsCleaned)
+                console.log(`    settings entries ${legacy.settingsCleaned}`);
+            if (legacy.modelsMoved)
+                console.log(`    model cache      kept (moved, not re-downloaded)`);
+            console.log("");
+        }
+    }
+    if (opts.projectLocal) {
+        // Memory lives with the code, so it travels through git to other machines
+        // and to teammates — and there is still no server.
+        (0, fs_1.mkdirSync)((0, path_1.join)(process.cwd(), ".agentic-memory"), { recursive: true });
+        console.log(`  Storing memory in ./.agentic-memory/ (commit it to share and sync)`);
+    }
+    (0, db_1.db)(process.cwd());
+    (0, db_1.upsertProject)(require("path").basename(process.cwd()), process.cwd());
+    const hooks = installHooks();
+    registerSettings();
+    console.log(`  Hooks installed   ${hooks.length}`);
+    console.log(`  MCP registered    agentic-memory`);
+    console.log(`  Database          ${require("../db").resolveDbPath(process.cwd())}`);
+    console.log("\n  Nothing leaves this machine. Restart Claude Code to pick it up.\n");
+}

package/dist/commands/status.js

@@ -0,0 +1,29 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.status = status;
+const db_1 = require("../db");
+const uninstall_legacy_1 = require("./uninstall-legacy");
+const db_2 = require("../db");
+const compliance_1 = require("../lib/compliance");
+function status() {
+    const path = (0, db_1.resolveDbPath)(process.cwd());
+    const conn = (0, db_1.db)(process.cwd());
+    const one = (sql) => conn.prepare(sql).get()?.n ?? 0;
+    console.log(`\n  database   ${path}`);
+    console.log(`  projects   ${one("SELECT count(*) n FROM projects")}`);
+    console.log(`  memories   ${one("SELECT count(*) n FROM memories WHERE archived_at IS NULL AND superseded_at IS NULL")}`);
+    console.log(`    tier 2   ${one("SELECT count(*) n FROM memories WHERE tier = 2 AND archived_at IS NULL AND superseded_at IS NULL")}`);
+    console.log(`    archived ${one("SELECT count(*) n FROM memories WHERE archived_at IS NOT NULL")}`);
+    console.log(`    superseded ${one("SELECT count(*) n FROM memories WHERE superseded_at IS NOT NULL")}`);
+    console.log(`  facts      ${one("SELECT count(*) n FROM facts WHERE superseded_at IS NULL")}`);
+    // Retrieval numbers say whether the right memory was found. This says
+    // whether it was used, which is the only one that decides if it helps.
+    console.log((0, compliance_1.formatReport)((0, db_2.complianceReport)()).replace(/^/gm, "  ").trimEnd());
+    const left = (0, uninstall_legacy_1.findLegacyLeftovers)();
+    if (left.length) {
+        console.log(`\n  Old MemoryOS files still present — run 'agentic-memory purge-legacy':`);
+        for (const f of left)
+            console.log(`    ${f}`);
+    }
+    console.log("");
+}

package/dist/commands/uninstall-legacy.js

@@ -0,0 +1,159 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.removeLegacyInstall = removeLegacyInstall;
+exports.cleanSettings = cleanSettings;
+exports.findLegacyLeftovers = findLegacyLeftovers;
+/**
+ * Remove a previous MemoryOS install.
+ *
+ * The old CLI wrote hooks into ~/.claude/hooks/, an MCP shim into
+ * ~/.claude/memory/, a credential file and a shared lib into ~/.memoryos/, and
+ * entries into ~/.claude/settings.json. All of it points at a hosted API this
+ * package does not use, so leaving it in place means two systems firing on
+ * every prompt and a live credential sitting on disk.
+ *
+ * The downloaded embedding model is the one thing worth keeping — it is
+ * hundreds of megabytes and identical to what this package needs — so it is
+ * moved rather than deleted.
+ */
+const fs_1 = require("fs");
+const os_1 = require("os");
+const path_1 = require("path");
+const LEGACY_HOOKS = [
+    "atom-session-start.mjs",
+    "atom-user-prompt-submit.mjs",
+    "atom-pre-tool-use.mjs",
+    "atom-post-tool-use.mjs",
+    "atom-stop.mjs",
+    "atom-rules-reinject.mjs",
+    "session-start-load.mjs",
+    "session-end-save.mjs",
+    "session-final-save.mjs",
+    "pre-compact-save.mjs",
+];
+function removeLegacyInstall(home = (0, os_1.homedir)(), apply = true) {
+    const report = {
+        hooksRemoved: [],
+        mcpRemoved: false,
+        libRemoved: false,
+        credentialRemoved: false,
+        modelsMoved: false,
+        settingsCleaned: 0,
+    };
+    const claudeDir = (0, path_1.join)(home, ".claude");
+    const hooksDir = (0, path_1.join)(claudeDir, "hooks");
+    for (const name of LEGACY_HOOKS) {
+        const p = (0, path_1.join)(hooksDir, name);
+        if (!(0, fs_1.existsSync)(p))
+            continue;
+        report.hooksRemoved.push(name);
+        if (apply)
+            (0, fs_1.rmSync)(p, { force: true });
+    }
+    const mcpShim = (0, path_1.join)(claudeDir, "memory", "mcp-server.mjs");
+    if ((0, fs_1.existsSync)(mcpShim)) {
+        report.mcpRemoved = true;
+        if (apply)
+            (0, fs_1.rmSync)((0, path_1.join)(claudeDir, "memory"), { recursive: true, force: true });
+    }
+    const oldRoot = (0, path_1.join)(home, ".memoryos");
+    if ((0, fs_1.existsSync)(oldRoot)) {
+        // Salvage the model cache before removing the directory around it.
+        const oldModels = (0, path_1.join)(oldRoot, "models");
+        const newModels = (0, path_1.join)(home, ".agentic-memory", "models");
+        if ((0, fs_1.existsSync)(oldModels) && !(0, fs_1.existsSync)(newModels)) {
+            report.modelsMoved = true;
+            if (apply) {
+                (0, fs_1.mkdirSync)((0, path_1.join)(home, ".agentic-memory"), { recursive: true });
+                try {
+                    (0, fs_1.renameSync)(oldModels, newModels);
+                }
+                catch {
+                    // Cross-device rename fails; leaving the model behind only costs a
+                    // re-download, so it is not worth failing the uninstall over.
+                    report.modelsMoved = false;
+                }
+            }
+        }
+        if ((0, fs_1.existsSync)((0, path_1.join)(oldRoot, "credentials.json")))
+            report.credentialRemoved = true;
+        if ((0, fs_1.existsSync)((0, path_1.join)(oldRoot, "lib")))
+            report.libRemoved = true;
+        if (apply)
+            (0, fs_1.rmSync)(oldRoot, { recursive: true, force: true });
+    }
+    report.settingsCleaned = cleanSettings((0, path_1.join)(claudeDir, "settings.json"), apply);
+    return report;
+}
+/**
+ * Strip hook entries and the MCP server registration that point at the old
+ * install, leaving everything else in the file untouched.
+ */
+function cleanSettings(path, apply = true) {
+    if (!(0, fs_1.existsSync)(path))
+        return 0;
+    let parsed;
+    const raw = (0, fs_1.readFileSync)(path, "utf8");
+    try {
+        parsed = JSON.parse(raw);
+    }
+    catch {
+        return 0;
+    }
+    let removed = 0;
+    const isLegacy = (s) => typeof s === "string" && (/atom-[a-z-]+\.mjs/.test(s) || /\.claude\/memory\/mcp-server\.mjs/.test(s) || /memoryos/i.test(s));
+    if (parsed.hooks && typeof parsed.hooks === "object") {
+        for (const [event, entries] of Object.entries(parsed.hooks)) {
+            if (!Array.isArray(entries))
+                continue;
+            const kept = entries
+                .map((group) => {
+                if (!group || !Array.isArray(group.hooks))
+                    return group;
+                const before = group.hooks.length;
+                group.hooks = group.hooks.filter((h) => !isLegacy(h?.command));
+                removed += before - group.hooks.length;
+                return group;
+            })
+                .filter((group) => !Array.isArray(group?.hooks) || group.hooks.length > 0);
+            if (kept.length)
+                parsed.hooks[event] = kept;
+            else
+                delete parsed.hooks[event];
+        }
+        if (Object.keys(parsed.hooks).length === 0)
+            delete parsed.hooks;
+    }
+    if (parsed.mcpServers && typeof parsed.mcpServers === "object") {
+        for (const key of Object.keys(parsed.mcpServers)) {
+            const entry = parsed.mcpServers[key];
+            const args = Array.isArray(entry?.args) ? entry.args : [];
+            if (/memoryos|claude-memory/i.test(key) || args.some(isLegacy)) {
+                delete parsed.mcpServers[key];
+                removed++;
+            }
+        }
+        if (Object.keys(parsed.mcpServers).length === 0)
+            delete parsed.mcpServers;
+    }
+    if (apply && removed > 0)
+        (0, fs_1.writeFileSync)(path, JSON.stringify(parsed, null, 2) + "\n");
+    return removed;
+}
+/** Anything left behind that mentions the old install, for reporting. */
+function findLegacyLeftovers(home = (0, os_1.homedir)()) {
+    const out = [];
+    const hooksDir = (0, path_1.join)(home, ".claude", "hooks");
+    if ((0, fs_1.existsSync)(hooksDir)) {
+        for (const f of (0, fs_1.readdirSync)(hooksDir)) {
+            if (/^atom-|memoryos/i.test(f))
+                out.push((0, path_1.join)(hooksDir, f));
+        }
+    }
+    if ((0, fs_1.existsSync)((0, path_1.join)(home, ".memoryos")))
+        out.push((0, path_1.join)(home, ".memoryos"));
+    if ((0, fs_1.existsSync)((0, path_1.join)(home, ".claude", "memory", "mcp-server.mjs"))) {
+        out.push((0, path_1.join)(home, ".claude", "memory", "mcp-server.mjs"));
+    }
+    return out;
+}