@vheins/local-memory-mcp 0.18.12 → 0.19.0

package/dist/{chunk-UWAZ66N5.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.12") {
-  pkgVersion = "0.18.12";
-} 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" },
@@ -672,7 +576,7 @@ var MigrationManager = class {
 			HAVING cnt > 1
 		`);
     if (dupRows.length > 0) {
-      console.log(`Found ${dupRows.length} duplicate task_code(s). Deduplicating by suffix...`);
+      logger.info(`Found ${dupRows.length} duplicate task_code(s). Deduplicating by suffix...`);
       for (const dup of dupRows) {
         const rows = this.all(
           `SELECT id, task_code, created_at FROM tasks
@@ -686,7 +590,7 @@ var MigrationManager = class {
           const newCode = `${dup.task_code}-${i + 1}`;
           this.run("UPDATE tasks SET task_code = ? WHERE id = ?", newCode, rows[i].id);
         }
-        console.log(`  Deduplicated ${dup.task_code}: kept 1 (${rows[0].id}), renamed ${rows.length - 1} rows`);
+        logger.info(`  Deduplicated ${dup.task_code}: kept 1 (${rows[0].id}), renamed ${rows.length - 1} rows`);
       }
     }
     this.exec(`CREATE UNIQUE INDEX IF NOT EXISTS idx_tasks_code_owner_repo ON tasks(owner, repo, task_code);`);
@@ -1323,7 +1227,7 @@ var MemoryEntity = class extends BaseEntity {
     let sql = "SELECT * FROM memories WHERE code = ?";
     const params = [code];
     if (owner && repo) {
-      sql += " AND owner = ? AND repo = ?";
+      sql += " AND ((owner = ? AND repo = ?) OR is_global = 1)";
       params.push(owner, repo);
     }
     const row = this.get(sql, params);
@@ -1523,9 +1427,11 @@ var MemoryEntity = class extends BaseEntity {
   incrementHitCounts(ids) {
     if (!ids || ids.length === 0) return;
     const now = (/* @__PURE__ */ new Date()).toISOString();
-    for (const id of ids) {
-      this.run("UPDATE memories SET hit_count = hit_count + 1, last_used_at = ? WHERE id = ?", [now, id]);
-    }
+    const placeholders = ids.map(() => "?").join(",");
+    this.run(`UPDATE memories SET hit_count = hit_count + 1, last_used_at = ? WHERE id IN (${placeholders})`, [
+      now,
+      ...ids
+    ]);
   }
   incrementRecallCount(id) {
     this.run("UPDATE memories SET recall_count = recall_count + 1, last_used_at = ? WHERE id = ?", [
@@ -1570,9 +1476,20 @@ 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",
+      "importance",
+      "hit_count",
+      "title",
+      "recall_rate"
+    ]);
+    if (!ALLOWED_SORT_COLUMNS.has(sortBy)) {
+      sortBy = "created_at";
+    }
     const where = ["1=1"];
     const params = [];
     if (owner) {
@@ -1616,7 +1533,7 @@ var MemoryEntity = class extends BaseEntity {
       ...this.rowToMemoryEntry(row),
       recall_rate: row.recall_rate || 0
     }));
-    return { items, memories: items, total, limit, offset };
+    return { items, total, limit, offset };
   }
 };
 
@@ -2479,34 +2396,45 @@ var SystemEntity = class extends BaseEntity {
     const pendingHandoffsByRepo = Object.fromEntries(pendingHandoffRows.map((row) => [row.repo, row.count]));
     const unassignedHandoffsByRepo = Object.fromEntries(unassignedHandoffRows.map((row) => [row.repo, row.count]));
     const staleClaimsByRepo = Object.fromEntries(staleClaimRows.map((row) => [row.repo, row.count]));
-    const repoOwnerFilter = owner ? " AND owner = ?" : "";
+    const ownerWhere = owner ? " WHERE owner = ?" : "";
+    const memoryCountRows = this.all(
+      `SELECT repo, COUNT(*) as count FROM memories${ownerWhere} GROUP BY repo`,
+      ownerParams
+    );
+    const memoryCountByRepo = Object.fromEntries(memoryCountRows.map((r) => [r.repo, r.count]));
+    const taskAggRows = this.all(
+      `SELECT repo, status, COUNT(*) as count FROM tasks${ownerWhere} GROUP BY repo, status`,
+      ownerParams
+    );
+    const taskCountsByRepo = {};
+    for (const row of taskAggRows) {
+      if (!taskCountsByRepo[row.repo]) {
+        taskCountsByRepo[row.repo] = { total: 0, byStatus: {} };
+      }
+      taskCountsByRepo[row.repo].total += row.count;
+      taskCountsByRepo[row.repo].byStatus[row.status] = row.count;
+    }
+    const lastActivityRows = this.all(
+      `SELECT repo, MAX(updated_at) as last FROM (
+				SELECT repo, updated_at FROM memories${ownerWhere}
+				UNION ALL
+				SELECT repo, updated_at FROM tasks${ownerWhere}
+			) GROUP BY repo`,
+      owner ? [owner, owner] : []
+    );
+    const lastActivityByRepo = Object.fromEntries(lastActivityRows.map((r) => [r.repo, r.last]));
     return repos.map((repo) => {
-      const memoryCountRow = this.get(
-        `SELECT COUNT(*) as count FROM memories WHERE repo = ?${repoOwnerFilter}`,
-        owner ? [repo, owner] : [repo]
-      );
-      const lastActivityRow = this.get(
-        `SELECT MAX(created_at) as last FROM (SELECT created_at FROM memories WHERE repo = ?${repoOwnerFilter} UNION ALL SELECT created_at FROM tasks WHERE repo = ?${repoOwnerFilter} UNION ALL SELECT created_at FROM action_log WHERE repo = ?${repoOwnerFilter})`,
-        owner ? [repo, owner, repo, owner, repo, owner] : [repo, repo, repo]
-      );
-      const taskStatusRows = this.all(
-        `SELECT status, COUNT(*) as count FROM tasks WHERE repo = ?${repoOwnerFilter} GROUP BY status`,
-        owner ? [repo, owner] : [repo]
-      );
-      const taskStatusMap = {};
-      taskStatusRows.forEach((r) => {
-        taskStatusMap[r.status] = r.count;
-      });
-      const taskCount = taskStatusRows.reduce((sum, r) => sum + r.count, 0);
+      const memCount = memoryCountByRepo[repo] ?? 0;
+      const taskInfo = taskCountsByRepo[repo] ?? { total: 0, byStatus: {} };
       return {
         repo,
-        memoryCount: memoryCountRow?.count ?? 0,
-        taskCount,
-        inProgressCount: taskStatusMap["in_progress"] ?? 0,
-        pendingCount: taskStatusMap["pending"] ?? 0,
-        blockedCount: taskStatusMap["blocked"] ?? 0,
-        backlogCount: taskStatusMap["backlog"] ?? 0,
-        lastActivity: lastActivityRow?.last ?? null,
+        memoryCount: memCount,
+        taskCount: taskInfo.total,
+        inProgressCount: taskInfo.byStatus["in_progress"] ?? 0,
+        pendingCount: taskInfo.byStatus["pending"] ?? 0,
+        blockedCount: taskInfo.byStatus["blocked"] ?? 0,
+        backlogCount: taskInfo.byStatus["backlog"] ?? 0,
+        lastActivity: lastActivityByRepo[repo] ?? null,
         activeClaims: activeClaimsByRepo[repo] ?? 0,
         pendingHandoffs: pendingHandoffsByRepo[repo] ?? 0,
         unassignedHandoffs: unassignedHandoffsByRepo[repo] ?? 0,
@@ -2766,7 +2694,7 @@ var StandardEntity = class extends BaseEntity {
     let sql = "SELECT * FROM coding_standards WHERE code = ?";
     const params = [code];
     if (owner && repo) {
-      sql += " AND owner = ? AND repo = ?";
+      sql += " AND ((owner = ? AND repo = ?) OR is_global = 1)";
       params.push(owner, repo);
     }
     const row = this.get(sql, params);
@@ -3175,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;
@@ -3185,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, "");
     }
   }
   /**
@@ -3239,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();
@@ -3268,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);
@@ -3329,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) });
@@ -3352,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) });
     }
@@ -3475,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: [],
@@ -3488,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 {
     }
   }
@@ -3550,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;
     }
   }
@@ -3571,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];
     }
@@ -3586,8 +3467,84 @@ function inferOwnerFromSession(session) {
   return void 0;
 }
 
-// src/mcp/tools/tool-definitions.ts
-var TOOL_DEFINITIONS = [
+// 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 = [
   {
     name: "memory-synthesize",
     title: "Memory Synthesize",
@@ -3640,60 +3597,6 @@ var TOOL_DEFINITIONS = [
       required: ["repo", "objective", "answer", "iterations", "toolCalls"]
     }
   },
-  {
-    name: "task-create-interactive",
-    title: "Interactive Task Create",
-    description: "Create a task with MCP elicitation fallback for any missing required fields. Best when an agent knows a task is needed but still needs user confirmation for repo, title, or phase.",
-    annotations: {
-      readOnlyHint: false,
-      idempotentHint: false,
-      destructiveHint: false,
-      openWorldHint: false
-    },
-    inputSchema: {
-      type: "object",
-      properties: {
-        owner: { type: "string", description: "Organization/namespace (e.g., GitHub org or username)" },
-        repo: {
-          type: "string",
-          description: "Repository name. Optional when it can be inferred from MCP roots or elicited from the user."
-        },
-        task_code: { type: "string" },
-        phase: { type: "string" },
-        title: { type: "string", minLength: 3, maxLength: 100 },
-        description: {
-          type: "string",
-          minLength: 1,
-          description: "Detailed description. MUST follow format: 1. Context & Analysis, 2. Step & Implementation, 3. Acceptance & Verification"
-        },
-        status: { type: "string", enum: ["backlog", "pending"], default: "backlog" },
-        priority: {
-          type: "number",
-          minimum: 1,
-          maximum: 5,
-          default: 3,
-          description: "Task priority where 1=Low, 2=Normal, 3=Medium, 4=High, 5=Critical."
-        },
-        agent: { type: "string" },
-        role: { type: "string" },
-        doc_path: { type: "string" },
-        structured: { type: "boolean", default: false, description: "If true, returns structured JSON result." }
-      },
-      required: ["owner"]
-    },
-    outputSchema: {
-      type: "object",
-      properties: {
-        repo: { type: "string" },
-        task_code: { type: "string" },
-        phase: { type: "string" },
-        title: { type: "string" },
-        status: { type: "string" },
-        priority: { type: "number" }
-      },
-      required: ["repo", "task_code", "phase", "title", "status", "priority"]
-    }
-  },
   {
     name: "memory-detail",
     title: "Memory Detail",
@@ -3723,100 +3626,15 @@ var TOOL_DEFINITIONS = [
     }
   },
   {
-    name: "standard-detail",
-    title: "Standard Detail",
-    description: "Fetch full details of a specific coding standard by ID or short code. Use after standard-search when a result is relevant and full guidance is needed.",
-    inputSchema: {
-      type: "object",
-      oneOf: [
-        {
-          title: "By ID",
-          required: ["id"],
-          properties: {
-            id: { type: "string", format: "uuid", description: "Coding standard ID." },
-            structured: { type: "boolean", default: false, description: "If true, returns structured JSON details." }
-          }
-        },
-        {
-          title: "By code",
-          required: ["code", "owner", "repo"],
-          properties: {
-            code: { type: "string", description: "Short standard code (e.g. 'A3KPQ2')." },
-            owner: { type: "string", description: "Organization/namespace (e.g., GitHub org or username)." },
-            repo: { type: "string", description: "Repository/project name." },
-            structured: { type: "boolean", default: false, description: "If true, returns structured JSON details." }
-          }
-        }
-      ]
-    }
-  },
-  {
-    name: "task-detail",
-    title: "Task Detail",
-    description: "Fetch full details of a specific task by ID or task code. Use this when you have a task ID or code and need to read the full description and comments.",
-    inputSchema: {
-      type: "object",
-      oneOf: [
-        {
-          title: "By ID",
-          required: ["owner", "repo", "id"],
-          properties: {
-            owner: { type: "string", description: "Organization/namespace (e.g., GitHub org or username)" },
-            repo: { type: "string", description: "Repository name" },
-            id: { type: "string", format: "uuid", description: "Task ID" },
-            structured: {
-              type: "boolean",
-              default: false,
-              description: "If true, returns structured JSON without the text content details."
-            }
-          }
-        },
-        {
-          title: "By task_code",
-          required: ["owner", "repo", "task_code"],
-          properties: {
-            owner: { type: "string", description: "Organization/namespace (e.g., GitHub org or username)" },
-            repo: { type: "string", description: "Repository name" },
-            task_code: { type: "string", description: "Task code (e.g. TASK-001)" },
-            structured: {
-              type: "boolean",
-              default: false,
-              description: "If true, returns structured JSON without the text content details."
-            }
-          }
-        },
-        {
-          title: "By task_codes",
-          required: ["owner", "repo", "task_codes"],
-          properties: {
-            owner: { type: "string", description: "Organization/namespace (e.g., GitHub org or username)" },
-            repo: { type: "string", description: "Repository name" },
-            task_codes: {
-              type: "array",
-              items: { type: "string" },
-              minItems: 1,
-              description: "Array of task codes (e.g. TASK-001)"
-            },
-            structured: {
-              type: "boolean",
-              default: false,
-              description: "If true, returns structured JSON without the text content details."
-            }
-          }
-        }
-      ]
-    }
-  },
-  {
-    name: "memory-store",
-    title: "Memory Store",
-    description: "Store a new durable knowledge entry. Do not store coordination state here: task claims, file claims, agent registration, and handoffs belong to task-claim, task-update, and handoff-* tools. Keep 'title' concise and human-readable; put auxiliary context into 'metadata'.",
-    annotations: {
-      readOnlyHint: false,
-      idempotentHint: false,
-      destructiveHint: false,
-      openWorldHint: false
-    },
+    name: "memory-store",
+    title: "Memory Store",
+    description: "Store a new durable knowledge entry. Do not store coordination state here: task claims, file claims, agent registration, and handoffs belong to task-claim, task-update, and handoff-* tools. Keep 'title' concise and human-readable; put auxiliary context into 'metadata'.",
+    annotations: {
+      readOnlyHint: false,
+      idempotentHint: false,
+      destructiveHint: false,
+      openWorldHint: false
+    },
     inputSchema: {
       type: "object",
       oneOf: [
@@ -4278,85 +4096,6 @@ var TOOL_DEFINITIONS = [
       required: ["success"]
     }
   },
-  {
-    name: "standard-delete",
-    title: "Standard Delete",
-    description: "Delete one or more coding standards. Supports single 'id' or bulk 'ids'.",
-    annotations: {
-      readOnlyHint: false,
-      idempotentHint: false,
-      destructiveHint: true,
-      openWorldHint: false
-    },
-    inputSchema: {
-      type: "object",
-      oneOf: [
-        {
-          title: "By single ID",
-          required: ["owner", "repo", "id"],
-          properties: {
-            owner: { type: "string", description: "Organization/namespace (e.g., GitHub org or username)" },
-            repo: { type: "string", description: "Repository name." },
-            id: { type: "string", format: "uuid", description: "Coding standard ID to delete." },
-            structured: { type: "boolean", default: false, description: "If true, returns structured JSON result." }
-          }
-        },
-        {
-          title: "By bulk IDs",
-          required: ["owner", "repo", "ids"],
-          properties: {
-            owner: { type: "string", description: "Organization/namespace (e.g., GitHub org or username)" },
-            repo: { type: "string", description: "Repository name." },
-            ids: {
-              type: "array",
-              items: { type: "string", format: "uuid" },
-              minItems: 1,
-              description: "Array of coding standard IDs to delete"
-            },
-            structured: { type: "boolean", default: false, description: "If true, returns structured JSON result." }
-          }
-        },
-        {
-          title: "By single code",
-          required: ["owner", "repo", "code"],
-          properties: {
-            owner: { type: "string", description: "Organization/namespace (e.g., GitHub org or username)" },
-            repo: { type: "string", description: "Repository name." },
-            code: { type: "string", maxLength: 20, description: "Short standard code." },
-            structured: { type: "boolean", default: false, description: "If true, returns structured JSON result." }
-          }
-        },
-        {
-          title: "By bulk codes",
-          required: ["owner", "repo", "codes"],
-          properties: {
-            owner: { type: "string", description: "Organization/namespace (e.g., GitHub org or username)" },
-            repo: { type: "string", description: "Repository name." },
-            codes: {
-              type: "array",
-              items: { type: "string", maxLength: 20 },
-              minItems: 1,
-              description: "Array of standard codes to delete"
-            },
-            structured: { type: "boolean", default: false, description: "If true, returns structured JSON result." }
-          }
-        }
-      ]
-    },
-    outputSchema: {
-      type: "object",
-      properties: {
-        success: { type: "boolean" },
-        id: { type: "string" },
-        code: { type: "string" },
-        ids: { type: "array", items: { type: "string" } },
-        codes: { type: "array", items: { type: "string" } },
-        repo: { type: "string" },
-        deletedCount: { type: "number" }
-      },
-      required: ["success"]
-    }
-  },
   {
     name: "memory-recap",
     title: "Memory Recap",
@@ -4430,39 +4169,38 @@ var TOOL_DEFINITIONS = [
       },
       required: ["schema", "repo", "count", "total", "offset", "limit", "stats", "top"]
     }
-  },
+  }
+];
+
+// src/mcp/tools/definitions/task.ts
+var TASK_TOOL_DEFINITIONS = [
   {
-    name: "task-create",
-    title: "Task Create",
-    description: "Register one or more new tasks in a repository. task_code must be unique within the repository. Supports single task object or an array of tasks for bulk creation.",
+    name: "task-create-interactive",
+    title: "Interactive Task Create",
+    description: "Create a task with MCP elicitation fallback for any missing required fields. Best when an agent knows a task is needed but still needs user confirmation for repo, title, or phase.",
     annotations: {
       readOnlyHint: false,
       idempotentHint: false,
+      destructiveHint: false,
       openWorldHint: false
     },
     inputSchema: {
       type: "object",
       properties: {
         owner: { type: "string", description: "Organization/namespace (e.g., GitHub org or username)" },
-        repo: { type: "string", description: "Repository/project name" },
-        task_code: { type: "string", description: "Unique task code (e.g. TASK-001) (Required for single task)" },
-        phase: { type: "string", description: "Project phase (Required for single task)" },
-        title: {
+        repo: {
           type: "string",
-          minLength: 3,
-          maxLength: 100,
-          description: "Task objective (Required for single task)"
+          description: "Repository name. Optional when it can be inferred from MCP roots or elicited from the user."
         },
+        task_code: { type: "string" },
+        phase: { type: "string" },
+        title: { type: "string", minLength: 3, maxLength: 100 },
         description: {
           type: "string",
+          minLength: 1,
           description: "Detailed description. MUST follow format: 1. Context & Analysis, 2. Step & Implementation, 3. Acceptance & Verification"
         },
-        status: {
-          type: "string",
-          enum: ["backlog", "pending"],
-          default: "backlog",
-          description: "New tasks MUST start in 'backlog' if there are already 10 pending tasks. Otherwise can start in 'pending'."
-        },
+        status: { type: "string", enum: ["backlog", "pending"], default: "backlog" },
         priority: {
           type: "number",
           minimum: 1,
@@ -4470,22 +4208,138 @@ var TOOL_DEFINITIONS = [
           default: 3,
           description: "Task priority where 1=Low, 2=Normal, 3=Medium, 4=High, 5=Critical."
         },
-        agent: { type: "string", description: "Agent assigned to this task" },
-        role: { type: "string", description: "Role of the assigned agent" },
-        doc_path: { type: "string", description: "Path to related documentation file" },
-        tags: { type: "array", items: { type: "string" }, description: "Tags for categorization" },
-        metadata: { type: "object", description: "Structured metadata for additional context" },
-        parent_id: {
-          type: "string",
-          description: "Optional parent task ID (UUID) or parent task code (e.g. TASK-001). Resolved to UUID before storing."
-        },
-        depends_on: {
-          type: "string",
-          description: "Optional task ID (UUID) or task code (e.g. TASK-001). Resolved to UUID before storing."
+        agent: { type: "string" },
+        role: { type: "string" },
+        doc_path: { type: "string" },
+        structured: { type: "boolean", default: false, description: "If true, returns structured JSON result." }
+      },
+      required: ["owner"]
+    },
+    outputSchema: {
+      type: "object",
+      properties: {
+        repo: { type: "string" },
+        task_code: { type: "string" },
+        phase: { type: "string" },
+        title: { type: "string" },
+        status: { type: "string" },
+        priority: { type: "number" }
+      },
+      required: ["repo", "task_code", "phase", "title", "status", "priority"]
+    }
+  },
+  {
+    name: "task-detail",
+    title: "Task Detail",
+    description: "Fetch full details of a specific task by ID or task code. Use this when you have a task ID or code and need to read the full description and comments.",
+    inputSchema: {
+      type: "object",
+      oneOf: [
+        {
+          title: "By ID",
+          required: ["owner", "repo", "id"],
+          properties: {
+            owner: { type: "string", description: "Organization/namespace (e.g., GitHub org or username)" },
+            repo: { type: "string", description: "Repository name" },
+            id: { type: "string", format: "uuid", description: "Task ID" },
+            structured: {
+              type: "boolean",
+              default: false,
+              description: "If true, returns structured JSON without the text content details."
+            }
+          }
         },
-        est_tokens: { type: "number", minimum: 0, description: "Estimated tokens budget for this task" },
-        tasks: {
-          type: "array",
+        {
+          title: "By task_code",
+          required: ["owner", "repo", "task_code"],
+          properties: {
+            owner: { type: "string", description: "Organization/namespace (e.g., GitHub org or username)" },
+            repo: { type: "string", description: "Repository name" },
+            task_code: { type: "string", description: "Task code (e.g. TASK-001)" },
+            structured: {
+              type: "boolean",
+              default: false,
+              description: "If true, returns structured JSON without the text content details."
+            }
+          }
+        },
+        {
+          title: "By task_codes",
+          required: ["owner", "repo", "task_codes"],
+          properties: {
+            owner: { type: "string", description: "Organization/namespace (e.g., GitHub org or username)" },
+            repo: { type: "string", description: "Repository name" },
+            task_codes: {
+              type: "array",
+              items: { type: "string" },
+              minItems: 1,
+              description: "Array of task codes (e.g. TASK-001)"
+            },
+            structured: {
+              type: "boolean",
+              default: false,
+              description: "If true, returns structured JSON without the text content details."
+            }
+          }
+        }
+      ]
+    }
+  },
+  {
+    name: "task-create",
+    title: "Task Create",
+    description: "Register one or more new tasks in a repository. task_code must be unique within the repository. Supports single task object or an array of tasks for bulk creation.",
+    annotations: {
+      readOnlyHint: false,
+      idempotentHint: false,
+      openWorldHint: false
+    },
+    inputSchema: {
+      type: "object",
+      properties: {
+        owner: { type: "string", description: "Organization/namespace (e.g., GitHub org or username)" },
+        repo: { type: "string", description: "Repository/project name" },
+        task_code: { type: "string", description: "Unique task code (e.g. TASK-001) (Required for single task)" },
+        phase: { type: "string", description: "Project phase (Required for single task)" },
+        title: {
+          type: "string",
+          minLength: 3,
+          maxLength: 100,
+          description: "Task objective (Required for single task)"
+        },
+        description: {
+          type: "string",
+          description: "Detailed description. MUST follow format: 1. Context & Analysis, 2. Step & Implementation, 3. Acceptance & Verification"
+        },
+        status: {
+          type: "string",
+          enum: ["backlog", "pending"],
+          default: "backlog",
+          description: "New tasks MUST start in 'backlog' if there are already 10 pending tasks. Otherwise can start in 'pending'."
+        },
+        priority: {
+          type: "number",
+          minimum: 1,
+          maximum: 5,
+          default: 3,
+          description: "Task priority where 1=Low, 2=Normal, 3=Medium, 4=High, 5=Critical."
+        },
+        agent: { type: "string", description: "Agent assigned to this task" },
+        role: { type: "string", description: "Role of the assigned agent" },
+        doc_path: { type: "string", description: "Path to related documentation file" },
+        tags: { type: "array", items: { type: "string" }, description: "Tags for categorization" },
+        metadata: { type: "object", description: "Structured metadata for additional context" },
+        parent_id: {
+          type: "string",
+          description: "Optional parent task ID (UUID) or parent task code (e.g. TASK-001). Resolved to UUID before storing."
+        },
+        depends_on: {
+          type: "string",
+          description: "Optional task ID (UUID) or task code (e.g. TASK-001). Resolved to UUID before storing."
+        },
+        est_tokens: { type: "number", minimum: 0, description: "Estimated tokens budget for this task" },
+        tasks: {
+          type: "array",
           items: {
             type: "object",
             properties: {
@@ -5047,7 +4901,11 @@ var TOOL_DEFINITIONS = [
       },
       required: ["schema", "query", "count", "total", "offset", "limit", "results"]
     }
-  },
+  }
+];
+
+// src/mcp/tools/definitions/handoff.ts
+var HANDOFF_TOOL_DEFINITIONS = [
   {
     name: "handoff-create",
     title: "Handoff Create",
@@ -5303,6 +5161,117 @@ var TOOL_DEFINITIONS = [
       },
       required: ["success", "repo", "task_id"]
     }
+  }
+];
+
+// src/mcp/tools/definitions/standard.ts
+var STANDARD_TOOL_DEFINITIONS = [
+  {
+    name: "standard-detail",
+    title: "Standard Detail",
+    description: "Fetch full details of a specific coding standard by ID or short code. Use after standard-search when a result is relevant and full guidance is needed.",
+    inputSchema: {
+      type: "object",
+      oneOf: [
+        {
+          title: "By ID",
+          required: ["id"],
+          properties: {
+            id: { type: "string", format: "uuid", description: "Coding standard ID." },
+            structured: { type: "boolean", default: false, description: "If true, returns structured JSON details." }
+          }
+        },
+        {
+          title: "By code",
+          required: ["code", "owner", "repo"],
+          properties: {
+            code: { type: "string", description: "Short standard code (e.g. 'A3KPQ2')." },
+            owner: { type: "string", description: "Organization/namespace (e.g., GitHub org or username)." },
+            repo: { type: "string", description: "Repository/project name." },
+            structured: { type: "boolean", default: false, description: "If true, returns structured JSON details." }
+          }
+        }
+      ]
+    }
+  },
+  {
+    name: "standard-delete",
+    title: "Standard Delete",
+    description: "Delete one or more coding standards. Supports single 'id' or bulk 'ids'.",
+    annotations: {
+      readOnlyHint: false,
+      idempotentHint: false,
+      destructiveHint: true,
+      openWorldHint: false
+    },
+    inputSchema: {
+      type: "object",
+      oneOf: [
+        {
+          title: "By single ID",
+          required: ["owner", "repo", "id"],
+          properties: {
+            owner: { type: "string", description: "Organization/namespace (e.g., GitHub org or username)" },
+            repo: { type: "string", description: "Repository name." },
+            id: { type: "string", format: "uuid", description: "Coding standard ID to delete." },
+            structured: { type: "boolean", default: false, description: "If true, returns structured JSON result." }
+          }
+        },
+        {
+          title: "By bulk IDs",
+          required: ["owner", "repo", "ids"],
+          properties: {
+            owner: { type: "string", description: "Organization/namespace (e.g., GitHub org or username)" },
+            repo: { type: "string", description: "Repository name." },
+            ids: {
+              type: "array",
+              items: { type: "string", format: "uuid" },
+              minItems: 1,
+              description: "Array of coding standard IDs to delete"
+            },
+            structured: { type: "boolean", default: false, description: "If true, returns structured JSON result." }
+          }
+        },
+        {
+          title: "By single code",
+          required: ["owner", "repo", "code"],
+          properties: {
+            owner: { type: "string", description: "Organization/namespace (e.g., GitHub org or username)" },
+            repo: { type: "string", description: "Repository name." },
+            code: { type: "string", maxLength: 20, description: "Short standard code." },
+            structured: { type: "boolean", default: false, description: "If true, returns structured JSON result." }
+          }
+        },
+        {
+          title: "By bulk codes",
+          required: ["owner", "repo", "codes"],
+          properties: {
+            owner: { type: "string", description: "Organization/namespace (e.g., GitHub org or username)" },
+            repo: { type: "string", description: "Repository name." },
+            codes: {
+              type: "array",
+              items: { type: "string", maxLength: 20 },
+              minItems: 1,
+              description: "Array of standard codes to delete"
+            },
+            structured: { type: "boolean", default: false, description: "If true, returns structured JSON result." }
+          }
+        }
+      ]
+    },
+    outputSchema: {
+      type: "object",
+      properties: {
+        success: { type: "boolean" },
+        id: { type: "string" },
+        code: { type: "string" },
+        ids: { type: "array", items: { type: "string" } },
+        codes: { type: "array", items: { type: "string" } },
+        repo: { type: "string" },
+        deletedCount: { type: "number" }
+      },
+      required: ["success"]
+    }
   },
   {
     name: "standard-store",
@@ -5483,82 +5452,652 @@ var TOOL_DEFINITIONS = [
             structured: { type: "boolean", default: false }
           }
         }
-      ]
+      ]
+    },
+    outputSchema: {
+      type: "object",
+      properties: {
+        success: { type: "boolean" },
+        id: { type: "string" },
+        updatedFields: { type: "array", items: { type: "string" } }
+      },
+      required: ["success", "id", "updatedFields"]
+    }
+  },
+  {
+    name: "standard-search",
+    title: "Standard Search",
+    description: "MANDATORY PRE-IMPLEMENTATION CHECK: Call before any code edit, test edit, refactor, migration, or implementation decision to find applicable coding standards. Returns a compact pointer table; use `standard-detail` for relevant results. If no relevant standards are returned, continue and state that no applicable standards were found.",
+    annotations: {
+      readOnlyHint: true,
+      idempotentHint: true,
+      openWorldHint: false
+    },
+    inputSchema: {
+      type: "object",
+      properties: {
+        query: { type: "string", description: "Search query (optional, searches title/content)" },
+        stack: {
+          type: "array",
+          items: { type: "string" },
+          description: "Technology stack to filter by (e.g., ['react', 'nextjs'])"
+        },
+        tags: {
+          type: "array",
+          items: { type: "string" },
+          description: "Tag filter"
+        },
+        language: { type: "string", description: "Programming language filter" },
+        context: { type: "string", description: "Context/category filter" },
+        version: { type: "string", description: "Version filter" },
+        repo: { type: "string", description: "Repository filter (optional)" },
+        is_global: { type: "boolean", description: "Filter by global/repo-specific" },
+        limit: { type: "number", minimum: 1, maximum: 100, default: 20 },
+        offset: { type: "number", minimum: 0, default: 0 },
+        structured: { type: "boolean", default: false }
+      },
+      required: []
+    },
+    outputSchema: {
+      type: "object",
+      properties: {
+        schema: { type: "string", enum: ["standard-search"] },
+        query: { type: "string" },
+        count: { type: "number", description: "Number of rows returned" },
+        total: { type: "number", description: "Total number of matches before pagination" },
+        offset: { type: "number" },
+        limit: { type: "number" },
+        results: {
+          type: "object",
+          properties: {
+            columns: {
+              type: "array",
+              items: { type: "string" }
+            },
+            rows: {
+              type: "array",
+              items: { type: "array" },
+              description: "Each row includes standard id and pointer metadata. Fetch full content via standard-detail."
+            }
+          },
+          required: ["columns", "rows"]
+        }
+      },
+      required: ["schema", "query", "count", "total", "offset", "limit", "results"]
+    }
+  }
+];
+
+// 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
+    },
+    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"]
+    }
+  },
+  {
+    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
+    },
+    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"]
+    },
+    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
+    },
+    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
+    },
+    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"]
     },
     outputSchema: {
       type: "object",
       properties: {
         success: { type: "boolean" },
-        id: { type: "string" },
-        updatedFields: { type: "array", items: { type: "string" } }
-      },
-      required: ["success", "id", "updatedFields"]
+        deletedCount: { type: "number" }
+      }
     }
   },
   {
-    name: "standard-search",
-    title: "Standard Search",
-    description: "MANDATORY PRE-IMPLEMENTATION CHECK: Call before any code edit, test edit, refactor, migration, or implementation decision to find applicable coding standards. Returns a compact pointer table; use `standard-detail` for relevant results. If no relevant standards are returned, continue and state that no applicable standards were found.",
+    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: true,
-      idempotentHint: true,
+      readOnlyHint: false,
+      idempotentHint: false,
+      destructiveHint: true,
       openWorldHint: false
     },
     inputSchema: {
       type: "object",
       properties: {
-        query: { type: "string", description: "Search query (optional, searches title/content)" },
-        stack: {
-          type: "array",
-          items: { type: "string" },
-          description: "Technology stack to filter by (e.g., ['react', 'nextjs'])"
+        id: {
+          type: "string",
+          description: "UUID of the observation to delete."
         },
-        tags: {
-          type: "array",
-          items: { type: "string" },
-          description: "Tag filter"
+        owner: {
+          type: "string",
+          description: "Organization/namespace. Auto-detected from session when omitted."
         },
-        language: { type: "string", description: "Programming language filter" },
-        context: { type: "string", description: "Context/category filter" },
-        version: { type: "string", description: "Version filter" },
-        repo: { type: "string", description: "Repository filter (optional)" },
-        is_global: { type: "boolean", description: "Filter by global/repo-specific" },
-        limit: { type: "number", minimum: 1, maximum: 100, default: 20 },
-        offset: { type: "number", minimum: 0, default: 0 },
-        structured: { type: "boolean", default: false }
+        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: []
+      required: ["id"]
     },
     outputSchema: {
       type: "object",
       properties: {
-        schema: { type: "string", enum: ["standard-search"] },
-        query: { type: "string" },
-        count: { type: "number", description: "Number of rows returned" },
-        total: { type: "number", description: "Total number of matches before pagination" },
-        offset: { type: "number" },
-        limit: { type: "number" },
-        results: {
-          type: "object",
-          properties: {
-            columns: {
-              type: "array",
-              items: { type: "string" }
-            },
-            rows: {
-              type: "array",
-              items: { type: "array" },
-              description: "Each row includes standard id and pointer metadata. Fetch full content via standard-detail."
-            }
-          },
-          required: ["columns", "rows"]
-        }
-      },
-      required: ["schema", "query", "count", "total", "offset", "limit", "results"]
+        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");
@@ -5591,27 +6130,6 @@ function invalidPaginationParams(message) {
   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;
@@ -5645,87 +6163,6 @@ function listResources(session, params) {
   ];
   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 }
-    },
-    {
-      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 }
-    },
-    {
-      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 }
-    },
-    // ── 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 }
-    },
-    {
-      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 }
-    },
-    {
-      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 }
-    },
-    // ── 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 }
-    },
-    {
-      uriTemplate: "repository://{name}/actions",
-      name: "Repository Actions",
-      title: "Repository Actions",
-      description: "Audit log of agent tool actions scoped to a repository",
-      mimeType: "application/json",
-      annotations: { audience: ["assistant"], priority: 0.6 }
-    },
-    // ── Action detail ────────────────────────────────────────────────────────
-    {
-      uriTemplate: "action://{id}",
-      name: "Action Detail",
-      title: "Action Detail",
-      description: "Full details of a specific audit log entry by integer ID",
-      mimeType: "application/json",
-      annotations: { audience: ["assistant"], priority: 0.55 }
-    }
-  ];
-  return paginateEntries("resourceTemplates", templates, 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") {
     if (argumentName === "name") {
@@ -5739,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);
@@ -5983,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;
@@ -6026,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;
@@ -6216,7 +6370,7 @@ var SingleMemorySchema = z2.object({
   ttlDays: z2.number().min(1).optional(),
   supersedes: z2.string().optional(),
   tags: z2.array(z2.string()).optional(),
-  metadata: z2.record(z2.string(), z2.any()).optional(),
+  metadata: z2.record(z2.string(), z2.unknown()).optional(),
   is_global: z2.boolean().default(false)
 });
 var SingleStandardSchema = z2.object({
@@ -6229,7 +6383,7 @@ var SingleStandardSchema = z2.object({
   stack: z2.array(z2.string()).optional(),
   is_global: z2.boolean().optional(),
   tags: z2.array(z2.string().min(1)).min(1),
-  metadata: z2.record(z2.string(), z2.any()).refine((value) => Object.keys(value).length > 0, {
+  metadata: z2.record(z2.string(), z2.unknown()).refine((value) => Object.keys(value).length > 0, {
     message: "metadata must contain at least one key"
   }),
   agent: z2.string().optional(),
@@ -6252,7 +6406,7 @@ var MemoryStoreSchema = z3.object({
   ttlDays: z3.number().min(1).optional(),
   supersedes: z3.string().optional(),
   tags: z3.array(z3.string()).optional(),
-  metadata: z3.record(z3.string(), z3.any()).optional(),
+  metadata: z3.record(z3.string(), z3.unknown()).optional(),
   is_global: z3.boolean().default(false),
   structured: z3.boolean().default(false),
   memories: z3.array(SingleMemorySchema).min(1).optional()
@@ -6279,7 +6433,7 @@ var MemoryUpdateSchema = z3.object({
   status: z3.enum(["active", "archived"]).optional(),
   supersedes: z3.string().optional(),
   tags: z3.array(z3.string()).optional(),
-  metadata: z3.record(z3.string(), z3.any()).optional(),
+  metadata: z3.record(z3.string(), z3.unknown()).optional(),
   is_global: z3.boolean().optional(),
   completed_at: z3.string().optional(),
   structured: z3.boolean().default(false)
@@ -6367,7 +6521,7 @@ var MemorySynthesizeSchema = z3.object({
 
 // src/mcp/tools/schemas/task.ts
 import { z as z4 } from "zod";
-var TaskMetadataSchema = z4.record(z4.string(), z4.any()).optional().superRefine((metadata, ctx) => {
+var TaskMetadataSchema = z4.record(z4.string(), z4.unknown()).optional().superRefine((metadata, ctx) => {
   if (!metadata) return;
   if (metadata.required_skills !== void 0) {
     if (!Array.isArray(metadata.required_skills)) {
@@ -6453,7 +6607,7 @@ var TaskCreateSchema = z4.object({
   doc_path: z4.string().optional(),
   tags: z4.array(z4.string()).optional(),
   suggested_skills: z4.array(z4.string()).optional(),
-  metadata: z4.record(z4.string(), z4.any()).optional(),
+  metadata: z4.record(z4.string(), z4.unknown()).optional(),
   parent_id: z4.string().optional(),
   depends_on: z4.string().optional(),
   est_tokens: z4.number().int().min(0).optional(),
@@ -6490,7 +6644,7 @@ var TaskUpdateSchema = z4.object({
   comment: z4.string().min(1).optional(),
   doc_path: z4.string().optional(),
   tags: z4.array(z4.string()).optional(),
-  metadata: z4.record(z4.string(), z4.any()).optional(),
+  metadata: z4.record(z4.string(), z4.unknown()).optional(),
   suggested_skills: z4.array(z4.string()).optional(),
   parent_id: z4.string().optional(),
   depends_on: z4.string().optional(),
@@ -6559,7 +6713,7 @@ var HandoffCreateSchema = z5.object({
   task_id: z5.string().uuid().optional(),
   task_code: z5.string().optional(),
   summary: z5.string().min(1),
-  context: z5.record(z5.string(), z5.any()).optional(),
+  context: z5.record(z5.string(), z5.unknown()).optional(),
   expires_at: z5.string().optional(),
   structured: z5.boolean().default(false)
 }).refine((data) => !(data.task_id && data.task_code), {
@@ -6592,7 +6746,7 @@ var TaskClaimSchema = z5.object({
   task_code: z5.string().optional(),
   agent: z5.string().min(1),
   role: z5.string().optional(),
-  metadata: z5.record(z5.string(), z5.any()).optional(),
+  metadata: z5.record(z5.string(), z5.unknown()).optional(),
   structured: z5.boolean().default(false)
 }).refine((data) => data.task_id !== void 0 || data.task_code !== void 0, {
   message: "Either task_id or task_code must be provided"
@@ -6635,7 +6789,7 @@ var StandardStoreSchema = z6.object({
   repo: z6.string().transform(normalizeRepo).optional(),
   is_global: z6.boolean().optional(),
   tags: z6.array(z6.string().min(1)).min(1).optional(),
-  metadata: z6.record(z6.string(), z6.any()).refine((value) => Object.keys(value).length > 0, { message: "metadata must contain at least one key" }).optional(),
+  metadata: z6.record(z6.string(), z6.unknown()).refine((value) => Object.keys(value).length > 0, { message: "metadata must contain at least one key" }).optional(),
   agent: z6.string().optional(),
   model: z6.string().optional(),
   structured: z6.boolean().default(false),
@@ -6663,7 +6817,7 @@ var StandardUpdateSchema = z6.object({
   repo: z6.string().transform(normalizeRepo),
   is_global: z6.boolean().optional(),
   tags: z6.array(z6.string().min(1)).min(1).optional(),
-  metadata: z6.record(z6.string(), z6.any()).refine((value) => Object.keys(value).length > 0, { message: "metadata must contain at least one key" }).optional(),
+  metadata: z6.record(z6.string(), z6.unknown()).refine((value) => Object.keys(value).length > 0, { message: "metadata must contain at least one key" }).optional(),
   agent: z6.string().optional(),
   model: z6.string().optional(),
   structured: z6.boolean().default(false)
@@ -6713,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}".`];
@@ -7013,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,
@@ -7069,6 +7282,14 @@ export {
   StandardSearchSchema,
   StandardDeleteSchema,
   StandardDetailSchema,
+  AgentContextSchema,
+  DecisionLogSchema,
+  SessionSummarizeSchema,
+  CreateEntitySchema,
+  DeleteEntitySchema,
+  CreateRelationSchema,
+  DeleteRelationSchema,
+  DeleteObservationSchema,
   handleHandoffCreate,
   handleHandoffList,
   handleHandoffUpdate,