@vheins/local-memory-mcp 0.10.10 → 0.10.12

package/dist/{chunk-76IHLGKG.js → chunk-WWVIDZ5P.js}

@@ -1,131 +1,5 @@
-// src/mcp/capabilities.ts
-import { fileURLToPath as fileURLToPath2 } from "url";
-import path2 from "path";
-
-// src/mcp/prompts/loader.ts
-import fs from "fs";
-import path from "path";
-import { fileURLToPath } from "url";
-import matter from "gray-matter";
-var __filename = fileURLToPath(import.meta.url);
-var __dirname = path.dirname(__filename);
-function findPromptDir() {
-  const candidates = [
-    // Production if chunked into dist/
-    "./prompts",
-    // Production if inlined into dist/mcp/
-    "../prompts",
-    // Dev: /src/mcp/prompts/definitions (next to loader.ts)
-    "./definitions"
-  ].map((relPath) => path.resolve(__dirname, relPath));
-  for (const dir of candidates) {
-    if (fs.existsSync(dir)) {
-      const files = fs.readdirSync(dir);
-      if (files.some((f) => f.endsWith(".md"))) {
-        return dir;
-      }
-    }
-  }
-  return path.resolve(__dirname, "./definitions");
-}
-var PROMPT_DIR = findPromptDir();
-function listPromptFiles() {
-  if (!fs.existsSync(PROMPT_DIR)) return [];
-  return fs.readdirSync(PROMPT_DIR).filter((file) => file.endsWith(".md")).map((file) => file.replace(/\.md$/, "")).sort();
-}
-function loadPromptFromMarkdown(name) {
-  const filePath = path.join(PROMPT_DIR, `${name}.md`);
-  if (!fs.existsSync(filePath)) {
-    throw new Error(`Prompt file not found: ${filePath}`);
-  }
-  const fileContent = fs.readFileSync(filePath, "utf-8");
-  const { data, content } = matter(fileContent);
-  return {
-    name: data.name || name,
-    description: data.description || "",
-    arguments: data.arguments || [],
-    agent: data.agent,
-    content: content.trim()
-  };
-}
-function findServerInstructionsDir() {
-  const candidates = [
-    // Production if chunked into dist/
-    "./prompts/server",
-    // Production if inlined into dist/mcp/
-    "../prompts/server",
-    // Dev: /src/mcp/prompts/server (next to loader.ts)
-    "./server"
-  ].map((relPath) => path.resolve(__dirname, relPath));
-  for (const dir of candidates) {
-    if (fs.existsSync(dir)) {
-      const filePath = path.join(dir, "instructions.md");
-      if (fs.existsSync(filePath)) {
-        return dir;
-      }
-    }
-  }
-  return path.resolve(__dirname, "./server");
-}
-var SERVER_DIR = findServerInstructionsDir();
-function loadServerInstructions() {
-  const filePath = path.join(SERVER_DIR, "instructions.md");
-  if (!fs.existsSync(filePath)) {
-    throw new Error(`Server instructions file not found: ${filePath}`);
-  }
-  const fileContent = fs.readFileSync(filePath, "utf-8");
-  const { content } = matter(fileContent);
-  return content.trim();
-}
-
-// src/mcp/capabilities.ts
-var __dirname2 = path2.dirname(fileURLToPath2(import.meta.url));
-var pkgVersion = "0.1.0";
-if ("0.10.10") {
-  pkgVersion = "0.10.10";
-} else {
-  let searchDir = __dirname2;
-  for (let i = 0; i < 5; i++) {
-    const candidate = path2.join(searchDir, "package.json");
-    try {
-      if (fs.existsSync(candidate)) {
-        const pkg = JSON.parse(fs.readFileSync(candidate, "utf8"));
-        if (pkg.name === "@vheins/local-memory-mcp" && pkg.version) {
-          pkgVersion = pkg.version;
-          break;
-        }
-      }
-    } catch {
-    }
-    searchDir = path2.dirname(searchDir);
-  }
-}
-var MCP_PROTOCOL_VERSION = "2025-03-26";
-var SERVER_INSTRUCTIONS = loadServerInstructions();
-var CAPABILITIES = {
-  serverInfo: {
-    name: "local-memory-mcp",
-    version: pkgVersion,
-    instructions: SERVER_INSTRUCTIONS
-  },
-  capabilities: {
-    completions: {},
-    logging: {},
-    resources: {
-      subscribe: true,
-      listChanged: true
-    },
-    tools: {
-      listChanged: false
-    },
-    prompts: {
-      listChanged: true
-    }
-  }
-};
-
 // src/mcp/utils/logger.ts
-import fs2 from "fs";
+import fs from "fs";
 var LEVELS = {
   debug: 0,
   info: 1,
@@ -245,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 {
     }
   }
@@ -259,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 path4 from "path";
-import fs4 from "fs";
+import path3 from "path";
+import fs3 from "fs";
 import os from "os";
 
 // src/mcp/storage/migrations.ts
@@ -2760,8 +2736,8 @@ var HandoffEntity = class extends BaseEntity {
 
 // src/mcp/storage/write-lock.ts
 import lockfile from "proper-lockfile";
-import path3 from "path";
-import fs3 from "fs";
+import path2 from "path";
+import fs2 from "fs";
 var LOCK_STALE_MS = 3e4;
 var LOCK_RETRY_DELAY_MS = 200;
 var LOCK_RETRY_COUNT = 250;
@@ -2770,9 +2746,9 @@ var WriteLock = class {
   locked = false;
   constructor(dbPath) {
     this.lockTarget = dbPath;
-    if (!fs3.existsSync(dbPath)) {
-      fs3.mkdirSync(path3.dirname(dbPath), { recursive: true });
-      fs3.writeFileSync(dbPath, "");
+    if (!fs2.existsSync(dbPath)) {
+      fs2.mkdirSync(path2.dirname(dbPath), { recursive: true });
+      fs2.writeFileSync(dbPath, "");
     }
   }
   /**
@@ -2824,13 +2800,13 @@ var WriteLock = class {
 // src/mcp/storage/sqlite.ts
 function resolveDbPath() {
   if (process.env.MEMORY_DB_PATH) return process.env.MEMORY_DB_PATH;
-  const standardConfigDir = process.platform === "win32" ? path4.join(os.homedir(), ".local-memory-mcp") : process.platform === "darwin" ? path4.join(os.homedir(), "Library", "Application Support", "local-memory-mcp") : path4.join(os.homedir(), ".config", "local-memory-mcp");
-  const standardPath = path4.join(standardConfigDir, "memory.db");
-  if (fs4.existsSync(standardPath)) return standardPath;
-  const legacyPath = path4.join(os.homedir(), ".config", "local-memory-mcp", "memory.db");
-  if (fs4.existsSync(legacyPath)) return legacyPath;
-  const localCwdFile = path4.join(process.cwd(), "storage", "memory.db");
-  if (fs4.existsSync(localCwdFile)) return localCwdFile;
+  const standardConfigDir = process.platform === "win32" ? path3.join(os.homedir(), ".local-memory-mcp") : process.platform === "darwin" ? path3.join(os.homedir(), "Library", "Application Support", "local-memory-mcp") : path3.join(os.homedir(), ".config", "local-memory-mcp");
+  const standardPath = path3.join(standardConfigDir, "memory.db");
+  if (fs3.existsSync(standardPath)) return standardPath;
+  const legacyPath = path3.join(os.homedir(), ".config", "local-memory-mcp", "memory.db");
+  if (fs3.existsSync(legacyPath)) return legacyPath;
+  const localCwdFile = path3.join(process.cwd(), "storage", "memory.db");
+  if (fs3.existsSync(localCwdFile)) return localCwdFile;
   return standardPath;
 }
 var DB_PATH = resolveDbPath();
@@ -2849,9 +2825,9 @@ var SQLiteStore = class _SQLiteStore {
     const finalPath = dbPath ?? DB_PATH;
     this.dbPathInstance = finalPath;
     if (finalPath !== ":memory:") {
-      const dbDir = path4.dirname(finalPath);
-      if (!fs4.existsSync(dbDir)) {
-        fs4.mkdirSync(dbDir, { recursive: true });
+      const dbDir = path3.dirname(finalPath);
+      if (!fs3.existsSync(dbDir)) {
+        fs3.mkdirSync(dbDir, { recursive: true });
       }
     }
     this.db = new Database(finalPath);
@@ -2906,12 +2882,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) });
@@ -2929,7 +2905,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) });
     }
@@ -3051,1128 +3027,1243 @@ var RealVectorStore = class {
   }
 };
 
-// src/mcp/session.ts
-import path5 from "path";
+// src/mcp/capabilities.ts
 import { fileURLToPath as fileURLToPath3 } from "url";
-function createSessionContext() {
+import path5 from "path";
+
+// src/mcp/prompts/loader.ts
+import fs4 from "fs";
+import path4 from "path";
+import { fileURLToPath as fileURLToPath2 } from "url";
+import matter from "gray-matter";
+var __filename = fileURLToPath2(import.meta.url);
+var __dirname = path4.dirname(__filename);
+function findPromptDir() {
+  const candidates = [
+    // Production if chunked into dist/
+    "./prompts",
+    // Production if inlined into dist/mcp/
+    "../prompts",
+    // Dev: /src/mcp/prompts/definitions (next to loader.ts)
+    "./definitions"
+  ].map((relPath) => path4.resolve(__dirname, relPath));
+  for (const dir of candidates) {
+    if (fs4.existsSync(dir)) {
+      const files = fs4.readdirSync(dir);
+      if (files.some((f) => f.endsWith(".md"))) {
+        return dir;
+      }
+    }
+  }
+  return path4.resolve(__dirname, "./definitions");
+}
+var PROMPT_DIR = findPromptDir();
+function listPromptFiles() {
+  if (!fs4.existsSync(PROMPT_DIR)) return [];
+  return fs4.readdirSync(PROMPT_DIR).filter((file) => file.endsWith(".md")).map((file) => file.replace(/\.md$/, "")).sort();
+}
+function loadPromptFromMarkdown(name) {
+  const filePath = path4.join(PROMPT_DIR, `${name}.md`);
+  if (!fs4.existsSync(filePath)) {
+    throw new Error(`Prompt file not found: ${filePath}`);
+  }
+  const fileContent = fs4.readFileSync(filePath, "utf-8");
+  const { data, content } = matter(fileContent);
   return {
-    roots: [],
-    supportsRoots: false,
-    supportsSampling: false,
-    supportsSamplingTools: false,
-    supportsElicitation: false,
-    supportsElicitationForm: false,
-    supportsElicitationUrl: false
+    name: data.name || name,
+    description: data.description || "",
+    arguments: data.arguments || [],
+    agent: data.agent,
+    content: content.trim()
   };
 }
-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";
+function findServerInstructionsDir() {
+  const candidates = [
+    // Production if chunked into dist/
+    "./prompts/server",
+    // Production if inlined into dist/mcp/
+    "../prompts/server",
+    // Dev: /src/mcp/prompts/server (next to loader.ts)
+    "./server"
+  ].map((relPath) => path4.resolve(__dirname, relPath));
+  for (const dir of candidates) {
+    if (fs4.existsSync(dir)) {
+      const filePath = path4.join(dir, "instructions.md");
+      if (fs4.existsSync(filePath)) {
+        return dir;
+      }
+    }
   }
-  return 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;
+  return path4.resolve(__dirname, "./server");
 }
-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 });
+var SERVER_DIR = findServerInstructionsDir();
+function loadServerInstructions() {
+  const filePath = path4.join(SERVER_DIR, "instructions.md");
+  if (!fs4.existsSync(filePath)) {
+    throw new Error(`Server instructions file not found: ${filePath}`);
   }
-  return normalized;
-}
-function extractRootsFromResult(result) {
-  return normalizeRoots(result?.roots);
+  const fileContent = fs4.readFileSync(filePath, "utf-8");
+  const { content } = matter(fileContent);
+  return content.trim();
 }
-function getFilesystemRoots(session) {
-  if (!session) return [];
-  const resolved = [];
-  for (const root of session.roots) {
-    if (!root.uri.startsWith("file://")) continue;
+
+// src/mcp/capabilities.ts
+var __dirname2 = path5.dirname(fileURLToPath3(import.meta.url));
+var pkgVersion = "0.1.0";
+if ("0.10.12") {
+  pkgVersion = "0.10.12";
+} else {
+  let searchDir = __dirname2;
+  for (let i = 0; i < 5; i++) {
+    const candidate = path5.join(searchDir, "package.json");
     try {
-      resolved.push(path5.resolve(fileURLToPath3(root.uri)));
+      if (fs.existsSync(candidate)) {
+        const pkg = JSON.parse(fs.readFileSync(candidate, "utf8"));
+        if (pkg.name === "@vheins/local-memory-mcp" && pkg.version) {
+          pkgVersion = pkg.version;
+          break;
+        }
+      }
     } catch {
     }
+    searchDir = path5.dirname(searchDir);
   }
-  return resolved;
-}
-function isPathWithinRoots(targetPath, session) {
-  const roots = getFilesystemRoots(session);
-  if (roots.length === 0) return true;
-  const normalizedTarget = path5.resolve(targetPath);
-  return roots.some((rootPath) => {
-    const relative = path5.relative(rootPath, normalizedTarget);
-    return relative === "" || !relative.startsWith("..") && !path5.isAbsolute(relative);
-  });
 }
-function findContainingRoot(targetPath, session) {
-  const roots = getFilesystemRoots(session);
-  if (roots.length === 0) return null;
-  const normalizedTarget = path5.resolve(targetPath);
-  for (const rootPath of roots) {
-    const relative = path5.relative(rootPath, normalizedTarget);
-    if (relative === "" || !relative.startsWith("..") && !path5.isAbsolute(relative)) {
-      return rootPath;
+var MCP_PROTOCOL_VERSION = "2025-03-26";
+var SERVER_INSTRUCTIONS = loadServerInstructions();
+var CAPABILITIES = {
+  serverInfo: {
+    name: "local-memory-mcp",
+    version: pkgVersion,
+    instructions: SERVER_INSTRUCTIONS
+  },
+  capabilities: {
+    completions: {},
+    logging: {},
+    resources: {
+      subscribe: true,
+      listChanged: true
+    },
+    tools: {
+      listChanged: false
+    },
+    prompts: {
+      listChanged: true
     }
   }
-  return null;
+};
+
+// src/mcp/utils/pagination.ts
+function encodeCursor(offset) {
+  return Buffer.from(String(offset), "utf8").toString("base64");
 }
-function inferRepoFromSession(session) {
-  const roots = getFilesystemRoots(session);
-  if (roots.length === 1) {
-    return path5.basename(roots[0]);
+function decodeCursor(cursor) {
+  if (cursor === void 0 || cursor === null || cursor === "") {
+    return 0;
   }
-  return void 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/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", "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().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().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().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 || data.task_code !== void 0, {
-  message: "Either 'id', 'ids', or 'task_code' 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 StandardDetailSchema = 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 StandardDeleteSchema = 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 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 HandoffStatusSchema = z.enum(["pending", "accepted", "rejected", "expired"]);
-var HandoffCreateSchema = z.object({
-  repo: z.string().min(1).transform(normalizeRepo),
-  from_agent: z.string().min(1),
-  to_agent: z.string().min(1).optional(),
-  task_id: z.string().uuid().optional(),
-  task_code: z.string().optional(),
-  summary: z.string().min(1),
-  context: z.record(z.string(), z.any()).optional(),
-  expires_at: z.string().optional(),
-  structured: z.boolean().default(false)
-}).refine((data) => !(data.task_id && data.task_code), {
-  message: "Provide either task_id or task_code, not both"
-}).refine(
-  (data) => data.to_agent || data.task_id || data.task_code || data.context?.next_steps || data.context?.blockers || data.context?.remaining_work,
-  {
-    message: "Handoffs must identify a target agent, linked task, next_steps, blockers, or remaining_work. Do not create pending handoffs for completed-work summaries."
+// 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);
   }
-);
-var HandoffUpdateSchema = z.object({
-  id: z.string().uuid(),
-  status: HandoffStatusSchema,
-  structured: z.boolean().default(false)
-});
-var HandoffListSchema = z.object({
-  repo: z.string().min(1).transform(normalizeRepo),
-  status: HandoffStatusSchema.optional(),
-  from_agent: z.string().min(1).optional(),
-  to_agent: z.string().min(1).optional(),
-  limit: z.number().min(1).max(100).default(20),
-  offset: z.number().min(0).default(0),
-  structured: z.boolean().default(false)
-});
-var TaskClaimSchema = z.object({
-  repo: z.string().min(1).transform(normalizeRepo),
-  task_id: z.string().uuid().optional(),
-  task_code: z.string().optional(),
-  agent: z.string().min(1),
-  role: z.string().optional(),
-  metadata: z.record(z.string(), z.any()).optional(),
-  structured: z.boolean().default(false)
-}).refine((data) => data.task_id !== void 0 || data.task_code !== void 0, {
-  message: "Either task_id or task_code must be provided"
-}).refine((data) => !(data.task_id && data.task_code), {
-  message: "Provide either task_id or task_code, not both"
-});
-var ClaimListSchema = z.object({
-  repo: z.string().min(1).transform(normalizeRepo),
-  agent: z.string().min(1).optional(),
-  active_only: z.boolean().default(true),
-  limit: z.number().min(1).max(100).default(20),
-  offset: z.number().min(0).default(0),
-  structured: z.boolean().default(false)
-});
-var ClaimReleaseSchema = z.object({
-  repo: z.string().min(1).transform(normalizeRepo),
-  task_id: z.string().uuid().optional(),
-  task_code: z.string().optional(),
-  agent: z.string().min(1).optional(),
-  structured: z.boolean().default(false)
-}).refine((data) => data.task_id !== void 0 || data.task_code !== void 0, {
-  message: "Either task_id or task_code must be provided"
-}).refine((data) => !(data.task_id && data.task_code), {
-  message: "Provide either task_id or task_code, not both"
-});
-var StandardStoreSchema = z.object({
-  name: z.string().min(3).max(255),
-  content: z.string().min(10),
-  parent_id: z.string().uuid().optional(),
-  context: z.string().optional(),
-  version: z.string().optional(),
-  language: z.string().optional(),
-  stack: z.array(z.string()).optional(),
-  repo: z.string().transform(normalizeRepo).optional(),
-  is_global: z.boolean().optional(),
-  tags: z.array(z.string().min(1)).min(1),
-  metadata: z.record(z.string(), z.any()).refine((value) => Object.keys(value).length > 0, {
-    message: "metadata must contain at least one key"
-  }),
-  agent: z.string().optional(),
-  model: z.string().optional(),
-  structured: z.boolean().default(false)
-}).refine((data) => data.is_global !== false || !!data.repo, {
-  message: "repo is required for repo-specific standards"
-});
-var StandardUpdateSchema = z.object({
-  id: z.string().uuid(),
-  name: z.string().min(3).max(255).optional(),
-  content: z.string().min(10).optional(),
-  parent_id: z.string().uuid().nullable().optional(),
-  context: z.string().optional(),
-  version: z.string().optional(),
-  language: z.string().optional(),
-  stack: z.array(z.string().min(1)).min(1).optional(),
-  repo: z.string().transform(normalizeRepo).optional(),
-  is_global: z.boolean().optional(),
-  tags: z.array(z.string().min(1)).min(1).optional(),
-  metadata: z.record(z.string(), z.any()).refine((value) => Object.keys(value).length > 0, { message: "metadata must contain at least one key" }).optional(),
-  agent: z.string().optional(),
-  model: z.string().optional(),
-  structured: z.boolean().default(false)
-}).refine(
-  (data) => data.name !== void 0 || data.content !== void 0 || data.parent_id !== void 0 || data.context !== void 0 || data.version !== void 0 || data.language !== void 0 || data.stack !== void 0 || data.repo !== void 0 || data.is_global !== void 0 || data.tags !== void 0 || data.metadata !== void 0 || data.agent !== void 0 || data.model !== void 0,
-  { message: "At least one field must be provided for update" }
-).refine((data) => data.is_global !== false || !!data.repo, {
-  message: "repo is required for repo-specific standards"
-});
-var StandardSearchSchema = z.object({
-  query: z.string().optional(),
-  stack: z.array(z.string()).optional(),
-  tags: z.array(z.string()).optional(),
-  language: z.string().optional(),
-  context: z.string().optional(),
-  version: z.string().optional(),
-  repo: z.string().transform(normalizeRepo).optional(),
-  is_global: z.boolean().optional(),
-  limit: z.number().min(1).max(100).default(20),
-  offset: z.number().min(0).default(0),
-  structured: z.boolean().default(false)
-});
-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
+  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()
+      }
     },
-    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 }
+    },
+    // ── 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 }
     },
-    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,
-          description: "Task priority where 1=Low, 2=Normal, 3=Medium, 4=High, 5=Critical."
-        },
-        agent: { type: "string" },
-        role: { type: "string" },
-        doc_path: { type: "string" },
-        structured: { type: "boolean", default: false, description: "If true, returns structured JSON result." }
-      }
+    {
+      uriTemplate: "task://{id}",
+      name: "Task Detail",
+      title: "Task Detail",
+      description: "Full content and comments for a specific task UUID",
+      mimeType: "application/json",
+      annotations: { audience: ["assistant"], priority: 0.8 }
     },
-    outputSchema: {
-      type: "object",
-      properties: {
-        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"]
+    // ── 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 or short code. Use after memory-recap or memory-search when a pointer row is relevant and full content is needed.",
-    inputSchema: {
-      type: "object",
-      properties: {
-        id: { type: "string", format: "uuid", description: "Memory entry ID. Optional if code is provided." },
-        code: { type: "string", description: "Short memory code. Optional if id is provided." },
-        structured: { type: "boolean", default: false, description: "If true, returns structured JSON details." }
-      }
+  ];
+  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: "standard-detail",
-    title: "Standard Detail",
-    description: "Fetch full details of a specific coding standard by ID or short code. Use after standard-search when a result is relevant and full guidance is needed.",
-    inputSchema: {
-      type: "object",
-      properties: {
-        id: { type: "string", format: "uuid", description: "Coding standard ID. Optional if code is provided." },
-        code: { type: "string", description: "Short standard code (e.g. 'A3KPQ2'). Optional if id is provided." },
-        structured: { type: "boolean", default: false, description: "If true, returns structured JSON details." }
-      }
+  }
+  if (resourceUri === "repository://{name}/memories?search={search}&type={type}&tag={tag}") {
+    if (argumentName === "tag") {
+      return rankCompletionValues(dataSources.tags, 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."
+  }
+  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()
+          }
         }
-      },
-      required: ["repo"]
-    }
-  },
-  {
-    name: "memory-store",
-    title: "Memory Store",
-    description: "Store a new durable knowledge entry. Do not store coordination state here: task claims, file claims, agent registration, and handoffs belong to task-claim, task-update, and handoff-* tools. Keep 'title' concise and human-readable; put auxiliary context into 'metadata'.",
-    annotations: {
-      readOnlyHint: false,
-      idempotentHint: false,
-      destructiveHint: false,
-      openWorldHint: false
-    },
-    inputSchema: {
-      type: "object",
-      properties: {
-        type: {
-          type: "string",
-          enum: ["code_fact", "decision", "mistake", "pattern", "task_archive"],
-          description: "Type of durable knowledge being stored. Coordination types such as file_claim are intentionally unsupported."
-        },
-        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."
+      ]
+    };
+  }
+  if (uri === "session://roots") {
+    const payload = JSON.stringify({ roots: session?.roots ?? [] }, null, 2);
+    return {
+      contents: [
+        {
+          uri,
+          mimeType: "application/json",
+          text: payload,
+          size: Buffer.byteLength(payload, "utf8"),
+          annotations: {
+            audience: ["assistant"],
+            priority: 0.95,
+            lastModified: (/* @__PURE__ */ new Date()).toISOString()
+          }
+        }
+      ]
+    };
+  }
+  const memoryIdMatch = uri.match(/^memory:\/\/([0-9a-f-]{36})$/i);
+  if (memoryIdMatch) {
+    const id = memoryIdMatch[1];
+    const entry = db.memories.getByIdWithStats(id);
+    if (!entry) throw resourceNotFound(`Memory with ID ${id} not found.`, uri);
+    const payload = JSON.stringify(entry, null, 2);
+    return {
+      contents: [
+        {
+          uri,
+          mimeType: "application/json",
+          text: payload,
+          size: Buffer.byteLength(payload, "utf8"),
+          annotations: {
+            audience: ["assistant"],
+            priority: 0.75,
+            lastModified: entry.updated_at || entry.created_at
+          }
         }
-      },
-      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"]
+      ]
+    };
+  }
+  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-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"]
+    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-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", "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" }
+    if (repoPath === "tasks") {
+      const status = query.get("status");
+      const priority = query.get("priority");
+      let tasks;
+      if (status && status !== "all") {
+        const statuses = status.split(",").map((s) => s.trim());
+        tasks = db.tasks.getTasksByMultipleStatuses(name, statuses);
+      } else {
+        tasks = db.tasks.getTasksByMultipleStatuses(name, ["backlog", "pending", "in_progress", "blocked"]);
+      }
+      if (priority) {
+        const p = Number(priority);
+        if (!isNaN(p)) {
+          tasks = tasks.filter((t) => t.priority === p);
         }
-      },
-      required: ["success", "id", "repo", "updatedFields"]
+      }
+      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))
+            }
+          }
+        ]
+      };
     }
-  },
-  {
-    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", "task_archive"]
+    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))
+            }
           }
-        },
-        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" }
+        ]
+      };
+    }
+  }
+  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
           }
-        },
-        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"]
+      ]
+    };
+  }
+  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/registry.ts
+function createPromptDefinition(loaded) {
+  return {
+    name: loaded.name,
+    description: loaded.description,
+    arguments: loaded.arguments,
+    agent: loaded.agent,
+    messages: [
+      {
+        role: "user",
+        content: {
+          type: "text",
+          text: loaded.content
         }
-      },
-      required: ["schema", "query", "count", "total", "offset", "limit", "results"]
+      }
+    ]
+  };
+}
+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", "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().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().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().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 || data.task_code !== void 0, {
+  message: "Either 'id', 'ids', or 'task_code' 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 StandardDetailSchema = 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 StandardDeleteSchema = 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 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 HandoffStatusSchema = z.enum(["pending", "accepted", "rejected", "expired"]);
+var HandoffCreateSchema = z.object({
+  repo: z.string().min(1).transform(normalizeRepo),
+  from_agent: z.string().min(1),
+  to_agent: z.string().min(1).optional(),
+  task_id: z.string().uuid().optional(),
+  task_code: z.string().optional(),
+  summary: z.string().min(1),
+  context: z.record(z.string(), z.any()).optional(),
+  expires_at: z.string().optional(),
+  structured: z.boolean().default(false)
+}).refine((data) => !(data.task_id && data.task_code), {
+  message: "Provide either task_id or task_code, not both"
+}).refine(
+  (data) => data.to_agent || data.task_id || data.task_code || data.context?.next_steps || data.context?.blockers || data.context?.remaining_work,
+  {
+    message: "Handoffs must identify a target agent, linked task, next_steps, blockers, or remaining_work. Do not create pending handoffs for completed-work summaries."
+  }
+);
+var HandoffUpdateSchema = z.object({
+  id: z.string().uuid(),
+  status: HandoffStatusSchema,
+  structured: z.boolean().default(false)
+});
+var HandoffListSchema = z.object({
+  repo: z.string().min(1).transform(normalizeRepo),
+  status: HandoffStatusSchema.optional(),
+  from_agent: z.string().min(1).optional(),
+  to_agent: z.string().min(1).optional(),
+  limit: z.number().min(1).max(100).default(20),
+  offset: z.number().min(0).default(0),
+  structured: z.boolean().default(false)
+});
+var TaskClaimSchema = z.object({
+  repo: z.string().min(1).transform(normalizeRepo),
+  task_id: z.string().uuid().optional(),
+  task_code: z.string().optional(),
+  agent: z.string().min(1),
+  role: z.string().optional(),
+  metadata: z.record(z.string(), z.any()).optional(),
+  structured: z.boolean().default(false)
+}).refine((data) => data.task_id !== void 0 || data.task_code !== void 0, {
+  message: "Either task_id or task_code must be provided"
+}).refine((data) => !(data.task_id && data.task_code), {
+  message: "Provide either task_id or task_code, not both"
+});
+var ClaimListSchema = z.object({
+  repo: z.string().min(1).transform(normalizeRepo),
+  agent: z.string().min(1).optional(),
+  active_only: z.boolean().default(true),
+  limit: z.number().min(1).max(100).default(20),
+  offset: z.number().min(0).default(0),
+  structured: z.boolean().default(false)
+});
+var ClaimReleaseSchema = z.object({
+  repo: z.string().min(1).transform(normalizeRepo),
+  task_id: z.string().uuid().optional(),
+  task_code: z.string().optional(),
+  agent: z.string().min(1).optional(),
+  structured: z.boolean().default(false)
+}).refine((data) => data.task_id !== void 0 || data.task_code !== void 0, {
+  message: "Either task_id or task_code must be provided"
+}).refine((data) => !(data.task_id && data.task_code), {
+  message: "Provide either task_id or task_code, not both"
+});
+var StandardStoreSchema = z.object({
+  name: z.string().min(3).max(255),
+  content: z.string().min(10),
+  parent_id: z.string().uuid().optional(),
+  context: z.string().optional(),
+  version: z.string().optional(),
+  language: z.string().optional(),
+  stack: z.array(z.string()).optional(),
+  repo: z.string().transform(normalizeRepo).optional(),
+  is_global: z.boolean().optional(),
+  tags: z.array(z.string().min(1)).min(1),
+  metadata: z.record(z.string(), z.any()).refine((value) => Object.keys(value).length > 0, {
+    message: "metadata must contain at least one key"
+  }),
+  agent: z.string().optional(),
+  model: z.string().optional(),
+  structured: z.boolean().default(false)
+}).refine((data) => data.is_global !== false || !!data.repo, {
+  message: "repo is required for repo-specific standards"
+});
+var StandardUpdateSchema = z.object({
+  id: z.string().uuid(),
+  name: z.string().min(3).max(255).optional(),
+  content: z.string().min(10).optional(),
+  parent_id: z.string().uuid().nullable().optional(),
+  context: z.string().optional(),
+  version: z.string().optional(),
+  language: z.string().optional(),
+  stack: z.array(z.string().min(1)).min(1).optional(),
+  repo: z.string().transform(normalizeRepo).optional(),
+  is_global: z.boolean().optional(),
+  tags: z.array(z.string().min(1)).min(1).optional(),
+  metadata: z.record(z.string(), z.any()).refine((value) => Object.keys(value).length > 0, { message: "metadata must contain at least one key" }).optional(),
+  agent: z.string().optional(),
+  model: z.string().optional(),
+  structured: z.boolean().default(false)
+}).refine(
+  (data) => data.name !== void 0 || data.content !== void 0 || data.parent_id !== void 0 || data.context !== void 0 || data.version !== void 0 || data.language !== void 0 || data.stack !== void 0 || data.repo !== void 0 || data.is_global !== void 0 || data.tags !== void 0 || data.metadata !== void 0 || data.agent !== void 0 || data.model !== void 0,
+  { message: "At least one field must be provided for update" }
+).refine((data) => data.is_global !== false || !!data.repo, {
+  message: "repo is required for repo-specific standards"
+});
+var StandardSearchSchema = z.object({
+  query: z.string().optional(),
+  stack: z.array(z.string()).optional(),
+  tags: z.array(z.string()).optional(),
+  language: z.string().optional(),
+  context: z.string().optional(),
+  version: z.string().optional(),
+  repo: z.string().transform(normalizeRepo).optional(),
+  is_global: z.boolean().optional(),
+  limit: z.number().min(1).max(100).default(20),
+  offset: z.number().min(0).default(0),
+  structured: z.boolean().default(false)
+});
+var TOOL_DEFINITIONS = [
   {
-    name: "memory-summarize",
-    title: "Memory Summarize",
-    description: "Update the summary for a repository",
+    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: false,
-      idempotentHint: false,
+      readOnlyHint: true,
+      idempotentHint: true,
       openWorldHint: false
     },
+    execution: {
+      taskSupport: "optional"
+    },
     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"
+        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: { type: "boolean", default: false, description: "If true, returns structured JSON of the summary." }
+        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: ["repo", "signals"]
+      required: ["objective"]
     },
     outputSchema: {
       type: "object",
       properties: {
-        success: { type: "boolean" },
         repo: { type: "string" },
-        summary: { type: "string" },
-        signalCount: { type: "number" }
+        objective: { type: "string" },
+        answer: { type: "string" },
+        model: { type: "string" },
+        stopReason: { type: "string" },
+        iterations: { type: "number" },
+        toolCalls: { type: "number" }
       },
-      required: ["success", "repo", "summary", "signalCount"]
+      required: ["repo", "objective", "answer", "iterations", "toolCalls"]
     }
   },
   {
-    name: "memory-delete",
-    title: "Memory Delete",
-    description: "Soft-delete one or more memory entries. Supports single 'id' or bulk 'ids'.",
+    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: true,
+      destructiveHint: false,
       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"
+        repo: {
+          type: "string",
+          description: "Repository name. Optional when it can be inferred from MCP roots or elicited from the user."
+        },
+        task_code: { type: "string" },
+        phase: { type: "string" },
+        title: { type: "string", minLength: 3, maxLength: 100 },
+        description: {
+          type: "string",
+          minLength: 1,
+          description: "Detailed description. MUST follow format: 1. Context & Analysis, 2. Step & Implementation, 3. Acceptance & Verification"
+        },
+        status: { type: "string", enum: ["backlog", "pending"], default: "backlog" },
+        priority: {
+          type: "number",
+          minimum: 1,
+          maximum: 5,
+          default: 3,
+          description: "Task priority where 1=Low, 2=Normal, 3=Medium, 4=High, 5=Critical."
         },
+        agent: { type: "string" },
+        role: { type: "string" },
+        doc_path: { type: "string" },
         structured: { type: "boolean", default: false, description: "If true, returns structured JSON result." }
       }
     },
     outputSchema: {
       type: "object",
       properties: {
-        success: { type: "boolean" },
-        id: { type: "string" },
-        ids: { type: "array", items: { type: "string" } },
         repo: { type: "string" },
-        deletedCount: { type: "number" }
+        task_code: { type: "string" },
+        phase: { type: "string" },
+        title: { type: "string" },
+        status: { type: "string" },
+        priority: { type: "number" }
       },
-      required: ["success"]
+      required: ["repo", "task_code", "phase", "title", "status", "priority"]
     }
   },
   {
-    name: "standard-delete",
-    title: "Standard Delete",
-    description: "Delete one or more coding standards. Supports single 'id' or bulk 'ids'.",
-    annotations: {
-      readOnlyHint: false,
-      idempotentHint: false,
-      destructiveHint: true,
-      openWorldHint: false
-    },
+    name: "memory-detail",
+    title: "Memory Detail",
+    description: "Fetch full details of a specific memory by ID or short code. Use after memory-recap or memory-search when a pointer row is relevant and full content is needed.",
     inputSchema: {
       type: "object",
       properties: {
-        repo: { type: "string", description: "Repository name (optional for single id)" },
-        id: { type: "string", format: "uuid", description: "Coding standard ID to delete" },
-        ids: {
-          type: "array",
-          items: { type: "string", format: "uuid" },
-          minItems: 1,
-          description: "Array of coding standard IDs to delete"
-        },
-        structured: { type: "boolean", default: false, description: "If true, returns structured JSON result." }
+        id: { type: "string", format: "uuid", description: "Memory entry ID. Optional if code is provided." },
+        code: { type: "string", description: "Short memory code. Optional if id is provided." },
+        structured: { type: "boolean", default: false, description: "If true, returns structured JSON details." }
       }
-    },
-    outputSchema: {
+    }
+  },
+  {
+    name: "standard-detail",
+    title: "Standard Detail",
+    description: "Fetch full details of a specific coding standard by ID or short code. Use after standard-search when a result is relevant and full guidance is needed.",
+    inputSchema: {
       type: "object",
       properties: {
-        success: { type: "boolean" },
-        id: { type: "string" },
-        ids: { type: "array", items: { type: "string" } },
-        repo: { type: "string" },
-        deletedCount: { type: "number" }
-      },
-      required: ["success"]
+        id: { type: "string", format: "uuid", description: "Coding standard ID. Optional if code is provided." },
+        code: { type: "string", description: "Short standard code (e.g. 'A3KPQ2'). Optional if id is provided." },
+        structured: { type: "boolean", default: false, description: "If true, returns structured JSON details." }
+      }
     }
   },
   {
-    name: "memory-recap",
-    title: "Memory Recap",
-    description: "AGGREGATED OVERVIEW LAYER: Returns stats (counts by type) and a pointer table of top memories [id, code, title, type, importance]. NO content. Use for orientation only \u2014 retrieve full memory via memory-detail.",
-    annotations: {
-      readOnlyHint: true,
-      idempotentHint: 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 (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" },
+        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 summary."
+          description: "If true, returns structured JSON without the text content details."
         }
       },
       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: {
-            byType: {
-              type: "object",
-              description: "Count of active memories per type (e.g. { decision: 3, code_fact: 7 })"
-            }
-          },
-          required: ["byType"]
-        },
-        top: {
-          type: "object",
-          properties: {
-            columns: {
-              type: "array",
-              items: { type: "string" },
-              description: "Column names: [id, code, title, type, importance]"
-            },
-            rows: {
-              type: "array",
-              items: { type: "array" },
-              description: "Each row: [id, code, title, type, importance]. Fetch full content via memory-detail"
-            }
-          },
-          required: ["columns", "rows"]
-        }
-      },
-      required: ["schema", "repo", "count", "total", "offset", "limit", "stats", "top"]
     }
   },
   {
-    name: "task-create",
-    title: "Task Create",
-    description: "Register one or more new tasks in a repository. task_code must be unique within the repository. Supports single task object or an array of tasks for bulk creation.",
+    name: "memory-store",
+    title: "Memory Store",
+    description: "Store a new durable knowledge entry. Do not store coordination state here: task claims, file claims, agent registration, and handoffs belong to task-claim, task-update, and handoff-* tools. Keep 'title' concise and human-readable; put auxiliary context into 'metadata'.",
     annotations: {
       readOnlyHint: false,
       idempotentHint: false,
+      destructiveHint: false,
       openWorldHint: false
     },
     inputSchema: {
       type: "object",
       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)" },
+        type: {
+          type: "string",
+          enum: ["code_fact", "decision", "mistake", "pattern", "task_archive"],
+          description: "Type of durable knowledge being stored. Coordination types such as file_claim are intentionally unsupported."
+        },
         title: {
           type: "string",
           minLength: 3,
           maxLength: 100,
-          description: "Task objective (Required for single task)"
+          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"
         },
-        description: { type: "string", description: "Detailed description (Required for single task)" },
-        status: {
+        model: {
           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: "AI model used by the agent"
         },
-        priority: {
-          type: "number",
-          minimum: 1,
-          maximum: 5,
-          default: 3,
-          description: "Task priority where 1=Low, 2=Normal, 3=Medium, 4=High, 5=Critical."
+        scope: {
+          type: "object",
+          properties: {
+            repo: { type: "string", description: "Repository name" },
+            branch: { type: "string" },
+            folder: { type: "string" },
+            language: { type: "string" }
+          },
+          required: ["repo"]
         },
-        agent: { type: "string" },
-        role: { type: "string" },
-        doc_path: { type: "string" },
-        tags: { type: "array", items: { type: "string" } },
-        metadata: { type: "object" },
-        parent_id: { type: "string", description: "Optional parent task ID (UUID) or parent task code (e.g. TASK-001). Resolved to UUID before storing." },
-        depends_on: { type: "string", format: "uuid" },
-        est_tokens: { type: "number", minimum: 0, description: "Estimated tokens budget for this task" },
-        tasks: {
+        tags: {
           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,
-                description: "Task priority where 1=Low, 2=Normal, 3=Medium, 4=High, 5=Critical."
-              },
-              agent: { type: "string" },
-              role: { type: "string" },
-              doc_path: { type: "string" },
-              tags: { type: "array", items: { type: "string" } },
-              metadata: { type: "object" },
-              parent_id: { type: "string", description: "Optional parent task ID (UUID) or parent task code (e.g. TASK-001). Resolved to UUID before storing." },
-              depends_on: { type: "string", format: "uuid" },
-              est_tokens: { type: "number", minimum: 0 }
-            },
-            required: ["task_code", "phase", "title", "description"]
-          },
-          description: "Array of tasks for bulk creation"
+          items: { type: "string" },
+          description: "Technology stack tags (e.g., ['filament', 'laravel'])"
         },
-        structured: { type: "boolean", default: false, description: "If true, returns structured JSON result." }
+        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: ["repo"]
+      required: ["type", "title", "content", "importance", "scope", "agent", "model"]
     },
     outputSchema: {
       type: "object",
       properties: {
         success: { type: "boolean" },
         id: { type: "string" },
-        task_code: { type: "string" },
+        code: { type: "string" },
         repo: { type: "string" },
-        phase: { type: "string" },
+        type: { type: "string" },
         title: { type: "string" },
-        status: { type: "string" },
-        priority: { type: "number" },
-        createdCount: { type: "number" },
-        taskCodes: { type: "array", items: { type: "string" } }
+        error: { type: "string" },
+        message: { type: "string" }
       },
-      required: ["success", "repo"]
+      required: ["success"]
     }
   },
   {
-    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.",
+    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,
@@ -4181,103 +4272,78 @@ var TOOL_DEFINITIONS = [
     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,
-          description: "Task priority where 1=Low, 2=Normal, 3=Medium, 4=High, 5=Critical."
-        },
-        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", description: "Optional parent task ID (UUID) or parent task code (e.g. TASK-001). Resolved to UUID before storing." },
-        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)."
-        },
+        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: ["repo"]
+      required: ["memory_id", "status"]
     },
     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" }
+        status: { type: "string" }
       },
-      required: ["success", "repo"]
+      required: ["success", "id", "status"]
     }
   },
   {
-    name: "task-delete",
-    title: "Task Delete",
-    description: "Delete one or more tasks from a repository. Supports single 'id' or bulk 'ids'.",
+    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: true,
+      destructiveHint: false,
       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." }
+        id: { type: "string", format: "uuid" },
+        type: {
+          type: "string",
+          enum: ["code_fact", "decision", "mistake", "pattern", "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: ["repo"]
+      required: ["id"]
     },
     outputSchema: {
       type: "object",
       properties: {
         success: { type: "boolean" },
         id: { type: "string" },
-        ids: { type: "array", items: { type: "string" } },
         repo: { type: "string" },
-        deletedCount: { type: "number" }
+        updatedFields: {
+          type: "array",
+          items: { type: "string" }
+        }
       },
-      required: ["success", "repo"]
+      required: ["success", "id", "repo", "updatedFields"]
     }
   },
   {
-    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, updated_at, comments_count). 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-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,
@@ -4286,35 +4352,35 @@ var TOOL_DEFINITIONS = [
     inputSchema: {
       type: "object",
       properties: {
-        repo: {
-          type: "string",
-          description: "Repository name (required)"
-        },
-        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"
+        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'])"
         },
-        limit: {
-          type: "number",
-          minimum: 1,
-          maximum: 100,
-          default: 5,
-          description: "Maximum rows to return (default 5)"
+        types: {
+          type: "array",
+          items: {
+            type: "string",
+            enum: ["code_fact", "decision", "mistake", "pattern", "task_archive"]
+          }
         },
-        offset: {
-          type: "number",
-          minimum: 0,
-          default: 0,
-          description: "Offset for pagination"
+        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",
@@ -4322,113 +4388,147 @@ var TOOL_DEFINITIONS = [
           description: "If true, returns structured JSON without the text content summary."
         }
       },
-      required: ["repo"]
+      required: ["query", "repo"]
     },
     outputSchema: {
       type: "object",
       properties: {
-        schema: { type: "string", enum: ["task-list"] },
-        tasks: {
+        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 in order: id, task_code, title, status, priority, updated_at, comments_count"
+              description: "Column names: [id, title, type, importance]"
             },
             rows: {
               type: "array",
               items: { type: "array" },
-              description: "Each row: [id, task_code, title, status, priority, updated_at, comments_count]. Use task-detail to fetch full task."
+              description: "Each row: [id, title, type, importance]. Fetch full content via memory-detail"
             }
           },
           required: ["columns", "rows"]
-        },
-        count: { type: "number" },
-        offset: { type: "number" }
+        }
       },
-      required: ["schema", "tasks", "count"]
+      required: ["schema", "query", "count", "total", "offset", "limit", "results"]
     }
   },
   {
-    name: "handoff-create",
-    title: "Handoff Create",
-    description: "Create a pending handoff only when unfinished work needs context transfer between agents. Do not use this for completed-work summaries, release notes, validation notes, or archives; put those on task-update/task comments or durable memory.",
+    name: "memory-summarize",
+    title: "Memory Summarize",
+    description: "Update the summary for a repository",
     annotations: {
       readOnlyHint: false,
       idempotentHint: false,
-      destructiveHint: false,
       openWorldHint: false
     },
     inputSchema: {
       type: "object",
       properties: {
         repo: { type: "string", description: "Repository name" },
-        from_agent: { type: "string", description: "Agent creating the handoff" },
-        to_agent: { type: "string", description: "Optional target agent" },
-        task_id: { type: "string", format: "uuid", description: "Optional task id to associate" },
-        task_code: { type: "string", description: "Optional task code to associate" },
-        summary: { type: "string", minLength: 1, description: "Concise human-readable transfer summary" },
-        context: {
-          type: "object",
-          description: "Structured handoff context. Include next_steps, blockers, or remaining_work unless a target agent or task is provided."
+        signals: {
+          type: "array",
+          items: { type: "string", maxLength: 200 },
+          minItems: 1,
+          description: "High-level signals to include in summary"
         },
-        expires_at: { type: "string", description: "Optional expiration timestamp" },
-        structured: { type: "boolean", default: false }
+        structured: { type: "boolean", default: false, description: "If true, returns structured JSON of the summary." }
       },
-      required: ["repo", "from_agent", "summary"]
+      required: ["repo", "signals"]
     },
     outputSchema: {
       type: "object",
       properties: {
-        id: { type: "string" },
+        success: { type: "boolean" },
         repo: { type: "string" },
-        from_agent: { type: "string" },
-        to_agent: { type: "string", nullable: true },
-        task_id: { type: "string", nullable: true },
         summary: { type: "string" },
-        context: { type: "object" },
-        status: { type: "string", enum: ["pending", "accepted", "rejected", "expired"] },
-        created_at: { type: "string" },
-        updated_at: { type: "string" },
-        expires_at: { type: "string", nullable: true }
+        signalCount: { type: "number" }
       },
-      required: ["id", "repo", "from_agent", "summary", "context", "status", "created_at", "updated_at"]
+      required: ["success", "repo", "summary", "signalCount"]
     }
   },
   {
-    name: "handoff-update",
-    title: "Handoff Update",
-    description: "Close or reclassify a handoff after it has been consumed or found stale. Use accepted when transfer context was consumed, rejected when intentionally declined, and expired when the handoff is obsolete or only described completed work.",
+    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: false,
+      destructiveHint: true,
       openWorldHint: false
     },
     inputSchema: {
       type: "object",
       properties: {
-        id: { type: "string", format: "uuid", description: "Handoff ID" },
-        status: { type: "string", enum: ["pending", "accepted", "rejected", "expired"] },
-        structured: { type: "boolean", default: false }
+        repo: { type: "string", description: "Repository name (optional for single id)" },
+        id: { type: "string", format: "uuid", description: "Memory entry ID to delete" },
+        ids: {
+          type: "array",
+          items: { type: "string", format: "uuid" },
+          minItems: 1,
+          description: "Array of memory IDs to delete"
+        },
+        structured: { type: "boolean", default: false, description: "If true, returns structured JSON result." }
+      }
+    },
+    outputSchema: {
+      type: "object",
+      properties: {
+        success: { type: "boolean" },
+        id: { type: "string" },
+        ids: { type: "array", items: { type: "string" } },
+        repo: { type: "string" },
+        deletedCount: { type: "number" }
       },
-      required: ["id", "status"]
+      required: ["success"]
+    }
+  },
+  {
+    name: "standard-delete",
+    title: "Standard Delete",
+    description: "Delete one or more coding standards. Supports single 'id' or bulk 'ids'.",
+    annotations: {
+      readOnlyHint: false,
+      idempotentHint: false,
+      destructiveHint: true,
+      openWorldHint: false
+    },
+    inputSchema: {
+      type: "object",
+      properties: {
+        repo: { type: "string", description: "Repository name (optional for single id)" },
+        id: { type: "string", format: "uuid", description: "Coding standard ID to delete" },
+        ids: {
+          type: "array",
+          items: { type: "string", format: "uuid" },
+          minItems: 1,
+          description: "Array of coding standard IDs to delete"
+        },
+        structured: { type: "boolean", default: false, description: "If true, returns structured JSON result." }
+      }
     },
     outputSchema: {
       type: "object",
       properties: {
         success: { type: "boolean" },
         id: { type: "string" },
-        status: { type: "string", enum: ["pending", "accepted", "rejected", "expired"] }
+        ids: { type: "array", items: { type: "string" } },
+        repo: { type: "string" },
+        deletedCount: { type: "number" }
       },
-      required: ["success", "id", "status"]
+      required: ["success"]
     }
   },
   {
-    name: "handoff-list",
-    title: "Handoff List",
-    description: "Navigation layer for handoff queues. List repository handoffs with optional status and agent filters, then inspect selected rows before acting.",
+    name: "memory-recap",
+    title: "Memory Recap",
+    description: "AGGREGATED OVERVIEW LAYER: Returns stats (counts by type) and a pointer table of top memories [id, code, title, type, importance]. NO content. Use for orientation only \u2014 retrieve full memory via memory-detail.",
     annotations: {
       readOnlyHint: true,
       idempotentHint: true,
@@ -4437,155 +4537,260 @@ var TOOL_DEFINITIONS = [
     inputSchema: {
       type: "object",
       properties: {
-        repo: { type: "string", description: "Repository name" },
-        status: { type: "string", enum: ["pending", "accepted", "rejected", "expired"] },
-        from_agent: { type: "string" },
-        to_agent: { type: "string" },
-        limit: { type: "number", minimum: 1, maximum: 100, default: 20 },
-        offset: { type: "number", minimum: 0, default: 0 },
-        structured: { type: "boolean", default: false }
+        repo: { type: "string", description: "Repository 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."
+        }
       },
       required: ["repo"]
     },
     outputSchema: {
       type: "object",
       properties: {
-        schema: { type: "string", enum: ["handoff-list"] },
-        handoffs: {
+        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: {
+            byType: {
+              type: "object",
+              description: "Count of active memories per type (e.g. { decision: 3, code_fact: 7 })"
+            }
+          },
+          required: ["byType"]
+        },
+        top: {
           type: "object",
           properties: {
             columns: {
               type: "array",
               items: { type: "string" },
-              description: "Column names: [id, from_agent, to_agent, task_id, task_code, status, created_at, updated_at, expires_at, summary, context]"
+              description: "Column names: [id, code, title, type, importance]"
             },
             rows: {
               type: "array",
               items: { type: "array" },
-              description: "Each row: [id, from_agent, to_agent, task_id, task_code, status, created_at, updated_at, expires_at, summary, context]"
+              description: "Each row: [id, code, title, type, importance]. Fetch full content via memory-detail"
             }
           },
           required: ["columns", "rows"]
-        },
-        count: { type: "number" },
-        offset: { type: "number" }
+        }
       },
-      required: ["schema", "handoffs", "count", "offset"]
+      required: ["schema", "repo", "count", "total", "offset", "limit", "stats", "top"]
     }
   },
   {
-    name: "task-claim",
-    title: "Task Claim",
-    description: "Claim task ownership for an agent using the dedicated claims table. Use this before taking work from task-list; provide either task_id or task_code.",
+    name: "task-create",
+    title: "Task Create",
+    description: "Register one or more new tasks in a repository. task_code must be unique within the repository. Supports single task object or an array of tasks for bulk creation.",
     annotations: {
       readOnlyHint: false,
       idempotentHint: false,
-      destructiveHint: false,
       openWorldHint: false
     },
     inputSchema: {
       type: "object",
       properties: {
         repo: { type: "string", description: "Repository name" },
-        task_id: {
+        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",
-          format: "uuid",
-          description: "Task id to claim. Optional if task_code is provided."
+          minLength: 3,
+          maxLength: 100,
+          description: "Task objective (Required for single task)"
         },
-        task_code: { type: "string", description: "Task code to claim. Optional if task_id is provided." },
-        agent: { type: "string", description: "Claiming agent name" },
-        role: { type: "string", description: "Claiming agent role" },
-        metadata: { type: "object", description: "Optional claim metadata" },
-        structured: { type: "boolean", default: false }
+        description: {
+          type: "string",
+          description: "Detailed description. MUST follow format: 1. Context & Analysis, 2. Step & Implementation, 3. Acceptance & Verification"
+        },
+        status: {
+          type: "string",
+          enum: ["backlog", "pending"],
+          default: "backlog",
+          description: "New tasks MUST start in 'backlog' if there are already 10 pending tasks. Otherwise can start in 'pending'."
+        },
+        priority: {
+          type: "number",
+          minimum: 1,
+          maximum: 5,
+          default: 3,
+          description: "Task priority where 1=Low, 2=Normal, 3=Medium, 4=High, 5=Critical."
+        },
+        agent: { type: "string" },
+        role: { type: "string" },
+        doc_path: { type: "string" },
+        tags: { type: "array", items: { type: "string" } },
+        metadata: { type: "object" },
+        parent_id: { type: "string", description: "Optional parent task ID (UUID) or parent task code (e.g. TASK-001). Resolved to UUID before storing." },
+        depends_on: { type: "string", 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",
+                description: "Detailed description. MUST follow format: 1. Context & Analysis, 2. Step & Implementation, 3. Acceptance & Verification"
+              },
+              status: { type: "string", enum: ["backlog", "pending"], default: "backlog" },
+              priority: {
+                type: "number",
+                minimum: 1,
+                maximum: 5,
+                default: 3,
+                description: "Task priority where 1=Low, 2=Normal, 3=Medium, 4=High, 5=Critical."
+              },
+              agent: { type: "string" },
+              role: { type: "string" },
+              doc_path: { type: "string" },
+              tags: { type: "array", items: { type: "string" } },
+              metadata: { type: "object" },
+              parent_id: { type: "string", description: "Optional parent task ID (UUID) or parent task code (e.g. TASK-001). Resolved to UUID before storing." },
+              depends_on: { type: "string", 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", "agent"]
+      required: ["repo"]
     },
     outputSchema: {
       type: "object",
       properties: {
+        success: { type: "boolean" },
         id: { type: "string" },
+        task_code: { type: "string" },
         repo: { type: "string" },
-        task_id: { type: "string" },
-        task_code: { type: "string", nullable: true },
-        agent: { type: "string" },
-        role: { type: "string" },
-        claimed_at: { type: "string" },
-        released_at: { type: "string", nullable: true },
-        metadata: { type: "object" }
+        phase: { type: "string" },
+        title: { type: "string" },
+        status: { type: "string" },
+        priority: { type: "number" },
+        createdCount: { type: "number" },
+        taskCodes: { type: "array", items: { type: "string" } }
       },
-      required: ["id", "repo", "task_id", "agent", "role", "claimed_at", "metadata"]
+      required: ["success", "repo"]
     }
   },
   {
-    name: "claim-list",
-    title: "Claim List",
-    description: "List task claims in a repository. Use this to inspect active ownership, optionally filtered by agent.",
+    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: true,
-      idempotentHint: true,
-      destructiveHint: false,
+      readOnlyHint: false,
+      idempotentHint: false,
       openWorldHint: false
     },
     inputSchema: {
       type: "object",
       properties: {
         repo: { type: "string", description: "Repository name" },
-        agent: { type: "string", description: "Optional agent filter" },
-        active_only: { type: "boolean", description: "When true, return only unreleased claims" },
-        limit: { type: "number", minimum: 1, maximum: 100, default: 20 },
-        offset: { type: "number", minimum: 0, default: 0 },
-        structured: { type: "boolean", default: false }
+        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",
+          description: "Detailed description. MUST follow format: 1. Context & Analysis, 2. Step & Implementation, 3. Acceptance & Verification"
+        },
+        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,
+          description: "Task priority where 1=Low, 2=Normal, 3=Medium, 4=High, 5=Critical."
+        },
+        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", description: "Optional parent task ID (UUID) or parent task code (e.g. TASK-001). Resolved to UUID before storing." },
+        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: {
-        schema: { type: "string", enum: ["claim-list"] },
-        claims: {
-          type: "object",
-          properties: {
-            columns: {
-              type: "array",
-              items: { type: "string" },
-              description: "Column names: [id, task_id, task_code, agent, role, claimed_at, released_at, metadata]"
-            },
-            rows: {
-              type: "array",
-              items: { type: "array" },
-              description: "Each row: [id, task_id, task_code, agent, role, claimed_at, released_at, metadata]"
-            }
-          },
-          required: ["columns", "rows"]
+        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" }
         },
-        count: { type: "number" },
-        offset: { type: "number" }
+        updatedCount: { type: "number" }
       },
-      required: ["schema", "claims", "count", "offset"]
+      required: ["success", "repo"]
     }
   },
   {
-    name: "claim-release",
-    title: "Claim Release",
-    description: "Release an active claim for a task. Optionally restrict the release to a specific agent.",
+    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: false,
+      destructiveHint: true,
       openWorldHint: false
     },
     inputSchema: {
       type: "object",
       properties: {
         repo: { type: "string", description: "Repository name" },
-        task_id: {
-          type: "string",
-          format: "uuid",
-          description: "Task id to release. Optional if task_code is provided."
-        },
-        task_code: { type: "string", description: "Task code to release. Optional if task_id is provided." },
-        agent: { type: "string", description: "Optional agent name to release only that claim" },
-        structured: { type: "boolean", default: false }
+        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"]
     },
@@ -4593,116 +4798,94 @@ var TOOL_DEFINITIONS = [
       type: "object",
       properties: {
         success: { type: "boolean" },
+        id: { type: "string" },
+        ids: { type: "array", items: { type: "string" } },
         repo: { type: "string" },
-        task_id: { type: "string" },
-        task_code: { type: "string", nullable: true },
-        agent: { type: "string", nullable: true }
+        deletedCount: { type: "number" }
       },
-      required: ["success", "repo", "task_id"]
+      required: ["success", "repo"]
     }
   },
   {
-    name: "standard-store",
-    title: "Standard Store",
-    description: "Store one atomic coding standard. Use for durable implementation rules with explicit context, stack/language filters, and repo/global scope.",
+    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, updated_at, comments_count). Defaults to in_progress and pending tasks. Use 'query' to filter by code, title, or description. Use 'status' (comma-separated) for specific filters. AGENTS: call this once at start, pick ONE task, then call task-detail.",
     annotations: {
-      readOnlyHint: false,
-      idempotentHint: false,
-      destructiveHint: false,
+      readOnlyHint: true,
+      idempotentHint: true,
       openWorldHint: false
     },
     inputSchema: {
       type: "object",
       properties: {
-        name: { type: "string", minLength: 3, maxLength: 255, description: "Human-readable standard name" },
-        content: {
+        repo: {
           type: "string",
-          minLength: 10,
-          description: "One atomic, actionable standard written as concise Markdown"
+          description: "Repository name (required)"
         },
-        parent_id: {
+        status: {
           type: "string",
-          format: "uuid",
-          description: "Optional parent standard ID when this rule is a child/specialization."
+          default: "in_progress,pending",
+          description: "Comma-separated status filter (backlog, pending, in_progress, completed, canceled, blocked). Defaults to 'in_progress,pending'."
         },
-        context: { type: "string", description: "Context or category (e.g., 'error-handling', 'security')" },
-        version: { type: "string", description: "Version of the standard (e.g., '1.0.0')" },
-        language: { type: "string", description: "Programming language (e.g., 'typescript', 'python')" },
-        stack: {
-          type: "array",
-          items: { type: "string" },
-          description: "Technology stack (e.g., ['react', 'nextjs'])"
+        phase: {
+          type: "string",
+          description: "Filter by phase (e.g., 'research', 'implementation')"
         },
-        repo: {
+        query: {
           type: "string",
-          description: "Repository name for repo-specific standards. Omit only for global standards."
+          description: "Search keyword matching task code, title, or description"
         },
-        is_global: { type: "boolean", description: "Whether standard applies globally or repo-specific" },
-        tags: {
-          type: "array",
-          items: { type: "string" },
-          description: "Tags for categorization"
+        limit: {
+          type: "number",
+          minimum: 1,
+          maximum: 100,
+          default: 5,
+          description: "Maximum rows to return (default 5)"
         },
-        metadata: {
-          type: "object",
-          description: "Additional metadata"
+        offset: {
+          type: "number",
+          minimum: 0,
+          default: 0,
+          description: "Offset for pagination"
         },
-        agent: { type: "string", description: "Agent creating the standard" },
-        model: { type: "string", description: "AI model used" },
-        structured: { type: "boolean", default: false }
+        structured: {
+          type: "boolean",
+          default: false,
+          description: "If true, returns structured JSON without the text content summary."
+        }
       },
-      required: ["name", "content", "tags", "metadata"]
+      required: ["repo"]
     },
     outputSchema: {
       type: "object",
       properties: {
-        success: { type: "boolean" },
-        standard: {
+        schema: { type: "string", enum: ["task-list"] },
+        tasks: {
           type: "object",
           properties: {
-            id: { type: "string" },
-            title: { type: "string" },
-            content: { type: "string" },
-            parent_id: { type: "string", nullable: true },
-            context: { type: "string" },
-            version: { type: "string" },
-            language: { type: "string", nullable: true },
-            stack: { type: "array", items: { type: "string" } },
-            is_global: { type: "boolean" },
-            repo: { type: "string", nullable: true },
-            tags: { type: "array", items: { type: "string" } },
-            metadata: { type: "object" },
-            created_at: { type: "string" },
-            updated_at: { type: "string" },
-            agent: { type: "string" },
-            model: { type: "string" }
+            columns: {
+              type: "array",
+              items: { type: "string" },
+              description: "Column names in order: id, task_code, title, status, priority, updated_at, comments_count"
+            },
+            rows: {
+              type: "array",
+              items: { type: "array" },
+              description: "Each row: [id, task_code, title, status, priority, updated_at, comments_count]. Use task-detail to fetch full task."
+            }
           },
-          required: [
-            "id",
-            "title",
-            "content",
-            "parent_id",
-            "context",
-            "version",
-            "stack",
-            "is_global",
-            "tags",
-            "metadata",
-            "created_at",
-            "updated_at",
-            "agent",
-            "model"
-          ]
+          required: ["columns", "rows"]
         },
-        message: { type: "string" }
+        count: { type: "number" },
+        offset: { type: "number" }
       },
-      required: ["success", "standard", "message"]
+      required: ["schema", "tasks", "count"]
     }
   },
-  {
-    name: "standard-update",
-    title: "Standard Update",
-    description: "Update an existing coding standard. Use this when the rule changes, expands scope, or metadata/tags need correction.",
+  {
+    name: "handoff-create",
+    title: "Handoff Create",
+    description: "Create a pending handoff only when unfinished work needs context transfer between agents. Do not use this for completed-work summaries, release notes, validation notes, or archives; put those on task-update/task comments or durable memory.",
     annotations: {
       readOnlyHint: false,
       idempotentHint: false,
@@ -4712,616 +4895,446 @@ var TOOL_DEFINITIONS = [
     inputSchema: {
       type: "object",
       properties: {
-        id: { type: "string", description: "Standard ID to update" },
-        name: { type: "string", minLength: 3, maxLength: 255 },
-        content: { type: "string", minLength: 10 },
-        parent_id: { type: "string", format: "uuid", nullable: true },
-        context: { type: "string" },
-        version: { type: "string" },
-        language: { type: "string" },
-        stack: { type: "array", items: { type: "string" } },
-        repo: { type: "string" },
-        is_global: { type: "boolean" },
-        tags: { type: "array", items: { type: "string" } },
-        metadata: { type: "object" },
-        agent: { type: "string" },
-        model: { type: "string" },
+        repo: { type: "string", description: "Repository name" },
+        from_agent: { type: "string", description: "Agent creating the handoff" },
+        to_agent: { type: "string", description: "Optional target agent" },
+        task_id: { type: "string", format: "uuid", description: "Optional task id to associate" },
+        task_code: { type: "string", description: "Optional task code to associate" },
+        summary: { type: "string", minLength: 1, description: "Concise human-readable transfer summary" },
+        context: {
+          type: "object",
+          description: "Structured handoff context. Include next_steps, blockers, or remaining_work unless a target agent or task is provided."
+        },
+        expires_at: { type: "string", description: "Optional expiration timestamp" },
         structured: { type: "boolean", default: false }
       },
-      required: ["id"]
+      required: ["repo", "from_agent", "summary"]
     },
     outputSchema: {
       type: "object",
       properties: {
-        success: { type: "boolean" },
         id: { type: "string" },
-        updatedFields: { type: "array", items: { type: "string" } }
+        repo: { type: "string" },
+        from_agent: { type: "string" },
+        to_agent: { type: "string", nullable: true },
+        task_id: { type: "string", nullable: true },
+        summary: { type: "string" },
+        context: { type: "object" },
+        status: { type: "string", enum: ["pending", "accepted", "rejected", "expired"] },
+        created_at: { type: "string" },
+        updated_at: { type: "string" },
+        expires_at: { type: "string", nullable: true }
       },
-      required: ["success", "id", "updatedFields"]
+      required: ["id", "repo", "from_agent", "summary", "context", "status", "created_at", "updated_at"]
     }
   },
   {
-    name: "standard-search",
-    title: "Standard Search",
-    description: "MANDATORY PRE-IMPLEMENTATION CHECK: Call before any code edit, test edit, refactor, migration, or implementation decision to find applicable coding standards. Returns a compact pointer table; use `standard-detail` for relevant results. If no relevant standards are returned, continue and state that no applicable standards were found.",
+    name: "handoff-update",
+    title: "Handoff Update",
+    description: "Close or reclassify a handoff after it has been consumed or found stale. Use accepted when transfer context was consumed, rejected when intentionally declined, and expired when the handoff is obsolete or only described completed work.",
     annotations: {
-      readOnlyHint: true,
-      idempotentHint: true,
+      readOnlyHint: false,
+      idempotentHint: false,
+      destructiveHint: false,
       openWorldHint: false
     },
     inputSchema: {
       type: "object",
       properties: {
-        query: { type: "string", description: "Search query (optional, searches title/content)" },
-        stack: {
-          type: "array",
-          items: { type: "string" },
-          description: "Technology stack to filter by (e.g., ['react', 'nextjs'])"
-        },
-        tags: {
-          type: "array",
-          items: { type: "string" },
-          description: "Tag filter"
-        },
-        language: { type: "string", description: "Programming language filter" },
-        context: { type: "string", description: "Context/category filter" },
-        version: { type: "string", description: "Version filter" },
-        repo: { type: "string", description: "Repository filter (optional)" },
-        is_global: { type: "boolean", description: "Filter by global/repo-specific" },
-        limit: { type: "number", minimum: 1, maximum: 100, default: 20 },
-        offset: { type: "number", minimum: 0, default: 0 },
+        id: { type: "string", format: "uuid", description: "Handoff ID" },
+        status: { type: "string", enum: ["pending", "accepted", "rejected", "expired"] },
         structured: { type: "boolean", default: false }
       },
-      required: []
+      required: ["id", "status"]
     },
     outputSchema: {
       type: "object",
       properties: {
-        schema: { type: "string", enum: ["standard-search"] },
-        query: { type: "string" },
-        count: { type: "number", description: "Number of rows returned" },
-        total: { type: "number", description: "Total number of matches before pagination" },
-        offset: { type: "number" },
-        limit: { type: "number" },
-        results: {
-          type: "object",
-          properties: {
-            columns: {
-              type: "array",
-              items: { type: "string" }
-            },
-            rows: {
-              type: "array",
-              items: { type: "array" },
-              description: "Each row includes standard id and pointer metadata. Fetch full content via standard-detail."
-            }
-          },
-          required: ["columns", "rows"]
-        }
+        success: { type: "boolean" },
+        id: { type: "string" },
+        status: { type: "string", enum: ["pending", "accepted", "rejected", "expired"] }
       },
-      required: ["schema", "query", "count", "total", "offset", "limit", "results"]
-    }
-  }
-];
-
-// 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()
-      }
+      required: ["success", "id", "status"]
     }
-  ];
-  return paginateEntries("resources", resources, params);
-}
-function listResourceTemplates(params) {
-  const templates = [
-    // ── Memory ──────────────────────────────────────────────────────────────
-    {
-      uriTemplate: "repository://{name}/memories",
-      name: "Repository Memories",
-      title: "Repository Memories",
-      description: "All active memory entries for a specific repository",
-      mimeType: "application/json",
-      annotations: { audience: ["assistant"], priority: 0.85 }
-    },
-    {
-      uriTemplate: "repository://{name}/memories?search={search}&type={type}&tag={tag}",
-      name: "Filtered Repository Memories",
-      title: "Filtered Repository Memories",
-      description: "Filter or search memories within a repository by keyword, type, or tag",
-      mimeType: "application/json",
-      annotations: { audience: ["assistant"], priority: 0.8 }
-    },
-    {
-      uriTemplate: "memory://{id}",
-      name: "Memory Detail",
-      title: "Memory Detail",
-      description: "Full content and statistics for a specific memory UUID",
-      mimeType: "application/json",
-      annotations: { audience: ["assistant"], priority: 0.75 }
-    },
-    // ── Tasks ────────────────────────────────────────────────────────────────
-    {
-      uriTemplate: "repository://{name}/tasks",
-      name: "Repository Tasks",
-      title: "Repository Tasks",
-      description: "All active tasks for a specific repository",
-      mimeType: "application/json",
-      annotations: { audience: ["assistant"], priority: 0.9 }
-    },
-    {
-      uriTemplate: "repository://{name}/tasks?status={status}&priority={priority}",
-      name: "Filtered Repository Tasks",
-      title: "Filtered Repository Tasks",
-      description: "Filter tasks within a repository by status or priority level",
-      mimeType: "application/json",
-      annotations: { audience: ["assistant"], priority: 0.85 }
-    },
-    {
-      uriTemplate: "task://{id}",
-      name: "Task Detail",
-      title: "Task Detail",
-      description: "Full content and comments for a specific task UUID",
-      mimeType: "application/json",
-      annotations: { audience: ["assistant"], priority: 0.8 }
-    },
-    // ── Repository extras ────────────────────────────────────────────────────
-    {
-      uriTemplate: "repository://{name}/summary",
-      name: "Repository Summary",
-      title: "Repository Summary",
-      description: "High-level architectural summary for a repository",
-      mimeType: "text/plain",
-      annotations: { audience: ["assistant"], priority: 0.95 }
+  },
+  {
+    name: "handoff-list",
+    title: "Handoff List",
+    description: "Navigation layer for handoff queues. List repository handoffs with optional status and agent filters, then inspect selected rows before acting.",
+    annotations: {
+      readOnlyHint: true,
+      idempotentHint: true,
+      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: {
+        repo: { type: "string", description: "Repository name" },
+        status: { type: "string", enum: ["pending", "accepted", "rejected", "expired"] },
+        from_agent: { type: "string" },
+        to_agent: { type: "string" },
+        limit: { type: "number", minimum: 1, maximum: 100, default: 20 },
+        offset: { type: "number", minimum: 0, default: 0 },
+        structured: { type: "boolean", default: false }
+      },
+      required: ["repo"]
     },
-    // ── Action detail ────────────────────────────────────────────────────────
-    {
-      uriTemplate: "action://{id}",
-      name: "Action Detail",
-      title: "Action Detail",
-      description: "Full details of a specific audit log entry by integer ID",
-      mimeType: "application/json",
-      annotations: { audience: ["assistant"], priority: 0.55 }
-    }
-  ];
-  return paginateEntries("resourceTemplates", templates, params);
-}
-function completeResourceArgument(resourceUri, argumentName, argumentValue, _contextArguments, dataSources) {
-  if (resourceUri === "repository://{name}/memories" || resourceUri === "repository://{name}/memories?search={search}&type={type}&tag={tag}" || resourceUri === "repository://{name}/tasks" || resourceUri === "repository://{name}/tasks?status={status}&priority={priority}" || resourceUri === "repository://{name}/summary" || resourceUri === "repository://{name}/actions") {
-    if (argumentName === "name") {
-      return rankCompletionValues(dataSources.repos, argumentValue);
-    }
-  }
-  if (resourceUri === "repository://{name}/memories?search={search}&type={type}&tag={tag}") {
-    if (argumentName === "tag") {
-      return rankCompletionValues(dataSources.tags, argumentValue);
-    }
-  }
-  throw invalidCompletionParams(`Unknown resource template or argument: ${resourceUri} (${argumentName})`);
-}
-function readResource(uri, db, session) {
-  logger.info("[Tool] resource.read", { uri });
-  if (uri === "repository://index") {
-    const repos = db.system.listRepoNavigation();
-    const payload = JSON.stringify(repos, null, 2);
-    return {
-      contents: [
-        {
-          uri,
-          mimeType: "application/json",
-          text: payload,
-          size: Buffer.byteLength(payload, "utf8"),
-          annotations: {
-            audience: ["assistant"],
-            priority: 1,
-            lastModified: (/* @__PURE__ */ new Date()).toISOString()
-          }
-        }
-      ]
-    };
-  }
-  if (uri === "session://roots") {
-    const payload = JSON.stringify({ roots: session?.roots ?? [] }, null, 2);
-    return {
-      contents: [
-        {
-          uri,
-          mimeType: "application/json",
-          text: payload,
-          size: Buffer.byteLength(payload, "utf8"),
-          annotations: {
-            audience: ["assistant"],
-            priority: 0.95,
-            lastModified: (/* @__PURE__ */ new Date()).toISOString()
-          }
-        }
-      ]
-    };
-  }
-  const memoryIdMatch = uri.match(/^memory:\/\/([0-9a-f-]{36})$/i);
-  if (memoryIdMatch) {
-    const id = memoryIdMatch[1];
-    const entry = db.memories.getByIdWithStats(id);
-    if (!entry) throw resourceNotFound(`Memory with ID ${id} not found.`, uri);
-    const payload = JSON.stringify(entry, null, 2);
-    return {
-      contents: [
-        {
-          uri,
-          mimeType: "application/json",
-          text: payload,
-          size: Buffer.byteLength(payload, "utf8"),
-          annotations: {
-            audience: ["assistant"],
-            priority: 0.75,
-            lastModified: entry.updated_at || entry.created_at
-          }
-        }
-      ]
-    };
-  }
-  const taskIdMatch = uri.match(/^task:\/\/([0-9a-f-]{36})$/i);
-  if (taskIdMatch) {
-    const id = taskIdMatch[1];
-    const task = db.tasks.getTaskById(id);
-    if (!task) throw resourceNotFound(`Task with ID ${id} not found.`, uri);
-    const payload = JSON.stringify(task, null, 2);
-    return {
-      contents: [
-        {
-          uri,
-          mimeType: "application/json",
-          text: payload,
-          size: Buffer.byteLength(payload, "utf8"),
-          annotations: {
-            audience: ["assistant"],
-            priority: 0.8,
-            lastModified: task.updated_at || task.created_at
-          }
-        }
-      ]
-    };
-  }
-  const repoBase = parseRepoUri(uri);
-  if (repoBase) {
-    const { name, path: repoPath, query } = repoBase;
-    if (repoPath === "summary") {
-      const summary = db.summaries.getSummary(name);
-      const text = summary?.summary || `No summary available for repository: ${name}`;
-      return {
-        contents: [
-          {
-            uri,
-            mimeType: "text/plain",
-            text,
-            size: Buffer.byteLength(text, "utf8"),
-            annotations: {
-              audience: ["assistant"],
-              priority: 0.95,
-              lastModified: summary?.updated_at || (/* @__PURE__ */ new Date()).toISOString()
+    outputSchema: {
+      type: "object",
+      properties: {
+        schema: { type: "string", enum: ["handoff-list"] },
+        handoffs: {
+          type: "object",
+          properties: {
+            columns: {
+              type: "array",
+              items: { type: "string" },
+              description: "Column names: [id, from_agent, to_agent, task_id, task_code, status, created_at, updated_at, expires_at, summary, context]"
+            },
+            rows: {
+              type: "array",
+              items: { type: "array" },
+              description: "Each row: [id, from_agent, to_agent, task_id, task_code, status, created_at, updated_at, expires_at, summary, context]"
             }
-          }
-        ]
-      };
+          },
+          required: ["columns", "rows"]
+        },
+        count: { type: "number" },
+        offset: { type: "number" }
+      },
+      required: ["schema", "handoffs", "count", "offset"]
     }
-    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: "task-claim",
+    title: "Task Claim",
+    description: "Claim task ownership for an agent using the dedicated claims table. Use this before taking work from task-list; provide either task_id or task_code.",
+    annotations: {
+      readOnlyHint: false,
+      idempotentHint: false,
+      destructiveHint: false,
+      openWorldHint: false
+    },
+    inputSchema: {
+      type: "object",
+      properties: {
+        repo: { type: "string", description: "Repository name" },
+        task_id: {
+          type: "string",
+          format: "uuid",
+          description: "Task id to claim. Optional if task_code is provided."
+        },
+        task_code: { type: "string", description: "Task code to claim. Optional if task_id is provided." },
+        agent: { type: "string", description: "Claiming agent name" },
+        role: { type: "string", description: "Claiming agent role" },
+        metadata: { type: "object", description: "Optional claim metadata" },
+        structured: { type: "boolean", default: false }
+      },
+      required: ["repo", "agent"]
+    },
+    outputSchema: {
+      type: "object",
+      properties: {
+        id: { type: "string" },
+        repo: { type: "string" },
+        task_id: { type: "string" },
+        task_code: { type: "string", nullable: true },
+        agent: { type: "string" },
+        role: { type: "string" },
+        claimed_at: { type: "string" },
+        released_at: { type: "string", nullable: true },
+        metadata: { type: "object" }
+      },
+      required: ["id", "repo", "task_id", "agent", "role", "claimed_at", "metadata"]
+    }
+  },
+  {
+    name: "claim-list",
+    title: "Claim List",
+    description: "List task claims in a repository. Use this to inspect active ownership, optionally filtered by agent.",
+    annotations: {
+      readOnlyHint: true,
+      idempotentHint: true,
+      destructiveHint: false,
+      openWorldHint: false
+    },
+    inputSchema: {
+      type: "object",
+      properties: {
+        repo: { type: "string", description: "Repository name" },
+        agent: { type: "string", description: "Optional agent filter" },
+        active_only: { type: "boolean", description: "When true, return only unreleased claims" },
+        limit: { type: "number", minimum: 1, maximum: 100, default: 20 },
+        offset: { type: "number", minimum: 0, default: 0 },
+        structured: { type: "boolean", default: false }
+      },
+      required: ["repo"]
+    },
+    outputSchema: {
+      type: "object",
+      properties: {
+        schema: { type: "string", enum: ["claim-list"] },
+        claims: {
+          type: "object",
+          properties: {
+            columns: {
+              type: "array",
+              items: { type: "string" },
+              description: "Column names: [id, task_id, task_code, agent, role, claimed_at, released_at, metadata]"
+            },
+            rows: {
+              type: "array",
+              items: { type: "array" },
+              description: "Each row: [id, task_id, task_code, agent, role, claimed_at, released_at, metadata]"
             }
-          }
-        ]
-      };
+          },
+          required: ["columns", "rows"]
+        },
+        count: { type: "number" },
+        offset: { type: "number" }
+      },
+      required: ["schema", "claims", "count", "offset"]
     }
-    if (repoPath === "tasks") {
-      const status = query.get("status");
-      const priority = query.get("priority");
-      let tasks;
-      if (status && status !== "all") {
-        const statuses = status.split(",").map((s) => s.trim());
-        tasks = db.tasks.getTasksByMultipleStatuses(name, statuses);
-      } else {
-        tasks = db.tasks.getTasksByMultipleStatuses(name, ["backlog", "pending", "in_progress", "blocked"]);
-      }
-      if (priority) {
-        const p = Number(priority);
-        if (!isNaN(p)) {
-          tasks = tasks.filter((t) => t.priority === p);
-        }
-      }
-      const payload = JSON.stringify(tasks, null, 2);
-      return {
-        contents: [
-          {
-            uri,
-            mimeType: "application/json",
-            text: payload,
-            size: Buffer.byteLength(payload, "utf8"),
-            annotations: {
-              audience: ["assistant"],
-              priority: 0.9,
-              lastModified: deriveLastModifiedFromCollection(tasks.map((t) => t.updated_at))
-            }
-          }
-        ]
-      };
+  },
+  {
+    name: "claim-release",
+    title: "Claim Release",
+    description: "Release an active claim for a task. Optionally restrict the release to a specific agent.",
+    annotations: {
+      readOnlyHint: false,
+      idempotentHint: false,
+      destructiveHint: false,
+      openWorldHint: false
+    },
+    inputSchema: {
+      type: "object",
+      properties: {
+        repo: { type: "string", description: "Repository name" },
+        task_id: {
+          type: "string",
+          format: "uuid",
+          description: "Task id to release. Optional if task_code is provided."
+        },
+        task_code: { type: "string", description: "Task code to release. Optional if task_id is provided." },
+        agent: { type: "string", description: "Optional agent name to release only that claim" },
+        structured: { type: "boolean", default: false }
+      },
+      required: ["repo"]
+    },
+    outputSchema: {
+      type: "object",
+      properties: {
+        success: { type: "boolean" },
+        repo: { type: "string" },
+        task_id: { type: "string" },
+        task_code: { type: "string", nullable: true },
+        agent: { type: "string", nullable: true }
+      },
+      required: ["success", "repo", "task_id"]
     }
-    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: "standard-store",
+    title: "Standard Store",
+    description: "Store one atomic coding standard. Use for durable implementation rules with explicit context, stack/language filters, and repo/global scope.",
+    annotations: {
+      readOnlyHint: false,
+      idempotentHint: false,
+      destructiveHint: false,
+      openWorldHint: false
+    },
+    inputSchema: {
+      type: "object",
+      properties: {
+        name: { type: "string", minLength: 3, maxLength: 255, description: "Human-readable standard name" },
+        content: {
+          type: "string",
+          minLength: 10,
+          description: "One atomic, actionable standard written as concise Markdown"
+        },
+        parent_id: {
+          type: "string",
+          format: "uuid",
+          description: "Optional parent standard ID when this rule is a child/specialization."
+        },
+        context: { type: "string", description: "Context or category (e.g., 'error-handling', 'security')" },
+        version: { type: "string", description: "Version of the standard (e.g., '1.0.0')" },
+        language: { type: "string", description: "Programming language (e.g., 'typescript', 'python')" },
+        stack: {
+          type: "array",
+          items: { type: "string" },
+          description: "Technology stack (e.g., ['react', 'nextjs'])"
+        },
+        repo: {
+          type: "string",
+          description: "Repository name for repo-specific standards. Omit only for global standards."
+        },
+        is_global: { type: "boolean", description: "Whether standard applies globally or repo-specific" },
+        tags: {
+          type: "array",
+          items: { type: "string" },
+          description: "Tags for categorization"
+        },
+        metadata: {
+          type: "object",
+          description: "Additional metadata"
+        },
+        agent: { type: "string", description: "Agent creating the standard" },
+        model: { type: "string", description: "AI model used" },
+        structured: { type: "boolean", default: false }
+      },
+      required: ["name", "content", "tags", "metadata"]
+    },
+    outputSchema: {
+      type: "object",
+      properties: {
+        success: { type: "boolean" },
+        standard: {
+          type: "object",
+          properties: {
+            id: { type: "string" },
+            title: { type: "string" },
+            content: { type: "string" },
+            parent_id: { type: "string", nullable: true },
+            context: { type: "string" },
+            version: { type: "string" },
+            language: { type: "string", nullable: true },
+            stack: { type: "array", items: { type: "string" } },
+            is_global: { type: "boolean" },
+            repo: { type: "string", nullable: true },
+            tags: { type: "array", items: { type: "string" } },
+            metadata: { type: "object" },
+            created_at: { type: "string" },
+            updated_at: { type: "string" },
+            agent: { type: "string" },
+            model: { type: "string" }
+          },
+          required: [
+            "id",
+            "title",
+            "content",
+            "parent_id",
+            "context",
+            "version",
+            "stack",
+            "is_global",
+            "tags",
+            "metadata",
+            "created_at",
+            "updated_at",
+            "agent",
+            "model"
+          ]
+        },
+        message: { type: "string" }
+      },
+      required: ["success", "standard", "message"]
+    }
+  },
+  {
+    name: "standard-update",
+    title: "Standard Update",
+    description: "Update an existing coding standard. Use this when the rule changes, expands scope, or metadata/tags need correction.",
+    annotations: {
+      readOnlyHint: false,
+      idempotentHint: false,
+      destructiveHint: false,
+      openWorldHint: false
+    },
+    inputSchema: {
+      type: "object",
+      properties: {
+        id: { type: "string", description: "Standard ID to update" },
+        name: { type: "string", minLength: 3, maxLength: 255 },
+        content: { type: "string", minLength: 10 },
+        parent_id: { type: "string", format: "uuid", nullable: true },
+        context: { type: "string" },
+        version: { type: "string" },
+        language: { type: "string" },
+        stack: { type: "array", items: { type: "string" } },
+        repo: { type: "string" },
+        is_global: { type: "boolean" },
+        tags: { type: "array", items: { type: "string" } },
+        metadata: { type: "object" },
+        agent: { type: "string" },
+        model: { type: "string" },
+        structured: { type: "boolean", default: false }
+      },
+      required: ["id"]
+    },
+    outputSchema: {
+      type: "object",
+      properties: {
+        success: { type: "boolean" },
+        id: { type: "string" },
+        updatedFields: { type: "array", items: { type: "string" } }
+      },
+      required: ["success", "id", "updatedFields"]
     }
-  }
-  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/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: "standard-search",
+    title: "Standard Search",
+    description: "MANDATORY PRE-IMPLEMENTATION CHECK: Call before any code edit, test edit, refactor, migration, or implementation decision to find applicable coding standards. Returns a compact pointer table; use `standard-detail` for relevant results. If no relevant standards are returned, continue and state that no applicable standards were found.",
+    annotations: {
+      readOnlyHint: true,
+      idempotentHint: true,
+      openWorldHint: false
+    },
+    inputSchema: {
+      type: "object",
+      properties: {
+        query: { type: "string", description: "Search query (optional, searches title/content)" },
+        stack: {
+          type: "array",
+          items: { type: "string" },
+          description: "Technology stack to filter by (e.g., ['react', 'nextjs'])"
+        },
+        tags: {
+          type: "array",
+          items: { type: "string" },
+          description: "Tag filter"
+        },
+        language: { type: "string", description: "Programming language filter" },
+        context: { type: "string", description: "Context/category filter" },
+        version: { type: "string", description: "Version filter" },
+        repo: { type: "string", description: "Repository filter (optional)" },
+        is_global: { type: "boolean", description: "Filter by global/repo-specific" },
+        limit: { type: "number", minimum: 1, maximum: 100, default: 20 },
+        offset: { type: "number", minimum: 0, default: 0 },
+        structured: { type: "boolean", default: false }
+      },
+      required: []
+    },
+    outputSchema: {
+      type: "object",
+      properties: {
+        schema: { type: "string", enum: ["standard-search"] },
+        query: { type: "string" },
+        count: { type: "number", description: "Number of rows returned" },
+        total: { type: "number", description: "Total number of matches before pagination" },
+        offset: { type: "number" },
+        limit: { type: "number" },
+        results: {
+          type: "object",
+          properties: {
+            columns: {
+              type: "array",
+              items: { type: "string" }
+            },
+            rows: {
+              type: "array",
+              items: { type: "array" },
+              description: "Each row includes standard id and pointer metadata. Fetch full content via standard-detail."
+            }
+          },
+          required: ["columns", "rows"]
         }
-      }
-    ]
-  };
-}
-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: ["schema", "query", "count", "total", "offset", "limit", "results"]
     }
-    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/standard.shared.ts
 function toContextSlug(value) {
@@ -5341,17 +5354,31 @@ function buildStandardVectorText(standard) {
 }
 
 export {
-  MCP_PROTOCOL_VERSION,
-  CAPABILITIES,
   logger,
   setLogLevel,
   getLogLevel,
   addLogSink,
   LOG_LEVEL_VALUES,
   createFileSink,
+  encodeCursor,
+  decodeCursor,
+  listResources,
+  listResourceTemplates,
+  completeResourceArgument,
+  readResource,
+  createSessionContext,
+  updateSessionFromInitialize,
+  updateSessionRoots,
+  extractRootsFromResult,
+  getFilesystemRoots,
+  isPathWithinRoots,
+  findContainingRoot,
+  inferRepoFromSession,
+  PROMPTS,
+  listPrompts,
+  getPrompt,
+  completePromptArgument,
   normalizeRepo,
-  SQLiteStore,
-  RealVectorStore,
   MemoryStoreSchema,
   MemoryUpdateSchema,
   MemorySearchSchema,
@@ -5379,24 +5406,10 @@ export {
   StandardUpdateSchema,
   StandardSearchSchema,
   TOOL_DEFINITIONS,
-  encodeCursor,
-  decodeCursor,
-  listResources,
-  listResourceTemplates,
-  completeResourceArgument,
-  readResource,
-  createSessionContext,
-  updateSessionFromInitialize,
-  updateSessionRoots,
-  extractRootsFromResult,
-  getFilesystemRoots,
-  isPathWithinRoots,
-  findContainingRoot,
-  inferRepoFromSession,
-  PROMPTS,
-  listPrompts,
-  getPrompt,
-  completePromptArgument,
   toContextSlug,
-  buildStandardVectorText
+  buildStandardVectorText,
+  SQLiteStore,
+  RealVectorStore,
+  MCP_PROTOCOL_VERSION,
+  CAPABILITIES
 };