@vheins/local-memory-mcp 0.8.13 → 0.8.15

package/dist/{chunk-54RJM6ZE.js → chunk-4LVZQKWD.js}

@@ -1,5 +1,41 @@
-// src/mcp/utils/logger.ts
+// src/mcp/capabilities.ts
+import { fileURLToPath } from "url";
+import path from "path";
 import fs from "fs";
+var __dirname = path.dirname(fileURLToPath(import.meta.url));
+var pkgPath = path.join(__dirname, "../../package.json");
+var pkgVersion = "0.1.0";
+try {
+  if (fs.existsSync(pkgPath)) {
+    const pkg = JSON.parse(fs.readFileSync(pkgPath, "utf8"));
+    pkgVersion = pkg.version;
+  }
+} catch {
+}
+var MCP_PROTOCOL_VERSION = "2025-11-25";
+var CAPABILITIES = {
+  serverInfo: {
+    name: "mcp-memory-local",
+    version: pkgVersion
+  },
+  capabilities: {
+    completions: {},
+    logging: {},
+    resources: {
+      subscribe: true,
+      listChanged: true
+    },
+    tools: {
+      listChanged: false
+    },
+    prompts: {
+      listChanged: true
+    }
+  }
+};
+
+// src/mcp/utils/logger.ts
+import fs2 from "fs";
 var LEVELS = {
   debug: 0,
   info: 1,
@@ -119,11 +155,11 @@ function addLogSink(sink) {
 }
 var LOG_LEVEL_VALUES = Object.keys(LEVELS);
 function createFileSink(logDir, maxFiles = 5) {
-  fs.mkdirSync(logDir, { recursive: true });
-  const existing = fs.readdirSync(logDir).filter((f) => f.startsWith("mcp-") && f.endsWith(".log")).sort();
+  fs2.mkdirSync(logDir, { recursive: true });
+  const existing = fs2.readdirSync(logDir).filter((f) => f.startsWith("mcp-") && f.endsWith(".log")).sort();
   while (existing.length >= maxFiles) {
     try {
-      fs.unlinkSync(`${logDir}/${existing.shift()}`);
+      fs2.unlinkSync(`${logDir}/${existing.shift()}`);
     } catch {
     }
   }
@@ -133,118 +169,16 @@ function createFileSink(logDir, maxFiles = 5) {
     const line = `${(/* @__PURE__ */ new Date()).toISOString()} [${payload.level.toUpperCase()}] [pid:${process.pid}] ${JSON.stringify(payload.data)}
 `;
     try {
-      fs.appendFileSync(logFile, line);
+      fs2.appendFileSync(logFile, line);
     } catch {
     }
   };
 }
 
-// src/mcp/session.ts
-import path from "path";
-import { fileURLToPath } from "url";
-function createSessionContext() {
-  return {
-    roots: [],
-    supportsRoots: false,
-    supportsSampling: false,
-    supportsSamplingTools: false,
-    supportsElicitation: false,
-    supportsElicitationForm: false,
-    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(path.resolve(fileURLToPath(root.uri)));
-    } catch {
-    }
-  }
-  return resolved;
-}
-function isPathWithinRoots(targetPath, session) {
-  const roots = getFilesystemRoots(session);
-  if (roots.length === 0) return true;
-  const normalizedTarget = path.resolve(targetPath);
-  return roots.some((rootPath) => {
-    const relative = path.relative(rootPath, normalizedTarget);
-    return relative === "" || !relative.startsWith("..") && !path.isAbsolute(relative);
-  });
-}
-function findContainingRoot(targetPath, session) {
-  const roots = getFilesystemRoots(session);
-  if (roots.length === 0) return null;
-  const normalizedTarget = path.resolve(targetPath);
-  for (const rootPath of roots) {
-    const relative = path.relative(rootPath, normalizedTarget);
-    if (relative === "" || !relative.startsWith("..") && !path.isAbsolute(relative)) {
-      return rootPath;
-    }
-  }
-  return null;
-}
-function inferRepoFromSession(session) {
-  const roots = getFilesystemRoots(session);
-  if (roots.length === 1) {
-    return path.basename(roots[0]);
-  }
-  return void 0;
-}
-
 // src/mcp/storage/sqlite.ts
 import Database from "better-sqlite3";
 import path3 from "path";
-import fs3 from "fs";
+import fs4 from "fs";
 import os from "os";
 
 // src/mcp/storage/migrations.ts
@@ -1966,18 +1900,18 @@ var SummaryEntity = class extends BaseEntity {
 // src/mcp/storage/write-lock.ts
 import lockfile from "proper-lockfile";
 import path2 from "path";
-import fs2 from "fs";
-var LOCK_STALE_MS = 15e3;
-var LOCK_RETRY_DELAY_MS = 100;
-var LOCK_RETRY_COUNT = 150;
+import fs3 from "fs";
+var LOCK_STALE_MS = 3e4;
+var LOCK_RETRY_DELAY_MS = 200;
+var LOCK_RETRY_COUNT = 250;
 var WriteLock = class {
   lockTarget;
   locked = false;
   constructor(dbPath) {
     this.lockTarget = dbPath;
-    if (!fs2.existsSync(dbPath)) {
-      fs2.mkdirSync(path2.dirname(dbPath), { recursive: true });
-      fs2.writeFileSync(dbPath, "");
+    if (!fs3.existsSync(dbPath)) {
+      fs3.mkdirSync(path2.dirname(dbPath), { recursive: true });
+      fs3.writeFileSync(dbPath, "");
     }
   }
   /**
@@ -2031,11 +1965,11 @@ function resolveDbPath() {
   if (process.env.MEMORY_DB_PATH) return process.env.MEMORY_DB_PATH;
   const standardConfigDir = process.platform === "win32" ? path3.join(os.homedir(), ".local-memory-mcp") : process.platform === "darwin" ? path3.join(os.homedir(), "Library", "Application Support", "local-memory-mcp") : path3.join(os.homedir(), ".config", "local-memory-mcp");
   const standardPath = path3.join(standardConfigDir, "memory.db");
-  if (fs3.existsSync(standardPath)) return standardPath;
+  if (fs4.existsSync(standardPath)) return standardPath;
   const legacyPath = path3.join(os.homedir(), ".config", "local-memory-mcp", "memory.db");
-  if (fs3.existsSync(legacyPath)) return legacyPath;
+  if (fs4.existsSync(legacyPath)) return legacyPath;
   const localCwdFile = path3.join(process.cwd(), "storage", "memory.db");
-  if (fs3.existsSync(localCwdFile)) return localCwdFile;
+  if (fs4.existsSync(localCwdFile)) return localCwdFile;
   return standardPath;
 }
 var DB_PATH = resolveDbPath();
@@ -2053,8 +1987,8 @@ var SQLiteStore = class _SQLiteStore {
     this.dbPathInstance = finalPath;
     if (finalPath !== ":memory:") {
       const dbDir = path3.dirname(finalPath);
-      if (!fs3.existsSync(dbDir)) {
-        fs3.mkdirSync(dbDir, { recursive: true });
+      if (!fs4.existsSync(dbDir)) {
+        fs4.mkdirSync(dbDir, { recursive: true });
       }
     }
     this.db = new Database(finalPath);
@@ -2106,12 +2040,12 @@ var SQLiteStore = class _SQLiteStore {
    */
   _attemptRecovery(dbPath) {
     const backupPath = dbPath + ".backup";
-    if (fs3.existsSync(backupPath)) {
+    if (fs4.existsSync(backupPath)) {
       logger.warn("[SQLiteStore] Attempting recovery from backup", { backupPath });
       try {
         const corruptPath = `${dbPath}.corrupt_${(/* @__PURE__ */ new Date()).toISOString().replace(/[:.]/g, "").slice(0, 15)}`;
-        fs3.copyFileSync(dbPath, corruptPath);
-        fs3.copyFileSync(backupPath, dbPath);
+        fs4.copyFileSync(dbPath, corruptPath);
+        fs4.copyFileSync(backupPath, dbPath);
         logger.warn("[SQLiteStore] Recovery successful. Corrupt file saved to", { corruptPath });
       } catch (err) {
         logger.error("[SQLiteStore] Recovery failed", { error: String(err) });
@@ -2129,7 +2063,7 @@ var SQLiteStore = class _SQLiteStore {
     try {
       this.db.pragma("wal_checkpoint(PASSIVE)");
       const backupPath = this.dbPathInstance + ".backup";
-      fs3.copyFileSync(this.dbPathInstance, backupPath);
+      fs4.copyFileSync(this.dbPathInstance, backupPath);
     } catch (err) {
       logger.warn("[SQLiteStore] Backup failed", { error: String(err) });
     }
@@ -2174,606 +2108,106 @@ var SQLiteStore = class _SQLiteStore {
   }
 };
 
-// src/mcp/capabilities.ts
-import { fileURLToPath as fileURLToPath2 } from "url";
+// src/mcp/session.ts
 import path4 from "path";
-import fs4 from "fs";
-var __dirname = path4.dirname(fileURLToPath2(import.meta.url));
-var pkgPath = path4.join(__dirname, "../../package.json");
-var pkgVersion = "0.1.0";
-try {
-  if (fs4.existsSync(pkgPath)) {
-    const pkg = JSON.parse(fs4.readFileSync(pkgPath, "utf8"));
-    pkgVersion = pkg.version;
-  }
-} catch {
+import { fileURLToPath as fileURLToPath2 } from "url";
+function createSessionContext() {
+  return {
+    roots: [],
+    supportsRoots: false,
+    supportsSampling: false,
+    supportsSamplingTools: false,
+    supportsElicitation: false,
+    supportsElicitationForm: false,
+    supportsElicitationUrl: false
+  };
 }
-var MCP_PROTOCOL_VERSION = "2025-11-25";
-var CAPABILITIES = {
-  serverInfo: {
-    name: "mcp-memory-local",
-    version: pkgVersion
-  },
-  capabilities: {
-    completions: {},
-    logging: {},
-    resources: {
-      subscribe: true,
-      listChanged: true
-    },
-    tools: {
-      listChanged: false
-    },
-    prompts: {
-      listChanged: true
-    }
-  }
-};
-
-// src/mcp/utils/pagination.ts
-function encodeCursor(offset) {
-  return Buffer.from(String(offset), "utf8").toString("base64");
+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 decodeCursor(cursor) {
-  if (cursor === void 0 || cursor === null || cursor === "") {
-    return 0;
-  }
-  if (typeof cursor !== "string" || cursor.trim() === "") {
-    throw invalidPaginationParams("Invalid cursor");
-  }
-  let decoded;
-  try {
-    decoded = Buffer.from(cursor, "base64").toString("utf8");
-  } catch {
-    throw invalidPaginationParams("Invalid cursor");
-  }
-  if (!/^\d+$/.test(decoded)) {
-    throw invalidPaginationParams("Invalid cursor");
+function supportsElicitationMode(capability, mode) {
+  if (!capability || typeof capability !== "object") {
+    return false;
   }
-  const offset = Number.parseInt(decoded, 10);
-  if (!Number.isFinite(offset) || offset < 0) {
-    throw invalidPaginationParams("Invalid cursor");
+  const cap = capability;
+  if (mode === "form") {
+    return Object.keys(cap).length === 0 || typeof cap.form === "object";
   }
-  return offset;
+  return typeof cap.url === "object";
 }
-function invalidPaginationParams(message) {
-  const error = new Error(message);
-  error.code = -32602;
-  return error;
+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;
 }
-
-// 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);
+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 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;
+  return normalized;
 }
-
-// src/mcp/resources/index.ts
-var DEFAULT_PAGE_SIZE = 25;
-var MAX_PAGE_SIZE = 100;
-function listResources(session, params) {
-  const resources = [
-    {
-      uri: "repository://index",
-      name: "Repository Index",
-      title: "Repository Index",
-      description: "List of all known repositories with memory/task counts and last activity",
-      mimeType: "application/json",
-      annotations: {
-        audience: ["assistant"],
-        priority: 1,
-        lastModified: (/* @__PURE__ */ new Date()).toISOString()
-      }
-    },
-    {
-      uri: "session://roots",
-      name: "Session Roots",
-      title: "Session Roots",
-      description: session?.roots.length ? "Active workspace roots provided by the MCP client" : "No active workspace roots were provided by the MCP client",
-      mimeType: "application/json",
-      size: Buffer.byteLength(JSON.stringify({ roots: session?.roots ?? [] }), "utf8"),
-      annotations: {
-        audience: ["assistant"],
-        priority: 0.95,
-        lastModified: (/* @__PURE__ */ new Date()).toISOString()
-      }
-    }
-  ];
-  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 extractRootsFromResult(result) {
+  return normalizeRoots(result?.roots);
 }
-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") {
-      return rankCompletionValues(dataSources.repos, argumentValue);
+function getFilesystemRoots(session) {
+  if (!session) return [];
+  const resolved = [];
+  for (const root of session.roots) {
+    if (!root.uri.startsWith("file://")) continue;
+    try {
+      resolved.push(path4.resolve(fileURLToPath2(root.uri)));
+    } catch {
     }
   }
-  if (resourceUri === "repository://{name}/memories?search={search}&type={type}&tag={tag}") {
-    if (argumentName === "tag") {
-      return rankCompletionValues(dataSources.tags, argumentValue);
+  return resolved;
+}
+function isPathWithinRoots(targetPath, session) {
+  const roots = getFilesystemRoots(session);
+  if (roots.length === 0) return true;
+  const normalizedTarget = path4.resolve(targetPath);
+  return roots.some((rootPath) => {
+    const relative = path4.relative(rootPath, normalizedTarget);
+    return relative === "" || !relative.startsWith("..") && !path4.isAbsolute(relative);
+  });
+}
+function findContainingRoot(targetPath, session) {
+  const roots = getFilesystemRoots(session);
+  if (roots.length === 0) return null;
+  const normalizedTarget = path4.resolve(targetPath);
+  for (const rootPath of roots) {
+    const relative = path4.relative(rootPath, normalizedTarget);
+    if (relative === "" || !relative.startsWith("..") && !path4.isAbsolute(relative)) {
+      return rootPath;
     }
   }
-  throw invalidCompletionParams(`Unknown resource template or argument: ${resourceUri} (${argumentName})`);
+  return null;
 }
-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
-          }
-        }
-      ]
-    };
+function inferRepoFromSession(session) {
+  const roots = getFilesystemRoots(session);
+  if (roots.length === 1) {
+    return path4.basename(roots[0]);
   }
-  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");
-      let tasks;
-      if (status && status !== "all") {
-        const statuses = status.split(",").map((s) => s.trim());
-        tasks = db.tasks.getTasksByMultipleStatuses(name, statuses);
-      } else {
-        tasks = db.tasks.getTasksByMultipleStatuses(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);
-  const sliced = entries.slice(offset, offset + limit);
-  const nextOffset = offset + sliced.length;
-  return {
-    [key]: sliced,
-    nextCursor: nextOffset < entries.length ? encodeCursor(nextOffset) : void 0
-  };
-}
-function normalizeLimit(limit) {
-  if (typeof limit !== "number" || !Number.isFinite(limit)) {
-    return DEFAULT_PAGE_SIZE;
-  }
-  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;
-  return error;
-}
-
-// src/mcp/prompts/loader.ts
-import fs5 from "fs";
-import path5 from "path";
-import { fileURLToPath as fileURLToPath3 } from "url";
-import matter from "gray-matter";
-var __filename = fileURLToPath3(import.meta.url);
-var __dirname2 = path5.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) => path5.resolve(__dirname2, relPath));
-  for (const dir of candidates) {
-    if (fs5.existsSync(dir)) {
-      const files = fs5.readdirSync(dir);
-      if (files.some((f) => f.endsWith(".md"))) {
-        return dir;
-      }
-    }
-  }
-  return path5.resolve(__dirname2, "./definitions");
-}
-var PROMPT_DIR = findPromptDir();
-function listPromptFiles() {
-  if (!fs5.existsSync(PROMPT_DIR)) return [];
-  return fs5.readdirSync(PROMPT_DIR).filter((file) => file.endsWith(".md")).map((file) => file.replace(/\.md$/, "")).sort();
-}
-function loadPromptFromMarkdown(name) {
-  const filePath = path5.join(PROMPT_DIR, `${name}.md`);
-  if (!fs5.existsSync(filePath)) {
-    throw new Error(`Prompt file not found: ${filePath}`);
-  }
-  const fileContent = fs5.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()
-  };
-}
-
-// src/mcp/prompts/registry.ts
-function createPromptDefinition(loaded) {
-  return {
-    name: loaded.name,
-    description: loaded.description,
-    arguments: loaded.arguments,
-    agent: loaded.agent,
-    messages: [
-      {
-        role: "user",
-        content: {
-          type: "text",
-          text: loaded.content
-        }
-      }
-    ]
-  };
-}
-var PROMPTS = {};
-var promptFiles = listPromptFiles();
-for (const name of promptFiles) {
-  try {
-    PROMPTS[name] = createPromptDefinition(loadPromptFromMarkdown(name));
-  } catch (e) {
-    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 : 25;
-  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 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");
-    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;
-  if (argName === "task_id") {
-    const values = dataSources.tasks.map((t) => t.id);
-    return rankCompletionValues(values, value);
-  }
-  return [];
+  return void 0;
 }
 
 // src/mcp/tools/schemas.ts
@@ -2999,829 +2433,1380 @@ var TaskGetSchema = z.object({
 });
 var TOOL_DEFINITIONS = [
   {
-    name: "memory-synthesize",
-    title: "Memory Synthesize",
-    description: "Use client sampling to synthesize a grounded answer from local memory and tasks. Best for project briefings, tradeoff summaries, and context-aware answers.",
+    name: "memory-synthesize",
+    title: "Memory Synthesize",
+    description: "Use client sampling to synthesize a grounded answer from local memory and tasks. Best for project briefings, tradeoff summaries, and context-aware answers.",
+    annotations: {
+      readOnlyHint: true,
+      idempotentHint: true,
+      openWorldHint: false
+    },
+    execution: {
+      taskSupport: "optional"
+    },
+    inputSchema: {
+      type: "object",
+      properties: {
+        repo: { type: "string", description: "Repository name. Optional when a single MCP root is active." },
+        objective: { type: "string", minLength: 5, description: "Question or synthesis objective." },
+        current_file_path: {
+          type: "string",
+          description: "Optional absolute file path for workspace-local grounding."
+        },
+        include_summary: { type: "boolean", default: true },
+        include_tasks: { type: "boolean", default: true },
+        use_tools: {
+          type: "boolean",
+          default: true,
+          description: "Allow the sampled model to call local memory/task tools during synthesis when the client supports sampling.tools."
+        },
+        max_iterations: { type: "number", minimum: 1, maximum: 5, default: 3 },
+        max_tokens: { type: "number", minimum: 128, maximum: 4e3, default: 1200 },
+        structured: { type: "boolean", default: false, description: "If true, returns structured JSON results." }
+      },
+      required: ["objective"]
+    },
+    outputSchema: {
+      type: "object",
+      properties: {
+        repo: { type: "string" },
+        objective: { type: "string" },
+        answer: { type: "string" },
+        model: { type: "string" },
+        stopReason: { type: "string" },
+        iterations: { type: "number" },
+        toolCalls: { type: "number" }
+      },
+      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: {
+        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 },
+        status: { type: "string", enum: ["backlog", "pending"], default: "backlog" },
+        priority: { type: "number", minimum: 1, maximum: 5, default: 3 },
+        agent: { type: "string" },
+        role: { type: "string" },
+        doc_path: { type: "string" },
+        structured: { type: "boolean", default: false, description: "If true, returns structured JSON result." }
+      }
+    },
+    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",
+    description: "Fetch full details of a specific memory by ID. Use this when you have a memory ID (e.g. from search results) and need to read the full content.",
+    inputSchema: {
+      type: "object",
+      properties: {
+        id: { type: "string", format: "uuid", description: "Memory entry ID" },
+        structured: { type: "boolean", default: false, description: "If true, returns structured JSON details." }
+      },
+      required: ["id"]
+    }
+  },
+  {
+    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",
+      properties: {
+        repo: { type: "string", description: "Repository name" },
+        id: { type: "string", format: "uuid", description: "Task ID (optional if task_code is provided)" },
+        task_code: { type: "string", description: "Task code (e.g. TASK-001) (optional if id is provided)" },
+        structured: {
+          type: "boolean",
+          default: false,
+          description: "If true, returns structured JSON without the text content details."
+        }
+      },
+      required: ["repo"]
+    }
+  },
+  {
+    name: "memory-store",
+    title: "Memory Store",
+    description: "Store a new memory entry. Keep 'title' concise and human-readable; do not embed agent/role/date metadata in the title. Put auxiliary context into 'metadata'. Use 'tags' for tech-stack and 'is_global' for universal rules.",
+    annotations: {
+      readOnlyHint: false,
+      idempotentHint: false,
+      destructiveHint: false,
+      openWorldHint: false
+    },
+    inputSchema: {
+      type: "object",
+      properties: {
+        type: {
+          type: "string",
+          enum: [
+            "code_fact",
+            "decision",
+            "mistake",
+            "pattern",
+            "agent_handoff",
+            "agent_registered",
+            "file_claim",
+            "task_archive"
+          ],
+          description: "Type of memory being stored"
+        },
+        title: {
+          type: "string",
+          minLength: 3,
+          maxLength: 100,
+          description: "Short human-readable title for the memory. Do not embed bracketed metadata like agent/role/date prefixes here."
+        },
+        content: {
+          type: "string",
+          minLength: 10,
+          description: "The memory content"
+        },
+        importance: {
+          type: "number",
+          minimum: 1,
+          maximum: 5,
+          description: "Importance score (1-5)"
+        },
+        agent: {
+          type: "string",
+          description: "Name of the agent creating this memory"
+        },
+        role: {
+          type: "string",
+          description: "Role of the agent creating this memory"
+        },
+        model: {
+          type: "string",
+          description: "AI model used by the agent"
+        },
+        scope: {
+          type: "object",
+          properties: {
+            repo: { type: "string", description: "Repository name" },
+            branch: { type: "string" },
+            folder: { type: "string" },
+            language: { type: "string" }
+          },
+          required: ["repo"]
+        },
+        tags: {
+          type: "array",
+          items: { type: "string" },
+          description: "Technology stack tags (e.g., ['filament', 'laravel'])"
+        },
+        metadata: {
+          type: "object",
+          description: "Structured metadata for non-title context such as source agent, claim fields, or timestamps"
+        },
+        is_global: {
+          type: "boolean",
+          description: "If true, this memory is shared across all repositories"
+        },
+        ttlDays: { type: "number", minimum: 1 },
+        supersedes: { type: "string", format: "uuid" },
+        structured: { type: "boolean", default: false, description: "If true, returns structured JSON of the stored memory." }
+      },
+      required: ["type", "title", "content", "importance", "scope", "agent", "model"]
+    },
+    outputSchema: {
+      type: "object",
+      properties: {
+        success: { type: "boolean" },
+        id: { type: "string" },
+        code: { type: "string" },
+        repo: { type: "string" },
+        type: { type: "string" },
+        title: { type: "string" },
+        error: { type: "string" },
+        message: { type: "string" }
+      },
+      required: ["success"]
+    }
+  },
+  {
+    name: "memory-acknowledge",
+    title: "Memory Acknowledge",
+    description: "Acknowledge the use of a memory or report its irrelevance/contradiction. Mandatory after using memory to generate code.",
+    annotations: {
+      readOnlyHint: false,
+      idempotentHint: false,
+      openWorldHint: false
+    },
+    inputSchema: {
+      type: "object",
+      properties: {
+        memory_id: { type: "string", format: "uuid" },
+        status: { type: "string", enum: ["used", "irrelevant", "contradictory"] },
+        application_context: { type: "string", minLength: 10 },
+        structured: { type: "boolean", default: false, description: "If true, returns structured JSON result." }
+      },
+      required: ["memory_id", "status"]
+    },
+    outputSchema: {
+      type: "object",
+      properties: {
+        success: { type: "boolean" },
+        id: { type: "string" },
+        status: { type: "string" }
+      },
+      required: ["success", "id", "status"]
+    }
+  },
+  {
+    name: "memory-update",
+    title: "Memory Update",
+    description: "Update an existing memory entry. Keep 'title' concise and move agent/role/date or claim context into 'metadata' instead of the title.",
+    annotations: {
+      readOnlyHint: false,
+      idempotentHint: false,
+      destructiveHint: false,
+      openWorldHint: false
+    },
+    inputSchema: {
+      type: "object",
+      properties: {
+        id: { type: "string", format: "uuid" },
+        type: {
+          type: "string",
+          enum: [
+            "code_fact",
+            "decision",
+            "mistake",
+            "pattern",
+            "agent_handoff",
+            "agent_registered",
+            "file_claim",
+            "task_archive"
+          ]
+        },
+        title: { type: "string", minLength: 3, maxLength: 100 },
+        content: { type: "string", minLength: 10 },
+        importance: { type: "number", minimum: 1, maximum: 5 },
+        agent: { type: "string" },
+        role: { type: "string" },
+        status: { type: "string", enum: ["active", "archived"] },
+        supersedes: { type: "string", format: "uuid" },
+        tags: { type: "array", items: { type: "string" } },
+        metadata: { type: "object" },
+        is_global: { type: "boolean" },
+        completed_at: { type: "string" },
+        structured: { type: "boolean", default: false, description: "If true, returns structured JSON of the updated memory." }
+      },
+      required: ["id"]
+    },
+    outputSchema: {
+      type: "object",
+      properties: {
+        success: { type: "boolean" },
+        id: { type: "string" },
+        repo: { type: "string" },
+        updatedFields: {
+          type: "array",
+          items: { type: "string" }
+        }
+      },
+      required: ["success", "id", "repo", "updatedFields"]
+    }
+  },
+  {
+    name: "memory-search",
+    title: "Memory Search",
+    description: "NAVIGATION LAYER: Returns a pointer table of matching memory IDs only. Returns columns [id, title, type, importance] \u2014 NO content. Retrieve full memory via memory-detail. Use 'current_tags' to find tech-stack specific knowledge from other projects.",
+    annotations: {
+      readOnlyHint: true,
+      idempotentHint: true,
+      openWorldHint: false
+    },
+    inputSchema: {
+      type: "object",
+      properties: {
+        query: { type: "string", minLength: 3 },
+        prompt: { type: "string" },
+        repo: { type: "string" },
+        current_tags: {
+          type: "array",
+          items: { type: "string" },
+          description: "Active tech stack tags (e.g., ['filament', 'react'])"
+        },
+        types: {
+          type: "array",
+          items: {
+            type: "string",
+            enum: [
+              "code_fact",
+              "decision",
+              "mistake",
+              "pattern",
+              "agent_handoff",
+              "agent_registered",
+              "file_claim",
+              "task_archive"
+            ]
+          }
+        },
+        minImportance: { type: "number", minimum: 1, maximum: 5 },
+        limit: { type: "number", minimum: 1, maximum: 100, default: 5 },
+        offset: { type: "number", minimum: 0, default: 0 },
+        includeRecap: { type: "boolean", default: false },
+        current_file_path: { type: "string" },
+        include_archived: { type: "boolean", default: false },
+        scope: {
+          type: "object",
+          properties: {
+            repo: { type: "string" },
+            branch: { type: "string" },
+            folder: { type: "string" },
+            language: { type: "string" }
+          }
+        },
+        structured: {
+          type: "boolean",
+          default: false,
+          description: "If true, returns structured JSON without the text content summary."
+        }
+      },
+      required: ["query", "repo"]
+    },
+    outputSchema: {
+      type: "object",
+      properties: {
+        schema: { type: "string", enum: ["memory-search"] },
+        query: { type: "string" },
+        count: { type: "number", description: "Number of rows returned" },
+        total: { type: "number", description: "Total matching memories" },
+        offset: { type: "number" },
+        limit: { type: "number" },
+        results: {
+          type: "object",
+          properties: {
+            columns: {
+              type: "array",
+              items: { type: "string" },
+              description: "Column names: [id, title, type, importance]"
+            },
+            rows: {
+              type: "array",
+              items: { type: "array" },
+              description: "Each row: [id, title, type, importance]. Fetch full content via memory-detail"
+            }
+          },
+          required: ["columns", "rows"]
+        }
+      },
+      required: ["schema", "query", "count", "total", "offset", "limit", "results"]
+    }
+  },
+  {
+    name: "memory-summarize",
+    title: "Memory Summarize",
+    description: "Update the summary for a repository",
+    annotations: {
+      readOnlyHint: false,
+      idempotentHint: false,
+      openWorldHint: false
+    },
+    inputSchema: {
+      type: "object",
+      properties: {
+        repo: { type: "string", description: "Repository name" },
+        signals: {
+          type: "array",
+          items: { type: "string", maxLength: 200 },
+          minItems: 1,
+          description: "High-level signals to include in summary"
+        },
+        structured: { type: "boolean", default: false, description: "If true, returns structured JSON of the summary." }
+      },
+      required: ["repo", "signals"]
+    },
+    outputSchema: {
+      type: "object",
+      properties: {
+        success: { type: "boolean" },
+        repo: { type: "string" },
+        summary: { type: "string" },
+        signalCount: { type: "number" }
+      },
+      required: ["success", "repo", "summary", "signalCount"]
+    }
+  },
+  {
+    name: "memory-delete",
+    title: "Memory Delete",
+    description: "Soft-delete one or more memory entries. Supports single 'id' or bulk 'ids'.",
+    annotations: {
+      readOnlyHint: false,
+      idempotentHint: false,
+      destructiveHint: true,
+      openWorldHint: false
+    },
+    inputSchema: {
+      type: "object",
+      properties: {
+        repo: { type: "string", description: "Repository name (optional for single id)" },
+        id: { type: "string", format: "uuid", description: "Memory entry ID to delete" },
+        ids: {
+          type: "array",
+          items: { type: "string", format: "uuid" },
+          minItems: 1,
+          description: "Array of memory IDs to delete"
+        },
+        structured: { type: "boolean", default: false, description: "If true, returns structured JSON result." }
+      }
+    },
+    outputSchema: {
+      type: "object",
+      properties: {
+        success: { type: "boolean" },
+        id: { type: "string" },
+        ids: { type: "array", items: { type: "string" } },
+        repo: { type: "string" },
+        deletedCount: { type: "number" }
+      },
+      required: ["success"]
+    }
+  },
+  {
+    name: "memory-recap",
+    title: "Memory Recap",
+    description: "AGGREGATED OVERVIEW LAYER: Returns stats (counts by type) and a pointer table of top memories [id, title, type, importance]. NO content. Use for orientation only \u2014 retrieve full memory via memory-detail.",
     annotations: {
       readOnlyHint: true,
       idempotentHint: true,
       openWorldHint: false
     },
-    execution: {
-      taskSupport: "optional"
-    },
     inputSchema: {
       type: "object",
       properties: {
-        repo: { type: "string", description: "Repository name. Optional when a single MCP root is active." },
-        objective: { type: "string", minLength: 5, description: "Question or synthesis objective." },
-        current_file_path: {
-          type: "string",
-          description: "Optional absolute file path for workspace-local grounding."
+        repo: { type: "string", description: "Repository name (required)" },
+        limit: {
+          type: "number",
+          minimum: 1,
+          maximum: 50,
+          default: 20,
+          description: "Maximum number of top memories to return in the pointer table"
         },
-        include_summary: { type: "boolean", default: true },
-        include_tasks: { type: "boolean", default: true },
-        use_tools: {
-          type: "boolean",
-          default: true,
-          description: "Allow the sampled model to call local memory/task tools during synthesis when the client supports sampling.tools."
+        offset: {
+          type: "number",
+          minimum: 0,
+          default: 0,
+          description: "Number of memories to skip for pagination (optional, default 0)"
         },
-        max_iterations: { type: "number", minimum: 1, maximum: 5, default: 3 },
-        max_tokens: { type: "number", minimum: 128, maximum: 4e3, default: 1200 },
-        structured: { type: "boolean", default: false, description: "If true, returns structured JSON results." }
+        structured: {
+          type: "boolean",
+          default: false,
+          description: "If true, returns structured JSON without the text content summary."
+        }
       },
-      required: ["objective"]
+      required: ["repo"]
     },
     outputSchema: {
       type: "object",
       properties: {
+        schema: { type: "string", enum: ["memory-recap"] },
         repo: { type: "string" },
-        objective: { type: "string" },
-        answer: { type: "string" },
-        model: { type: "string" },
-        stopReason: { type: "string" },
-        iterations: { type: "number" },
-        toolCalls: { type: "number" }
+        count: { type: "number", description: "Number of rows in the top pointer table" },
+        total: { type: "number", description: "Total active memories in repo" },
+        offset: { type: "number" },
+        limit: { type: "number" },
+        stats: {
+          type: "object",
+          properties: {
+            by_type: {
+              type: "object",
+              description: "Count of active memories per type (e.g. { decision: 3, code_fact: 7 })"
+            }
+          },
+          required: ["by_type"]
+        },
+        top: {
+          type: "object",
+          properties: {
+            columns: {
+              type: "array",
+              items: { type: "string" },
+              description: "Column names: [id, title, type, importance]"
+            },
+            rows: {
+              type: "array",
+              items: { type: "array" },
+              description: "Each row: [id, title, type, importance]. Fetch full content via memory-detail"
+            }
+          },
+          required: ["columns", "rows"]
+        }
       },
-      required: ["repo", "objective", "answer", "iterations", "toolCalls"]
+      required: ["schema", "repo", "count", "total", "offset", "limit", "stats", "top"]
     }
   },
   {
-    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.",
+    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,
-      destructiveHint: false,
       openWorldHint: false
     },
     inputSchema: {
       type: "object",
       properties: {
-        repo: {
+        repo: { type: "string", description: "Repository 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",
-          description: "Repository name. Optional when it can be inferred from MCP roots or elicited from the user."
+          minLength: 3,
+          maxLength: 100,
+          description: "Task objective (Required for single task)"
+        },
+        description: { type: "string", description: "Detailed description (Required for single task)" },
+        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'."
         },
-        task_code: { type: "string" },
-        phase: { type: "string" },
-        title: { type: "string", minLength: 3, maxLength: 100 },
-        description: { type: "string", minLength: 1 },
-        status: { type: "string", enum: ["backlog", "pending"], default: "backlog" },
         priority: { type: "number", minimum: 1, maximum: 5, default: 3 },
         agent: { type: "string" },
         role: { type: "string" },
         doc_path: { type: "string" },
+        tags: { type: "array", items: { type: "string" } },
+        metadata: { type: "object" },
+        parent_id: { type: "string", format: "uuid" },
+        depends_on: { type: "string", format: "uuid" },
+        est_tokens: { type: "number", minimum: 0, description: "Estimated tokens budget for this task" },
+        tasks: {
+          type: "array",
+          items: {
+            type: "object",
+            properties: {
+              task_code: { type: "string" },
+              phase: { type: "string" },
+              title: { type: "string", minLength: 3, maxLength: 100 },
+              description: { type: "string" },
+              status: { type: "string", enum: ["backlog", "pending"], default: "backlog" },
+              priority: { type: "number", minimum: 1, maximum: 5, default: 3 },
+              agent: { type: "string" },
+              role: { type: "string" },
+              doc_path: { type: "string" },
+              tags: { type: "array", items: { type: "string" } },
+              metadata: { type: "object" },
+              parent_id: { type: "string", format: "uuid" },
+              depends_on: { type: "string", format: "uuid" },
+              est_tokens: { type: "number", minimum: 0 }
+            },
+            required: ["task_code", "phase", "title", "description"]
+          },
+          description: "Array of tasks for bulk creation"
+        },
         structured: { type: "boolean", default: false, description: "If true, returns structured JSON result." }
-      }
+      },
+      required: ["repo"]
     },
     outputSchema: {
       type: "object",
       properties: {
-        repo: { type: "string" },
+        success: { type: "boolean" },
+        id: { type: "string" },
         task_code: { type: "string" },
+        repo: { type: "string" },
         phase: { type: "string" },
         title: { type: "string" },
         status: { type: "string" },
-        priority: { type: "number" }
+        priority: { type: "number" },
+        createdCount: { type: "number" },
+        taskCodes: { type: "array", items: { type: "string" } }
       },
-      required: ["repo", "task_code", "phase", "title", "status", "priority"]
+      required: ["success", "repo"]
     }
   },
   {
-    name: "memory-detail",
-    title: "Memory Detail",
-    description: "Fetch full details of a specific memory by ID. Use this when you have a memory ID (e.g. from search results) and need to read the full content.",
+    name: "task-update",
+    title: "Task Update",
+    description: "Update one or more tasks. Supports single update via 'id' or bulk update via 'ids'. Provide only the fields that need to be changed. MANDATORY WORKFLOW: You cannot move a task from 'pending' or 'blocked' directly to 'completed'. You MUST move it to 'in_progress' first. When changing status to 'completed', include 'est_tokens' with the estimated total tokens actually used for the task.",
+    annotations: {
+      readOnlyHint: false,
+      idempotentHint: false,
+      openWorldHint: false
+    },
     inputSchema: {
       type: "object",
       properties: {
-        id: { type: "string", format: "uuid", description: "Memory entry ID" },
-        structured: { type: "boolean", default: false, description: "If true, returns structured JSON details." }
+        repo: { type: "string", description: "Repository name" },
+        id: { type: "string", format: "uuid", description: "Task ID (for single update)" },
+        ids: { type: "array", items: { type: "string", format: "uuid" }, description: "Task IDs (for bulk update)" },
+        task_code: { type: "string" },
+        phase: { type: "string" },
+        title: { type: "string", minLength: 3, maxLength: 100 },
+        description: { type: "string" },
+        status: {
+          type: "string",
+          enum: ["backlog", "pending", "in_progress", "completed", "canceled", "blocked"],
+          description: "New status. Transitions from 'backlog', 'pending' or 'blocked' to 'completed' are NOT allowed."
+        },
+        priority: { type: "number", minimum: 1, maximum: 5 },
+        agent: { type: "string" },
+        role: { type: "string" },
+        model: { type: "string" },
+        comment: {
+          type: "string",
+          description: "REQUIRED when changing task status. Explain WHY the status is changing (e.g., 'Starting implementation', 'Blocked by missing API docs', 'Verified fix')."
+        },
+        doc_path: { type: "string" },
+        tags: { type: "array", items: { type: "string" } },
+        metadata: { type: "object" },
+        parent_id: { type: "string", format: "uuid" },
+        depends_on: { type: "string", format: "uuid" },
+        est_tokens: {
+          type: "number",
+          minimum: 0,
+          description: "Estimated total tokens actually used for this task. Required when status changes to 'completed'."
+        },
+        force: {
+          type: "boolean",
+          description: "If true, bypasses status transition validation (e.g. pending -> completed)."
+        },
+        structured: { type: "boolean", default: false, description: "If true, returns structured JSON result." }
       },
-      required: ["id"]
+      required: ["repo"]
+    },
+    outputSchema: {
+      type: "object",
+      properties: {
+        success: { type: "boolean" },
+        id: { type: "string" },
+        ids: { type: "array", items: { type: "string" } },
+        repo: { type: "string" },
+        status: { type: "string" },
+        archivedToMemory: { type: "boolean" },
+        updatedFields: {
+          type: "array",
+          items: { type: "string" }
+        },
+        updatedCount: { type: "number" }
+      },
+      required: ["success", "repo"]
     }
   },
   {
-    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.",
+    name: "task-delete",
+    title: "Task Delete",
+    description: "Delete one or more tasks from a repository. Supports single 'id' or bulk 'ids'.",
+    annotations: {
+      readOnlyHint: false,
+      idempotentHint: false,
+      destructiveHint: true,
+      openWorldHint: false
+    },
     inputSchema: {
       type: "object",
       properties: {
         repo: { type: "string", description: "Repository name" },
-        id: { type: "string", format: "uuid", description: "Task ID (optional if task_code is provided)" },
-        task_code: { type: "string", description: "Task code (e.g. TASK-001) (optional if id is provided)" },
-        structured: {
-          type: "boolean",
-          default: false,
-          description: "If true, returns structured JSON without the text content details."
-        }
+        id: { type: "string", format: "uuid", description: "Task ID (for single deletion)" },
+        ids: { type: "array", items: { type: "string", format: "uuid" }, description: "Task IDs (for bulk deletion)" },
+        structured: { type: "boolean", default: false, description: "If true, returns structured JSON result." }
       },
       required: ["repo"]
+    },
+    outputSchema: {
+      type: "object",
+      properties: {
+        success: { type: "boolean" },
+        id: { type: "string" },
+        ids: { type: "array", items: { type: "string" } },
+        repo: { type: "string" },
+        deletedCount: { type: "number" }
+      },
+      required: ["success", "repo"]
     }
   },
   {
-    name: "memory-store",
-    title: "Memory Store",
-    description: "Store a new memory entry. Keep 'title' concise and human-readable; do not embed agent/role/date metadata in the title. Put auxiliary context into 'metadata'. Use 'tags' for tech-stack and 'is_global' for universal rules.",
+    name: "task-list",
+    title: "Task List",
+    description: "PRIMARY navigation and search tool for tasks. Returns a compact tabular list of tasks (id, task_code, title, status, priority). Defaults to in_progress and pending tasks. Use 'query' to filter by code, title, or description. Use 'status' (comma-separated) for specific filters. AGENTS: call this once at start, pick ONE task, then call task-detail.",
     annotations: {
-      readOnlyHint: false,
-      idempotentHint: false,
-      destructiveHint: false,
+      readOnlyHint: true,
+      idempotentHint: true,
       openWorldHint: false
     },
     inputSchema: {
       type: "object",
       properties: {
-        type: {
-          type: "string",
-          enum: [
-            "code_fact",
-            "decision",
-            "mistake",
-            "pattern",
-            "agent_handoff",
-            "agent_registered",
-            "file_claim",
-            "task_archive"
-          ],
-          description: "Type of memory being stored"
-        },
-        title: {
-          type: "string",
-          minLength: 3,
-          maxLength: 100,
-          description: "Short human-readable title for the memory. Do not embed bracketed metadata like agent/role/date prefixes here."
-        },
-        content: {
+        repo: {
           type: "string",
-          minLength: 10,
-          description: "The memory content"
-        },
-        importance: {
-          type: "number",
-          minimum: 1,
-          maximum: 5,
-          description: "Importance score (1-5)"
+          description: "Repository name"
         },
-        agent: {
+        status: {
           type: "string",
-          description: "Name of the agent creating this memory"
+          default: "in_progress,pending",
+          description: "Comma-separated status filter (backlog, pending, in_progress, completed, canceled, blocked). Defaults to 'in_progress,pending'."
         },
-        role: {
+        phase: {
           type: "string",
-          description: "Role of the agent creating this memory"
+          description: "Filter by phase (e.g., 'research', 'implementation')"
         },
-        model: {
+        query: {
           type: "string",
-          description: "AI model used by the agent"
-        },
-        scope: {
-          type: "object",
-          properties: {
-            repo: { type: "string", description: "Repository name" },
-            branch: { type: "string" },
-            folder: { type: "string" },
-            language: { type: "string" }
-          },
-          required: ["repo"]
+          description: "Search keyword matching task code, title, or description"
         },
-        tags: {
-          type: "array",
-          items: { type: "string" },
-          description: "Technology stack tags (e.g., ['filament', 'laravel'])"
+        limit: {
+          type: "number",
+          minimum: 1,
+          maximum: 100,
+          default: 5,
+          description: "Maximum rows to return (default 5)"
         },
-        metadata: {
-          type: "object",
-          description: "Structured metadata for non-title context such as source agent, claim fields, or timestamps"
+        offset: {
+          type: "number",
+          minimum: 0,
+          default: 0,
+          description: "Offset for pagination"
         },
-        is_global: {
+        structured: {
           type: "boolean",
-          description: "If true, this memory is shared across all repositories"
-        },
-        ttlDays: { type: "number", minimum: 1 },
-        supersedes: { type: "string", format: "uuid" },
-        structured: { type: "boolean", default: false, description: "If true, returns structured JSON of the stored memory." }
+          default: false,
+          description: "If true, returns structured JSON without the text content summary."
+        }
       },
-      required: ["type", "title", "content", "importance", "scope", "agent", "model"]
+      required: ["repo"]
     },
     outputSchema: {
       type: "object",
       properties: {
-        success: { type: "boolean" },
-        id: { type: "string" },
-        code: { type: "string" },
-        repo: { type: "string" },
-        type: { type: "string" },
-        title: { type: "string" },
-        error: { type: "string" },
-        message: { type: "string" }
+        schema: { type: "string", enum: ["task-list"] },
+        tasks: {
+          type: "object",
+          properties: {
+            columns: {
+              type: "array",
+              items: { type: "string" },
+              description: "Column names in order: id, task_code, title, status, priority, comments_count"
+            },
+            rows: {
+              type: "array",
+              items: { type: "array" },
+              description: "Each row: [id, task_code, title, status, priority, comments_count]. Use task-detail to fetch full task."
+            }
+          },
+          required: ["columns", "rows"]
+        },
+        count: { type: "number" },
+        offset: { type: "number" }
       },
-      required: ["success"]
+      required: ["schema", "tasks", "count"]
     }
-  },
-  {
-    name: "memory-acknowledge",
-    title: "Memory Acknowledge",
-    description: "Acknowledge the use of a memory or report its irrelevance/contradiction. Mandatory after using memory to generate code.",
-    annotations: {
-      readOnlyHint: false,
-      idempotentHint: false,
-      openWorldHint: false
+  }
+];
+
+// src/mcp/utils/pagination.ts
+function encodeCursor(offset) {
+  return Buffer.from(String(offset), "utf8").toString("base64");
+}
+function decodeCursor(cursor) {
+  if (cursor === void 0 || cursor === null || cursor === "") {
+    return 0;
+  }
+  if (typeof cursor !== "string" || cursor.trim() === "") {
+    throw invalidPaginationParams("Invalid cursor");
+  }
+  let decoded;
+  try {
+    decoded = Buffer.from(cursor, "base64").toString("utf8");
+  } catch {
+    throw invalidPaginationParams("Invalid cursor");
+  }
+  if (!/^\d+$/.test(decoded)) {
+    throw invalidPaginationParams("Invalid cursor");
+  }
+  const offset = Number.parseInt(decoded, 10);
+  if (!Number.isFinite(offset) || offset < 0) {
+    throw invalidPaginationParams("Invalid cursor");
+  }
+  return offset;
+}
+function invalidPaginationParams(message) {
+  const error = new Error(message);
+  error.code = -32602;
+  return error;
+}
+
+// src/mcp/utils/completion.ts
+var MAX_COMPLETION_VALUES = 100;
+function rankCompletionValues(candidates, input) {
+  const unique = [...new Set(candidates.filter(Boolean))];
+  const needle = input.trim().toLowerCase();
+  if (!needle) {
+    return unique.slice(0, MAX_COMPLETION_VALUES);
+  }
+  return unique.map((value) => ({ value, score: scoreCompletionValue(value, needle) })).filter((entry) => entry.score > 0).sort((a, b) => b.score - a.score || a.value.localeCompare(b.value)).map((entry) => entry.value);
+}
+function scoreCompletionValue(value, needle) {
+  const haystack = value.toLowerCase();
+  if (haystack === needle) return 100;
+  if (haystack.startsWith(needle)) return 75;
+  if (haystack.includes(needle)) return 50;
+  const compactNeedle = needle.replace(/[\s_-]+/g, "");
+  const compactHaystack = haystack.replace(/[\s_-]+/g, "");
+  if (compactNeedle && compactHaystack.includes(compactNeedle)) return 25;
+  return 0;
+}
+
+// src/mcp/resources/index.ts
+var DEFAULT_PAGE_SIZE = 25;
+var MAX_PAGE_SIZE = 100;
+function listResources(session, params) {
+  const resources = [
+    {
+      uri: "repository://index",
+      name: "Repository Index",
+      title: "Repository Index",
+      description: "List of all known repositories with memory/task counts and last activity",
+      mimeType: "application/json",
+      annotations: {
+        audience: ["assistant"],
+        priority: 1,
+        lastModified: (/* @__PURE__ */ new Date()).toISOString()
+      }
+    },
+    {
+      uri: "session://roots",
+      name: "Session Roots",
+      title: "Session Roots",
+      description: session?.roots.length ? "Active workspace roots provided by the MCP client" : "No active workspace roots were provided by the MCP client",
+      mimeType: "application/json",
+      size: Buffer.byteLength(JSON.stringify({ roots: session?.roots ?? [] }), "utf8"),
+      annotations: {
+        audience: ["assistant"],
+        priority: 0.95,
+        lastModified: (/* @__PURE__ */ new Date()).toISOString()
+      }
+    }
+  ];
+  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 }
     },
-    inputSchema: {
-      type: "object",
-      properties: {
-        memory_id: { type: "string", format: "uuid" },
-        status: { type: "string", enum: ["used", "irrelevant", "contradictory"] },
-        application_context: { type: "string", minLength: 10 },
-        structured: { type: "boolean", default: false, description: "If true, returns structured JSON result." }
-      },
-      required: ["memory_id", "status"]
+    // ── 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 }
     },
-    outputSchema: {
-      type: "object",
-      properties: {
-        success: { type: "boolean" },
-        id: { type: "string" },
-        status: { type: "string" }
-      },
-      required: ["success", "id", "status"]
-    }
-  },
-  {
-    name: "memory-update",
-    title: "Memory Update",
-    description: "Update an existing memory entry. Keep 'title' concise and move agent/role/date or claim context into 'metadata' instead of the title.",
-    annotations: {
-      readOnlyHint: false,
-      idempotentHint: false,
-      destructiveHint: false,
-      openWorldHint: false
+    {
+      uriTemplate: "repository://{name}/tasks?status={status}&priority={priority}",
+      name: "Filtered Repository Tasks",
+      title: "Filtered Repository Tasks",
+      description: "Filter tasks within a repository by status or priority level",
+      mimeType: "application/json",
+      annotations: { audience: ["assistant"], priority: 0.85 }
     },
-    inputSchema: {
-      type: "object",
-      properties: {
-        id: { type: "string", format: "uuid" },
-        type: {
-          type: "string",
-          enum: [
-            "code_fact",
-            "decision",
-            "mistake",
-            "pattern",
-            "agent_handoff",
-            "agent_registered",
-            "file_claim",
-            "task_archive"
-          ]
-        },
-        title: { type: "string", minLength: 3, maxLength: 100 },
-        content: { type: "string", minLength: 10 },
-        importance: { type: "number", minimum: 1, maximum: 5 },
-        agent: { type: "string" },
-        role: { type: "string" },
-        status: { type: "string", enum: ["active", "archived"] },
-        supersedes: { type: "string", format: "uuid" },
-        tags: { type: "array", items: { type: "string" } },
-        metadata: { type: "object" },
-        is_global: { type: "boolean" },
-        completed_at: { type: "string" },
-        structured: { type: "boolean", default: false, description: "If true, returns structured JSON of the updated memory." }
-      },
-      required: ["id"]
+    {
+      uriTemplate: "task://{id}",
+      name: "Task Detail",
+      title: "Task Detail",
+      description: "Full content and comments for a specific task UUID",
+      mimeType: "application/json",
+      annotations: { audience: ["assistant"], priority: 0.8 }
     },
-    outputSchema: {
-      type: "object",
-      properties: {
-        success: { type: "boolean" },
-        id: { type: "string" },
-        repo: { type: "string" },
-        updatedFields: {
-          type: "array",
-          items: { type: "string" }
-        }
-      },
-      required: ["success", "id", "repo", "updatedFields"]
-    }
-  },
-  {
-    name: "memory-search",
-    title: "Memory Search",
-    description: "NAVIGATION LAYER: Returns a pointer table of matching memory IDs only. Returns columns [id, title, type, importance] \u2014 NO content. Retrieve full memory via memory-detail. Use 'current_tags' to find tech-stack specific knowledge from other projects.",
-    annotations: {
-      readOnlyHint: true,
-      idempotentHint: true,
-      openWorldHint: false
+    // ── Repository extras ────────────────────────────────────────────────────
+    {
+      uriTemplate: "repository://{name}/summary",
+      name: "Repository Summary",
+      title: "Repository Summary",
+      description: "High-level architectural summary for a repository",
+      mimeType: "text/plain",
+      annotations: { audience: ["assistant"], priority: 0.95 }
     },
-    inputSchema: {
-      type: "object",
-      properties: {
-        query: { type: "string", minLength: 3 },
-        prompt: { type: "string" },
-        repo: { type: "string" },
-        current_tags: {
-          type: "array",
-          items: { type: "string" },
-          description: "Active tech stack tags (e.g., ['filament', 'react'])"
-        },
-        types: {
-          type: "array",
-          items: {
-            type: "string",
-            enum: [
-              "code_fact",
-              "decision",
-              "mistake",
-              "pattern",
-              "agent_handoff",
-              "agent_registered",
-              "file_claim",
-              "task_archive"
-            ]
+    {
+      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") {
+      return rankCompletionValues(dataSources.repos, argumentValue);
+    }
+  }
+  if (resourceUri === "repository://{name}/memories?search={search}&type={type}&tag={tag}") {
+    if (argumentName === "tag") {
+      return rankCompletionValues(dataSources.tags, argumentValue);
+    }
+  }
+  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()
           }
-        },
-        minImportance: { type: "number", minimum: 1, maximum: 5 },
-        limit: { type: "number", minimum: 1, maximum: 100, default: 5 },
-        offset: { type: "number", minimum: 0, default: 0 },
-        includeRecap: { type: "boolean", default: false },
-        current_file_path: { type: "string" },
-        include_archived: { type: "boolean", default: false },
-        scope: {
-          type: "object",
-          properties: {
-            repo: { type: "string" },
-            branch: { type: "string" },
-            folder: { type: "string" },
-            language: { type: "string" }
+        }
+      ]
+    };
+  }
+  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
           }
-        },
-        structured: {
-          type: "boolean",
-          default: false,
-          description: "If true, returns structured JSON without the text content summary."
         }
-      },
-      required: ["query", "repo"]
-    },
-    outputSchema: {
-      type: "object",
-      properties: {
-        schema: { type: "string", enum: ["memory-search"] },
-        query: { type: "string" },
-        count: { type: "number", description: "Number of rows returned" },
-        total: { type: "number", description: "Total matching memories" },
-        offset: { type: "number" },
-        limit: { type: "number" },
-        results: {
-          type: "object",
-          properties: {
-            columns: {
-              type: "array",
-              items: { type: "string" },
-              description: "Column names: [id, title, type, importance]"
-            },
-            rows: {
-              type: "array",
-              items: { type: "array" },
-              description: "Each row: [id, title, type, importance]. Fetch full content via memory-detail"
+      ]
+    };
+  }
+  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()
             }
-          },
-          required: ["columns", "rows"]
-        }
-      },
-      required: ["schema", "query", "count", "total", "offset", "limit", "results"]
+          }
+        ]
+      };
     }
-  },
-  {
-    name: "memory-summarize",
-    title: "Memory Summarize",
-    description: "Update the summary for a repository",
-    annotations: {
-      readOnlyHint: false,
-      idempotentHint: false,
-      openWorldHint: false
-    },
-    inputSchema: {
-      type: "object",
-      properties: {
-        repo: { type: "string", description: "Repository name" },
-        signals: {
-          type: "array",
-          items: { type: "string", maxLength: 200 },
-          minItems: 1,
-          description: "High-level signals to include in summary"
-        },
-        structured: { type: "boolean", default: false, description: "If true, returns structured JSON of the summary." }
-      },
-      required: ["repo", "signals"]
-    },
-    outputSchema: {
-      type: "object",
-      properties: {
-        success: { type: "boolean" },
-        repo: { type: "string" },
-        summary: { type: "string" },
-        signalCount: { type: "number" }
-      },
-      required: ["success", "repo", "summary", "signalCount"]
+    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)
+              )
+            }
+          }
+        ]
+      };
     }
-  },
-  {
-    name: "memory-delete",
-    title: "Memory Delete",
-    description: "Soft-delete one or more memory entries. Supports single 'id' or bulk 'ids'.",
-    annotations: {
-      readOnlyHint: false,
-      idempotentHint: false,
-      destructiveHint: true,
-      openWorldHint: false
-    },
-    inputSchema: {
-      type: "object",
-      properties: {
-        repo: { type: "string", description: "Repository name (optional for single id)" },
-        id: { type: "string", format: "uuid", description: "Memory entry ID to delete" },
-        ids: {
-          type: "array",
-          items: { type: "string", format: "uuid" },
-          minItems: 1,
-          description: "Array of memory IDs to delete"
-        },
-        structured: { type: "boolean", default: false, description: "If true, returns structured JSON result." }
+    if (repoPath === "tasks") {
+      const status = query.get("status");
+      const priority = query.get("priority");
+      let tasks;
+      if (status && status !== "all") {
+        const statuses = status.split(",").map((s) => s.trim());
+        tasks = db.tasks.getTasksByMultipleStatuses(name, statuses);
+      } else {
+        tasks = db.tasks.getTasksByMultipleStatuses(name, ["backlog", "pending", "in_progress", "blocked"]);
       }
-    },
-    outputSchema: {
-      type: "object",
-      properties: {
-        success: { type: "boolean" },
-        id: { type: "string" },
-        ids: { type: "array", items: { type: "string" } },
-        repo: { type: "string" },
-        deletedCount: { type: "number" }
-      },
-      required: ["success"]
-    }
-  },
-  {
-    name: "memory-recap",
-    title: "Memory Recap",
-    description: "AGGREGATED OVERVIEW LAYER: Returns stats (counts by type) and a pointer table of top memories [id, title, type, importance]. NO content. Use for orientation only \u2014 retrieve full memory via memory-detail.",
-    annotations: {
-      readOnlyHint: true,
-      idempotentHint: true,
-      openWorldHint: false
-    },
-    inputSchema: {
-      type: "object",
-      properties: {
-        repo: { type: "string", description: "Repository name (required)" },
-        limit: {
-          type: "number",
-          minimum: 1,
-          maximum: 50,
-          default: 20,
-          description: "Maximum number of top memories to return in the pointer table"
-        },
-        offset: {
-          type: "number",
-          minimum: 0,
-          default: 0,
-          description: "Number of memories to skip for pagination (optional, default 0)"
-        },
-        structured: {
-          type: "boolean",
-          default: false,
-          description: "If true, returns structured JSON without the text content summary."
+      if (priority) {
+        const p = Number(priority);
+        if (!isNaN(p)) {
+          tasks = tasks.filter((t) => t.priority === p);
         }
-      },
-      required: ["repo"]
-    },
-    outputSchema: {
-      type: "object",
-      properties: {
-        schema: { type: "string", enum: ["memory-recap"] },
-        repo: { type: "string" },
-        count: { type: "number", description: "Number of rows in the top pointer table" },
-        total: { type: "number", description: "Total active memories in repo" },
-        offset: { type: "number" },
-        limit: { type: "number" },
-        stats: {
-          type: "object",
-          properties: {
-            by_type: {
-              type: "object",
-              description: "Count of active memories per type (e.g. { decision: 3, code_fact: 7 })"
-            }
-          },
-          required: ["by_type"]
-        },
-        top: {
-          type: "object",
-          properties: {
-            columns: {
-              type: "array",
-              items: { type: "string" },
-              description: "Column names: [id, title, type, importance]"
-            },
-            rows: {
-              type: "array",
-              items: { type: "array" },
-              description: "Each row: [id, title, type, importance]. Fetch full content via memory-detail"
+      }
+      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))
             }
-          },
-          required: ["columns", "rows"]
-        }
-      },
-      required: ["schema", "repo", "count", "total", "offset", "limit", "stats", "top"]
-    }
-  },
-  {
-    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: {
-        repo: { type: "string", description: "Repository 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 (Required for single task)" },
-        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 },
-        agent: { type: "string" },
-        role: { type: "string" },
-        doc_path: { type: "string" },
-        tags: { type: "array", items: { type: "string" } },
-        metadata: { type: "object" },
-        parent_id: { type: "string", format: "uuid" },
-        depends_on: { type: "string", format: "uuid" },
-        est_tokens: { type: "number", minimum: 0, description: "Estimated tokens budget for this task" },
-        tasks: {
-          type: "array",
-          items: {
-            type: "object",
-            properties: {
-              task_code: { type: "string" },
-              phase: { type: "string" },
-              title: { type: "string", minLength: 3, maxLength: 100 },
-              description: { type: "string" },
-              status: { type: "string", enum: ["backlog", "pending"], default: "backlog" },
-              priority: { type: "number", minimum: 1, maximum: 5, default: 3 },
-              agent: { type: "string" },
-              role: { type: "string" },
-              doc_path: { type: "string" },
-              tags: { type: "array", items: { type: "string" } },
-              metadata: { type: "object" },
-              parent_id: { type: "string", format: "uuid" },
-              depends_on: { type: "string", format: "uuid" },
-              est_tokens: { type: "number", minimum: 0 }
-            },
-            required: ["task_code", "phase", "title", "description"]
-          },
-          description: "Array of tasks for bulk creation"
-        },
-        structured: { type: "boolean", default: false, description: "If true, returns structured JSON result." }
-      },
-      required: ["repo"]
-    },
-    outputSchema: {
-      type: "object",
-      properties: {
-        success: { type: "boolean" },
-        id: { type: "string" },
-        task_code: { type: "string" },
-        repo: { type: "string" },
-        phase: { type: "string" },
-        title: { type: "string" },
-        status: { type: "string" },
-        priority: { type: "number" },
-        createdCount: { type: "number" },
-        taskCodes: { type: "array", items: { type: "string" } }
-      },
-      required: ["success", "repo"]
+          }
+        ]
+      };
     }
-  },
-  {
-    name: "task-update",
-    title: "Task Update",
-    description: "Update one or more tasks. Supports single update via 'id' or bulk update via 'ids'. Provide only the fields that need to be changed. MANDATORY WORKFLOW: You cannot move a task from 'pending' or 'blocked' directly to 'completed'. You MUST move it to 'in_progress' first. When changing status to 'completed', include 'est_tokens' with the estimated total tokens actually used for the task.",
-    annotations: {
-      readOnlyHint: false,
-      idempotentHint: false,
-      openWorldHint: false
-    },
-    inputSchema: {
-      type: "object",
-      properties: {
-        repo: { type: "string", description: "Repository name" },
-        id: { type: "string", format: "uuid", description: "Task ID (for single update)" },
-        ids: { type: "array", items: { type: "string", format: "uuid" }, description: "Task IDs (for bulk update)" },
-        task_code: { type: "string" },
-        phase: { type: "string" },
-        title: { type: "string", minLength: 3, maxLength: 100 },
-        description: { type: "string" },
-        status: {
-          type: "string",
-          enum: ["backlog", "pending", "in_progress", "completed", "canceled", "blocked"],
-          description: "New status. Transitions from 'backlog', 'pending' or 'blocked' to 'completed' are NOT allowed."
-        },
-        priority: { type: "number", minimum: 1, maximum: 5 },
-        agent: { type: "string" },
-        role: { type: "string" },
-        model: { type: "string" },
-        comment: {
-          type: "string",
-          description: "REQUIRED when changing task status. Explain WHY the status is changing (e.g., 'Starting implementation', 'Blocked by missing API docs', 'Verified fix')."
-        },
-        doc_path: { type: "string" },
-        tags: { type: "array", items: { type: "string" } },
-        metadata: { type: "object" },
-        parent_id: { type: "string", format: "uuid" },
-        depends_on: { type: "string", format: "uuid" },
-        est_tokens: {
-          type: "number",
-          minimum: 0,
-          description: "Estimated total tokens actually used for this task. Required when status changes to 'completed'."
-        },
-        force: {
-          type: "boolean",
-          description: "If true, bypasses status transition validation (e.g. pending -> completed)."
-        },
-        structured: { type: "boolean", default: false, description: "If true, returns structured JSON result." }
-      },
-      required: ["repo"]
-    },
-    outputSchema: {
-      type: "object",
-      properties: {
-        success: { type: "boolean" },
-        id: { type: "string" },
-        ids: { type: "array", items: { type: "string" } },
-        repo: { type: "string" },
-        status: { type: "string" },
-        archivedToMemory: { type: "boolean" },
-        updatedFields: {
-          type: "array",
-          items: { type: "string" }
-        },
-        updatedCount: { type: "number" }
-      },
-      required: ["success", "repo"]
+    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))
+            }
+          }
+        ]
+      };
     }
-  },
-  {
-    name: "task-delete",
-    title: "Task Delete",
-    description: "Delete one or more tasks from a repository. Supports single 'id' or bulk 'ids'.",
-    annotations: {
-      readOnlyHint: false,
-      idempotentHint: false,
-      destructiveHint: true,
-      openWorldHint: false
-    },
-    inputSchema: {
-      type: "object",
-      properties: {
-        repo: { type: "string", description: "Repository name" },
-        id: { type: "string", format: "uuid", description: "Task ID (for single deletion)" },
-        ids: { type: "array", items: { type: "string", format: "uuid" }, description: "Task IDs (for bulk deletion)" },
-        structured: { type: "boolean", default: false, description: "If true, returns structured JSON result." }
-      },
-      required: ["repo"]
-    },
-    outputSchema: {
-      type: "object",
-      properties: {
-        success: { type: "boolean" },
-        id: { type: "string" },
-        ids: { type: "array", items: { type: "string" } },
-        repo: { type: "string" },
-        deletedCount: { type: "number" }
-      },
-      required: ["success", "repo"]
+  }
+  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);
+  const sliced = entries.slice(offset, offset + limit);
+  const nextOffset = offset + sliced.length;
+  return {
+    [key]: sliced,
+    nextCursor: nextOffset < entries.length ? encodeCursor(nextOffset) : void 0
+  };
+}
+function normalizeLimit(limit) {
+  if (typeof limit !== "number" || !Number.isFinite(limit)) {
+    return DEFAULT_PAGE_SIZE;
+  }
+  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;
+  return error;
+}
+
+// src/mcp/prompts/loader.ts
+import fs5 from "fs";
+import path5 from "path";
+import { fileURLToPath as fileURLToPath3 } from "url";
+import matter from "gray-matter";
+var __filename = fileURLToPath3(import.meta.url);
+var __dirname2 = path5.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) => path5.resolve(__dirname2, relPath));
+  for (const dir of candidates) {
+    if (fs5.existsSync(dir)) {
+      const files = fs5.readdirSync(dir);
+      if (files.some((f) => f.endsWith(".md"))) {
+        return dir;
+      }
     }
-  },
-  {
-    name: "task-list",
-    title: "Task List",
-    description: "PRIMARY navigation and search tool for tasks. Returns a compact tabular list of tasks (id, task_code, title, status, priority). Defaults to in_progress and pending tasks. Use 'query' to filter by code, title, or description. Use 'status' (comma-separated) for specific filters. AGENTS: call this once at start, pick ONE task, then call task-detail.",
-    annotations: {
-      readOnlyHint: true,
-      idempotentHint: true,
-      openWorldHint: false
-    },
-    inputSchema: {
-      type: "object",
-      properties: {
-        repo: {
-          type: "string",
-          description: "Repository name"
-        },
-        status: {
-          type: "string",
-          default: "in_progress,pending",
-          description: "Comma-separated status filter (backlog, pending, in_progress, completed, canceled, blocked). Defaults to 'in_progress,pending'."
-        },
-        phase: {
-          type: "string",
-          description: "Filter by phase (e.g., 'research', 'implementation')"
-        },
-        query: {
-          type: "string",
-          description: "Search keyword matching task code, title, or description"
-        },
-        limit: {
-          type: "number",
-          minimum: 1,
-          maximum: 100,
-          default: 5,
-          description: "Maximum rows to return (default 5)"
-        },
-        offset: {
-          type: "number",
-          minimum: 0,
-          default: 0,
-          description: "Offset for pagination"
-        },
-        structured: {
-          type: "boolean",
-          default: false,
-          description: "If true, returns structured JSON without the text content summary."
+  }
+  return path5.resolve(__dirname2, "./definitions");
+}
+var PROMPT_DIR = findPromptDir();
+function listPromptFiles() {
+  if (!fs5.existsSync(PROMPT_DIR)) return [];
+  return fs5.readdirSync(PROMPT_DIR).filter((file) => file.endsWith(".md")).map((file) => file.replace(/\.md$/, "")).sort();
+}
+function loadPromptFromMarkdown(name) {
+  const filePath = path5.join(PROMPT_DIR, `${name}.md`);
+  if (!fs5.existsSync(filePath)) {
+    throw new Error(`Prompt file not found: ${filePath}`);
+  }
+  const fileContent = fs5.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()
+  };
+}
+
+// src/mcp/prompts/registry.ts
+function createPromptDefinition(loaded) {
+  return {
+    name: loaded.name,
+    description: loaded.description,
+    arguments: loaded.arguments,
+    agent: loaded.agent,
+    messages: [
+      {
+        role: "user",
+        content: {
+          type: "text",
+          text: loaded.content
         }
-      },
-      required: ["repo"]
-    },
-    outputSchema: {
-      type: "object",
-      properties: {
-        schema: { type: "string", enum: ["task-list"] },
-        tasks: {
-          type: "object",
-          properties: {
-            columns: {
-              type: "array",
-              items: { type: "string" },
-              description: "Column names in order: id, task_code, title, status, priority, comments_count"
-            },
-            rows: {
-              type: "array",
-              items: { type: "array" },
-              description: "Each row: [id, task_code, title, status, priority, comments_count]. Use task-detail to fetch full task."
-            }
-          },
-          required: ["columns", "rows"]
-        },
-        count: { type: "number" },
-        offset: { type: "number" }
-      },
-      required: ["schema", "tasks", "count"]
+      }
+    ]
+  };
+}
+var PROMPTS = {};
+var promptFiles = listPromptFiles();
+for (const name of promptFiles) {
+  try {
+    PROMPTS[name] = createPromptDefinition(loadPromptFromMarkdown(name));
+  } catch (e) {
+    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 : 25;
+  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 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");
+    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;
+  if (argName === "task_id") {
+    const values = dataSources.tasks.map((t) => t.id);
+    return rankCompletionValues(values, value);
   }
-];
+  return [];
+}
 
 export {
+  MCP_PROTOCOL_VERSION,
+  CAPABILITIES,
   logger,
   setLogLevel,
   getLogLevel,
   addLogSink,
   LOG_LEVEL_VALUES,
   createFileSink,
-  encodeCursor,
-  decodeCursor,
-  listResources,
-  listResourceTemplates,
-  completeResourceArgument,
-  readResource,
-  createSessionContext,
-  updateSessionFromInitialize,
-  updateSessionRoots,
-  extractRootsFromResult,
-  getFilesystemRoots,
-  isPathWithinRoots,
-  findContainingRoot,
-  inferRepoFromSession,
-  PROMPTS,
-  listPrompts,
-  getPrompt,
-  completePromptArgument,
   normalizeRepo,
+  SQLiteStore,
   MemoryStoreSchema,
   MemoryUpdateSchema,
   MemorySearchSchema,
@@ -3838,7 +3823,22 @@ export {
   MemoryDetailSchema,
   TaskGetSchema,
   TOOL_DEFINITIONS,
-  SQLiteStore,
-  MCP_PROTOCOL_VERSION,
-  CAPABILITIES
+  encodeCursor,
+  decodeCursor,
+  listResources,
+  listResourceTemplates,
+  completeResourceArgument,
+  readResource,
+  createSessionContext,
+  updateSessionFromInitialize,
+  updateSessionRoots,
+  extractRootsFromResult,
+  getFilesystemRoots,
+  isPathWithinRoots,
+  findContainingRoot,
+  inferRepoFromSession,
+  PROMPTS,
+  listPrompts,
+  getPrompt,
+  completePromptArgument
 };