@finchagentic/mcp 4.6.1 → 4.6.2

package/dist/tools/memory.js

@@ -1,1059 +0,0 @@
-"use strict";
-var __createBinding = (this && this.__createBinding) || (Object.create ? (function(o, m, k, k2) {
-    if (k2 === undefined) k2 = k;
-    var desc = Object.getOwnPropertyDescriptor(m, k);
-    if (!desc || ("get" in desc ? !m.__esModule : desc.writable || desc.configurable)) {
-      desc = { enumerable: true, get: function() { return m[k]; } };
-    }
-    Object.defineProperty(o, k2, desc);
-}) : (function(o, m, k, k2) {
-    if (k2 === undefined) k2 = k;
-    o[k2] = m[k];
-}));
-var __setModuleDefault = (this && this.__setModuleDefault) || (Object.create ? (function(o, v) {
-    Object.defineProperty(o, "default", { enumerable: true, value: v });
-}) : function(o, v) {
-    o["default"] = v;
-});
-var __importStar = (this && this.__importStar) || (function () {
-    var ownKeys = function(o) {
-        ownKeys = Object.getOwnPropertyNames || function (o) {
-            var ar = [];
-            for (var k in o) if (Object.prototype.hasOwnProperty.call(o, k)) ar[ar.length] = k;
-            return ar;
-        };
-        return ownKeys(o);
-    };
-    return function (mod) {
-        if (mod && mod.__esModule) return mod;
-        var result = {};
-        if (mod != null) for (var k = ownKeys(mod), i = 0; i < k.length; i++) if (k[i] !== "default") __createBinding(result, mod, k[i]);
-        __setModuleDefault(result, mod);
-        return result;
-    };
-})();
-Object.defineProperty(exports, "__esModule", { value: true });
-exports.MEMORY_TOOLS = void 0;
-exports.syncToSupermemory = syncToSupermemory;
-exports.searchSupermemory = searchSupermemory;
-exports.fuseRRF = fuseRRF;
-exports.hybridMemorySearch = hybridMemorySearch;
-exports.buildMemorySearch = buildMemorySearch;
-exports.buildMemoryContext = buildMemoryContext;
-exports.buildMemoryProfile = buildMemoryProfile;
-exports.buildMemoryList = buildMemoryList;
-exports.handleMemoryTool = handleMemoryTool;
-const zod_1 = require("zod");
-const crypto = __importStar(require("crypto"));
-const convex_js_1 = require("../convex.js");
-const public_url_js_1 = require("../public-url.js");
-const local_vault_js_1 = require("../local-vault.js");
-const local_memory_js_1 = require("../local-memory.js");
-const _text_search_js_1 = require("../_text-search.js");
-// memory_extract and memory_consolidate used to run their own LLM calls here
-// (and a matching pair of Convex routes did the same server-side). Both are now
-// two-pass: the tool fetches and stores, the caller decides what the facts are
-// and how they merge. Local mode no longer needs a provider key at all.
-// ─── Helpers (proxied through Convex - server-side Supermemory key) ──────────
-// Normalize content for dedup: lowercase + collapse whitespace + trim. This
-// catches accidental duplicates from agents that re-emit the same fact with
-// different leading/trailing whitespace or casing.
-function contentHash(content) {
-    const normalized = content.toLowerCase().replace(/\s+/g, " ").trim();
-    return crypto.createHash("sha256").update(normalized).digest("hex").slice(0, 16);
-}
-// In-process LRU cache of content hashes added in this session. Supermemory
-// is eventually consistent - calling memory_add twice rapidly with the same
-// content would otherwise both succeed because /memory/list doesn't see
-// the just-inserted entry yet. The cache closes that race so same-session
-// duplicates are caught even before the index sees them.
-const RECENT_HASH_TTL_MS = 60 * 60 * 1000; // 1 hour
-const RECENT_HASH_MAX = 500;
-const recentHashCache = new Map();
-function rememberRecentHash(hash, id, title) {
-    // Re-insert moves it to the end of the Map (most-recently-used).
-    recentHashCache.delete(hash);
-    recentHashCache.set(hash, { id, title, addedAt: Date.now() });
-    while (recentHashCache.size > RECENT_HASH_MAX) {
-        const oldest = recentHashCache.keys().next().value;
-        if (oldest === undefined)
-            break;
-        recentHashCache.delete(oldest);
-    }
-}
-function lookupRecentHash(hash) {
-    const hit = recentHashCache.get(hash);
-    if (!hit)
-        return null;
-    if (Date.now() - hit.addedAt > RECENT_HASH_TTL_MS) {
-        recentHashCache.delete(hash);
-        return null;
-    }
-    return hit;
-}
-// memory_delete must purge this too - otherwise a deleted memory's hash stays
-// cached (up to an hour) and re-adding the exact same content within that
-// window gets silently skipped as a "duplicate" of an id that no longer
-// exists, when there is no longer any real duplicate to skip.
-function forgetRecentHashById(id) {
-    for (const [hash, entry] of recentHashCache) {
-        if (entry.id === id) {
-            recentHashCache.delete(hash);
-            break;
-        }
-    }
-}
-// Two-tier dedup lookup: in-process cache first (catches same-session
-// dupes during eventual-consistency window), then a list call (catches
-// cross-session dupes once they've been indexed). Returns null on any
-// failure - dedup must never block legitimate writes.
-async function findDuplicateMemory(hash) {
-    const cached = lookupRecentHash(hash);
-    if (cached)
-        return cached;
-    try {
-        const local = (0, local_memory_js_1.getLocalMemoryConfig)();
-        const results = local
-            ? await (0, local_memory_js_1.localMemoryList)(local, 50)
-            : ((await (0, convex_js_1.callConvex)("/memory/list", "POST", { n: 50 }, "memory_list"))?.results ?? []);
-        const match = results.find((r) => r.metadata?.contentHash === hash);
-        if (!match)
-            return null;
-        return { id: match.id, title: match.metadata?.title, addedAt: match.metadata?.addedAt };
-    }
-    catch {
-        return null;
-    }
-}
-const SYNC_RETRY_DELAYS_MS = [500, 2000, 5000];
-async function syncToSupermemory(content, metadata, sourceUrl) {
-    const local = (0, local_memory_js_1.getLocalMemoryConfig)();
-    let lastError = null;
-    if (local) {
-        // Same retry shape as the Convex path below - a transient local-server
-        // hiccup (e.g. mid-restart) shouldn't silently drop a vault_save-driven
-        // memory sync with only a console.error nobody sees.
-        for (let attempt = 0; attempt <= SYNC_RETRY_DELAYS_MS.length; attempt++) {
-            try {
-                await (0, local_memory_js_1.localMemoryAdd)(local, content, metadata, sourceUrl);
-                return;
-            }
-            catch (err) {
-                lastError = err;
-                const delay = SYNC_RETRY_DELAYS_MS[attempt];
-                if (delay === undefined)
-                    break;
-                await new Promise((r) => setTimeout(r, delay));
-            }
-        }
-        const errMsg = lastError instanceof Error ? lastError.message : String(lastError);
-        const preview = content.slice(0, 120).replace(/\s+/g, " ");
-        console.error(`[memory] local sync_failed after ${SYNC_RETRY_DELAYS_MS.length + 1} attempts: ${errMsg} | preview: "${preview}"`);
-        // Chronicle has no local equivalent yet, so the failure is still logged
-        // centrally (best-effort) even in local-memory mode - this is audit
-        // trail, not memory content, so it doesn't defeat the local-mode intent.
-        await (0, convex_js_1.callConvex)("/chronicle/add", "POST", {
-            type: "system",
-            title: `Local memory sync failed after ${SYNC_RETRY_DELAYS_MS.length + 1} attempts`,
-            detail: `Error: ${errMsg}\nPreview: ${preview}`,
-            metadata: { ...metadata, sourceUrl, attempts: SYNC_RETRY_DELAYS_MS.length + 1, kind: "memory_sync_failed", backend: "local" },
-            source: "mcp",
-        }).catch(() => { });
-        return;
-    }
-    const payload = {
-        content,
-        metadata,
-        ...(sourceUrl ? { sourceUrl } : {}),
-    };
-    for (let attempt = 0; attempt <= SYNC_RETRY_DELAYS_MS.length; attempt++) {
-        try {
-            await (0, convex_js_1.callConvex)("/memory/add", "POST", payload, "memory_add");
-            return;
-        }
-        catch (err) {
-            lastError = err;
-            const delay = SYNC_RETRY_DELAYS_MS[attempt];
-            if (delay === undefined)
-                break;
-            await new Promise((r) => setTimeout(r, delay));
-        }
-    }
-    const errMsg = lastError instanceof Error ? lastError.message : String(lastError);
-    const preview = content.slice(0, 120).replace(/\s+/g, " ");
-    await (0, convex_js_1.callConvex)("/chronicle/add", "POST", {
-        type: "system",
-        title: `Supermemory sync failed after ${SYNC_RETRY_DELAYS_MS.length + 1} attempts`,
-        detail: `Error: ${errMsg}\nPreview: ${preview}`,
-        metadata: { ...metadata, sourceUrl, attempts: SYNC_RETRY_DELAYS_MS.length + 1, kind: "memory_sync_failed" },
-        source: "mcp",
-    }).catch(() => {
-        // Chronicle write itself failed - last-resort console; supermemory is best-effort.
-        console.error(`[memory] sync_failed: ${errMsg} | preview: "${preview}"`);
-    });
-}
-async function searchSupermemory(query, limit = 10) {
-    try {
-        const local = (0, local_memory_js_1.getLocalMemoryConfig)();
-        if (local)
-            return await (0, local_memory_js_1.localMemorySearch)(local, query, limit);
-        const data = await (0, convex_js_1.callConvex)("/memory/search", "POST", { q: query, n: limit }, "memory_search");
-        return data?.results ?? [];
-    }
-    catch {
-        return [];
-    }
-}
-// Lexical (full-text / BM25-style) search over the Convex memories mirror.
-// Returns rows in relevance-rank order so the fusion step can use rank
-// directly without re-normalizing raw scores.
-async function lexicalSearch(query, limit = 30) {
-    try {
-        const data = await (0, convex_js_1.callConvex)("/memory/lexical", "POST", { q: query, n: limit }, "memory_search");
-        const rows = (data?.results ?? []);
-        return rows.map((r, idx) => ({
-            id: r.id,
-            content: r.content ?? "",
-            metadata: r.metadata ?? {},
-            rank: typeof r.rank === "number" ? r.rank : idx,
-        }));
-    }
-    catch {
-        return [];
-    }
-}
-// Reciprocal Rank Fusion - combines two ranked lists into one without needing
-// to normalize raw scores. Each list contributes 1/(k + rank) to a doc's
-// final score; docs that appear in both lists rank above docs in only one.
-// k=60 is the canonical TREC/Lucene default; ours can be tuned via the eval
-// suite. See: "Reciprocal Rank Fusion outperforms Condorcet and individual
-// Rank Learning Methods" (Cormack et al., SIGIR 2009).
-const RRF_K = 60;
-function fuseRRF(semantic, lexical, k = RRF_K) {
-    const merged = new Map();
-    semantic.forEach((doc, rank) => {
-        merged.set(doc.id, {
-            id: doc.id,
-            content: doc.content,
-            metadata: doc.metadata,
-            fusedScore: 1 / (k + rank),
-            semanticRank: rank,
-            lexicalRank: null,
-            score: doc.score,
-        });
-    });
-    lexical.forEach((doc) => {
-        const existing = merged.get(doc.id);
-        const lexContrib = 1 / (k + doc.rank);
-        if (existing) {
-            existing.fusedScore += lexContrib;
-            existing.lexicalRank = doc.rank;
-        }
-        else {
-            merged.set(doc.id, {
-                id: doc.id,
-                content: doc.content,
-                metadata: doc.metadata,
-                fusedScore: lexContrib,
-                semanticRank: null,
-                lexicalRank: doc.rank,
-            });
-        }
-    });
-    return [...merged.values()].sort((a, b) => b.fusedScore - a.fusedScore);
-}
-// Hybrid retrieval: fan out semantic + lexical in parallel, fuse via RRF.
-// Returns the unified candidate list - callers (memory_search) layer their
-// own decay + reranking on top.
-//
-// Local mode skips the separate lexical fusion entirely: the self-hosted
-// supermemory server already does hybrid semantic+lexical search server-side
-// (that's the whole point of the RRF layer here - fusing cloud Supermemory's
-// semantic-only results with Convex's own BM25 mirror table), so re-fusing
-// on top of an already-hybrid result set would be redundant.
-async function hybridMemorySearch(query, limit = 30) {
-    const local = (0, local_memory_js_1.getLocalMemoryConfig)();
-    if (local) {
-        const results = await searchSupermemory(query, limit); // routes to localMemorySearch
-        return results.map((r, rank) => ({
-            id: r.id,
-            content: r.content,
-            metadata: r.metadata,
-            fusedScore: r.score ?? 1 / (RRF_K + rank),
-            semanticRank: rank,
-            lexicalRank: null,
-            score: r.score,
-        }));
-    }
-    // Over-fetch from each side so the fusion has enough overlap to find
-    // co-ranked docs. Each side returns up to `limit` items; the union is
-    // capped to keep response size bounded.
-    const [semantic, lexical] = await Promise.all([
-        searchSupermemory(query, limit),
-        lexicalSearch(query, limit),
-    ]);
-    return fuseRRF(semantic, lexical);
-}
-// ─── Tool definitions ────────────────────────────────────────────────────────
-exports.MEMORY_TOOLS = [
-    {
-        name: "memory_add",
-        description: "Add content to your Finch memory - no setup needed, no extra API keys. " +
-            "Unlike vault_save, memory_add is instant: no versioning, no type required. " +
-            "Use for notes, decisions, preferences, or anything you want to find later. " +
-            "Pass sourceUrl to fetch and index any web page, GitHub repo, or Notion page automatically - " +
-            "searchable in ~30s. Retrieval is full-text (keyword) search, not embeddings - " +
-            "'what did I say about ETH yield?' finds notes containing those words or close variants, " +
-            "not unrelated phrasing with the same meaning. " +
-            "Auto-deduplicates: identical content in your recent 50 memories is skipped (override with force:true). " +
-            "Also surfaces up to 3 existing memories that share real keyword overlap with what you just saved (a " +
-            "possible-conflict HINT, not a verdict - Finch doesn't call an LLM to judge this). When that shows up, " +
-            "read them and decide yourself whether the new one supersedes an old preference/fact; if so, say so in a " +
-            "follow-up memory_add, or fold both into one with memory_consolidate.",
-        inputSchema: {
-            type: "object",
-            properties: {
-                content: { type: "string", description: "Content to remember - text, markdown, or a note. Use a short title if providing sourceUrl." },
-                title: { type: "string", description: "Optional title for this memory" },
-                tags: { type: "array", items: { type: "string" }, description: "Tags for grouping" },
-                sourceUrl: { type: "string", description: "URL to fetch and index automatically (GitHub, Notion, web page, etc.). Content becomes searchable in ~30s." },
-                force: { type: "boolean", description: "Bypass duplicate detection. Set true to allow a second copy of identical content." },
-            },
-            required: ["content"],
-        },
-    },
-    {
-        name: "memory_search",
-        description: "Full-text (keyword) search over your stored memories, with 90-day time-decay weighting so " +
-            "recent notes outrank stale ones with similar wording. Good for exact-token lookups (env var " +
-            "names, contract addresses, IDs, specific phrases) - it does not understand meaning, so " +
-            "'low risk crypto yield' will not match a note phrased as 'conservative DeFi strategies' " +
-            "unless the words themselves overlap.",
-        inputSchema: {
-            type: "object",
-            properties: {
-                query: { type: "string", description: "Natural language query" },
-                limit: { type: "number", description: "Max results (default 10)" },
-            },
-            required: ["query"],
-        },
-    },
-    {
-        name: "memory_context",
-        description: "Retrieve the most relevant memories for a topic, formatted as AI-ready context. " +
-            "Use at the start of research tasks to prime with everything stored about a topic. " +
-            "Uses full-text (keyword) search, not embeddings - phrase your topic with the words " +
-            "you expect were actually used when the memory was saved.",
-        inputSchema: {
-            type: "object",
-            properties: {
-                topic: { type: "string", description: "Topic to load context for, e.g. 'ETH liquid staking' or 'user DeFi preferences'" },
-                limit: { type: "number", description: "Max entries to include (default 8)" },
-            },
-            required: ["topic"],
-        },
-    },
-    {
-        name: "memory_profile",
-        description: "Show your memory stats - total memories stored, your memory space, and connected sources. " +
-            "Useful for auditing what Finch knows about you.",
-        inputSchema: {
-            type: "object",
-            properties: {},
-            required: [],
-        },
-    },
-    {
-        name: "memory_list",
-        description: "List your most recent Finch memories without a search query. " +
-            "Useful to browse what's stored or audit before clearing. " +
-            "Sorted by most recently added.",
-        inputSchema: {
-            type: "object",
-            properties: {
-                limit: { type: "number", description: "Max memories to return (default 20)" },
-                tag: { type: "string", description: "Optional: filter by tag" },
-            },
-            required: [],
-        },
-    },
-    {
-        name: "memory_delete",
-        description: "PERMANENT. Delete a specific memory by its ID — it cannot be recovered. " +
-            "Get IDs from memory_search or memory_list. Requires confirm: true. " +
-            "Show the user which memory you are about to delete (title/content) and get their " +
-            "agreement first — IDs come from search results and are easy to mix up.",
-        inputSchema: {
-            type: "object",
-            properties: {
-                id: { type: "string", description: "Memory ID to delete (from memory_search or memory_list results)" },
-                confirm: { type: "boolean", description: "Must be true to delete. Guards against irreversible loss." },
-            },
-            required: ["id", "confirm"],
-        },
-    },
-    {
-        name: "memory_insight",
-        description: "Get a full intelligence report on any topic - combines memory AND vault entries, " +
-            "then identifies knowledge gaps and suggests next actions. " +
-            "Use this before starting any research or trade decision to see everything Finch already knows. " +
-            "Returns: confidence level, what you know, coverage timeline, gaps, and recommended next steps.",
-        inputSchema: {
-            type: "object",
-            properties: {
-                topic: { type: "string", description: "Topic to analyze - token, protocol, strategy, or any concept" },
-                depth: { type: "string", enum: ["quick", "standard", "deep"], description: "How many sources to pull (default: standard)" },
-            },
-            required: ["topic"],
-        },
-    },
-    {
-        name: "memory_extract",
-        description: "Save discrete facts, preferences and decisions to memory as individually searchable atoms " +
-            "instead of one wall of text. Two-pass, no API key needed. " +
-            "PASS 1 — call with `text`: returns the text with the extraction rubric. " +
-            "PASS 2 — call with `facts: [...]`: stores each fact separately, deduped. " +
-            "YOU decide what the facts are; this tool stores them. Best for chat logs, research notes, meeting summaries.",
-        inputSchema: {
-            type: "object",
-            properties: {
-                text: { type: "string", description: "PASS 1. Unstructured content to pull facts out of - notes, research, chat logs." },
-                facts: {
-                    type: "array",
-                    items: { type: "string" },
-                    description: "PASS 2. The atomic facts you extracted. Each is stored as its own searchable memory. Supplying this skips pass 1 entirely.",
-                },
-                source: { type: "string", description: "Optional label for where this came from (e.g. 'telegram', 'research', 'meeting')" },
-            },
-            required: [],
-        },
-    },
-    {
-        name: "memory_consolidate",
-        description: "Clean up fragmented knowledge after heavy research sessions. Two-pass, no API key needed. " +
-            "PASS 1 — call with `topic`: fetches every memory on that topic and returns them numbered, with the " +
-            "merge rubric. " +
-            "PASS 2 — call with `topic` + `summary`: saves your merged version as a new consolidated memory. " +
-            "Originals always remain intact.",
-        inputSchema: {
-            type: "object",
-            properties: {
-                topic: { type: "string", description: "Topic to consolidate memories for (e.g. 'ETH liquid staking', 'Base DeFi')" },
-                limit: { type: "number", description: "Max source memories to fetch (default 12)" },
-                summary: {
-                    type: "string",
-                    description: "PASS 2 only. Your merged summary. Supplying it switches this tool from 'return the memories' to 'save the result'.",
-                },
-            },
-            required: ["topic"],
-        },
-    },
-];
-// ─── Zod schemas ─────────────────────────────────────────────────────────────
-const AddSchema = zod_1.z.object({
-    content: zod_1.z.string().min(1),
-    title: zod_1.z.string().optional(),
-    tags: zod_1.z.array(zod_1.z.string()).optional(),
-    sourceUrl: zod_1.z.string().url().optional(),
-    force: zod_1.z.boolean().optional(),
-});
-const SearchSchema = zod_1.z.object({
-    query: zod_1.z.string().min(1),
-    limit: zod_1.z.number().optional(),
-});
-const ContextSchema = zod_1.z.object({
-    topic: zod_1.z.string().min(1),
-    limit: zod_1.z.number().optional(),
-});
-const ListSchema = zod_1.z.object({
-    limit: zod_1.z.number().optional(),
-    tag: zod_1.z.string().optional(),
-});
-const DeleteMemSchema = zod_1.z.object({ id: zod_1.z.string().min(1) });
-const InsightSchema = zod_1.z.object({
-    topic: zod_1.z.string().min(1),
-    depth: zod_1.z.enum(["quick", "standard", "deep"]).optional(),
-});
-const ExtractSchema = zod_1.z.object({
-    text: zod_1.z.string().min(1).optional(),
-    facts: zod_1.z.array(zod_1.z.string().min(1)).min(1).max(50).optional(),
-    source: zod_1.z.string().optional(),
-}).refine((v) => !!v.text || !!v.facts, { message: "pass `text` (pass 1) or `facts` (pass 2)" });
-const ConsolidateSchema = zod_1.z.object({
-    topic: zod_1.z.string().min(1),
-    limit: zod_1.z.number().optional(),
-    summary: zod_1.z.string().min(1).optional(),
-});
-// ─── Handler ─────────────────────────────────────────────────────────────────
-// ── Structured output builders (schemas in output-schemas.ts) ───────────────
-function buildMemorySearch(query, decayed) {
-    return {
-        query,
-        count: decayed.length,
-        memories: decayed.map((r) => ({
-            id: r.id,
-            title: r.metadata?.title ?? null,
-            content: r.content,
-            score: r._decayedScore ?? r.fusedScore ?? null,
-            ageDays: r._ageDays != null ? Math.round(r._ageDays) : null,
-            pinned: !!r._pinned,
-            semanticRank: r.semanticRank ?? null,
-            lexicalRank: r.lexicalRank ?? null,
-        })),
-    };
-}
-function buildMemoryContext(topic, results) {
-    return {
-        topic,
-        count: results.length,
-        memories: results.map((r) => ({ title: r.metadata?.title ?? null, content: r.content })),
-    };
-}
-function buildMemoryProfile(data) {
-    return { space: data?.space ?? null, total: data?.total ?? 0, status: data?.status ?? "unknown" };
-}
-function buildMemoryList(tag, results) {
-    return {
-        tag: tag ?? null,
-        count: results.length,
-        memories: results.map((r) => ({ id: r.id, title: r.metadata?.title ?? null, content: r.content })),
-    };
-}
-async function handleMemoryTool(name, args) {
-    switch (name) {
-        case "memory_add": {
-            const parsed = AddSchema.safeParse(args);
-            if (!parsed.success)
-                return { content: [{ type: "text", text: `${parsed.error.issues[0].message}` }], isError: true };
-            const { content, title, tags, sourceUrl, force } = parsed.data;
-            // `sourceUrl` is not stored, it is fetched and indexed — by the local
-            // memory server on the user's own machine when local mode is on. An
-            // unrestricted URL therefore pulls LAN and loopback content into memory,
-            // where memory_search reads it straight back out.
-            if (sourceUrl) {
-                const unsafe = await (0, public_url_js_1.assertPublicUrl)(sourceUrl);
-                if (unsafe) {
-                    return { content: [{ type: "text", text: (0, public_url_js_1.refuseUrlText)(sourceUrl, unsafe) }], isError: true };
-                }
-            }
-            const hash = contentHash(content);
-            // Dedup: skip if an identical-content memory exists in recent history,
-            // unless caller passed `force: true`. URL-sourced memories skip dedup -
-            // the same URL may legitimately be re-indexed after content changes.
-            if (!force && !sourceUrl) {
-                const existing = await findDuplicateMemory(hash);
-                if (existing) {
-                    const age = existing.addedAt ? Math.max(0, Math.round((Date.now() - existing.addedAt) / 60000)) : null;
-                    return {
-                        content: [{
-                                type: "text",
-                                text: [
-                                    `↩️ **Duplicate skipped** - identical content already stored.`,
-                                    `Existing ID: \`${existing.id}\`${existing.title ? ` · ${existing.title}` : ""}${age !== null ? ` · added ${age}m ago` : ""}`,
-                                    ``,
-                                    `Override with \`memory_add content: "…" force: true\` if you really want a second copy.`,
-                                ].join("\n"),
-                            }],
-                    };
-                }
-            }
-            const addMetadata = { title, tags, source: "memory_add", addedAt: Date.now(), contentHash: hash };
-            const localAdd = (0, local_memory_js_1.getLocalMemoryConfig)();
-            const data = localAdd
-                ? await (0, local_memory_js_1.localMemoryAdd)(localAdd, content, addMetadata, sourceUrl).catch((err) => ({ error: err.message }))
-                : await (0, convex_js_1.callConvex)("/memory/add", "POST", { content, metadata: addMetadata, ...(sourceUrl ? { sourceUrl } : {}) }, "memory_add").catch((err) => ({ error: err.message }));
-            if (data?.error)
-                return { content: [{ type: "text", text: `Error: ${data.error}` }], isError: true };
-            // Cache the hash so an immediate second call with identical content
-            // dedupes even before supermemory has indexed the first one.
-            if (!sourceUrl)
-                rememberRecentHash(hash, data?.id ?? "saved", title);
-            // ─── Conflict hint (not a proof) ──────────────────────────────────
-            // Finch never runs its own LLM call to judge this - "two-pass, no API
-            // key needed" is deliberate (see this file's header comment), and an
-            // autonomous contradiction call would break that. Instead this just
-            // resurfaces whatever memory_search's own retrieval already ranks as
-            // related to the content just saved, so the CALLING model - already
-            // reasoning about this exact save, in the same turn, no extra API
-            // cost - can judge for itself whether the two actually conflict and
-            // decide what to do (mark the old one superseded, fold both into
-            // memory_consolidate, or just note the new one is the current one).
-            // Best-effort: a search hiccup here must never fail or block the save
-            // that already succeeded above.
-            let conflictNote = "";
-            try {
-                const related = await hybridMemorySearch(content, 8);
-                // hybridMemorySearch's score is rank-based and normalized per-call -
-                // a single weak match (one common word) can still come back as
-                // "top result, 100%" purely for lack of competition. Found live:
-                // "the user's favorite pizza topping" registered as "related" to a
-                // completely unrelated units-preference memory, because both
-                // happened to say "user". Counting actual shared meaningful terms
-                // (>=2 distinct, not stop words) is a real, absolute bar instead of
-                // trusting a relative score - "user" alone no longer qualifies,
-                // "user"+"prefers"+"units"+"metric"/"imperial" does.
-                const newTerms = new Set((0, _text_search_js_1.meaningfulTerms)(content));
-                const candidates = related
-                    .filter((r) => r.id !== data?.id && contentHash(r.content) !== hash)
-                    .map((r) => ({ r, overlap: new Set((0, _text_search_js_1.meaningfulTerms)(r.content).filter((t) => newTerms.has(t))).size }))
-                    .filter((x) => x.overlap >= 2)
-                    .sort((a, b) => b.overlap - a.overlap)
-                    .slice(0, 3)
-                    .map((x) => x.r);
-                if (candidates.length) {
-                    conflictNote = "\n\n⚠️ **Possibly related existing memories** - skim these for a conflict with what you just saved (e.g. an old preference this replaces):\n" +
-                        candidates.map((r) => `- \`${r.id}\`: ${r.content.slice(0, 100)}${r.content.length > 100 ? "…" : ""}`).join("\n");
-                }
-            }
-            catch {
-                // best-effort only
-            }
-            return {
-                content: [{
-                        type: "text",
-                        text: [
-                            `🧠 **Memory added** - ID: \`${data?.id ?? "saved"}\``,
-                            title ? `Title: ${title}` : "",
-                            sourceUrl ? `Source: ${sourceUrl} (indexing in background…)` : "",
-                            tags?.length ? `Tags: ${tags.join(", ")}` : "",
-                            ``,
-                            `Find it with: \`memory_search query: "${(title ?? content).slice(0, 40)}"\``,
-                        ].filter(Boolean).join("\n") + conflictNote,
-                    }],
-            };
-        }
-        case "memory_search": {
-            const parsed = SearchSchema.safeParse(args);
-            if (!parsed.success)
-                return { content: [{ type: "text", text: `${parsed.error.issues[0].message}` }], isError: true };
-            const { query, limit = 10 } = parsed.data;
-            // Over-fetch so post-decay ranking still has enough material.
-            const overfetch = Math.min(50, Math.max(limit * 2, 20));
-            // ─── Retrieval ───────────────────────────────────────────────────
-            // Fan out two full-text queries (searchSupermemory and lexicalSearch -
-            // both call Convex full-text search under different names, there is no
-            // embedding step despite the "semantic"/"Supermemory" naming) in
-            // parallel, fuse via Reciprocal Rank Fusion so results present in both
-            // rank highest.
-            const fused = await hybridMemorySearch(query, overfetch);
-            const raw = fused;
-            if (!raw.length)
-                return { content: [{ type: "text", text: `No memories found for: "${query}"\nTry adding content with \`memory_add\` or \`vault_save\`.` }], structuredContent: buildMemorySearch(query, []) };
-            // ─── Time-decay weighting ─────────────────────────────────────────
-            // Apply an age-aware multiplier to the fused RRF score so a relevant
-            // old casual note doesn't outrank a recent precise one. Half-life of
-            // 90 days - a memory loses ~30% relevance over a quarter.
-            // Pinned memories (metadata.pinned) bypass decay.
-            const HALF_LIFE_DAYS = 90;
-            const decayed = raw.map((r) => {
-                const ageMs = Date.now() - (r.metadata?.addedAt ?? 0);
-                const ageDays = ageMs > 0 ? ageMs / 86400000 : 0;
-                const pinned = r.metadata?.pinned === true;
-                const decayMul = pinned ? 1 : Math.pow(0.5, ageDays / HALF_LIFE_DAYS);
-                return {
-                    ...r,
-                    _decayedScore: r.fusedScore * decayMul,
-                    _ageDays: ageDays,
-                    _pinned: pinned,
-                };
-            })
-                .sort((a, b) => b._decayedScore - a._decayedScore)
-                .slice(0, limit);
-            // Hybrid mode is on if any result was lexically ranked too.
-            const hybridHits = decayed.filter((r) => r.lexicalRank !== null).length;
-            const modeLabel = hybridHits > 0
-                ? `Hybrid (semantic + lexical), ${hybridHits} dual-ranked`
-                : `Semantic only (lexical empty for this query)`;
-            const header = `🔍 **Memory Search**: "${query}" - ${decayed.length} result(s) · ${modeLabel} · time-decay 90d half-life`;
-            const rows = decayed.map((r, i) => {
-                // Per-result rank annotation: shows whether each hit came from
-                // semantic, lexical, or both. Cheap signal of retrieval quality.
-                const tags = [];
-                if (r.semanticRank !== null)
-                    tags.push(`sem#${r.semanticRank + 1}`);
-                if (r.lexicalRank !== null)
-                    tags.push(`lex#${r.lexicalRank + 1}`);
-                const tagStr = tags.length ? ` (${tags.join(", ")})` : "";
-                const score = ` [${(r._decayedScore * 1000).toFixed(0)}]`;
-                const title = r.metadata?.title ?? "";
-                const ageNote = r._ageDays > 0 ? ` · ${Math.round(r._ageDays)}d` : "";
-                const pinBadge = r._pinned ? " 📌" : "";
-                const preview = r.content.slice(0, 200).replace(/\n/g, " ");
-                return [
-                    `${i + 1}.${score}${pinBadge}${title ? ` **${title}**` : ""}${ageNote}${tagStr} \`${r.id}\``,
-                    `   ${preview}${r.content.length > 200 ? "…" : ""}`,
-                ].join("\n");
-            });
-            // ─── Promotion hint when N+ memories cluster on a topic ───────────
-            // If 4+ memories surface for one query they're collectively load-
-            // bearing - suggest the user promote them to a single versioned vault
-            // entry so the knowledge becomes structured and citable.
-            let promotionHint = "";
-            if (decayed.length >= 4) {
-                const topic = query.toLowerCase().replace(/[^a-z0-9]+/g, "-").slice(0, 40);
-                promotionHint = [
-                    ``,
-                    `💡 **${decayed.length} memories on this topic.** Consider promoting to a vault entry for cleaner versioning + linking:`,
-                    ``,
-                    `\`\`\``,
-                    `memory_consolidate topic="${query}" n=${Math.min(decayed.length, 8)}`,
-                    `# Then: copy the summary and:`,
-                    `vault_save type=research key=memory-cluster/${topic} content="<the consolidation>"`,
-                    `\`\`\``,
-                ].join("\n");
-            }
-            return { content: [{ type: "text", text: [header, "", ...rows, promotionHint].filter(Boolean).join("\n") }], structuredContent: buildMemorySearch(query, decayed) };
-        }
-        case "memory_context": {
-            const parsed = ContextSchema.safeParse(args);
-            if (!parsed.success)
-                return { content: [{ type: "text", text: `${parsed.error.issues[0].message}` }], isError: true };
-            const { topic, limit = 8 } = parsed.data;
-            // v3.25.1: use hybrid retrieval so context loading picks up exact-token
-            // matches (env var names, model IDs, contract addresses) that semantic-
-            // only would miss. Same fusion as memory_search.
-            const results = await hybridMemorySearch(topic, limit);
-            if (!results.length)
-                return { content: [{ type: "text", text: `No context found for: "${topic}"\nBuild your memory base with vault_save or memory_add.` }], structuredContent: buildMemoryContext(topic, []) };
-            const contextParts = results.map((r, i) => {
-                const title = r.metadata?.title ? `### ${r.metadata.title}` : `### Memory ${i + 1}`;
-                return `${title}\n${r.content}`;
-            });
-            const summary = results.map(r => r.metadata?.title ?? r.content.slice(0, 50)).join(", ");
-            return {
-                content: [{
-                        type: "text",
-                        text: [
-                            `🧠 **Context** for: "${topic}" (hybrid retrieval)`,
-                            `Loaded ${results.length} relevant memories: ${summary}`,
-                            ``,
-                            `---`,
-                            ``,
-                            contextParts.join("\n\n---\n\n"),
-                        ].join("\n"),
-                    }],
-                structuredContent: buildMemoryContext(topic, results),
-            };
-        }
-        case "memory_profile": {
-            const localProfileCfg = (0, local_memory_js_1.getLocalMemoryConfig)();
-            const data = localProfileCfg
-                ? await (0, local_memory_js_1.localMemoryProfile)(localProfileCfg).catch(() => null)
-                : await (0, convex_js_1.callConvex)("/memory/profile", "GET", undefined, "memory_profile").catch(() => null);
-            const total = data?.total ?? 0;
-            const status = data?.status ?? "unknown";
-            const space = data?.space ?? "-";
-            return {
-                content: [{
-                        type: "text",
-                        text: [
-                            `🧠 **Finch Memory**`,
-                            ``,
-                            `Space: \`${space}\``,
-                            `Total memories: **${total}**`,
-                            `Status: ${status === "ok" ? "✅ Active" : status === "not_configured" ? "⏳ Setting up" : "⚠️ " + status}`,
-                            ``,
-                            `**Auto-synced sources:**`,
-                            `• vault_save - ✅`,
-                            `• memory_add (URL indexing) - ✅`,
-                            `• Google Drive / Gmail / Notion - connect at finchagentic.com`,
-                            ``,
-                            `**Capabilities:** Full-text (keyword) search with 90-day time-decay ranking - not embeddings, no vector search.`,
-                        ].join("\n"),
-                    }],
-                structuredContent: buildMemoryProfile(data),
-            };
-        }
-        case "memory_list": {
-            const parsed = ListSchema.safeParse(args ?? {});
-            if (!parsed.success)
-                return { content: [{ type: "text", text: `${parsed.error.issues[0].message}` }], isError: true };
-            const { limit = 20, tag } = parsed.data;
-            const localList = (0, local_memory_js_1.getLocalMemoryConfig)();
-            let results;
-            if (localList) {
-                try {
-                    results = await (0, local_memory_js_1.localMemoryList)(localList, limit, tag);
-                }
-                catch (err) {
-                    return { content: [{ type: "text", text: `Error: ${err.message}` }], isError: true };
-                }
-            }
-            else {
-                const data = await (0, convex_js_1.callConvex)("/memory/list", "POST", { n: limit, tag }, "memory_list").catch((err) => ({ error: err.message }));
-                if (data?.error)
-                    return { content: [{ type: "text", text: `Error: ${data.error}` }], isError: true };
-                results = data?.results ?? [];
-            }
-            if (!results.length)
-                return { content: [{ type: "text", text: `No memories stored yet. Use \`memory_add\` to start building your knowledge base.` }], structuredContent: buildMemoryList(tag, []) };
-            const header = `🧠 **Memories** (${results.length} shown${tag ? `, tag: ${tag}` : ""})`;
-            const rows = results.map((r, i) => {
-                const title = r.metadata?.title ?? "";
-                const preview = r.content.slice(0, 100).replace(/\n/g, " ");
-                return `${i + 1}. \`${r.id}\`${title ? ` **${title}**` : ""}\n   ${preview}${r.content.length > 100 ? "…" : ""}`;
-            });
-            return { content: [{ type: "text", text: [header, "", ...rows].join("\n") }], structuredContent: buildMemoryList(tag, results) };
-        }
-        case "memory_delete": {
-            const parsed = DeleteMemSchema.safeParse(args);
-            if (!parsed.success)
-                return { content: [{ type: "text", text: `${parsed.error.issues[0].message}` }], isError: true };
-            if (args?.confirm !== true) {
-                return {
-                    content: [{
-                            type: "text",
-                            text: "Refusing to delete: this permanently removes the memory and cannot be undone. " +
-                                "Show the user the memory you intend to delete, then pass `confirm: true`.",
-                        }],
-                    isError: true,
-                };
-            }
-            const localDel = (0, local_memory_js_1.getLocalMemoryConfig)();
-            if (localDel) {
-                try {
-                    await (0, local_memory_js_1.localMemoryDelete)(localDel, parsed.data.id);
-                }
-                catch (err) {
-                    return { content: [{ type: "text", text: `Error: ${err.message}` }], isError: true };
-                }
-            }
-            else {
-                const data = await (0, convex_js_1.callConvex)("/memory/delete", "POST", { id: parsed.data.id }, "memory_delete").catch((err) => ({ error: err.message }));
-                if (data?.error)
-                    return { content: [{ type: "text", text: `Error: ${data.error}` }], isError: true };
-            }
-            forgetRecentHashById(parsed.data.id);
-            return { content: [{ type: "text", text: `🗑️ Memory deleted: \`${parsed.data.id}\`` }] };
-        }
-        case "memory_insight": {
-            const parsed = InsightSchema.safeParse(args);
-            if (!parsed.success)
-                return { content: [{ type: "text", text: `${parsed.error.issues[0].message}` }], isError: true };
-            const { topic, depth = "standard" } = parsed.data;
-            const memLimit = depth === "deep" ? 15 : depth === "quick" ? 5 : 8;
-            // v3.25.1: hybrid retrieval for memory side (was semantic-only) so the
-            // intelligence report surfaces exact-token matches alongside meaning
-            // matches. Vault side runs in parallel as before - but only against
-            // Convex when the vault isn't local; a local vault's topic string must
-            // never leave the machine, and this never checked that before.
-            const localVault = (0, local_vault_js_1.getLocalVaultConfig)();
-            const [memResults, vaultData] = await Promise.all([
-                hybridMemorySearch(topic, memLimit),
-                localVault
-                    ? Promise.resolve((0, local_vault_js_1.localVaultSearch)(localVault, topic, { limit: 6 }))
-                    : (0, convex_js_1.callConvex)(`/vault/search?q=${encodeURIComponent(topic)}&limit=6`, "GET", undefined, "vault_search").catch(() => ({ results: [] })),
-            ]);
-            const vaultResults = vaultData.results ?? [];
-            const total = memResults.length + vaultResults.length;
-            if (!total) {
-                return {
-                    content: [{
-                            type: "text",
-                            text: [
-                                `🔮 **Intelligence Report: "${topic}"**`,
-                                ``,
-                                `No knowledge found yet.`,
-                                ``,
-                                `**Start building:**`,
-                                `• \`deep_research query: "${topic}" depth: "standard"\` - multi-agent research now`,
-                                `• \`memory_add content: "..." \` - add a manual note`,
-                                `• \`schedule_research topic: "${topic}"\` - recurring monitor that saves to vault`,
-                            ].join("\n"),
-                        }],
-                };
-            }
-            // Confidence tier
-            const confidence = total >= 10 ? "🟢 High" : total >= 4 ? "🟡 Medium" : "🔴 Low";
-            // Timeline from metadata timestamps
-            const timestamps = memResults.map(r => r.metadata?.addedAt).filter(Boolean);
-            const oldest = timestamps.length ? Math.min(...timestamps) : null;
-            const newest = timestamps.length ? Math.max(...timestamps) : null;
-            const daysSinceUpdate = newest ? Math.round((Date.now() - newest) / 86400000) : null;
-            // Knowledge summary lines
-            const memLines = memResults.slice(0, 6).map(r => {
-                const title = r.metadata?.title ?? r.content.slice(0, 70).replace(/\n/g, " ");
-                const score = r.score != null ? ` [${(r.score * 100).toFixed(0)}%]` : "";
-                return `  •${score} ${title}`;
-            });
-            const vaultLines = vaultResults.slice(0, 4).map((r) => `  • [vault/${r.type}] ${r.title} - v${r.version}`);
-            // Gap analysis
-            const gaps = [];
-            if (daysSinceUpdate !== null && daysSinceUpdate > 7) {
-                gaps.push(`Stale data - last update ${daysSinceUpdate} day${daysSinceUpdate !== 1 ? "s" : ""} ago`);
-            }
-            if (!vaultResults.some((r) => r.type === "research")) {
-                gaps.push("No formal research saved - only informal notes exist");
-            }
-            if (memResults.length < 3) {
-                gaps.push("Thin coverage - fewer than 3 semantic memories on this topic");
-            }
-            if (!vaultResults.some((r) => r.type === "execution")) {
-                gaps.push("No execution history - no trades or actions logged");
-            }
-            const lines = [
-                `🔮 **Intelligence Report: "${topic}"**`,
-                `Confidence: ${confidence} · ${memResults.length} semantic memories · ${vaultResults.length} vault entries`,
-                oldest ? `Coverage: ${new Date(oldest).toLocaleDateString("en-US")} – ${daysSinceUpdate === 0 ? "today" : daysSinceUpdate !== null ? `${daysSinceUpdate}d ago` : "unknown"}` : "",
-                ``,
-                `**What you know:**`,
-                ...memLines,
-                ...(vaultLines.length ? ["", "**Vault entries:**", ...vaultLines] : []),
-                ``,
-            ];
-            if (gaps.length) {
-                lines.push(`**⚠️ Knowledge gaps:**`);
-                gaps.forEach(g => lines.push(`  • ${g}`));
-                lines.push("");
-            }
-            lines.push(`**Suggested actions:**`);
-            if (gaps.some(g => g.includes("research") || g.includes("Stale"))) {
-                lines.push(`• \`deep_research query: "${topic}" depth: "standard"\` - refresh with multi-agent research`);
-            }
-            lines.push(`• \`memory_context topic: "${topic}"\` - inject full context into your next prompt`);
-            lines.push(`• \`schedule_research topic: "${topic}"\` - monitor this topic continuously`);
-            return { content: [{ type: "text", text: lines.filter(l => l !== undefined).join("\n") }] };
-        }
-        case "memory_extract": {
-            const parsed = ExtractSchema.safeParse(args);
-            if (!parsed.success)
-                return { content: [{ type: "text", text: `${parsed.error.issues[0].message}` }], isError: true };
-            const { text, facts, source = "extract" } = parsed.data;
-            // ── PASS 1: hand the text back with the extraction rubric ───────────
-            // Deciding what counts as a fact is judgement about *this user's*
-            // content - the caller has the conversation, the tool doesn't.
-            if (!facts) {
-                return {
-                    content: [{
-                            type: "text",
-                            text: [
-                                `📄 **Extract facts from this** (${text.length.toLocaleString()} chars)`,
-                                ``,
-                                `---`,
-                                text.slice(0, 20000) + (text.length > 20000 ? `\n\n…[truncated ${text.length - 20000} chars]` : ""),
-                                `---`,
-                                ``,
-                                `## Rules`,
-                                ``,
-                                `- One **atomic** fact per entry — independently true and independently searchable.`,
-                                `- Self-contained: "prefers Aerodrome over Uniswap on Base for stable pairs", not "prefers it".`,
-                                `- Keep facts, preferences and decisions. Drop pleasantries, restated questions and anything`,
-                                `  already obvious from the user's other memories.`,
-                                `- Preserve numbers, dates, addresses and names exactly. Never round or paraphrase them.`,
-                                `- Do not infer beyond the text. If it wasn't stated, it isn't a fact.`,
-                                `- 3-10 facts is typical. Fewer is fine — do not pad to hit a count.`,
-                                ``,
-                                `Then call \`memory_extract\` again with \`facts: ["…", "…"]\`${source !== "extract" ? ` and \`source: "${source}"\`` : ""} to store them.`,
-                            ].join("\n"),
-                        }],
-                };
-            }
-            // ── PASS 2: store each fact as its own memory ───────────────────────
-            const localExtractCfg = (0, local_memory_js_1.getLocalMemoryConfig)();
-            const metaFor = () => ({ source, addedAt: Date.now() });
-            const results = await Promise.allSettled(facts.map((fact) => localExtractCfg
-                ? (0, local_memory_js_1.localMemoryAdd)(localExtractCfg, fact, metaFor())
-                : (0, convex_js_1.callConvex)("/memory/add", "POST", { content: fact, metadata: metaFor() }, "memory_add")));
-            const saved = results.filter((r) => r.status === "fulfilled").length;
-            const failed = results.length - saved;
-            return {
-                content: [{
-                        type: "text",
-                        text: [
-                            `🧠 **Stored ${saved} of ${facts.length} facts**${failed ? ` — ${failed} failed` : ""}`,
-                            ``,
-                            ...facts.map((f, i) => `${results[i].status === "fulfilled" ? "✓" : "✗"} ${i + 1}. ${f}`),
-                            ``,
-                            failed
-                                ? `Failed writes are usually auth (\`finch login\`) or an unreachable local memory server.`
-                                : `All facts are now searchable via \`memory_search\`.`,
-                        ].join("\n"),
-                    }],
-            };
-        }
-        case "memory_consolidate": {
-            const parsed = ConsolidateSchema.safeParse(args);
-            if (!parsed.success)
-                return { content: [{ type: "text", text: `${parsed.error.issues[0].message}` }], isError: true };
-            const { topic, limit = 12, summary } = parsed.data;
-            const localConsolidateCfg = (0, local_memory_js_1.getLocalMemoryConfig)();
-            // ── PASS 2: save the caller's merged version ────────────────────────
-            if (summary) {
-                const meta = { title: `Consolidated: ${topic}`, source: "memory_consolidate", addedAt: Date.now() };
-                const saved = localConsolidateCfg
-                    ? await (0, local_memory_js_1.localMemoryAdd)(localConsolidateCfg, summary, meta).catch((err) => ({ error: err.message }))
-                    : await (0, convex_js_1.callConvex)("/memory/add", "POST", { content: summary, metadata: meta }, "memory_add").catch((err) => ({ error: err.message }));
-                if (saved?.error) {
-                    return { content: [{ type: "text", text: `Error saving consolidated memory: ${saved.error}` }], isError: true };
-                }
-                return {
-                    content: [{
-                            type: "text",
-                            text: [
-                                `🧠 **Consolidated "${topic}" saved** — ID: \`${saved?.id ?? "saved"}\``,
-                                `The source memories were left intact.`,
-                                ``,
-                                `Find it with \`memory_search query: "${topic}"\`.`,
-                            ].join("\n"),
-                        }],
-                };
-            }
-            // ── PASS 1: fetch every memory on the topic, numbered ───────────────
-            // Uses the same RRF-fused semantic+lexical retrieval as memory_search/
-            // memory_context - a plain single-source searchSupermemory() call here
-            // used to mean consolidation could miss memories only the lexical/BM25
-            // side would surface, while still claiming an exhaustive "N memories".
-            const rows = await hybridMemorySearch(topic, limit);
-            if (rows.length === 0) {
-                return { content: [{ type: "text", text: `No memories found for "${topic}" to consolidate.` }], isError: true };
-            }
-            const numbered = rows.map((r, i) => {
-                const title = r.metadata?.title ? `**${r.metadata.title}** — ` : "";
-                const when = r.metadata?.addedAt ? ` _(${new Date(r.metadata.addedAt).toISOString().slice(0, 10)})_` : "";
-                return `${i + 1}. ${title}${r.content.trim()}${when}`;
-            });
-            return {
-                content: [{
-                        type: "text",
-                        text: [
-                            `🧠 **${rows.length} memories on "${topic}"**`,
-                            ``,
-                            ...numbered,
-                            ``,
-                            `---`,
-                            ``,
-                            `## Merge them`,
-                            ``,
-                            `- Fold overlapping facts into one statement; drop verbatim duplicates.`,
-                            `- **Where two memories conflict, keep both and say which is newer** — dates are shown above.`,
-                            `  Silently dropping the older one destroys the record of a changed mind.`,
-                            `- Preserve every number, date, address and name exactly as written.`,
-                            `- Group by sub-theme if that makes the result easier to search later.`,
-                            `- Add nothing that isn't in the list above.`,
-                            ``,
-                            `Then call \`memory_consolidate\` again with \`topic: "${topic}"\` and \`summary: "<your merged text>"\` ` +
-                                `to save it. The ${rows.length} originals stay where they are.`,
-                        ].join("\n"),
-                    }],
-            };
-        }
-        // memory_publish was removed - it was broken two levels deep. The tool
-        // called POST /vault/save with isPublic/authorName fields that the
-        // handler silently dropped (only type/title/content/key/contentType/
-        // agentId/tags/commitMsg/metadata are forwarded to vault.saveEntry - see
-        // app/convex/http.ts), so `published` was never actually set true; the
-        // real publishEntry mutation (POST /vault/publish) existed but this tool
-        // never called it. And even a correctly-wired publish would have done
-        // nothing observable: nothing anywhere reads the `published` field for
-        // cross-user browsing - no /vault/community route (dangling comment
-        // only, same pattern as the other removed routes), no backend query for
-        // it, no "Memory Marketplace" page in app/src. The tool asked users to
-        // accept an "IRREVERSIBLE, PUBLIC" risk for a marketplace that doesn't
-        // exist at any layer. Re-add only alongside building the actual
-        // discovery path: a community-browse query + route + UI that reads
-        // `published: true` entries. vault_unpublish is left in place - it's a
-        // correct, harmless no-op until then.
-        default:
-            return null;
-    }
-}