@vheins/local-memory-mcp 0.8.11 → 0.8.13

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

@@ -1,41 +1,5 @@
-// 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";
+import fs from "fs";
 var LEVELS = {
   debug: 0,
   info: 1,
@@ -155,11 +119,11 @@ function addLogSink(sink) {
 }
 var LOG_LEVEL_VALUES = Object.keys(LEVELS);
 function createFileSink(logDir, maxFiles = 5) {
-  fs2.mkdirSync(logDir, { recursive: true });
-  const existing = fs2.readdirSync(logDir).filter((f) => f.startsWith("mcp-") && f.endsWith(".log")).sort();
+  fs.mkdirSync(logDir, { recursive: true });
+  const existing = fs.readdirSync(logDir).filter((f) => f.startsWith("mcp-") && f.endsWith(".log")).sort();
   while (existing.length >= maxFiles) {
     try {
-      fs2.unlinkSync(`${logDir}/${existing.shift()}`);
+      fs.unlinkSync(`${logDir}/${existing.shift()}`);
     } catch {
     }
   }
@@ -169,16 +133,118 @@ function createFileSink(logDir, maxFiles = 5) {
     const line = `${(/* @__PURE__ */ new Date()).toISOString()} [${payload.level.toUpperCase()}] [pid:${process.pid}] ${JSON.stringify(payload.data)}
 `;
     try {
-      fs2.appendFileSync(logFile, line);
+      fs.appendFileSync(logFile, line);
     } catch {
     }
   };
 }
 
+// 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 fs4 from "fs";
+import fs3 from "fs";
 import os from "os";
 
 // src/mcp/storage/migrations.ts
@@ -1900,7 +1966,7 @@ var SummaryEntity = class extends BaseEntity {
 // src/mcp/storage/write-lock.ts
 import lockfile from "proper-lockfile";
 import path2 from "path";
-import fs3 from "fs";
+import fs2 from "fs";
 var LOCK_STALE_MS = 15e3;
 var LOCK_RETRY_DELAY_MS = 100;
 var LOCK_RETRY_COUNT = 150;
@@ -1909,9 +1975,9 @@ var WriteLock = class {
   locked = false;
   constructor(dbPath) {
     this.lockTarget = dbPath;
-    if (!fs3.existsSync(dbPath)) {
-      fs3.mkdirSync(path2.dirname(dbPath), { recursive: true });
-      fs3.writeFileSync(dbPath, "");
+    if (!fs2.existsSync(dbPath)) {
+      fs2.mkdirSync(path2.dirname(dbPath), { recursive: true });
+      fs2.writeFileSync(dbPath, "");
     }
   }
   /**
@@ -1965,11 +2031,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 (fs4.existsSync(standardPath)) return standardPath;
+  if (fs3.existsSync(standardPath)) return standardPath;
   const legacyPath = path3.join(os.homedir(), ".config", "local-memory-mcp", "memory.db");
-  if (fs4.existsSync(legacyPath)) return legacyPath;
+  if (fs3.existsSync(legacyPath)) return legacyPath;
   const localCwdFile = path3.join(process.cwd(), "storage", "memory.db");
-  if (fs4.existsSync(localCwdFile)) return localCwdFile;
+  if (fs3.existsSync(localCwdFile)) return localCwdFile;
   return standardPath;
 }
 var DB_PATH = resolveDbPath();
@@ -1987,8 +2053,8 @@ var SQLiteStore = class _SQLiteStore {
     this.dbPathInstance = finalPath;
     if (finalPath !== ":memory:") {
       const dbDir = path3.dirname(finalPath);
-      if (!fs4.existsSync(dbDir)) {
-        fs4.mkdirSync(dbDir, { recursive: true });
+      if (!fs3.existsSync(dbDir)) {
+        fs3.mkdirSync(dbDir, { recursive: true });
       }
     }
     this.db = new Database(finalPath);
@@ -2040,12 +2106,12 @@ var SQLiteStore = class _SQLiteStore {
    */
   _attemptRecovery(dbPath) {
     const backupPath = dbPath + ".backup";
-    if (fs4.existsSync(backupPath)) {
+    if (fs3.existsSync(backupPath)) {
       logger.warn("[SQLiteStore] Attempting recovery from backup", { backupPath });
       try {
         const corruptPath = `${dbPath}.corrupt_${(/* @__PURE__ */ new Date()).toISOString().replace(/[:.]/g, "").slice(0, 15)}`;
-        fs4.copyFileSync(dbPath, corruptPath);
-        fs4.copyFileSync(backupPath, dbPath);
+        fs3.copyFileSync(dbPath, corruptPath);
+        fs3.copyFileSync(backupPath, dbPath);
         logger.warn("[SQLiteStore] Recovery successful. Corrupt file saved to", { corruptPath });
       } catch (err) {
         logger.error("[SQLiteStore] Recovery failed", { error: String(err) });
@@ -2063,7 +2129,7 @@ var SQLiteStore = class _SQLiteStore {
     try {
       this.db.pragma("wal_checkpoint(PASSIVE)");
       const backupPath = this.dbPathInstance + ".backup";
-      fs4.copyFileSync(this.dbPathInstance, backupPath);
+      fs3.copyFileSync(this.dbPathInstance, backupPath);
     } catch (err) {
       logger.warn("[SQLiteStore] Backup failed", { error: String(err) });
     }
@@ -2108,1721 +2174,1635 @@ var SQLiteStore = class _SQLiteStore {
   }
 };
 
-// src/mcp/session.ts
-import path4 from "path";
+// src/mcp/capabilities.ts
 import { fileURLToPath as fileURLToPath2 } from "url";
-function createSessionContext() {
-  return {
-    roots: [],
-    supportsRoots: false,
-    supportsSampling: false,
-    supportsSamplingTools: false,
-    supportsElicitation: false,
-    supportsElicitationForm: false,
-    supportsElicitationUrl: false
-  };
+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 {
 }
-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");
+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 supportsElicitationMode(capability, mode) {
-  if (!capability || typeof capability !== "object") {
-    return false;
+function decodeCursor(cursor) {
+  if (cursor === void 0 || cursor === null || cursor === "") {
+    return 0;
   }
-  const cap = capability;
-  if (mode === "form") {
-    return Object.keys(cap).length === 0 || typeof cap.form === "object";
+  if (typeof cursor !== "string" || cursor.trim() === "") {
+    throw invalidPaginationParams("Invalid cursor");
   }
-  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 });
+  let decoded;
+  try {
+    decoded = Buffer.from(cursor, "base64").toString("utf8");
+  } catch {
+    throw invalidPaginationParams("Invalid cursor");
   }
-  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(path4.resolve(fileURLToPath2(root.uri)));
-    } catch {
-    }
+  if (!/^\d+$/.test(decoded)) {
+    throw invalidPaginationParams("Invalid cursor");
   }
-  return resolved;
+  const offset = Number.parseInt(decoded, 10);
+  if (!Number.isFinite(offset) || offset < 0) {
+    throw invalidPaginationParams("Invalid cursor");
+  }
+  return offset;
 }
-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 invalidPaginationParams(message) {
+  const error = new Error(message);
+  error.code = -32602;
+  return error;
 }
-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;
-    }
+
+// 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 null;
+  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 inferRepoFromSession(session) {
-  const roots = getFilesystemRoots(session);
-  if (roots.length === 1) {
-    return path4.basename(roots[0]);
-  }
-  return void 0;
+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/tools/schemas.ts
-import { z } from "zod";
-var MemoryScopeSchema = z.object({
-  repo: z.string().min(1).transform(normalizeRepo),
-  branch: z.string().optional(),
-  folder: z.string().optional(),
-  language: z.string().optional()
-});
-var MemoryTypeSchema = z.enum([
-  "code_fact",
-  "decision",
-  "mistake",
-  "pattern",
-  "agent_handoff",
-  "agent_registered",
-  "file_claim",
-  "task_archive"
-]);
-var MemoryStoreSchema = z.object({
-  code: z.string().max(20).optional(),
-  type: MemoryTypeSchema,
-  title: z.string().min(3).max(255),
-  content: z.string().min(10),
-  importance: z.number().min(1).max(5),
-  agent: z.string().min(1),
-  role: z.string().optional().default("unknown"),
-  model: z.string().min(1),
-  scope: MemoryScopeSchema,
-  ttlDays: z.number().min(1).optional(),
-  supersedes: z.string().uuid().optional(),
-  tags: z.array(z.string()).optional(),
-  metadata: z.record(z.string(), z.any()).optional(),
-  is_global: z.boolean().default(false),
-  structured: z.boolean().default(false)
-});
-var MemoryUpdateSchema = z.object({
-  id: z.string().uuid(),
-  type: MemoryTypeSchema.optional(),
-  title: z.string().min(3).max(255).optional(),
-  content: z.string().min(10).optional(),
-  importance: z.number().min(1).max(5).optional(),
-  agent: z.string().optional(),
-  role: z.string().optional(),
-  status: z.enum(["active", "archived"]).optional(),
-  supersedes: z.string().uuid().optional(),
-  tags: z.array(z.string()).optional(),
-  metadata: z.record(z.string(), z.any()).optional(),
-  is_global: z.boolean().optional(),
-  completed_at: z.string().optional(),
-  structured: z.boolean().default(false)
-}).refine(
-  (data) => data.type !== void 0 || data.content !== void 0 || data.title !== void 0 || data.importance !== void 0 || data.status !== void 0 || data.supersedes !== void 0 || data.tags !== void 0 || data.metadata !== void 0 || data.is_global !== void 0 || data.agent !== void 0 || data.role !== void 0 || data.completed_at !== void 0,
-  { message: "At least one field must be provided for update" }
-);
-var MemorySearchSchema = z.object({
-  query: z.string().min(3),
-  prompt: z.string().optional(),
-  repo: z.string().min(1).transform(normalizeRepo),
-  types: z.array(MemoryTypeSchema).optional(),
-  minImportance: z.number().min(1).max(5).optional(),
-  limit: z.number().min(1).max(100).default(5),
-  offset: z.number().min(0).default(0),
-  includeRecap: z.boolean().default(false),
-  current_file_path: z.string().optional(),
-  include_archived: z.boolean().default(false),
-  current_tags: z.array(z.string()).optional(),
-  scope: MemoryScopeSchema.partial().optional(),
-  structured: z.boolean().default(false)
-});
-var MemoryAcknowledgeSchema = z.object({
-  memory_id: z.string().uuid(),
-  status: z.enum(["used", "irrelevant", "contradictory"]),
-  application_context: z.string().min(10).optional(),
-  structured: z.boolean().default(false)
-});
-var MemoryRecapSchema = z.object({
-  repo: z.string().min(1).transform(normalizeRepo),
-  limit: z.number().min(1).max(50).default(20),
-  offset: z.number().min(0).default(0),
-  structured: z.boolean().default(false)
-});
-var MemoryDeleteSchema = z.object({
-  repo: z.string().min(1).transform(normalizeRepo).optional(),
-  id: z.string().uuid().optional(),
-  ids: z.array(z.string().uuid()).min(1).optional(),
-  structured: z.boolean().default(false)
-}).refine((data) => data.id !== void 0 || data.ids !== void 0, {
-  message: "Either 'id' or 'ids' must be provided for deletion"
-});
-var MemorySummarizeSchema = z.object({
-  repo: z.string().min(1).transform(normalizeRepo),
-  signals: z.array(z.string().max(200)).min(1),
-  structured: z.boolean().default(false)
-});
-var MemorySynthesizeSchema = z.object({
-  repo: z.string().min(1).transform(normalizeRepo).optional(),
-  objective: z.string().min(5),
-  current_file_path: z.string().optional(),
-  include_summary: z.boolean().default(true),
-  include_tasks: z.boolean().default(true),
-  use_tools: z.boolean().default(true),
-  max_iterations: z.number().int().min(1).max(5).default(3),
-  max_tokens: z.number().int().min(128).max(4e3).default(1200),
-  structured: z.boolean().default(false)
-});
-var TaskStatusSchema = z.enum(["backlog", "pending", "in_progress", "completed", "canceled", "blocked"]);
-var TaskPrioritySchema = z.number().min(1).max(5);
-var SingleTaskCreateSchema = z.object({
-  task_code: z.string().min(1),
-  phase: z.string().min(1),
-  title: z.string().min(3).max(100),
-  description: z.string().min(1),
-  status: TaskStatusSchema.default("backlog"),
-  priority: TaskPrioritySchema.default(3),
-  agent: z.string().optional(),
-  role: z.string().optional(),
-  doc_path: z.string().optional(),
-  tags: z.array(z.string()).optional(),
-  metadata: z.record(z.string(), z.any()).optional(),
-  parent_id: z.string().uuid().optional(),
-  depends_on: z.string().uuid().optional(),
-  est_tokens: z.number().int().min(0).optional()
-});
-var TaskCreateSchema = z.object({
-  repo: z.string().min(1).transform(normalizeRepo),
-  // Allow single task fields at top level (backward compatibility & single use)
-  task_code: z.string().min(1).optional(),
-  phase: z.string().min(1).optional(),
-  title: z.string().min(3).max(100).optional(),
-  description: z.string().min(1).optional(),
-  status: TaskStatusSchema.optional(),
-  priority: TaskPrioritySchema.optional(),
-  agent: z.string().optional(),
-  role: z.string().optional(),
-  doc_path: z.string().optional(),
-  tags: z.array(z.string()).optional(),
-  metadata: z.record(z.string(), z.any()).optional(),
-  parent_id: z.string().uuid().optional(),
-  depends_on: z.string().uuid().optional(),
-  est_tokens: z.number().int().min(0).optional(),
-  // Allow bulk tasks
-  tasks: z.array(SingleTaskCreateSchema).min(1).optional(),
-  structured: z.boolean().default(false)
-}).refine(
-  (data) => {
-    if (data.tasks) return true;
-    return !!(data.task_code && data.phase && data.title && data.description);
-  },
-  { message: "Either 'tasks' array or single task fields (task_code, phase, title, description) must be provided" }
-);
-var TaskCreateInteractiveSchema = SingleTaskCreateSchema.partial().extend({
-  repo: z.string().min(1).transform(normalizeRepo).optional(),
-  structured: z.boolean().default(false)
-});
-var TaskUpdateSchema = z.object({
-  repo: z.string().min(1).transform(normalizeRepo),
-  id: z.string().uuid().optional(),
-  ids: z.array(z.string().uuid()).min(1).optional(),
-  task_code: z.string().optional(),
-  phase: z.string().optional(),
-  title: z.string().min(3).max(100).optional(),
-  description: z.string().optional(),
-  status: TaskStatusSchema.optional(),
-  priority: TaskPrioritySchema.optional(),
-  agent: z.string().min(1, "agent name is required").optional(),
-  role: z.string().min(1, "agent role is required").optional(),
-  model: z.string().optional(),
-  comment: z.string().min(1).optional(),
-  doc_path: z.string().optional(),
-  tags: z.array(z.string()).optional(),
-  metadata: z.record(z.string(), z.any()).optional(),
-  parent_id: z.string().uuid().optional(),
-  depends_on: z.string().uuid().optional(),
-  est_tokens: z.number().int().min(0).optional(),
-  force: z.boolean().optional(),
-  structured: z.boolean().default(false)
-}).refine((data) => data.id !== void 0 || data.ids !== void 0, {
-  message: "Either 'id' or 'ids' must be provided for update"
-}).refine((data) => Object.keys(data).length > 2, {
-  message: "At least one field besides repo and id/ids must be provided for update"
-});
-var TaskListSchema = z.object({
-  repo: z.string().min(1).transform(normalizeRepo),
-  status: z.string().optional(),
-  phase: z.string().optional(),
-  query: z.string().optional(),
-  limit: z.number().min(1).max(100).default(15),
-  offset: z.number().min(0).default(0),
-  structured: z.boolean().default(false)
-});
-var TaskSearchSchema = z.object({
-  repo: z.string().min(1).transform(normalizeRepo),
-  query: z.string().min(1),
-  status: z.string().optional(),
-  limit: z.number().min(1).max(100).default(10),
-  offset: z.number().min(0).default(0),
-  structured: z.boolean().default(false)
-});
-var TaskDeleteSchema = z.object({
-  repo: z.string().min(1).transform(normalizeRepo),
-  id: z.string().uuid().optional(),
-  ids: z.array(z.string().uuid()).min(1).optional(),
-  structured: z.boolean().default(false)
-}).refine((data) => data.id !== void 0 || data.ids !== void 0, {
-  message: "Either 'id' or 'ids' must be provided for deletion"
-});
-var MemoryDetailSchema = z.object({
-  id: z.string().uuid().optional(),
-  code: z.string().max(20).optional(),
-  structured: z.boolean().default(false)
-}).refine((data) => data.id !== void 0 || data.code !== void 0, {
-  message: "Either id or code must be provided"
-});
-var TaskGetSchema = z.object({
-  repo: z.string().min(1).transform(normalizeRepo),
-  id: z.string().uuid().optional(),
-  task_code: z.string().optional(),
-  structured: z.boolean().default(false)
-}).refine((data) => data.id !== void 0 || data.task_code !== void 0, {
-  message: "Either id or task_code must be provided"
-});
-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.",
-    annotations: {
-      readOnlyHint: true,
-      idempotentHint: true,
-      openWorldHint: false
+// 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()
+      }
     },
-    execution: {
-      taskSupport: "optional"
+    {
+      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 }
     },
-    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"]
+    {
+      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 }
     },
-    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
+    {
+      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: {
-        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." }
-      }
+    // ── 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: {
-        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"]
+    {
+      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 }
     }
-  },
-  {
-    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"]
+  ];
+  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);
     }
-  },
-  {
-    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"]
+  }
+  if (resourceUri === "repository://{name}/memories?search={search}&type={type}&tag={tag}") {
+    if (argumentName === "tag") {
+      return rankCompletionValues(dataSources.tags, argumentValue);
     }
-  },
-  {
-    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"
-            ]
+  }
+  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()
           }
-        },
-        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"]
+      ]
+    };
+  }
+  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
+          }
         }
-      },
-      required: ["schema", "query", "count", "total", "offset", "limit", "results"]
+      ]
+    };
+  }
+  const taskIdMatch = uri.match(/^task:\/\/([0-9a-f-]{36})$/i);
+  if (taskIdMatch) {
+    const id = taskIdMatch[1];
+    const task = db.tasks.getTaskById(id);
+    if (!task) throw resourceNotFound(`Task with ID ${id} not found.`, uri);
+    const payload = JSON.stringify(task, null, 2);
+    return {
+      contents: [
+        {
+          uri,
+          mimeType: "application/json",
+          text: payload,
+          size: Buffer.byteLength(payload, "utf8"),
+          annotations: {
+            audience: ["assistant"],
+            priority: 0.8,
+            lastModified: task.updated_at || task.created_at
+          }
+        }
+      ]
+    };
+  }
+  const repoBase = parseRepoUri(uri);
+  if (repoBase) {
+    const { name, path: repoPath, query } = repoBase;
+    if (repoPath === "summary") {
+      const summary = db.summaries.getSummary(name);
+      const text = summary?.summary || `No summary available for repository: ${name}`;
+      return {
+        contents: [
+          {
+            uri,
+            mimeType: "text/plain",
+            text,
+            size: Buffer.byteLength(text, "utf8"),
+            annotations: {
+              audience: ["assistant"],
+              priority: 0.95,
+              lastModified: summary?.updated_at || (/* @__PURE__ */ new Date()).toISOString()
+            }
+          }
+        ]
+      };
     }
-  },
-  {
-    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"]
+      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 [];
+}
+
+// src/mcp/tools/schemas.ts
+import { z } from "zod";
+var MemoryScopeSchema = z.object({
+  repo: z.string().min(1).transform(normalizeRepo),
+  branch: z.string().optional(),
+  folder: z.string().optional(),
+  language: z.string().optional()
+});
+var MemoryTypeSchema = z.enum([
+  "code_fact",
+  "decision",
+  "mistake",
+  "pattern",
+  "agent_handoff",
+  "agent_registered",
+  "file_claim",
+  "task_archive"
+]);
+var MemoryStoreSchema = z.object({
+  code: z.string().max(20).optional(),
+  type: MemoryTypeSchema,
+  title: z.string().min(3).max(255),
+  content: z.string().min(10),
+  importance: z.number().min(1).max(5),
+  agent: z.string().min(1),
+  role: z.string().optional().default("unknown"),
+  model: z.string().min(1),
+  scope: MemoryScopeSchema,
+  ttlDays: z.number().min(1).optional(),
+  supersedes: z.string().uuid().optional(),
+  tags: z.array(z.string()).optional(),
+  metadata: z.record(z.string(), z.any()).optional(),
+  is_global: z.boolean().default(false),
+  structured: z.boolean().default(false)
+});
+var MemoryUpdateSchema = z.object({
+  id: z.string().uuid(),
+  type: MemoryTypeSchema.optional(),
+  title: z.string().min(3).max(255).optional(),
+  content: z.string().min(10).optional(),
+  importance: z.number().min(1).max(5).optional(),
+  agent: z.string().optional(),
+  role: z.string().optional(),
+  status: z.enum(["active", "archived"]).optional(),
+  supersedes: z.string().uuid().optional(),
+  tags: z.array(z.string()).optional(),
+  metadata: z.record(z.string(), z.any()).optional(),
+  is_global: z.boolean().optional(),
+  completed_at: z.string().optional(),
+  structured: z.boolean().default(false)
+}).refine(
+  (data) => data.type !== void 0 || data.content !== void 0 || data.title !== void 0 || data.importance !== void 0 || data.status !== void 0 || data.supersedes !== void 0 || data.tags !== void 0 || data.metadata !== void 0 || data.is_global !== void 0 || data.agent !== void 0 || data.role !== void 0 || data.completed_at !== void 0,
+  { message: "At least one field must be provided for update" }
+);
+var MemorySearchSchema = z.object({
+  query: z.string().min(3),
+  prompt: z.string().optional(),
+  repo: z.string().min(1).transform(normalizeRepo),
+  types: z.array(MemoryTypeSchema).optional(),
+  minImportance: z.number().min(1).max(5).optional(),
+  limit: z.number().min(1).max(100).default(5),
+  offset: z.number().min(0).default(0),
+  includeRecap: z.boolean().default(false),
+  current_file_path: z.string().optional(),
+  include_archived: z.boolean().default(false),
+  current_tags: z.array(z.string()).optional(),
+  scope: MemoryScopeSchema.partial().optional(),
+  structured: z.boolean().default(false)
+});
+var MemoryAcknowledgeSchema = z.object({
+  memory_id: z.string().uuid(),
+  status: z.enum(["used", "irrelevant", "contradictory"]),
+  application_context: z.string().min(10).optional(),
+  structured: z.boolean().default(false)
+});
+var MemoryRecapSchema = z.object({
+  repo: z.string().min(1).transform(normalizeRepo),
+  limit: z.number().min(1).max(50).default(20),
+  offset: z.number().min(0).default(0),
+  structured: z.boolean().default(false)
+});
+var MemoryDeleteSchema = z.object({
+  repo: z.string().min(1).transform(normalizeRepo).optional(),
+  id: z.string().uuid().optional(),
+  ids: z.array(z.string().uuid()).min(1).optional(),
+  structured: z.boolean().default(false)
+}).refine((data) => data.id !== void 0 || data.ids !== void 0, {
+  message: "Either 'id' or 'ids' must be provided for deletion"
+});
+var MemorySummarizeSchema = z.object({
+  repo: z.string().min(1).transform(normalizeRepo),
+  signals: z.array(z.string().max(200)).min(1),
+  structured: z.boolean().default(false)
+});
+var MemorySynthesizeSchema = z.object({
+  repo: z.string().min(1).transform(normalizeRepo).optional(),
+  objective: z.string().min(5),
+  current_file_path: z.string().optional(),
+  include_summary: z.boolean().default(true),
+  include_tasks: z.boolean().default(true),
+  use_tools: z.boolean().default(true),
+  max_iterations: z.number().int().min(1).max(5).default(3),
+  max_tokens: z.number().int().min(128).max(4e3).default(1200),
+  structured: z.boolean().default(false)
+});
+var TaskStatusSchema = z.enum(["backlog", "pending", "in_progress", "completed", "canceled", "blocked"]);
+var TaskPrioritySchema = z.number().min(1).max(5);
+var SingleTaskCreateSchema = z.object({
+  task_code: z.string().min(1),
+  phase: z.string().min(1),
+  title: z.string().min(3).max(100),
+  description: z.string().min(1),
+  status: TaskStatusSchema.default("backlog"),
+  priority: TaskPrioritySchema.default(3),
+  agent: z.string().optional(),
+  role: z.string().optional(),
+  doc_path: z.string().optional(),
+  tags: z.array(z.string()).optional(),
+  metadata: z.record(z.string(), z.any()).optional(),
+  parent_id: z.string().uuid().optional(),
+  depends_on: z.string().uuid().optional(),
+  est_tokens: z.number().int().min(0).optional()
+});
+var TaskCreateSchema = z.object({
+  repo: z.string().min(1).transform(normalizeRepo),
+  // Allow single task fields at top level (backward compatibility & single use)
+  task_code: z.string().min(1).optional(),
+  phase: z.string().min(1).optional(),
+  title: z.string().min(3).max(100).optional(),
+  description: z.string().min(1).optional(),
+  status: TaskStatusSchema.optional(),
+  priority: TaskPrioritySchema.optional(),
+  agent: z.string().optional(),
+  role: z.string().optional(),
+  doc_path: z.string().optional(),
+  tags: z.array(z.string()).optional(),
+  metadata: z.record(z.string(), z.any()).optional(),
+  parent_id: z.string().uuid().optional(),
+  depends_on: z.string().uuid().optional(),
+  est_tokens: z.number().int().min(0).optional(),
+  // Allow bulk tasks
+  tasks: z.array(SingleTaskCreateSchema).min(1).optional(),
+  structured: z.boolean().default(false)
+}).refine(
+  (data) => {
+    if (data.tasks) return true;
+    return !!(data.task_code && data.phase && data.title && data.description);
+  },
+  { message: "Either 'tasks' array or single task fields (task_code, phase, title, description) must be provided" }
+);
+var TaskCreateInteractiveSchema = SingleTaskCreateSchema.partial().extend({
+  repo: z.string().min(1).transform(normalizeRepo).optional(),
+  structured: z.boolean().default(false)
+});
+var TaskUpdateSchema = z.object({
+  repo: z.string().min(1).transform(normalizeRepo),
+  id: z.string().uuid().optional(),
+  ids: z.array(z.string().uuid()).min(1).optional(),
+  task_code: z.string().optional(),
+  phase: z.string().optional(),
+  title: z.string().min(3).max(100).optional(),
+  description: z.string().optional(),
+  status: TaskStatusSchema.optional(),
+  priority: TaskPrioritySchema.optional(),
+  agent: z.string().min(1, "agent name is required").optional(),
+  role: z.string().min(1, "agent role is required").optional(),
+  model: z.string().optional(),
+  comment: z.string().min(1).optional(),
+  doc_path: z.string().optional(),
+  tags: z.array(z.string()).optional(),
+  metadata: z.record(z.string(), z.any()).optional(),
+  parent_id: z.string().uuid().optional(),
+  depends_on: z.string().uuid().optional(),
+  est_tokens: z.number().int().min(0).optional(),
+  force: z.boolean().optional(),
+  structured: z.boolean().default(false)
+}).refine((data) => data.id !== void 0 || data.ids !== void 0, {
+  message: "Either 'id' or 'ids' must be provided for update"
+}).refine((data) => Object.keys(data).length > 2, {
+  message: "At least one field besides repo and id/ids must be provided for update"
+});
+var TaskListSchema = z.object({
+  repo: z.string().min(1).transform(normalizeRepo),
+  status: z.string().optional(),
+  phase: z.string().optional(),
+  query: z.string().optional(),
+  limit: z.number().min(1).max(100).default(15),
+  offset: z.number().min(0).default(0),
+  structured: z.boolean().default(false)
+});
+var TaskSearchSchema = z.object({
+  repo: z.string().min(1).transform(normalizeRepo),
+  query: z.string().min(1),
+  status: z.string().optional(),
+  limit: z.number().min(1).max(100).default(10),
+  offset: z.number().min(0).default(0),
+  structured: z.boolean().default(false)
+});
+var TaskDeleteSchema = z.object({
+  repo: z.string().min(1).transform(normalizeRepo),
+  id: z.string().uuid().optional(),
+  ids: z.array(z.string().uuid()).min(1).optional(),
+  structured: z.boolean().default(false)
+}).refine((data) => data.id !== void 0 || data.ids !== void 0, {
+  message: "Either 'id' or 'ids' must be provided for deletion"
+});
+var MemoryDetailSchema = z.object({
+  id: z.string().uuid().optional(),
+  code: z.string().max(20).optional(),
+  structured: z.boolean().default(false)
+}).refine((data) => data.id !== void 0 || data.code !== void 0, {
+  message: "Either id or code must be provided"
+});
+var TaskGetSchema = z.object({
+  repo: z.string().min(1).transform(normalizeRepo),
+  id: z.string().uuid().optional(),
+  task_code: z.string().optional(),
+  structured: z.boolean().default(false)
+}).refine((data) => data.id !== void 0 || data.task_code !== void 0, {
+  message: "Either id or task_code must be provided"
+});
+var TOOL_DEFINITIONS = [
   {
-    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.",
+    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 (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)"
+        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."
         },
-        structured: {
+        include_summary: { type: "boolean", default: true },
+        include_tasks: { type: "boolean", default: true },
+        use_tools: {
           type: "boolean",
-          default: false,
-          description: "If true, returns structured JSON without the text content summary."
-        }
+          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: ["repo"]
+      required: ["objective"]
     },
     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"
-            }
-          },
-          required: ["columns", "rows"]
-        }
+        objective: { type: "string" },
+        answer: { type: "string" },
+        model: { type: "string" },
+        stopReason: { type: "string" },
+        iterations: { type: "number" },
+        toolCalls: { type: "number" }
       },
-      required: ["schema", "repo", "count", "total", "offset", "limit", "stats", "top"]
+      required: ["repo", "objective", "answer", "iterations", "toolCalls"]
     }
   },
   {
-    name: "task-create",
-    title: "Task Create",
-    description: "Register one or more new tasks in a repository. task_code must be unique within the repository. Supports single task object or an array of tasks for bulk creation.",
+    name: "task-create-interactive",
+    title: "Interactive Task Create",
+    description: "Create a task with MCP elicitation fallback for any missing required fields. Best when an agent knows a task is needed but still needs user confirmation for repo, title, or phase.",
     annotations: {
       readOnlyHint: false,
       idempotentHint: false,
+      destructiveHint: false,
       openWorldHint: false
     },
     inputSchema: {
       type: "object",
       properties: {
-        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: {
+        repo: {
           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'."
+          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" },
-        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" },
+        task_code: { type: "string" },
         phase: { type: "string" },
         title: { type: "string" },
         status: { type: "string" },
-        priority: { type: "number" },
-        createdCount: { type: "number" },
-        taskCodes: { type: "array", items: { type: "string" } }
+        priority: { type: "number" }
       },
-      required: ["success", "repo"]
+      required: ["repo", "task_code", "phase", "title", "status", "priority"]
     }
   },
   {
-    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
-    },
+    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: {
-        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" }
+        id: { type: "string", format: "uuid", description: "Memory entry ID" },
+        structured: { type: "boolean", default: false, description: "If true, returns structured JSON details." }
       },
-      required: ["success", "repo"]
+      required: ["id"]
     }
   },
   {
-    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
-    },
+    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 (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" }
+        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: ["success", "repo"]
+      required: ["repo"]
     }
   },
   {
-    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.",
+    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: true,
-      idempotentHint: true,
+      readOnlyHint: false,
+      idempotentHint: false,
+      destructiveHint: false,
       openWorldHint: false
     },
     inputSchema: {
       type: "object",
       properties: {
-        repo: {
-          type: "string",
-          description: "Repository name"
-        },
-        status: {
+        type: {
           type: "string",
-          default: "in_progress,pending",
-          description: "Comma-separated status filter (backlog, pending, in_progress, completed, canceled, blocked). Defaults to 'in_progress,pending'."
+          enum: [
+            "code_fact",
+            "decision",
+            "mistake",
+            "pattern",
+            "agent_handoff",
+            "agent_registered",
+            "file_claim",
+            "task_archive"
+          ],
+          description: "Type of memory being stored"
         },
-        phase: {
+        title: {
           type: "string",
-          description: "Filter by phase (e.g., 'research', 'implementation')"
+          minLength: 3,
+          maxLength: 100,
+          description: "Short human-readable title for the memory. Do not embed bracketed metadata like agent/role/date prefixes here."
         },
-        query: {
+        content: {
           type: "string",
-          description: "Search keyword matching task code, title, or description"
+          minLength: 10,
+          description: "The memory content"
         },
-        limit: {
+        importance: {
           type: "number",
           minimum: 1,
-          maximum: 100,
-          default: 5,
-          description: "Maximum rows to return (default 5)"
+          maximum: 5,
+          description: "Importance score (1-5)"
         },
-        offset: {
-          type: "number",
-          minimum: 0,
-          default: 0,
-          description: "Offset for pagination"
+        agent: {
+          type: "string",
+          description: "Name of the agent creating this memory"
         },
-        structured: {
-          type: "boolean",
-          default: false,
-          description: "If true, returns structured JSON without the text content summary."
-        }
-      },
-      required: ["repo"]
-    },
-    outputSchema: {
-      type: "object",
-      properties: {
-        schema: { type: "string", enum: ["task-list"] },
-        tasks: {
+        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: {
-            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."
-            }
+            repo: { type: "string", description: "Repository name" },
+            branch: { type: "string" },
+            folder: { type: "string" },
+            language: { type: "string" }
           },
-          required: ["columns", "rows"]
+          required: ["repo"]
         },
-        count: { type: "number" },
-        offset: { type: "number" }
-      },
-      required: ["schema", "tasks", "count"]
-    }
-  }
-];
-
-// 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 }
-    },
-    // ── 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 }
+        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"]
     },
-    // ── 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 }
+    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
     },
-    {
-      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 }
+    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"]
     },
-    // ── 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);
+    outputSchema: {
+      type: "object",
+      properties: {
+        success: { type: "boolean" },
+        id: { type: "string" },
+        status: { type: "string" }
+      },
+      required: ["success", "id", "status"]
     }
-  }
-  throw invalidCompletionParams(`Unknown resource template or argument: ${resourceUri} (${argumentName})`);
-}
-function readResource(uri, db, session) {
-  logger.info("[Tool] resource.read", { uri });
-  if (uri === "repository://index") {
-    const repos = db.system.listRepoNavigation();
-    const payload = JSON.stringify(repos, null, 2);
-    return {
-      contents: [
-        {
-          uri,
-          mimeType: "application/json",
-          text: payload,
-          size: Buffer.byteLength(payload, "utf8"),
-          annotations: {
-            audience: ["assistant"],
-            priority: 1,
-            lastModified: (/* @__PURE__ */ new Date()).toISOString()
-          }
-        }
-      ]
-    };
-  }
-  if (uri === "session://roots") {
-    const payload = JSON.stringify({ roots: session?.roots ?? [] }, null, 2);
-    return {
-      contents: [
-        {
-          uri,
-          mimeType: "application/json",
-          text: payload,
-          size: Buffer.byteLength(payload, "utf8"),
-          annotations: {
-            audience: ["assistant"],
-            priority: 0.95,
-            lastModified: (/* @__PURE__ */ new Date()).toISOString()
-          }
+  },
+  {
+    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" }
         }
-      ]
-    };
-  }
-  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
+      },
+      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"
+            ]
           }
-        }
-      ]
-    };
-  }
-  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
+        },
+        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."
         }
-      ]
-    };
-  }
-  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: ["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"]
     }
-    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-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 === "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"]);
+  },
+  {
+    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 (priority) {
-        const p = Number(priority);
-        if (!isNaN(p)) {
-          tasks = tasks.filter((t) => t.priority === p);
+    },
+    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."
         }
-      }
-      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: ["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"
             }
-          }
-        ]
-      };
+          },
+          required: ["columns", "rows"]
+        }
+      },
+      required: ["schema", "repo", "count", "total", "offset", "limit", "stats", "top"]
     }
-    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-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"]
     }
-  }
-  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-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"]
     }
-  }
-  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
+  },
+  {
+    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"]
+    }
+  },
+  {
+    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."
         }
-      }
-    ]
-  };
-}
-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);
+      },
+      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"]
     }
-    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,
-  normalizeRepo,
-  SQLiteStore,
-  MemoryStoreSchema,
-  MemoryUpdateSchema,
-  MemorySearchSchema,
-  MemoryAcknowledgeSchema,
-  MemoryRecapSchema,
-  MemoryDeleteSchema,
-  MemorySummarizeSchema,
-  MemorySynthesizeSchema,
-  TaskCreateSchema,
-  TaskCreateInteractiveSchema,
-  TaskUpdateSchema,
-  TaskListSchema,
-  TaskDeleteSchema,
-  MemoryDetailSchema,
-  TaskGetSchema,
-  TOOL_DEFINITIONS,
   encodeCursor,
   decodeCursor,
   listResources,
@@ -3840,5 +3820,25 @@ export {
   PROMPTS,
   listPrompts,
   getPrompt,
-  completePromptArgument
+  completePromptArgument,
+  normalizeRepo,
+  MemoryStoreSchema,
+  MemoryUpdateSchema,
+  MemorySearchSchema,
+  MemoryAcknowledgeSchema,
+  MemoryRecapSchema,
+  MemoryDeleteSchema,
+  MemorySummarizeSchema,
+  MemorySynthesizeSchema,
+  TaskCreateSchema,
+  TaskCreateInteractiveSchema,
+  TaskUpdateSchema,
+  TaskListSchema,
+  TaskDeleteSchema,
+  MemoryDetailSchema,
+  TaskGetSchema,
+  TOOL_DEFINITIONS,
+  SQLiteStore,
+  MCP_PROTOCOL_VERSION,
+  CAPABILITIES
 };