@vheins/local-memory-mcp 0.18.13 → 0.19.1

package/dist/{chunk-BK2QIQXS.js → chunk-AKFMCVQ4.js}

@@ -1,131 +1,5 @@
-// src/mcp/capabilities.ts
-import { fileURLToPath as fileURLToPath2 } from "url";
-import path2 from "path";
-
-// src/mcp/prompts/loader.ts
-import fs from "fs";
-import path from "path";
-import { fileURLToPath } from "url";
-import matter from "gray-matter";
-var __filename = fileURLToPath(import.meta.url);
-var __dirname = path.dirname(__filename);
-function findPromptDir() {
-  const candidates = [
-    // Production if chunked into dist/
-    "./prompts",
-    // Production if inlined into dist/mcp/
-    "../prompts",
-    // Dev: /src/mcp/prompts/definitions (next to loader.ts)
-    "./definitions"
-  ].map((relPath) => path.resolve(__dirname, relPath));
-  for (const dir of candidates) {
-    if (fs.existsSync(dir)) {
-      const files = fs.readdirSync(dir);
-      if (files.some((f) => f.endsWith(".md"))) {
-        return dir;
-      }
-    }
-  }
-  return path.resolve(__dirname, "./definitions");
-}
-var PROMPT_DIR = findPromptDir();
-function listPromptFiles() {
-  if (!fs.existsSync(PROMPT_DIR)) return [];
-  return fs.readdirSync(PROMPT_DIR).filter((file) => file.endsWith(".md")).map((file) => file.replace(/\.md$/, "")).sort();
-}
-function loadPromptFromMarkdown(name) {
-  const filePath = path.join(PROMPT_DIR, `${name}.md`);
-  if (!fs.existsSync(filePath)) {
-    throw new Error(`Prompt file not found: ${filePath}`);
-  }
-  const fileContent = fs.readFileSync(filePath, "utf-8");
-  const { data, content } = matter(fileContent);
-  return {
-    name: data.name || name,
-    description: data.description || "",
-    arguments: data.arguments || [],
-    agent: data.agent,
-    content: content.trim()
-  };
-}
-function findServerInstructionsDir() {
-  const candidates = [
-    // Production if chunked into dist/
-    "./prompts/server",
-    // Production if inlined into dist/mcp/
-    "../prompts/server",
-    // Dev: /src/mcp/prompts/server (next to loader.ts)
-    "./server"
-  ].map((relPath) => path.resolve(__dirname, relPath));
-  for (const dir of candidates) {
-    if (fs.existsSync(dir)) {
-      const filePath = path.join(dir, "instructions.md");
-      if (fs.existsSync(filePath)) {
-        return dir;
-      }
-    }
-  }
-  return path.resolve(__dirname, "./server");
-}
-var SERVER_DIR = findServerInstructionsDir();
-function loadServerInstructions() {
-  const filePath = path.join(SERVER_DIR, "instructions.md");
-  if (!fs.existsSync(filePath)) {
-    throw new Error(`Server instructions file not found: ${filePath}`);
-  }
-  const fileContent = fs.readFileSync(filePath, "utf-8");
-  const { content } = matter(fileContent);
-  return content.trim();
-}
-
-// src/mcp/capabilities.ts
-var __dirname2 = path2.dirname(fileURLToPath2(import.meta.url));
-var pkgVersion = "0.1.0";
-if ("0.18.13") {
-  pkgVersion = "0.18.13";
-} else {
-  let searchDir = __dirname2;
-  for (let i = 0; i < 5; i++) {
-    const candidate = path2.join(searchDir, "package.json");
-    try {
-      if (fs.existsSync(candidate)) {
-        const pkg = JSON.parse(fs.readFileSync(candidate, "utf8"));
-        if (pkg.name === "@vheins/local-memory-mcp" && pkg.version) {
-          pkgVersion = pkg.version;
-          break;
-        }
-      }
-    } catch {
-    }
-    searchDir = path2.dirname(searchDir);
-  }
-}
-var MCP_PROTOCOL_VERSION = "2025-03-26";
-var SERVER_INSTRUCTIONS = loadServerInstructions();
-var CAPABILITIES = {
-  serverInfo: {
-    name: "local-memory-mcp",
-    version: pkgVersion,
-    instructions: SERVER_INSTRUCTIONS
-  },
-  capabilities: {
-    completions: {},
-    logging: {},
-    resources: {
-      subscribe: true,
-      listChanged: true
-    },
-    tools: {
-      listChanged: false
-    },
-    prompts: {
-      listChanged: true
-    }
-  }
-};
-
 // src/mcp/utils/logger.ts
-import fs2 from "fs";
+import fs from "fs";
 var LEVELS = {
   debug: 0,
   info: 1,
@@ -225,31 +99,17 @@ var logger = {
     log("emergency", message, context);
   }
 };
-function setLogLevel(level) {
-  const raw = level.toLowerCase();
-  const normalized = LEVEL_ALIASES[raw] || raw;
-  if (!(normalized in LEVELS)) {
-    const error = new Error(`Invalid log level: ${level}`);
-    error.code = -32602;
-    throw error;
-  }
-  currentLevel = normalized;
-  return currentLevel;
-}
-function getLogLevel() {
-  return currentLevel;
-}
 function addLogSink(sink) {
   sinks.add(sink);
   return () => sinks.delete(sink);
 }
 var LOG_LEVEL_VALUES = Object.keys(LEVELS);
 function createFileSink(logDir, maxFiles = 5) {
-  fs2.mkdirSync(logDir, { recursive: true });
-  const existing = fs2.readdirSync(logDir).filter((f) => f.startsWith("mcp-") && f.endsWith(".log")).sort();
+  fs.mkdirSync(logDir, { recursive: true });
+  const existing = fs.readdirSync(logDir).filter((f) => f.startsWith("mcp-") && f.endsWith(".log")).sort();
   while (existing.length >= maxFiles) {
     try {
-      fs2.unlinkSync(`${logDir}/${existing.shift()}`);
+      fs.unlinkSync(`${logDir}/${existing.shift()}`);
     } catch {
     }
   }
@@ -259,7 +119,7 @@ function createFileSink(logDir, maxFiles = 5) {
     const line = `${(/* @__PURE__ */ new Date()).toISOString()} [${payload.level.toUpperCase()}] [pid:${process.pid}] ${JSON.stringify(payload.data)}
 `;
     try {
-      fs2.appendFileSync(logFile, line);
+      fs.appendFileSync(logFile, line);
     } catch {
     }
   };
@@ -267,8 +127,8 @@ function createFileSink(logDir, maxFiles = 5) {
 
 // src/mcp/storage/sqlite.ts
 import Database from "better-sqlite3";
-import path4 from "path";
-import fs4 from "fs";
+import path2 from "path";
+import fs3 from "fs";
 import os from "os";
 
 // src/mcp/storage/migrations.ts
@@ -504,6 +364,50 @@ var MigrationManager = class {
       CREATE INDEX IF NOT EXISTS idx_claims_task_id ON claims(task_id);
       CREATE INDEX IF NOT EXISTS idx_claims_agent ON claims(agent);
       CREATE INDEX IF NOT EXISTS idx_claims_claimed_at ON claims(claimed_at);
+
+      CREATE TABLE IF NOT EXISTS entities (
+        name TEXT PRIMARY KEY,
+        type TEXT NOT NULL DEFAULT 'unknown',
+        description TEXT,
+        repo TEXT NOT NULL DEFAULT '',
+        owner TEXT NOT NULL DEFAULT '',
+        created_at TEXT NOT NULL,
+        updated_at TEXT NOT NULL
+      );
+
+      CREATE INDEX IF NOT EXISTS idx_entities_type ON entities(type);
+      CREATE INDEX IF NOT EXISTS idx_entities_repo ON entities(repo);
+
+      CREATE TABLE IF NOT EXISTS relations (
+        from_entity TEXT NOT NULL,
+        to_entity TEXT NOT NULL,
+        relation_type TEXT NOT NULL,
+        repo TEXT NOT NULL DEFAULT '',
+        owner TEXT NOT NULL DEFAULT '',
+        created_at TEXT NOT NULL,
+        PRIMARY KEY (from_entity, to_entity, relation_type),
+        FOREIGN KEY (from_entity) REFERENCES entities(name) ON DELETE CASCADE,
+        FOREIGN KEY (to_entity) REFERENCES entities(name) ON DELETE CASCADE
+      );
+
+      CREATE INDEX IF NOT EXISTS idx_relations_from ON relations(from_entity);
+      CREATE INDEX IF NOT EXISTS idx_relations_to ON relations(to_entity);
+      CREATE INDEX IF NOT EXISTS idx_relations_type ON relations(relation_type);
+      CREATE INDEX IF NOT EXISTS idx_relations_repo ON relations(repo);
+
+      CREATE TABLE IF NOT EXISTS observations (
+        id TEXT PRIMARY KEY,
+        entity_name TEXT NOT NULL,
+        observation TEXT NOT NULL,
+        repo TEXT NOT NULL DEFAULT '',
+        owner TEXT NOT NULL DEFAULT '',
+        created_at TEXT NOT NULL,
+        FOREIGN KEY (entity_name) REFERENCES entities(name) ON DELETE CASCADE
+      );
+
+      CREATE INDEX IF NOT EXISTS idx_observations_entity ON observations(entity_name);
+      CREATE INDEX IF NOT EXISTS idx_observations_repo ON observations(repo);
+      CREATE INDEX IF NOT EXISTS idx_observations_created_at ON observations(created_at);
     `);
     const columnsToAdd = [
       { name: "title", table: "memories", definition: "ALTER TABLE memories ADD COLUMN title TEXT" },
@@ -1561,7 +1465,7 @@ var MemoryEntity = class extends BaseEntity {
     );
   }
   listMemoriesForDashboard(options) {
-    let {
+    const {
       owner,
       repo,
       type,
@@ -1572,9 +1476,9 @@ var MemoryEntity = class extends BaseEntity {
       search,
       offset = 0,
       limit = 50,
-      sortBy = "created_at",
       sortOrder = "DESC"
     } = options;
+    let sortBy = options.sortBy ?? "created_at";
     const ALLOWED_SORT_COLUMNS = /* @__PURE__ */ new Set([
       "created_at",
       "updated_at",
@@ -3199,8 +3103,8 @@ var HandoffEntity = class extends BaseEntity {
 
 // src/mcp/storage/write-lock.ts
 import lockfile from "proper-lockfile";
-import path3 from "path";
-import fs3 from "fs";
+import path from "path";
+import fs2 from "fs";
 var LOCK_STALE_MS = 3e4;
 var LOCK_RETRY_DELAY_MS = 200;
 var LOCK_RETRY_COUNT = 250;
@@ -3209,9 +3113,9 @@ var WriteLock = class {
   locked = false;
   constructor(dbPath) {
     this.lockTarget = dbPath;
-    if (!fs3.existsSync(dbPath)) {
-      fs3.mkdirSync(path3.dirname(dbPath), { recursive: true });
-      fs3.writeFileSync(dbPath, "");
+    if (!fs2.existsSync(dbPath)) {
+      fs2.mkdirSync(path.dirname(dbPath), { recursive: true });
+      fs2.writeFileSync(dbPath, "");
     }
   }
   /**
@@ -3263,13 +3167,13 @@ var WriteLock = class {
 // src/mcp/storage/sqlite.ts
 function resolveDbPath() {
   if (process.env.MEMORY_DB_PATH) return process.env.MEMORY_DB_PATH;
-  const standardConfigDir = process.platform === "win32" ? path4.join(os.homedir(), ".local-memory-mcp") : process.platform === "darwin" ? path4.join(os.homedir(), "Library", "Application Support", "local-memory-mcp") : path4.join(os.homedir(), ".config", "local-memory-mcp");
-  const standardPath = path4.join(standardConfigDir, "memory.db");
-  if (fs4.existsSync(standardPath)) return standardPath;
-  const legacyPath = path4.join(os.homedir(), ".config", "local-memory-mcp", "memory.db");
-  if (fs4.existsSync(legacyPath)) return legacyPath;
-  const localCwdFile = path4.join(process.cwd(), "storage", "memory.db");
-  if (fs4.existsSync(localCwdFile)) return localCwdFile;
+  const standardConfigDir = process.platform === "win32" ? path2.join(os.homedir(), ".local-memory-mcp") : process.platform === "darwin" ? path2.join(os.homedir(), "Library", "Application Support", "local-memory-mcp") : path2.join(os.homedir(), ".config", "local-memory-mcp");
+  const standardPath = path2.join(standardConfigDir, "memory.db");
+  if (fs3.existsSync(standardPath)) return standardPath;
+  const legacyPath = path2.join(os.homedir(), ".config", "local-memory-mcp", "memory.db");
+  if (fs3.existsSync(legacyPath)) return legacyPath;
+  const localCwdFile = path2.join(process.cwd(), "storage", "memory.db");
+  if (fs3.existsSync(localCwdFile)) return localCwdFile;
   return standardPath;
 }
 var DB_PATH = resolveDbPath();
@@ -3292,9 +3196,9 @@ var SQLiteStore = class _SQLiteStore {
     const finalPath = dbPath ?? DB_PATH;
     this.dbPathInstance = finalPath;
     if (finalPath !== ":memory:") {
-      const dbDir = path4.dirname(finalPath);
-      if (!fs4.existsSync(dbDir)) {
-        fs4.mkdirSync(dbDir, { recursive: true });
+      const dbDir = path2.dirname(finalPath);
+      if (!fs3.existsSync(dbDir)) {
+        fs3.mkdirSync(dbDir, { recursive: true });
       }
     }
     this.db = new Database(finalPath);
@@ -3353,12 +3257,12 @@ var SQLiteStore = class _SQLiteStore {
    */
   _attemptRecovery(dbPath) {
     const backupPath = dbPath + ".backup";
-    if (fs4.existsSync(backupPath)) {
+    if (fs3.existsSync(backupPath)) {
       logger.warn("[SQLiteStore] Attempting recovery from backup", { backupPath });
       try {
         const corruptPath = `${dbPath}.corrupt_${(/* @__PURE__ */ new Date()).toISOString().replace(/[:.]/g, "").slice(0, 15)}`;
-        fs4.copyFileSync(dbPath, corruptPath);
-        fs4.copyFileSync(backupPath, dbPath);
+        fs3.copyFileSync(dbPath, corruptPath);
+        fs3.copyFileSync(backupPath, dbPath);
         logger.warn("[SQLiteStore] Recovery successful. Corrupt file saved to", { corruptPath });
       } catch (err) {
         logger.error("[SQLiteStore] Recovery failed", { error: String(err) });
@@ -3376,7 +3280,7 @@ var SQLiteStore = class _SQLiteStore {
     try {
       this.db.pragma("wal_checkpoint(PASSIVE)");
       const backupPath = this.dbPathInstance + ".backup";
-      fs4.copyFileSync(this.dbPathInstance, backupPath);
+      fs3.copyFileSync(this.dbPathInstance, backupPath);
     } catch (err) {
       logger.warn("[SQLiteStore] Backup failed", { error: String(err) });
     }
@@ -3499,8 +3403,8 @@ var RealVectorStore = class {
 };
 
 // src/mcp/session.ts
-import path5 from "path";
-import { fileURLToPath as fileURLToPath3 } from "url";
+import path3 from "path";
+import { fileURLToPath } from "url";
 function createSessionContext() {
   return {
     roots: [],
@@ -3512,60 +3416,13 @@ function createSessionContext() {
     supportsElicitationUrl: false
   };
 }
-function updateSessionFromInitialize(session, params) {
-  const capabilities = params?.capabilities || {};
-  session.clientInfo = params?.clientInfo;
-  session.clientCapabilities = capabilities;
-  session.supportsRoots = Boolean(capabilities.roots);
-  session.supportsSampling = Boolean(capabilities.sampling);
-  const sampling = capabilities.sampling;
-  session.supportsSamplingTools = Boolean(sampling?.tools);
-  session.supportsElicitation = Boolean(capabilities.elicitation);
-  session.supportsElicitationForm = supportsElicitationMode(capabilities.elicitation, "form");
-  session.supportsElicitationUrl = supportsElicitationMode(capabilities.elicitation, "url");
-}
-function supportsElicitationMode(capability, mode) {
-  if (!capability || typeof capability !== "object") {
-    return false;
-  }
-  const cap = capability;
-  if (mode === "form") {
-    return Object.keys(cap).length === 0 || typeof cap.form === "object";
-  }
-  return typeof cap.url === "object";
-}
-function updateSessionRoots(session, roots) {
-  const normalized = normalizeRoots(roots);
-  const previous = JSON.stringify(session.roots);
-  const next = JSON.stringify(normalized);
-  session.roots = normalized;
-  return previous !== next;
-}
-function normalizeRoots(roots) {
-  if (!Array.isArray(roots)) return [];
-  const seen = /* @__PURE__ */ new Set();
-  const normalized = [];
-  for (const root of roots) {
-    if (!root || typeof root !== "object") continue;
-    const r = root;
-    const uri = typeof r.uri === "string" ? r.uri : void 0;
-    const name = typeof r.name === "string" ? r.name : void 0;
-    if (!uri || seen.has(uri)) continue;
-    seen.add(uri);
-    normalized.push({ uri, name });
-  }
-  return normalized;
-}
-function extractRootsFromResult(result) {
-  return normalizeRoots(result?.roots);
-}
 function getFilesystemRoots(session) {
   if (!session) return [];
   const resolved = [];
   for (const root of session.roots) {
     if (!root.uri.startsWith("file://")) continue;
     try {
-      resolved.push(path5.resolve(fileURLToPath3(root.uri)));
+      resolved.push(path3.resolve(fileURLToPath(root.uri)));
     } catch {
     }
   }
@@ -3574,19 +3431,19 @@ function getFilesystemRoots(session) {
 function isPathWithinRoots(targetPath, session) {
   const roots = getFilesystemRoots(session);
   if (roots.length === 0) return true;
-  const normalizedTarget = path5.resolve(targetPath);
+  const normalizedTarget = path3.resolve(targetPath);
   return roots.some((rootPath) => {
-    const relative = path5.relative(rootPath, normalizedTarget);
-    return relative === "" || !relative.startsWith("..") && !path5.isAbsolute(relative);
+    const relative = path3.relative(rootPath, normalizedTarget);
+    return relative === "" || !relative.startsWith("..") && !path3.isAbsolute(relative);
   });
 }
 function findContainingRoot(targetPath, session) {
   const roots = getFilesystemRoots(session);
   if (roots.length === 0) return null;
-  const normalizedTarget = path5.resolve(targetPath);
+  const normalizedTarget = path3.resolve(targetPath);
   for (const rootPath of roots) {
-    const relative = path5.relative(rootPath, normalizedTarget);
-    if (relative === "" || !relative.startsWith("..") && !path5.isAbsolute(relative)) {
+    const relative = path3.relative(rootPath, normalizedTarget);
+    if (relative === "" || !relative.startsWith("..") && !path3.isAbsolute(relative)) {
       return rootPath;
     }
   }
@@ -3595,14 +3452,14 @@ function findContainingRoot(targetPath, session) {
 function inferRepoFromSession(session) {
   const roots = getFilesystemRoots(session);
   if (roots.length === 1) {
-    return path5.basename(roots[0]);
+    return path3.basename(roots[0]);
   }
   return void 0;
 }
 function inferOwnerFromSession(session) {
   const roots = getFilesystemRoots(session);
   if (roots.length === 1) {
-    const parts = roots[0].split(path5.sep).filter(Boolean);
+    const parts = roots[0].split(path3.sep).filter(Boolean);
     if (parts.length >= 2) {
       return parts[parts.length - 2];
     }
@@ -3610,6 +3467,82 @@ function inferOwnerFromSession(session) {
   return void 0;
 }
 
+// src/mcp/prompts/loader.ts
+import fs4 from "fs";
+import path4 from "path";
+import { fileURLToPath as fileURLToPath2 } from "url";
+import matter from "gray-matter";
+var __filename = fileURLToPath2(import.meta.url);
+var __dirname = path4.dirname(__filename);
+function findPromptDir() {
+  const candidates = [
+    // Production if chunked into dist/
+    "./prompts",
+    // Production if inlined into dist/mcp/
+    "../prompts",
+    // Dev: /src/mcp/prompts/definitions (next to loader.ts)
+    "./definitions"
+  ].map((relPath) => path4.resolve(__dirname, relPath));
+  for (const dir of candidates) {
+    if (fs4.existsSync(dir)) {
+      const files = fs4.readdirSync(dir);
+      if (files.some((f) => f.endsWith(".md"))) {
+        return dir;
+      }
+    }
+  }
+  return path4.resolve(__dirname, "./definitions");
+}
+var PROMPT_DIR = findPromptDir();
+function listPromptFiles() {
+  if (!fs4.existsSync(PROMPT_DIR)) return [];
+  return fs4.readdirSync(PROMPT_DIR).filter((file) => file.endsWith(".md")).map((file) => file.replace(/\.md$/, "")).sort();
+}
+function loadPromptFromMarkdown(name) {
+  const filePath = path4.join(PROMPT_DIR, `${name}.md`);
+  if (!fs4.existsSync(filePath)) {
+    throw new Error(`Prompt file not found: ${filePath}`);
+  }
+  const fileContent = fs4.readFileSync(filePath, "utf-8");
+  const { data, content } = matter(fileContent);
+  return {
+    name: data.name || name,
+    description: data.description || "",
+    arguments: data.arguments || [],
+    agent: data.agent,
+    content: content.trim()
+  };
+}
+function findServerInstructionsDir() {
+  const candidates = [
+    // Production if chunked into dist/
+    "./prompts/server",
+    // Production if inlined into dist/mcp/
+    "../prompts/server",
+    // Dev: /src/mcp/prompts/server (next to loader.ts)
+    "./server"
+  ].map((relPath) => path4.resolve(__dirname, relPath));
+  for (const dir of candidates) {
+    if (fs4.existsSync(dir)) {
+      const filePath = path4.join(dir, "instructions.md");
+      if (fs4.existsSync(filePath)) {
+        return dir;
+      }
+    }
+  }
+  return path4.resolve(__dirname, "./server");
+}
+var SERVER_DIR = findServerInstructionsDir();
+function loadServerInstructions() {
+  const filePath = path4.join(SERVER_DIR, "instructions.md");
+  if (!fs4.existsSync(filePath)) {
+    throw new Error(`Server instructions file not found: ${filePath}`);
+  }
+  const fileContent = fs4.readFileSync(filePath, "utf-8");
+  const { content } = matter(fileContent);
+  return content.trim();
+}
+
 // src/mcp/tools/definitions/memory.ts
 var MEMORY_TOOL_DEFINITIONS = [
   {
@@ -5595,180 +5528,640 @@ var STANDARD_TOOL_DEFINITIONS = [
   }
 ];
 
-// src/mcp/tools/definitions/index.ts
-var TOOL_DEFINITIONS = [
-  ...MEMORY_TOOL_DEFINITIONS,
-  ...TASK_TOOL_DEFINITIONS,
-  ...HANDOFF_TOOL_DEFINITIONS,
-  ...STANDARD_TOOL_DEFINITIONS
-];
-
-// src/mcp/utils/pagination.ts
-function encodeCursor(offset) {
-  return Buffer.from(String(offset), "utf8").toString("base64");
-}
-function decodeCursor(cursor) {
-  if (cursor === void 0 || cursor === null || cursor === "") {
-    return 0;
-  }
-  if (typeof cursor !== "string" || cursor.trim() === "") {
-    throw invalidPaginationParams("Invalid cursor");
-  }
-  let decoded;
-  try {
-    decoded = Buffer.from(cursor, "base64").toString("utf8");
-  } catch {
-    throw invalidPaginationParams("Invalid cursor");
-  }
-  if (!/^\d+$/.test(decoded)) {
-    throw invalidPaginationParams("Invalid cursor");
-  }
-  const offset = Number.parseInt(decoded, 10);
-  if (!Number.isFinite(offset) || offset < 0) {
-    throw invalidPaginationParams("Invalid cursor");
-  }
-  return offset;
-}
-function invalidPaginationParams(message) {
-  const error = new Error(message);
-  error.code = -32602;
-  return error;
-}
-
-// src/mcp/utils/completion.ts
-var MAX_COMPLETION_VALUES = 100;
-function rankCompletionValues(candidates, input) {
-  const unique = [...new Set(candidates.filter(Boolean))];
-  const needle = input.trim().toLowerCase();
-  if (!needle) {
-    return unique.slice(0, MAX_COMPLETION_VALUES);
-  }
-  return unique.map((value) => ({ value, score: scoreCompletionValue(value, needle) })).filter((entry) => entry.score > 0).sort((a, b) => b.score - a.score || a.value.localeCompare(b.value)).map((entry) => entry.value);
-}
-function scoreCompletionValue(value, needle) {
-  const haystack = value.toLowerCase();
-  if (haystack === needle) return 100;
-  if (haystack.startsWith(needle)) return 75;
-  if (haystack.includes(needle)) return 50;
-  const compactNeedle = needle.replace(/[\s_-]+/g, "");
-  const compactHaystack = haystack.replace(/[\s_-]+/g, "");
-  if (compactNeedle && compactHaystack.includes(compactNeedle)) return 25;
-  return 0;
-}
-
-// src/mcp/resources/index.ts
-var DEFAULT_PAGE_SIZE = 25;
-var MAX_PAGE_SIZE = 100;
-function listResources(session, params) {
-  const resources = [
-    {
-      uri: "repository://index",
-      name: "Repository Index",
-      title: "Repository Index",
-      description: "List of all known repositories with memory/task counts and last activity",
-      mimeType: "application/json",
-      annotations: {
-        audience: ["assistant"],
-        priority: 1,
-        lastModified: (/* @__PURE__ */ new Date()).toISOString()
-      }
+// src/mcp/tools/definitions/agent.ts
+var AGENT_TOOL_DEFINITIONS = [
+  {
+    name: "agent-context",
+    title: "Agent Context Recall",
+    description: "Returns relevant context for the current agent session. Auto-detects active repo, searches relevant memories, lists active tasks, and surfaces recent decisions formatted as a single context block ready for injection into agent prompts.",
+    annotations: {
+      readOnlyHint: true,
+      idempotentHint: true,
+      openWorldHint: false
     },
-    {
-      uri: "session://roots",
-      name: "Session Roots",
-      title: "Session Roots",
-      description: session?.roots.length ? "Active workspace roots provided by the MCP client" : "No active workspace roots were provided by the MCP client",
-      mimeType: "application/json",
-      size: Buffer.byteLength(JSON.stringify({ roots: session?.roots ?? [] }), "utf8"),
-      annotations: {
-        audience: ["assistant"],
-        priority: 0.95,
-        lastModified: (/* @__PURE__ */ new Date()).toISOString()
+    inputSchema: {
+      type: "object",
+      properties: {
+        owner: {
+          type: "string",
+          description: "Organization/namespace (e.g., GitHub org or username). Auto-detected from session when omitted."
+        },
+        repo: {
+          type: "string",
+          description: "Repository/project name. Auto-detected from session when omitted."
+        },
+        objective: {
+          type: "string",
+          description: "Current agent objective to search relevant memories around."
+        },
+        type_filter: {
+          type: "string",
+          description: "Memory type to filter by (e.g., 'decision', 'code_fact', 'pattern', 'mistake'). Default: all."
+        },
+        limit: {
+          type: "number",
+          minimum: 1,
+          maximum: 100,
+          default: 5,
+          description: "Maximum number of memories to return."
+        },
+        structured: {
+          type: "boolean",
+          default: false,
+          description: "If true, returns structured JSON results."
+        }
       }
+    },
+    outputSchema: {
+      type: "object",
+      properties: {
+        schema: { type: "string", enum: ["agent-context"] },
+        repo: { type: "string" },
+        objective: { type: "string" },
+        memories: {
+          type: "array",
+          items: {
+            type: "object",
+            properties: {
+              id: { type: "string" },
+              code: { type: "string" },
+              title: { type: "string" },
+              type: { type: "string" },
+              importance: { type: "number" }
+            }
+          }
+        },
+        decisions: {
+          type: "array",
+          items: {
+            type: "object",
+            properties: {
+              id: { type: "string" },
+              code: { type: "string" },
+              title: { type: "string" },
+              importance: { type: "number" }
+            }
+          }
+        },
+        tasks: {
+          type: "array",
+          items: {
+            type: "object",
+            properties: {
+              task_code: { type: "string" },
+              title: { type: "string" },
+              status: { type: "string" },
+              priority: { type: "number" }
+            }
+          }
+        }
+      },
+      required: ["schema", "repo", "memories", "decisions", "tasks"]
     }
-  ];
-  return paginateEntries("resources", resources, params);
-}
-function listResourceTemplates(params) {
-  const templates = [
-    // ── Memory ──────────────────────────────────────────────────────────────
-    {
-      uriTemplate: "repository://{name}/memories",
-      name: "Repository Memories",
-      title: "Repository Memories",
-      description: "All active memory entries for a specific repository",
-      mimeType: "application/json",
-      annotations: { audience: ["assistant"], priority: 0.85 }
+  },
+  {
+    name: "decision-log",
+    title: "Decision Logger",
+    description: "Logs a structured decision as a memory entry. Accepts a summary of what was decided, the context/situation, the rationale, and optional alternatives considered. Internally reuses the memory-store handler with type='decision' and importance=4. Owner and repo are auto-inferred from session when omitted.",
+    annotations: {
+      readOnlyHint: false,
+      idempotentHint: false,
+      openWorldHint: false
     },
-    {
-      uriTemplate: "repository://{name}/memories?search={search}&type={type}&tag={tag}",
-      name: "Filtered Repository Memories",
-      title: "Filtered Repository Memories",
-      description: "Filter or search memories within a repository by keyword, type, or tag",
-      mimeType: "application/json",
-      annotations: { audience: ["assistant"], priority: 0.8 }
+    inputSchema: {
+      type: "object",
+      properties: {
+        summary: {
+          type: "string",
+          description: "What was decided (used as the memory title). Max 255 characters."
+        },
+        context: {
+          type: "string",
+          description: "The situation or context surrounding the decision. Min 10 characters."
+        },
+        rationale: {
+          type: "string",
+          description: "Why this decision was made. Min 10 characters."
+        },
+        alternatives: {
+          type: "array",
+          items: { type: "string" },
+          description: "Alternatives that were considered (optional)."
+        },
+        tags: {
+          type: "array",
+          items: { type: "string" },
+          description: "Additional tags to apply (auto-includes 'decision')."
+        },
+        owner: {
+          type: "string",
+          description: "Organization/namespace. Auto-detected from session when omitted."
+        },
+        repo: {
+          type: "string",
+          description: "Repository/project name. Auto-detected from session when omitted."
+        },
+        structured: {
+          type: "boolean",
+          default: false,
+          description: "If true, returns structured JSON results."
+        }
+      },
+      required: ["summary", "context", "rationale"]
     },
-    {
-      uriTemplate: "memory://{id}",
-      name: "Memory Detail",
-      title: "Memory Detail",
-      description: "Full content and statistics for a specific memory UUID",
-      mimeType: "application/json",
-      annotations: { audience: ["assistant"], priority: 0.75 }
+    outputSchema: {
+      type: "object",
+      properties: {
+        success: { type: "boolean" },
+        id: { type: "string" },
+        code: { type: "string" },
+        repo: { type: "string" },
+        type: { type: "string", enum: ["decision"] },
+        title: { type: "string" }
+      }
+    }
+  },
+  {
+    name: "session-summarize",
+    title: "Session Summarizer",
+    description: "Persists a session summary as a task_archive memory entry. Accepts a session summary, optional key decisions made, optional next steps, and optional tags. Internally reuses the memory-store handler with type='task_archive' and importance=3. Owner and repo are auto-inferred from session when omitted.",
+    annotations: {
+      readOnlyHint: false,
+      idempotentHint: false,
+      openWorldHint: false
     },
-    // ── Tasks ────────────────────────────────────────────────────────────────
-    {
-      uriTemplate: "repository://{name}/tasks",
-      name: "Repository Tasks",
-      title: "Repository Tasks",
-      description: "All active tasks for a specific repository",
-      mimeType: "application/json",
-      annotations: { audience: ["assistant"], priority: 0.9 }
+    inputSchema: {
+      type: "object",
+      properties: {
+        summary: {
+          type: "string",
+          description: "Session summary text. Min 10 characters."
+        },
+        key_decisions: {
+          type: "array",
+          items: { type: "string" },
+          description: "Key decisions made during this session (optional)."
+        },
+        next_steps: {
+          type: "array",
+          items: { type: "string" },
+          description: "Next steps or follow-up actions (optional)."
+        },
+        tags: {
+          type: "array",
+          items: { type: "string" },
+          description: "Additional tags to apply (auto-includes 'session-summary')."
+        },
+        owner: {
+          type: "string",
+          description: "Organization/namespace. Auto-detected from session when omitted."
+        },
+        repo: {
+          type: "string",
+          description: "Repository/project name. Auto-detected from session when omitted."
+        },
+        structured: {
+          type: "boolean",
+          default: false,
+          description: "If true, returns structured JSON results."
+        }
+      },
+      required: ["summary"]
+    },
+    outputSchema: {
+      type: "object",
+      properties: {
+        success: { type: "boolean" },
+        id: { type: "string" },
+        code: { type: "string" },
+        repo: { type: "string" },
+        type: { type: "string", enum: ["task_archive"] },
+        title: { type: "string" }
+      }
+    }
+  },
+  // ── Upstream compatibility aliases ──────────────────────────────────────
+  {
+    name: "remember_fact",
+    title: "Remember Fact (Upstream)",
+    description: "Upstream-compatible alias for memory-store. Stores a single fact as a memory entry. Accepts the same arguments as memory-store. Owner and repo are auto-inferred from session when omitted.",
+    annotations: { readOnlyHint: false, idempotentHint: false, openWorldHint: false },
+    inputSchema: {
+      type: "object",
+      properties: {
+        owner: { type: "string", description: "Auto-detected from session." },
+        repo: { type: "string", description: "Auto-detected from session." },
+        title: { type: "string", description: "Title for the fact/memory." },
+        content: { type: "string", description: "The fact content to store." },
+        type: { type: "string", default: "code_fact" },
+        importance: { type: "number", default: 3 },
+        tags: { type: "array", items: { type: "string" } }
+      },
+      required: ["content"]
+    },
+    outputSchema: {
+      type: "object",
+      properties: { success: { type: "boolean" }, id: { type: "string" }, code: { type: "string" } }
+    }
+  },
+  {
+    name: "remember_facts",
+    title: "Remember Facts (Upstream Bulk)",
+    description: "Upstream-compatible alias for bulk memory-store. Stores multiple facts at once.",
+    annotations: { readOnlyHint: false, idempotentHint: false, openWorldHint: false },
+    inputSchema: {
+      type: "object",
+      properties: {
+        owner: { type: "string" },
+        repo: { type: "string" },
+        facts: { type: "array", items: { type: "object" }, description: "Array of fact objects." }
+      },
+      required: ["facts"]
+    },
+    outputSchema: { type: "object", properties: { success: { type: "boolean" }, count: { type: "number" } } }
+  },
+  {
+    name: "recall",
+    title: "Recall (Upstream)",
+    description: "Upstream-compatible alias for memory-search. Searches stored memories by query.",
+    annotations: { readOnlyHint: true, idempotentHint: true, openWorldHint: false },
+    inputSchema: {
+      type: "object",
+      properties: {
+        owner: { type: "string" },
+        repo: { type: "string" },
+        query: { type: "string", description: "Search query." },
+        type: { type: "string", description: "Filter by memory type." },
+        limit: { type: "number", default: 10 }
+      },
+      required: ["query"]
+    },
+    outputSchema: { type: "object", properties: { memories: { type: "array", items: { type: "object" } } } }
+  },
+  {
+    name: "forget",
+    title: "Forget (Upstream)",
+    description: "Upstream-compatible alias for memory-delete. Deletes a stored memory by id or code.",
+    annotations: { readOnlyHint: false, idempotentHint: false, destructiveHint: true, openWorldHint: true },
+    inputSchema: {
+      type: "object",
+      properties: {
+        owner: { type: "string" },
+        repo: { type: "string" },
+        id: { type: "string", description: "Memory ID to delete." },
+        code: { type: "string", description: "Memory code to delete." }
+      },
+      required: []
+    },
+    outputSchema: { type: "object", properties: { success: { type: "boolean" } } }
+  }
+];
+
+// src/mcp/tools/definitions/knowledge-graph.ts
+var KG_TOOL_DEFINITIONS = [
+  {
+    name: "create_entity",
+    title: "KG Create Entity",
+    description: "Creates a new knowledge graph entity. Entities represent nodes in the knowledge graph (e.g., concepts, people, systems). Name must be unique per repo. Owner and repo are auto-inferred from session when omitted.",
+    annotations: {
+      readOnlyHint: false,
+      idempotentHint: false,
+      destructiveHint: false,
+      openWorldHint: false
+    },
+    inputSchema: {
+      type: "object",
+      properties: {
+        name: {
+          type: "string",
+          description: "Unique entity name (acts as primary key per repo)."
+        },
+        type: {
+          type: "string",
+          default: "unknown",
+          description: "Entity type for categorization (e.g., 'person', 'system', 'concept')."
+        },
+        description: {
+          type: "string",
+          description: "Optional description of the entity."
+        },
+        owner: {
+          type: "string",
+          description: "Organization/namespace. Auto-detected from session when omitted."
+        },
+        repo: {
+          type: "string",
+          description: "Repository/project name. Auto-detected from session when omitted."
+        },
+        structured: {
+          type: "boolean",
+          default: false,
+          description: "If true, returns structured JSON results."
+        }
+      },
+      required: ["name"]
+    },
+    outputSchema: {
+      type: "object",
+      properties: {
+        success: { type: "boolean" },
+        entity: {
+          type: "object",
+          properties: {
+            name: { type: "string" },
+            type: { type: "string" },
+            description: { type: "string" },
+            repo: { type: "string" },
+            owner: { type: "string" }
+          }
+        }
+      }
+    }
+  },
+  {
+    name: "delete_entity",
+    title: "KG Delete Entity",
+    description: "Deletes a knowledge graph entity by name. All related relations and observations are automatically removed via CASCADE. Owner and repo are auto-inferred from session when omitted.",
+    annotations: {
+      readOnlyHint: false,
+      idempotentHint: false,
+      destructiveHint: true,
+      openWorldHint: false
+    },
+    inputSchema: {
+      type: "object",
+      properties: {
+        name: {
+          type: "string",
+          description: "Name of the entity to delete."
+        },
+        owner: {
+          type: "string",
+          description: "Organization/namespace. Auto-detected from session when omitted."
+        },
+        repo: {
+          type: "string",
+          description: "Repository/project name. Auto-detected from session when omitted."
+        },
+        structured: {
+          type: "boolean",
+          default: false,
+          description: "If true, returns structured JSON results."
+        }
+      },
+      required: ["name"]
+    },
+    outputSchema: {
+      type: "object",
+      properties: {
+        success: { type: "boolean" },
+        deletedCount: { type: "number" }
+      }
+    }
+  },
+  {
+    name: "create_relation",
+    title: "KG Create Relation",
+    description: "Creates a directed relation between two existing knowledge graph entities. Both from_entity and to_entity must already exist. The composite key (from_entity, to_entity, relation_type) must be unique. Owner and repo are auto-inferred from session when omitted.",
+    annotations: {
+      readOnlyHint: false,
+      idempotentHint: false,
+      destructiveHint: false,
+      openWorldHint: false
+    },
+    inputSchema: {
+      type: "object",
+      properties: {
+        from_entity: {
+          type: "string",
+          description: "Source entity name (must exist)."
+        },
+        to_entity: {
+          type: "string",
+          description: "Target entity name (must exist)."
+        },
+        relation_type: {
+          type: "string",
+          description: "Type of relation (e.g., 'depends_on', 'implements', 'part_of')."
+        },
+        owner: {
+          type: "string",
+          description: "Organization/namespace. Auto-detected from session when omitted."
+        },
+        repo: {
+          type: "string",
+          description: "Repository/project name. Auto-detected from session when omitted."
+        },
+        structured: {
+          type: "boolean",
+          default: false,
+          description: "If true, returns structured JSON results."
+        }
+      },
+      required: ["from_entity", "to_entity", "relation_type"]
+    },
+    outputSchema: {
+      type: "object",
+      properties: {
+        success: { type: "boolean" },
+        relation: {
+          type: "object",
+          properties: {
+            from_entity: { type: "string" },
+            to_entity: { type: "string" },
+            relation_type: { type: "string" }
+          }
+        }
+      }
+    }
+  },
+  {
+    name: "delete_relation",
+    title: "KG Delete Relation",
+    description: "Deletes a relation by its composite key (from_entity, to_entity, relation_type). Owner and repo are auto-inferred from session when omitted.",
+    annotations: {
+      readOnlyHint: false,
+      idempotentHint: false,
+      destructiveHint: true,
+      openWorldHint: false
     },
-    {
-      uriTemplate: "repository://{name}/tasks?status={status}&priority={priority}",
-      name: "Filtered Repository Tasks",
-      title: "Filtered Repository Tasks",
-      description: "Filter tasks within a repository by status or priority level",
-      mimeType: "application/json",
-      annotations: { audience: ["assistant"], priority: 0.85 }
+    inputSchema: {
+      type: "object",
+      properties: {
+        from_entity: {
+          type: "string",
+          description: "Source entity name."
+        },
+        to_entity: {
+          type: "string",
+          description: "Target entity name."
+        },
+        relation_type: {
+          type: "string",
+          description: "Relation type."
+        },
+        owner: {
+          type: "string",
+          description: "Organization/namespace. Auto-detected from session when omitted."
+        },
+        repo: {
+          type: "string",
+          description: "Repository/project name. Auto-detected from session when omitted."
+        },
+        structured: {
+          type: "boolean",
+          default: false,
+          description: "If true, returns structured JSON results."
+        }
+      },
+      required: ["from_entity", "to_entity", "relation_type"]
     },
-    {
-      uriTemplate: "task://{id}",
-      name: "Task Detail",
-      title: "Task Detail",
-      description: "Full content and comments for a specific task UUID",
-      mimeType: "application/json",
-      annotations: { audience: ["assistant"], priority: 0.8 }
+    outputSchema: {
+      type: "object",
+      properties: {
+        success: { type: "boolean" },
+        deletedCount: { type: "number" }
+      }
+    }
+  },
+  {
+    name: "delete_observation",
+    title: "KG Delete Observation",
+    description: "Deletes an observation by its ID. Observation IDs are UUIDs returned when observations are created. Owner and repo are auto-inferred from session when omitted.",
+    annotations: {
+      readOnlyHint: false,
+      idempotentHint: false,
+      destructiveHint: true,
+      openWorldHint: false
     },
-    // ── Repository extras ────────────────────────────────────────────────────
-    {
-      uriTemplate: "repository://{name}/summary",
-      name: "Repository Summary",
-      title: "Repository Summary",
-      description: "High-level architectural summary for a repository",
-      mimeType: "text/plain",
-      annotations: { audience: ["assistant"], priority: 0.95 }
+    inputSchema: {
+      type: "object",
+      properties: {
+        id: {
+          type: "string",
+          description: "UUID of the observation to delete."
+        },
+        owner: {
+          type: "string",
+          description: "Organization/namespace. Auto-detected from session when omitted."
+        },
+        repo: {
+          type: "string",
+          description: "Repository/project name. Auto-detected from session when omitted."
+        },
+        structured: {
+          type: "boolean",
+          default: false,
+          description: "If true, returns structured JSON results."
+        }
+      },
+      required: ["id"]
     },
+    outputSchema: {
+      type: "object",
+      properties: {
+        success: { type: "boolean" },
+        deletedCount: { type: "number" }
+      }
+    }
+  }
+];
+
+// src/mcp/tools/definitions/index.ts
+var TOOL_DEFINITIONS = [
+  ...MEMORY_TOOL_DEFINITIONS,
+  ...TASK_TOOL_DEFINITIONS,
+  ...HANDOFF_TOOL_DEFINITIONS,
+  ...STANDARD_TOOL_DEFINITIONS,
+  ...AGENT_TOOL_DEFINITIONS,
+  ...KG_TOOL_DEFINITIONS
+];
+
+// src/mcp/utils/completion.ts
+var MAX_COMPLETION_VALUES = 100;
+function rankCompletionValues(candidates, input) {
+  const unique = [...new Set(candidates.filter(Boolean))];
+  const needle = input.trim().toLowerCase();
+  if (!needle) {
+    return unique.slice(0, MAX_COMPLETION_VALUES);
+  }
+  return unique.map((value) => ({ value, score: scoreCompletionValue(value, needle) })).filter((entry) => entry.score > 0).sort((a, b) => b.score - a.score || a.value.localeCompare(b.value)).map((entry) => entry.value);
+}
+function scoreCompletionValue(value, needle) {
+  const haystack = value.toLowerCase();
+  if (haystack === needle) return 100;
+  if (haystack.startsWith(needle)) return 75;
+  if (haystack.includes(needle)) return 50;
+  const compactNeedle = needle.replace(/[\s_-]+/g, "");
+  const compactHaystack = haystack.replace(/[\s_-]+/g, "");
+  if (compactNeedle && compactHaystack.includes(compactNeedle)) return 25;
+  return 0;
+}
+
+// src/mcp/utils/pagination.ts
+function encodeCursor(offset) {
+  return Buffer.from(String(offset), "utf8").toString("base64");
+}
+function decodeCursor(cursor) {
+  if (cursor === void 0 || cursor === null || cursor === "") {
+    return 0;
+  }
+  if (typeof cursor !== "string" || cursor.trim() === "") {
+    throw invalidPaginationParams("Invalid cursor");
+  }
+  let decoded;
+  try {
+    decoded = Buffer.from(cursor, "base64").toString("utf8");
+  } catch {
+    throw invalidPaginationParams("Invalid cursor");
+  }
+  if (!/^\d+$/.test(decoded)) {
+    throw invalidPaginationParams("Invalid cursor");
+  }
+  const offset = Number.parseInt(decoded, 10);
+  if (!Number.isFinite(offset) || offset < 0) {
+    throw invalidPaginationParams("Invalid cursor");
+  }
+  return offset;
+}
+function invalidPaginationParams(message) {
+  const error = new Error(message);
+  error.code = -32602;
+  return error;
+}
+
+// src/mcp/resources/index.ts
+var DEFAULT_PAGE_SIZE = 25;
+var MAX_PAGE_SIZE = 100;
+function listResources(session, params) {
+  const resources = [
     {
-      uriTemplate: "repository://{name}/actions",
-      name: "Repository Actions",
-      title: "Repository Actions",
-      description: "Audit log of agent tool actions scoped to a repository",
+      uri: "repository://index",
+      name: "Repository Index",
+      title: "Repository Index",
+      description: "List of all known repositories with memory/task counts and last activity",
       mimeType: "application/json",
-      annotations: { audience: ["assistant"], priority: 0.6 }
+      annotations: {
+        audience: ["assistant"],
+        priority: 1,
+        lastModified: (/* @__PURE__ */ new Date()).toISOString()
+      }
     },
-    // ── Action detail ────────────────────────────────────────────────────────
     {
-      uriTemplate: "action://{id}",
-      name: "Action Detail",
-      title: "Action Detail",
-      description: "Full details of a specific audit log entry by integer ID",
+      uri: "session://roots",
+      name: "Session Roots",
+      title: "Session Roots",
+      description: session?.roots.length ? "Active workspace roots provided by the MCP client" : "No active workspace roots were provided by the MCP client",
       mimeType: "application/json",
-      annotations: { audience: ["assistant"], priority: 0.55 }
+      size: Buffer.byteLength(JSON.stringify({ roots: session?.roots ?? [] }), "utf8"),
+      annotations: {
+        audience: ["assistant"],
+        priority: 0.95,
+        lastModified: (/* @__PURE__ */ new Date()).toISOString()
+      }
     }
   ];
-  return paginateEntries("resourceTemplates", templates, params);
+  return paginateEntries("resources", resources, params);
 }
 function completeResourceArgument(resourceUri, argumentName, argumentValue, _contextArguments, dataSources) {
   if (resourceUri === "repository://{name}/memories" || resourceUri === "repository://{name}/memories?search={search}&type={type}&tag={tag}" || resourceUri === "repository://{name}/tasks" || resourceUri === "repository://{name}/tasks?status={status}&priority={priority}" || resourceUri === "repository://{name}/summary" || resourceUri === "repository://{name}/actions") {
@@ -5783,234 +6176,6 @@ function completeResourceArgument(resourceUri, argumentName, argumentValue, _con
   }
   throw invalidCompletionParams(`Unknown resource template or argument: ${resourceUri} (${argumentName})`);
 }
-function readResource(uri, db, session) {
-  logger.info("[Tool] resource.read", { uri });
-  if (uri === "repository://index") {
-    const repos = db.system.listRepoNavigation();
-    const payload = JSON.stringify(repos, null, 2);
-    return {
-      contents: [
-        {
-          uri,
-          mimeType: "application/json",
-          text: payload,
-          size: Buffer.byteLength(payload, "utf8"),
-          annotations: {
-            audience: ["assistant"],
-            priority: 1,
-            lastModified: (/* @__PURE__ */ new Date()).toISOString()
-          }
-        }
-      ]
-    };
-  }
-  if (uri === "session://roots") {
-    const payload = JSON.stringify({ roots: session?.roots ?? [] }, null, 2);
-    return {
-      contents: [
-        {
-          uri,
-          mimeType: "application/json",
-          text: payload,
-          size: Buffer.byteLength(payload, "utf8"),
-          annotations: {
-            audience: ["assistant"],
-            priority: 0.95,
-            lastModified: (/* @__PURE__ */ new Date()).toISOString()
-          }
-        }
-      ]
-    };
-  }
-  const memoryIdMatch = uri.match(/^memory:\/\/([0-9a-f-]{36})$/i);
-  if (memoryIdMatch) {
-    const id = memoryIdMatch[1];
-    const entry = db.memories.getByIdWithStats(id);
-    if (!entry) throw resourceNotFound(`Memory with ID ${id} not found.`, uri);
-    const payload = JSON.stringify(entry, null, 2);
-    return {
-      contents: [
-        {
-          uri,
-          mimeType: "application/json",
-          text: payload,
-          size: Buffer.byteLength(payload, "utf8"),
-          annotations: {
-            audience: ["assistant"],
-            priority: 0.75,
-            lastModified: entry.updated_at || entry.created_at
-          }
-        }
-      ]
-    };
-  }
-  const taskIdMatch = uri.match(/^task:\/\/([0-9a-f-]{36})$/i);
-  if (taskIdMatch) {
-    const id = taskIdMatch[1];
-    const task = db.tasks.getTaskById(id);
-    if (!task) throw resourceNotFound(`Task with ID ${id} not found.`, uri);
-    const payload = JSON.stringify(task, null, 2);
-    return {
-      contents: [
-        {
-          uri,
-          mimeType: "application/json",
-          text: payload,
-          size: Buffer.byteLength(payload, "utf8"),
-          annotations: {
-            audience: ["assistant"],
-            priority: 0.8,
-            lastModified: task.updated_at || task.created_at
-          }
-        }
-      ]
-    };
-  }
-  const repoBase = parseRepoUri(uri);
-  if (repoBase) {
-    const { name, path: repoPath, query } = repoBase;
-    if (repoPath === "summary") {
-      const summary = db.summaries.getSummary("", name);
-      const text = summary?.summary || `No summary available for repository: ${name}`;
-      return {
-        contents: [
-          {
-            uri,
-            mimeType: "text/plain",
-            text,
-            size: Buffer.byteLength(text, "utf8"),
-            annotations: {
-              audience: ["assistant"],
-              priority: 0.95,
-              lastModified: summary?.updated_at || (/* @__PURE__ */ new Date()).toISOString()
-            }
-          }
-        ]
-      };
-    }
-    if (repoPath === "memories") {
-      const search = query.get("search") || "";
-      const type = query.get("type");
-      const tag = query.get("tag");
-      const result = db.memories.listMemoriesForDashboard({
-        repo: name,
-        type: type || void 0,
-        tag: tag || void 0,
-        search: search || void 0,
-        limit: 50
-      });
-      const entries = result.items;
-      const payload = JSON.stringify(entries, null, 2);
-      return {
-        contents: [
-          {
-            uri,
-            mimeType: "application/json",
-            text: payload,
-            size: Buffer.byteLength(payload, "utf8"),
-            annotations: {
-              audience: ["assistant"],
-              priority: 0.85,
-              lastModified: deriveLastModifiedFromCollection(
-                entries.map((e) => e.updated_at || e.created_at)
-              )
-            }
-          }
-        ]
-      };
-    }
-    if (repoPath === "tasks") {
-      const status = query.get("status");
-      const priority = query.get("priority");
-      const owner = parseRepoInput(name).owner;
-      let tasks;
-      if (status && status !== "all") {
-        const statuses = status.split(",").map((s) => s.trim());
-        tasks = db.tasks.getTasksByMultipleStatuses(owner, name, statuses);
-      } else {
-        tasks = db.tasks.getTasksByMultipleStatuses(owner, name, ["backlog", "pending", "in_progress", "blocked"]);
-      }
-      if (priority) {
-        const p = Number(priority);
-        if (!isNaN(p)) {
-          tasks = tasks.filter((t) => t.priority === p);
-        }
-      }
-      const payload = JSON.stringify(tasks, null, 2);
-      return {
-        contents: [
-          {
-            uri,
-            mimeType: "application/json",
-            text: payload,
-            size: Buffer.byteLength(payload, "utf8"),
-            annotations: {
-              audience: ["assistant"],
-              priority: 0.9,
-              lastModified: deriveLastModifiedFromCollection(tasks.map((t) => t.updated_at))
-            }
-          }
-        ]
-      };
-    }
-    if (repoPath === "actions") {
-      const actions = db.actions.getRecentActions("", name, 100);
-      const payload = JSON.stringify(actions, null, 2);
-      return {
-        contents: [
-          {
-            uri,
-            mimeType: "application/json",
-            text: payload,
-            size: Buffer.byteLength(payload, "utf8"),
-            annotations: {
-              audience: ["assistant"],
-              priority: 0.6,
-              lastModified: deriveLastModifiedFromCollection(actions.map((a) => a.created_at))
-            }
-          }
-        ]
-      };
-    }
-  }
-  const actionIdMatch = uri.match(/^action:\/\/(\d+)$/);
-  if (actionIdMatch) {
-    const id = Number(actionIdMatch[1]);
-    const action = db.actions.getActionById(id);
-    if (!action) throw resourceNotFound(`Action with ID ${id} not found.`, uri);
-    const payload = JSON.stringify(action, null, 2);
-    return {
-      contents: [
-        {
-          uri,
-          mimeType: "application/json",
-          text: payload,
-          size: Buffer.byteLength(payload, "utf8"),
-          annotations: {
-            audience: ["assistant"],
-            priority: 0.55,
-            lastModified: action.created_at
-          }
-        }
-      ]
-    };
-  }
-  throw resourceNotFound(`Unknown resource URI: ${uri}`, uri);
-}
-function parseRepoUri(uri) {
-  const prefix = "repository://";
-  if (!uri.startsWith(prefix)) return null;
-  const rest = uri.slice(prefix.length);
-  const queryStart = rest.indexOf("?");
-  const withoutQuery = queryStart === -1 ? rest : rest.slice(0, queryStart);
-  const queryString = queryStart === -1 ? "" : rest.slice(queryStart + 1);
-  const slashIdx = withoutQuery.indexOf("/");
-  if (slashIdx === -1) return null;
-  const name = withoutQuery.slice(0, slashIdx);
-  const path6 = withoutQuery.slice(slashIdx + 1);
-  if (!name || !path6) return null;
-  return { name, path: path6, query: new URLSearchParams(queryString) };
-}
 function paginateEntries(key, entries, params) {
   const limit = normalizeLimit(params?.limit);
   const offset = decodeCursor(params?.cursor);
@@ -6027,16 +6192,6 @@ function normalizeLimit(limit) {
   }
   return Math.min(MAX_PAGE_SIZE, Math.max(1, Math.trunc(limit)));
 }
-function deriveLastModifiedFromCollection(values) {
-  const normalized = values.filter((value) => typeof value === "string" && value.length > 0);
-  return normalized.sort().at(-1) ?? (/* @__PURE__ */ new Date()).toISOString();
-}
-function resourceNotFound(message, uri) {
-  const error = new Error(message);
-  error.code = -32002;
-  error.data = { uri };
-  return error;
-}
 function invalidCompletionParams(message) {
   const error = new Error(message);
   error.code = -32602;
@@ -6070,51 +6225,6 @@ for (const name of promptFiles) {
     logger.warn(`Failed to load prompt ${name}: ${e}`);
   }
 }
-async function listPrompts(db, session, params) {
-  const allPrompts = Object.values(PROMPTS).map((p) => ({
-    name: p.name,
-    description: p.description,
-    arguments: p.arguments,
-    metadata: p.agent ? { agent: p.agent } : void 0
-  }));
-  const rawLimit = typeof params?.limit === "number" && Number.isInteger(params?.limit) ? params.limit : 50;
-  const limit = Math.max(1, Math.min(100, Math.trunc(rawLimit)));
-  const offset = decodeCursor(params?.cursor);
-  const sliced = allPrompts.slice(offset, offset + limit);
-  const nextOffset = offset + sliced.length;
-  return {
-    prompts: sliced,
-    nextCursor: nextOffset < allPrompts.length ? encodeCursor(nextOffset) : void 0
-  };
-}
-async function getPrompt(name, args = {}, db, session) {
-  const prompt = PROMPTS[name];
-  if (!prompt) {
-    throw new Error(`Prompt not found: ${name}`);
-  }
-  const inferredRepo = inferRepoFromSession(session);
-  const inferredOwner = inferOwnerFromSession(session);
-  const messages = prompt.messages.map((m) => {
-    let text = m.content.text;
-    for (const [key, value] of Object.entries(args)) {
-      text = text.replace(new RegExp(`\\{{${key}\\}}`, "g"), value);
-    }
-    text = text.replace(/{{current_repo}}/g, inferredRepo || "unknown-repo");
-    text = text.replace(/{{current_owner}}/g, inferredOwner || "unknown-owner");
-    return {
-      ...m,
-      content: {
-        ...m.content,
-        text
-      }
-    };
-  });
-  return {
-    description: prompt.description,
-    messages,
-    metadata: prompt.agent ? { agent: prompt.agent } : void 0
-  };
-}
 async function completePromptArgument(name, argName, value, contextArguments, dataSources) {
   void name;
   void contextArguments;
@@ -6757,6 +6867,75 @@ var StandardDetailSchema = z6.object({
   message: "Either id or code must be provided"
 });
 
+// src/mcp/tools/schemas/agent.ts
+import { z as z7 } from "zod";
+var AgentContextSchema = z7.object({
+  owner: z7.string().min(1),
+  repo: z7.string().min(1),
+  objective: z7.string().optional(),
+  type_filter: z7.enum(["code_fact", "decision", "mistake", "pattern", "task_archive"]).optional(),
+  limit: z7.number().min(1).max(100).default(5),
+  structured: z7.boolean().default(false)
+});
+var DecisionLogSchema = z7.object({
+  summary: z7.string().min(3).max(255, { message: "Summary must be at most 255 characters" }),
+  context: z7.string().min(10, { message: "Context must be at least 10 characters" }),
+  rationale: z7.string().min(10, { message: "Rationale must be at least 10 characters" }),
+  alternatives: z7.array(z7.string()).optional(),
+  tags: z7.array(z7.string()).optional(),
+  owner: z7.string().optional(),
+  repo: z7.string().optional(),
+  structured: z7.boolean().default(false)
+});
+var SessionSummarizeSchema = z7.object({
+  summary: z7.string().min(10, { message: "Summary must be at least 10 characters" }),
+  key_decisions: z7.array(z7.string()).optional(),
+  next_steps: z7.array(z7.string()).optional(),
+  tags: z7.array(z7.string()).optional(),
+  owner: z7.string().optional(),
+  repo: z7.string().optional(),
+  structured: z7.boolean().default(false)
+});
+
+// src/mcp/tools/schemas/knowledge-graph.ts
+import { z as z8 } from "zod";
+var CreateEntitySchema = z8.object({
+  name: z8.string().min(1).max(255),
+  type: z8.string().default("unknown"),
+  description: z8.string().optional(),
+  owner: z8.string().optional(),
+  repo: z8.string().optional(),
+  structured: z8.boolean().default(false)
+});
+var DeleteEntitySchema = z8.object({
+  name: z8.string().min(1),
+  owner: z8.string().optional(),
+  repo: z8.string().optional(),
+  structured: z8.boolean().default(false)
+});
+var CreateRelationSchema = z8.object({
+  from_entity: z8.string().min(1),
+  to_entity: z8.string().min(1),
+  relation_type: z8.string().min(1),
+  owner: z8.string().optional(),
+  repo: z8.string().optional(),
+  structured: z8.boolean().default(false)
+});
+var DeleteRelationSchema = z8.object({
+  from_entity: z8.string().min(1),
+  to_entity: z8.string().min(1),
+  relation_type: z8.string().min(1),
+  owner: z8.string().optional(),
+  repo: z8.string().optional(),
+  structured: z8.boolean().default(false)
+});
+var DeleteObservationSchema = z8.object({
+  id: z8.string().min(1),
+  owner: z8.string().optional(),
+  repo: z8.string().optional(),
+  structured: z8.boolean().default(false)
+});
+
 // src/mcp/tools/handoff.manage.ts
 function buildHandoffListSummary(repo, count, status, fromAgent, toAgent) {
   const parts = [`Found ${count} handoff${count === 1 ? "" : "s"} in repo "${repo}".`];
@@ -7057,37 +7236,27 @@ function buildStandardVectorText(standard) {
 }
 
 export {
-  MCP_PROTOCOL_VERSION,
-  CAPABILITIES,
   logger,
-  setLogLevel,
-  getLogLevel,
   addLogSink,
-  LOG_LEVEL_VALUES,
   createFileSink,
   parseRepoInput,
   normalizeRepo,
   SQLiteStore,
   RealVectorStore,
   TOOL_DEFINITIONS,
-  encodeCursor,
-  decodeCursor,
+  rankCompletionValues,
   listResources,
-  listResourceTemplates,
   completeResourceArgument,
-  readResource,
   createSessionContext,
-  updateSessionFromInitialize,
-  updateSessionRoots,
-  extractRootsFromResult,
   getFilesystemRoots,
   isPathWithinRoots,
   findContainingRoot,
   inferRepoFromSession,
   inferOwnerFromSession,
+  listPromptFiles,
+  loadPromptFromMarkdown,
+  loadServerInstructions,
   PROMPTS,
-  listPrompts,
-  getPrompt,
   completePromptArgument,
   createMcpResponse,
   getPrimaryTextContent,
@@ -7113,6 +7282,14 @@ export {
   StandardSearchSchema,
   StandardDeleteSchema,
   StandardDetailSchema,
+  AgentContextSchema,
+  DecisionLogSchema,
+  SessionSummarizeSchema,
+  CreateEntitySchema,
+  DeleteEntitySchema,
+  CreateRelationSchema,
+  DeleteRelationSchema,
+  DeleteObservationSchema,
   handleHandoffCreate,
   handleHandoffList,
   handleHandoffUpdate,