@lotargo/memory_plugin 1.2.901 → 1.3.0

package/mcp-server/index.js

@@ -2,7 +2,34 @@
 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, projectKey, projectName, canonicalPath, listProjectStores } from "./memory.js";
+import { ensureDir, readMemory, readMemoryRaw, writeMemory, today, MEMORY_DIR, GLOBAL_KEY, scopeKey, projectKey, projectName, canonicalPath, listProjectStores, storeFilePath } from "./memory.js";
+import {
+  parseFactEntry,
+  factText,
+  factMeta,
+  withMeta,
+  nextFactId,
+  isKeepFact,
+  displayFact,
+  formatFactEntry,
+  matchesQuery,
+  matchesTags,
+  inDateRange,
+} from "./fact_format.js";
+import { readFile } from "node:fs/promises";
+import { join } from "node:path";
+
+// Resolve a fact reference (1-based number, metadata id, or text) to an index.
+function resolveFactIndex(entries, ref) {
+  const trimmed = String(ref || "").trim();
+  if (!trimmed) return -1;
+  const num = parseInt(trimmed, 10);
+  if (/^\d+$/.test(trimmed) && num >= 1 && num <= entries.length) return num - 1;
+  const idIdx = entries.findIndex((e) => factMeta(e).id === trimmed);
+  if (idIdx !== -1) return idIdx;
+  const textIdx = entries.findIndex((e) => factText(e).toLowerCase().includes(trimmed.toLowerCase()));
+  return textIdx;
+}
 
 const cliArgs = process.argv.slice(2);
 
@@ -32,6 +59,18 @@ const server = new McpServer({
   version: "1.0.0",
 });
 
+// Optional string/number that tolerates null (some tool-call layers fill omitted
+// optional args with null). Linking fields must NEVER be mandatory.
+const optStr = () => z.string().optional().nullable();
+const optNum = () => z.number().optional().nullable();
+const defStr = (fallback) =>
+  z
+    .string()
+    .nullish()
+    .transform((v) => (v === null || v === undefined || v === "" ? fallback : v));
+const defBool = (fallback) => z.boolean().nullish().transform((v) => (v === null || v === undefined ? fallback : v));
+const defNum = (fallback) => z.number().nullish().transform((v) => (v === null || v === undefined ? fallback : v));
+
 // --- Legacy Key-Value Memory Tools ---
 
 // --- Legacy Key-Value Memory Tools & Agent Graph Linking ---
@@ -42,27 +81,58 @@ server.registerTool(
     description:
       "Save an important, durable fact to memory. Only use for high-signal information " +
       "(name, goals, constraints, tech preferences, project conventions). " +
-      "Optionally link the fact to a Knowledge Base document or exact line range (docId, startLine, endLine). " +
+      "docId/startLine/endLine/relationType are OPTIONAL and only used to link the fact to a " +
+      "Knowledge Base document or line range; omit them when no linking is needed. " +
+      "ttl is OPTIONAL (e.g. '90d', '2w', '24h') — expired facts are shown with [EXPIRED] but not auto-deleted. " +
+      "keep=true protects the fact from forget deletion unless force=true. " +
+      "tags is OPTIONAL comma-separated text for filtering. " +
+      "supersedes is OPTIONAL: a number (from recall), id, or text of a fact this one replaces; " +
+      "the target is then marked [SUPERSEDED]. " +
       "Translate the fact into English and keep it concise. " +
       "scope: 'project' (default) or 'global'",
     inputSchema: z.object({
       fact: z.string().describe("The fact to remember, written in English"),
-      scope: z.string().default("project").describe("'project' (default) or 'global'"),
-      docId: z.string().optional().describe("Optional document ID, title, or path to link this fact to"),
-      startLine: z.number().optional().describe("Optional starting line number in target document"),
-      endLine: z.number().optional().describe("Optional ending line number in target document"),
-      relationType: z.string().default("LINKS_TO").describe("Relation type (e.g. 'RULES_FOR', 'IMPLEMENTS', 'REFERENCES')"),
+      scope: defStr("project").describe("'project' (default) or 'global'"),
+      docId: optStr().describe("Optional document ID, title, or path to link this fact to"),
+      startLine: optNum().describe("Optional starting line number in target document"),
+      endLine: optNum().describe("Optional ending line number in target document"),
+      relationType: defStr("LINKS_TO").describe("Relation type (e.g. 'RULES_FOR', 'IMPLEMENTS', 'REFERENCES')"),
+      ttl: optStr().describe("Optional time-to-live, e.g. '90d', '2w', '24h', '12m'"),
+      keep: defBool(false).describe("Protect the fact from forget deletion unless force=true"),
+      tags: optStr().describe("Optional comma-separated tags, e.g. 'pref,arch'"),
+      supersedes: optStr().describe("Optional number, id, or text of the fact this one replaces"),
     }),
   },
-  async ({ fact, scope, docId, startLine, endLine, relationType }) => {
+  async ({ fact, scope, docId, startLine, endLine, relationType, ttl, keep, tags, supersedes }) => {
     const key = scopeKey(scope, null, null);
     const entries = await readMemory(key);
     const factNormalized = fact.toLowerCase().trim();
-    if (!entries.some((e) => {
-      const idx = e.indexOf("] ");
-      return idx !== -1 && e.slice(idx + 2).toLowerCase().trim() === factNormalized;
-    })) {
-      entries.push(`- [${today()}] ${fact}`);
+    let duplicate = false;
+    if (entries.some((e) => factText(e).toLowerCase().trim() === factNormalized)) {
+      duplicate = true;
+    }
+
+    let supersededInfo = "";
+    if (!duplicate) {
+      const [date, time] = today().split(" ");
+      const meta = { ttl, tags };
+      if (keep) meta.keep = "1";
+      if (supersedes) {
+        const targetIdx = resolveFactIndex(entries, supersedes);
+        if (targetIdx !== -1) {
+          const newId = nextFactId(entries);
+          const targetMeta = factMeta(entries[targetIdx]);
+          const targetId = targetMeta.id || nextFactId(entries);
+          entries[targetIdx] = withMeta(entries[targetIdx], { id: targetId, supersededBy: newId });
+          meta.id = newId;
+          meta.supersedes = targetId;
+          supersededInfo = ` [superseded: "${factText(entries[targetIdx]).slice(0, 60)}"]`;
+        } else {
+          supersededInfo = " (note: supersedes target not found)";
+        }
+      }
+      if (!meta.id) meta.id = nextFactId(entries);
+      entries.push(formatFactEntry({ date, time, text: fact, meta }));
       await writeMemory(key, entries);
     }
 
@@ -85,7 +155,7 @@ server.registerTool(
       }
     }
 
-    return { content: [{ type: "text", text: `Memory updated${linkInfo}` }] };
+    return { content: [{ type: "text", text: `Memory updated${supersededInfo}${linkInfo}` }] };
   }
 );
 
@@ -95,20 +165,27 @@ server.registerTool(
     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.",
+      "Use project: '<directory path>' with scope 'project'/'all' to read facts of a specific project from any working directory. " +
+      "query filters by keyword (all space-separated terms must match). " +
+      "tags filters by comma-separated tags. since/until filter by date (YYYY-MM-DD, inclusive). " +
+      "Expired facts are shown with [EXPIRED], protected ones with [KEEP]. The response includes the store file paths.",
     inputSchema: z.object({
-      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')"),
+      scope: defStr("all").describe("'project', 'global', 'all', or 'list_projects'"),
+      project: optStr().describe("Directory path of the project to read facts from (e.g. 'F:/projects/plugins/memory')"),
+      query: optStr().describe("Optional keyword filter; all space-separated terms must match"),
+      tags: optStr().describe("Optional comma-separated tag filter (any match)"),
+      since: optStr().describe("Optional start date filter, YYYY-MM-DD (inclusive)"),
+      until: optStr().describe("Optional end date filter, YYYY-MM-DD (inclusive)"),
     }),
   },
-  async ({ scope, project }) => {
+  async ({ scope, project, query, tags, since, until }) => {
     const { getLinksForFact } = await import("./graph/knowledge_linker.js");
     const results = [];
 
-    const formatFactWithLinks = (factText, key) => {
-      let line = factText;
+    const formatFactWithLinks = (factLine, key) => {
+      let line = displayFact(factLine);
       try {
-        const links = getLinksForFact(key, factText);
+        const links = getLinksForFact(key, factText(factLine));
         if (links && links.length > 0) {
           const docStr = links
             .map((l) => {
@@ -122,6 +199,17 @@ server.registerTool(
       return line;
     };
 
+    const collect = (entries, key) => {
+      const matched = entries.filter(
+        (e) => matchesQuery(e, query) && matchesTags(e, tags) && inDateRange(e, since, until)
+      );
+      if (!matched.length) return;
+      if (results.length) results.push("");
+      results.push(`--- ${key === GLOBAL_KEY ? "Global" : `Project: ${key === target ? label : key}`} ---`);
+      matched.forEach((e, i) => results.push(`${i + 1}. ${formatFactWithLinks(e, key)}`));
+      results.push(`Store file: ${storeFilePath(key)}`);
+    };
+
     if (scope === "list_projects") {
       const stores = await listProjectStores();
       if (!stores.length) {
@@ -134,7 +222,7 @@ server.registerTool(
         content: [
           {
             type: "text",
-            text: `Project Memory Stores:\n${lines.join("\n")}\n\nUse recall(scope: "project", project: "<path>") to read a specific store.`,
+            text: `Project Memory Stores:\n${lines.join("\n")}\n\nUse recall(scope: "project", project: "<path>") to read a specific store.\n\nMemory dir: ${MEMORY_DIR}`,
           },
         ],
       };
@@ -143,21 +231,19 @@ server.registerTool(
     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) {
-        results.push("--- Global ---");
-        global.forEach((e, i) => results.push(`${i + 1}. ${formatFactWithLinks(e, GLOBAL_KEY)}`));
-      }
+      const global = await readMemory(GLOBAL_KEY);
+      collect(global, GLOBAL_KEY);
     }
     if (scope !== "global") {
-      const local = await readMemoryRaw(target);
-      if (local.length) {
-        if (results.length) results.push("");
-        results.push(`--- Project: ${label} ---`);
-        local.forEach((e, i) => results.push(`${i + 1}. ${formatFactWithLinks(e, target)}`));
-      }
+      const local = await readMemory(target);
+      collect(local, target);
     }
-    const text = results.length ? results.join("\n") : "Memory is empty.";
+    const filtered = Boolean(query || tags || since || until);
+    const text = results.length
+      ? `${results.join("\n")}\n\nMemory dir: ${MEMORY_DIR}`
+      : filtered
+        ? "No facts match the search."
+        : "Memory is empty.";
     return { content: [{ type: "text", text }] };
   }
 );
@@ -166,40 +252,143 @@ server.registerTool(
   "forget",
   {
     description:
-      "Delete a fact by number (from recall), by range (e.g. '3-30', inclusive), or by text search",
+      "Delete a fact by number (from recall), by range (e.g. '3-30', inclusive), or by text search. " +
+      "Protected facts (remember with keep=true) are skipped unless force=true.",
     inputSchema: z.object({
       query: z.string().describe("Number, range like '3-30', or text to search for"),
-      scope: z.string().default("project").describe("'project' (default) or 'global'"),
+      scope: defStr("project").describe("'project' (default) or 'global'"),
+      force: defBool(false).describe("Also delete protected (keep) facts"),
     }),
   },
-  async ({ query, scope }) => {
+  async ({ query, scope, force }) => {
     const key = scopeKey(scope, null, null);
     const entries = await readMemory(key);
     const rangeMatch = /^\s*(\d+)\s*-\s*(\d+)\s*$/.exec(query);
     const num = parseInt(query, 10);
-    let removed;
+    let indices = [];
     if (rangeMatch) {
       const from = parseInt(rangeMatch[1], 10);
       const to = parseInt(rangeMatch[2], 10);
       if (from > 0 && to >= from && to <= entries.length) {
-        removed = entries.splice(from - 1, to - from + 1);
+        for (let i = from - 1; i < to; i++) indices.push(i);
       }
     }
-    if (!removed && !isNaN(num) && num > 0 && num <= entries.length) {
-      removed = entries.splice(num - 1, 1);
+    if (!indices.length && !isNaN(num) && num > 0 && num <= entries.length) {
+      indices.push(num - 1);
     }
-    if (!removed) {
-      const filtered = entries.filter((e) => !e.toLowerCase().includes(query.toLowerCase()));
-      removed = entries.filter((e) => e.toLowerCase().includes(query.toLowerCase()));
-      entries.length = 0;
-      entries.push(...filtered);
+    if (!indices.length) {
+      const q = query.toLowerCase();
+      indices = entries.reduce((acc, e, i) => (e.toLowerCase().includes(q) ? acc.concat(i) : acc), []);
     }
-    await writeMemory(key, entries);
-    const text = removed.length ? "Memory updated" : "Not found.";
+    if (!indices.length) {
+      return { content: [{ type: "text", text: "Not found." }] };
+    }
+
+    const removable = indices.filter((i) => force || !isKeepFact(entries[i]));
+    const protectedCount = indices.length - removable.length;
+    if (removable.length) {
+      for (const i of removable.sort((a, b) => b - a)) entries.splice(i, 1);
+      await writeMemory(key, entries);
+    }
+    let text = removable.length ? "Memory updated" : "Nothing removed.";
+    if (protectedCount) text += ` (${protectedCount} protected fact(s) skipped; use force=true to override)`;
     return { content: [{ type: "text", text }] };
   }
 );
 
+server.registerTool(
+  "update_fact",
+  {
+    description:
+      "Update the text of an existing fact by number (from recall), id, or text match, " +
+      "preserving its original date and metadata. Linked Knowledge Base documents are re-pointed to the new text.",
+    inputSchema: z.object({
+      id: z.string().describe("Number (from recall), metadata id, or text of the fact to update"),
+      newText: z.string().describe("New fact text"),
+      scope: defStr("project").describe("'project' (default) or 'global'"),
+    }),
+  },
+  async ({ id, newText, scope }) => {
+    const key = scopeKey(scope, null, null);
+    const entries = await readMemory(key);
+    const idx = resolveFactIndex(entries, id);
+    if (idx === -1) throw new Error(`Fact not found: ${id}`);
+    const p = parseFactEntry(entries[idx]);
+    const oldText = p ? p.text : entries[idx];
+    const newLine = formatFactEntry({ date: p.date, time: p.time, text: newText, meta: p.meta });
+    entries[idx] = newLine;
+    await writeMemory(key, entries);
+
+    let linksUpdated = 0;
+    try {
+      const { getDatabase } = await import("./db/database.js");
+      const db = getDatabase();
+      const res = db
+        .prepare(
+          "UPDATE knowledge_links SET fact_text = ? WHERE fact_key = ? AND fact_text = ?"
+        )
+        .run(newText, key, oldText);
+      linksUpdated = res.changes;
+    } catch (e) {}
+
+    return {
+      content: [
+        { type: "text", text: `Fact updated${linksUpdated ? `, ${linksUpdated} doc link(s) updated` : ""}` },
+      ],
+    };
+  }
+);
+
+server.registerTool(
+  "memory_info",
+  {
+    description:
+      "Show memory storage paths (store file locations, MEMORY_DIR, SQLite DB), fact counts, " +
+      "Knowledge Base stats, and the installed package version.",
+    inputSchema: z.object({}),
+  },
+  async () => {
+    const dbPath = join(MEMORY_DIR, "storage", "memory.sqlite");
+    const globalFile = storeFilePath(GLOBAL_KEY);
+    const projectFile = storeFilePath(projectKey(null, null));
+
+    let version = "unknown";
+    try {
+      version = JSON.parse(await readFile(new URL("../package.json", import.meta.url), "utf-8")).version;
+    } catch (e) {}
+
+    let rag = {};
+    try {
+      const { getDatabase } = await import("./db/database.js");
+      const db = getDatabase();
+      rag.documents = db.prepare("SELECT COUNT(*) AS c FROM documents").get().c;
+      rag.sections = db.prepare("SELECT COUNT(*) AS c FROM sections").get().c;
+      rag.chunks = db.prepare("SELECT COUNT(*) AS c FROM micro_chunks").get().c;
+      rag.edges = db.prepare("SELECT COUNT(*) AS c FROM graph_edges").get().c;
+      rag.links = db.prepare("SELECT COUNT(*) AS c FROM knowledge_links").get().c;
+    } catch (e) {
+      rag.error = e.message;
+    }
+
+    const stores = await listProjectStores();
+    const lines = [
+      `Version: ${version}`,
+      `MEMORY_DIR: ${MEMORY_DIR}`,
+      `SQLite DB: ${dbPath}`,
+      `Global store: ${globalFile}`,
+      `Project store: ${projectFile}`,
+      `Project stores: ${stores.length}`,
+      `Facts (global): ${(await readMemoryRaw(GLOBAL_KEY)).length}`,
+      `Facts (project): ${(await readMemoryRaw(projectKey(null, null))).length}`,
+    ];
+    if (rag.error) lines.push(`RAG: unavailable (${rag.error})`);
+    else lines.push(
+      `RAG: ${rag.documents} doc(s), ${rag.sections} section(s), ${rag.chunks} chunk(s), ${rag.edges} edge(s), ${rag.links} memory link(s)`
+    );
+    return { content: [{ type: "text", text: lines.join("\n") }] };
+  }
+);
+
 server.registerTool(
   "link_knowledge",
   {
@@ -207,13 +396,13 @@ server.registerTool(
       "Explicitly link a Notebook memory fact to a Knowledge Base document, section, or line range. " +
       "Creates Agent-driven Graph Edges connecting memory to RAG documents.",
     inputSchema: z.object({
-      action: z.enum(["link", "list_links", "get_doc_links"]).default("link").describe("Action type"),
-      factText: z.string().optional().describe("Memory fact text or keyword"),
-      docId: z.string().optional().describe("Document ID, title, or file path"),
-      scope: z.string().default("project").describe("'project' (default) or 'global'"),
-      startLine: z.number().optional().describe("Starting line number in target document"),
-      endLine: z.number().optional().describe("Ending line number in target document"),
-      relationType: z.string().default("LINKS_TO").describe("Relation type (e.g. 'RULES_FOR', 'IMPLEMENTS', 'EXPLAINS')"),
+      action: z.enum(["link", "list_links", "get_doc_links"]).nullish().transform((v) => v || "link").describe("Action type"),
+      factText: optStr().describe("Memory fact text or keyword"),
+      docId: optStr().describe("Document ID, title, or file path"),
+      scope: defStr("project").describe("'project' (default) or 'global'"),
+      startLine: optNum().describe("Starting line number in target document"),
+      endLine: optNum().describe("Ending line number in target document"),
+      relationType: defStr("LINKS_TO").describe("Relation type (e.g. 'RULES_FOR', 'IMPLEMENTS', 'EXPLAINS')"),
     }),
   },
   async ({ action, factText, docId, scope, startLine, endLine, relationType }) => {
@@ -264,14 +453,15 @@ server.registerTool(
     description:
       "Ingest a document into the RAG knowledge base. " +
       "Accepts local file paths, web URLs, or raw Markdown/text content. " +
+      "For type='url' the page is fetched and its content is indexed (not just the URL). " +
       "Processes document through 3-tier hierarchy chunking (Big/Medium/Small), " +
       "computes dense vectors, and extracts GraphRAG code symbols.",
     inputSchema: z.object({
       content: z.string().describe("Raw text content, file path, or web URL"),
-      type: z.enum(["text", "file", "url"]).default("text").describe("Input content type"),
-      title: z.string().optional().describe("Document title"),
-      path: z.string().optional().describe("Original document file path"),
-      generateEmbeddings: z.boolean().default(true).describe("Compute dense vector embeddings"),
+      type: z.enum(["text", "file", "url"]).nullish().transform((v) => v || "text").describe("Input content type: 'text', 'file', or 'url' (url fetches the page content)"),
+      title: optStr().describe("Document title"),
+      path: optStr().describe("Original document file path"),
+      generateEmbeddings: defBool(true).describe("Compute dense vector embeddings"),
     }),
   },
   async ({ content, type, title, path, generateEmbeddings }) => {
@@ -313,15 +503,12 @@ server.registerTool(
       "Returns top-ranked candidate document sections with breadcrumbs, GraphRAG defined code symbols, and relevance scores.",
     inputSchema: z.object({
       query: z.string().describe("Search query in natural language or symbol name"),
-      limit: z.number().default(5).describe("Maximum number of sections to return"),
-      instruction: z
-        .string()
-        .optional()
-        .describe(
-          "Optional task-specific retrieval instruction shaping embedding focus (e.g. 'Retrieve code snippets', 'Find user preferences'). " +
-          "Recommended when using E5/BGE models for domain-specific queries."
-        ),
-      generateEmbeddings: z.boolean().default(true).describe("Use vector search alongside BM25"),
+      limit: defNum(5).describe("Maximum number of sections to return"),
+      instruction: optStr().describe(
+        "Optional task-specific retrieval instruction shaping embedding focus (e.g. 'Retrieve code snippets', 'Find user preferences'). " +
+        "Recommended when using E5/BGE models for domain-specific queries."
+      ),
+      generateEmbeddings: defBool(true).describe("Use vector search alongside BM25"),
     }),
   },
   async ({ query, limit, instruction, generateEmbeddings }) => {
@@ -374,8 +561,8 @@ server.registerTool(
       "Manage the RAG knowledge base: inspect stats, list documents, read full raw document, delete documents, or export/import snapshots.",
     inputSchema: z.object({
       action: z.enum(["stats", "list", "read_document", "delete", "export_snapshot", "import_snapshot"]).describe("Management action"),
-      docId: z.string().optional().describe("Document ID, title, or path (required for read_document and delete)"),
-      snapshotPath: z.string().optional().describe("File path for snapshot export/import"),
+      docId: optStr().describe("Document ID, title, or path (required for read_document and delete)"),
+      snapshotPath: optStr().describe("File path for snapshot export/import"),
     }),
   },
   async ({ action, docId, snapshotPath }) => {

package/mcp-server/ingest/normalizer.js

@@ -27,6 +27,48 @@ export function cleanHtml(html) {
   return cleaned;
 }
 
+// Fetch a web page and convert it to Markdown/text. Used by the 'url' ingestion type
+// so the RAG store gets the page CONTENT, not just the URL string.
+export async function fetchUrlContent(url) {
+  if (typeof url !== "string" || !/^https?:\/\//i.test(url.trim())) {
+    throw new Error(`Unsupported URL for ingestion: '${url}'. Only http/https URLs are supported.`);
+  }
+  let res;
+  try {
+    res = await fetch(url.trim(), {
+      headers: {
+        "User-Agent": "memory-agent-rag/1.0",
+        Accept: "text/html,application/xhtml+xml,application/json,text/plain,*/*",
+      },
+      redirect: "follow",
+      signal: AbortSignal.timeout(15000),
+    });
+  } catch (err) {
+    throw new Error(`Failed to fetch URL '${url}': ${err.message}`);
+  }
+  if (!res.ok) {
+    throw new Error(`Failed to fetch URL '${url}': HTTP ${res.status} ${res.statusText}`);
+  }
+  const raw = await res.text();
+  const contentType = (res.headers.get("content-type") || "").toLowerCase();
+  const looksLikeHtml = /<html|<body|<div|<article|<main|<!doctype/i.test(raw.slice(0, 4096));
+  let markdown;
+  if (contentType.includes("html") || looksLikeHtml) {
+    markdown = cleanHtml(raw);
+  } else if (contentType.includes("json") || /^[\[{]/.test(raw.trim())) {
+    try {
+      markdown = JSON.stringify(JSON.parse(raw), null, 2);
+    } catch {
+      markdown = raw.trim();
+    }
+  } else {
+    markdown = raw.trim();
+  }
+  const titleMatch = raw.match(/<title[^>]*>([\s\S]*?)<\/title>/i);
+  const title = titleMatch ? titleMatch[1].replace(/\s+/g, " ").trim() : null;
+  return { markdown, title: title || null, finalUrl: res.url || url.trim() };
+}
+
 export function extractTitle(markdown, fallbackName = "Untitled Document") {
   const h1Match = markdown.match(/^#\s+(.+)$/m);
   if (h1Match && h1Match[1].trim()) {

package/mcp-server/ingest/pipeline.js

@@ -1,7 +1,7 @@
 import { randomUUID } from "node:crypto";
 import { getDatabase, BLOBS_DIR } from "../db/database.js";
 import { saveBlob, deleteBlob } from "../storage/blob_store.js";
-import { normalizeContent } from "./normalizer.js";
+import { normalizeContent, fetchUrlContent } from "./normalizer.js";
 import { buildTripleHierarchy } from "./chunker.js";
 import { embedText, embedBatch, vectorToBuffer } from "../ml/model_manager.js";
 import { buildGraphEdges, saveGraphEdges } from "../graph/graph_extractor.js";
@@ -18,13 +18,26 @@ export async function ingestDocument({
 }) {
   const db = customDb || getDatabase();
 
-  const { markdown, title: docTitle, metadata } = normalizeContent({ content, type, path, title });
+  let effectiveType = type;
+  let effectivePath = path;
+  let effectiveTitle = title;
+
+  if (type === "url") {
+    const fetched = await fetchUrlContent(String(content));
+    content = fetched.markdown;
+    effectiveType = "text";
+    effectiveTitle = title || fetched.title;
+    effectivePath = path || fetched.finalUrl || content;
+  }
+
+  const { markdown, title: docTitle, metadata } = normalizeContent({ content, type: effectiveType, path: effectivePath, title: effectiveTitle });
+  if (type === "url") metadata.source_type = "url";
 
   const blobRes = await saveBlob(markdown, customBlobDir);
   const blobHash = blobRes.hash;
 
   const docId = `doc_${randomUUID().replace(/-/g, "").substring(0, 12)}`;
-  const docPath = path || `virtual://${type}/${docId}`;
+  const docPath = effectivePath || `virtual://${type}/${docId}`;
   const now = Date.now();
 
   const hierarchy = buildTripleHierarchy(markdown, docId, docTitle);
@@ -151,6 +164,14 @@ export async function deleteDocument(docIdOrPath, customDb = null, customBlobDir
 
   const microChunks = db.prepare("SELECT id FROM micro_chunks WHERE doc_id = ?").all(doc.id);
 
+  // Collect every id owned by this document so we can purge dangling graph edges
+  // (graph_edges has no FK constraints, so section/chunk/doc references would otherwise leak).
+  const ownedIds = [doc.id];
+  for (const table of ["sections", "medium_chunks", "micro_chunks"]) {
+    const rows = db.prepare(`SELECT id FROM ${table} WHERE doc_id = ?`).all(doc.id);
+    for (const r of rows) ownedIds.push(r.id);
+  }
+
   db.exec("BEGIN IMMEDIATE;");
   try {
     for (const mc of microChunks) {
@@ -159,7 +180,16 @@ export async function deleteDocument(docIdOrPath, customDb = null, customBlobDir
       } catch {}
     }
 
-    db.prepare("DELETE FROM graph_edges WHERE source_id = ? OR target_id = ?").run(doc.id, doc.id);
+    // Auto-clean Agent knowledge graph links pointing at this document.
+    db.prepare("DELETE FROM knowledge_links WHERE doc_id = ?").run(doc.id);
+
+    for (const id of ownedIds) {
+      // GLOB: '*' suffix is exact (unlike LIKE, '_' stays literal in ids like doc_xxx).
+      db.prepare(
+        "DELETE FROM graph_edges WHERE source_id = ? OR target_id = ? OR source_id GLOB ? OR target_id GLOB ?"
+      ).run(id, id, `${id}*`, `${id}*`);
+    }
+
     db.prepare("DELETE FROM documents WHERE id = ?").run(doc.id);
 
     db.exec("COMMIT;");
@@ -175,5 +205,5 @@ export async function deleteDocument(docIdOrPath, customDb = null, customBlobDir
     }
   }
 
-  return { deleted: true, docId: doc.id, title: doc.title };
+  return { deleted: true, docId: doc.id, title: doc.title, linksCleaned: true };
 }

package/mcp-server/memory.js

@@ -72,6 +72,10 @@ export function memoryFileName(key) {
   return basename(memoryPath(key));
 }
 
+export function storeFilePath(key) {
+  return memoryPath(key);
+}
+
 function parseMeta(content) {
   const m = content.match(/<!-- path: (.+?) -->/);
   return { path: m ? m[1].trim() : null };