@vheins/local-memory-mcp 0.8.44 → 0.8.45

package/dist/{chunk-RHTFBGAQ.js → chunk-Z4FZBRE2.js}

@@ -1,49 +1,3 @@
-// src/mcp/capabilities.ts
-import { fileURLToPath } from "url";
-import path from "path";
-var __dirname = path.dirname(fileURLToPath(import.meta.url));
-var pkgVersion = "0.1.0";
-if ("0.8.44") {
-  pkgVersion = "0.8.44";
-} else {
-  let searchDir = __dirname;
-  for (let i = 0; i < 5; i++) {
-    const candidate = path.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 = path.dirname(searchDir);
-  }
-}
-var MCP_PROTOCOL_VERSION = "2025-03-26";
-var CAPABILITIES = {
-  serverInfo: {
-    name: "mcp-memory-local",
-    version: pkgVersion
-  },
-  capabilities: {
-    completions: {},
-    logging: {},
-    resources: {
-      subscribe: true,
-      listChanged: true
-    },
-    tools: {
-      listChanged: false
-    },
-    prompts: {
-      listChanged: true
-    }
-  }
-};
-
 // src/mcp/utils/logger.ts
 import fs from "fs";
 var LEVELS = {
@@ -185,6 +139,108 @@ function createFileSink(logDir, maxFiles = 5) {
   };
 }
 
+// src/mcp/session.ts
+import path from "path";
+import { fileURLToPath } from "url";
+function createSessionContext() {
+  return {
+    roots: [],
+    supportsRoots: false,
+    supportsSampling: false,
+    supportsSamplingTools: false,
+    supportsElicitation: false,
+    supportsElicitationForm: false,
+    supportsElicitationUrl: false
+  };
+}
+function updateSessionFromInitialize(session, params) {
+  const capabilities = params?.capabilities || {};
+  session.clientInfo = params?.clientInfo;
+  session.clientCapabilities = capabilities;
+  session.supportsRoots = Boolean(capabilities.roots);
+  session.supportsSampling = Boolean(capabilities.sampling);
+  const sampling = capabilities.sampling;
+  session.supportsSamplingTools = Boolean(sampling?.tools);
+  session.supportsElicitation = Boolean(capabilities.elicitation);
+  session.supportsElicitationForm = supportsElicitationMode(capabilities.elicitation, "form");
+  session.supportsElicitationUrl = supportsElicitationMode(capabilities.elicitation, "url");
+}
+function supportsElicitationMode(capability, mode) {
+  if (!capability || typeof capability !== "object") {
+    return false;
+  }
+  const cap = capability;
+  if (mode === "form") {
+    return Object.keys(cap).length === 0 || typeof cap.form === "object";
+  }
+  return typeof cap.url === "object";
+}
+function updateSessionRoots(session, roots) {
+  const normalized = normalizeRoots(roots);
+  const previous = JSON.stringify(session.roots);
+  const next = JSON.stringify(normalized);
+  session.roots = normalized;
+  return previous !== next;
+}
+function normalizeRoots(roots) {
+  if (!Array.isArray(roots)) return [];
+  const seen = /* @__PURE__ */ new Set();
+  const normalized = [];
+  for (const root of roots) {
+    if (!root || typeof root !== "object") continue;
+    const r = root;
+    const uri = typeof r.uri === "string" ? r.uri : void 0;
+    const name = typeof r.name === "string" ? r.name : void 0;
+    if (!uri || seen.has(uri)) continue;
+    seen.add(uri);
+    normalized.push({ uri, name });
+  }
+  return normalized;
+}
+function extractRootsFromResult(result) {
+  return normalizeRoots(result?.roots);
+}
+function getFilesystemRoots(session) {
+  if (!session) return [];
+  const resolved = [];
+  for (const root of session.roots) {
+    if (!root.uri.startsWith("file://")) continue;
+    try {
+      resolved.push(path.resolve(fileURLToPath(root.uri)));
+    } catch {
+    }
+  }
+  return resolved;
+}
+function isPathWithinRoots(targetPath, session) {
+  const roots = getFilesystemRoots(session);
+  if (roots.length === 0) return true;
+  const normalizedTarget = path.resolve(targetPath);
+  return roots.some((rootPath) => {
+    const relative = path.relative(rootPath, normalizedTarget);
+    return relative === "" || !relative.startsWith("..") && !path.isAbsolute(relative);
+  });
+}
+function findContainingRoot(targetPath, session) {
+  const roots = getFilesystemRoots(session);
+  if (roots.length === 0) return null;
+  const normalizedTarget = path.resolve(targetPath);
+  for (const rootPath of roots) {
+    const relative = path.relative(rootPath, normalizedTarget);
+    if (relative === "" || !relative.startsWith("..") && !path.isAbsolute(relative)) {
+      return rootPath;
+    }
+  }
+  return null;
+}
+function inferRepoFromSession(session) {
+  const roots = getFilesystemRoots(session);
+  if (roots.length === 1) {
+    return path.basename(roots[0]);
+  }
+  return void 0;
+}
+
 // src/mcp/storage/sqlite.ts
 import Database from "better-sqlite3";
 import path3 from "path";
@@ -2563,1008 +2619,1124 @@ var SQLiteStore = class _SQLiteStore {
   }
 };
 
-// src/mcp/session.ts
-import path4 from "path";
+// src/mcp/capabilities.ts
 import { fileURLToPath as fileURLToPath2 } from "url";
-function createSessionContext() {
-  return {
-    roots: [],
-    supportsRoots: false,
-    supportsSampling: false,
-    supportsSamplingTools: false,
-    supportsElicitation: false,
-    supportsElicitationForm: false,
-    supportsElicitationUrl: false
-  };
-}
-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;
+import path4 from "path";
+var __dirname = path4.dirname(fileURLToPath2(import.meta.url));
+var pkgVersion = "0.1.0";
+if ("0.8.45") {
+  pkgVersion = "0.8.45";
+} else {
+  let searchDir = __dirname;
+  for (let i = 0; i < 5; i++) {
+    const candidate = path4.join(searchDir, "package.json");
     try {
-      resolved.push(path4.resolve(fileURLToPath2(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 = path4.dirname(searchDir);
   }
-  return resolved;
-}
-function isPathWithinRoots(targetPath, session) {
-  const roots = getFilesystemRoots(session);
-  if (roots.length === 0) return true;
-  const normalizedTarget = path4.resolve(targetPath);
-  return roots.some((rootPath) => {
-    const relative = path4.relative(rootPath, normalizedTarget);
-    return relative === "" || !relative.startsWith("..") && !path4.isAbsolute(relative);
-  });
 }
-function findContainingRoot(targetPath, session) {
-  const roots = getFilesystemRoots(session);
-  if (roots.length === 0) return null;
-  const normalizedTarget = path4.resolve(targetPath);
-  for (const rootPath of roots) {
-    const relative = path4.relative(rootPath, normalizedTarget);
-    if (relative === "" || !relative.startsWith("..") && !path4.isAbsolute(relative)) {
-      return rootPath;
+var MCP_PROTOCOL_VERSION = "2025-03-26";
+var CAPABILITIES = {
+  serverInfo: {
+    name: "mcp-memory-local",
+    version: pkgVersion
+  },
+  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 path4.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",
-  "file_claim",
-  "task_archive"
-]);
-var MemoryStoreSchema = z.object({
-  code: z.string().max(20).optional(),
-  type: MemoryTypeSchema,
-  title: z.string().min(3).max(255),
-  content: z.string().min(10),
-  importance: z.number().min(1).max(5),
-  agent: z.string().min(1),
-  role: z.string().optional().default("unknown"),
-  model: z.string().min(1),
-  scope: MemoryScopeSchema,
-  ttlDays: z.number().min(1).optional(),
-  supersedes: z.string().uuid().optional(),
-  tags: z.array(z.string()).optional(),
-  metadata: z.record(z.string(), z.any()).optional(),
-  is_global: z.boolean().default(false),
-  structured: z.boolean().default(false)
-});
-var MemoryUpdateSchema = z.object({
-  id: z.string().uuid(),
-  type: MemoryTypeSchema.optional(),
-  title: z.string().min(3).max(255).optional(),
-  content: z.string().min(10).optional(),
-  importance: z.number().min(1).max(5).optional(),
-  agent: z.string().optional(),
-  role: z.string().optional(),
-  status: z.enum(["active", "archived"]).optional(),
-  supersedes: z.string().uuid().optional(),
-  tags: z.array(z.string()).optional(),
-  metadata: z.record(z.string(), z.any()).optional(),
-  is_global: z.boolean().optional(),
-  completed_at: z.string().optional(),
-  structured: z.boolean().default(false)
-}).refine(
-  (data) => data.type !== void 0 || data.content !== void 0 || data.title !== void 0 || data.importance !== void 0 || data.status !== void 0 || data.supersedes !== void 0 || data.tags !== void 0 || data.metadata !== void 0 || data.is_global !== void 0 || data.agent !== void 0 || data.role !== void 0 || data.completed_at !== void 0,
-  { message: "At least one field must be provided for update" }
-);
-var MemorySearchSchema = z.object({
-  query: z.string().min(3),
-  prompt: z.string().optional(),
-  repo: z.string().min(1).transform(normalizeRepo),
-  types: z.array(MemoryTypeSchema).optional(),
-  minImportance: z.number().min(1).max(5).optional(),
-  limit: z.number().min(1).max(100).default(5),
-  offset: z.number().min(0).default(0),
-  includeRecap: z.boolean().default(false),
-  current_file_path: z.string().optional(),
-  include_archived: z.boolean().default(false),
-  current_tags: z.array(z.string()).optional(),
-  scope: MemoryScopeSchema.partial().optional(),
-  structured: z.boolean().default(false)
-});
-var MemoryAcknowledgeSchema = z.object({
-  memory_id: z.string().uuid(),
-  status: z.enum(["used", "irrelevant", "contradictory"]),
-  application_context: z.string().min(10).optional(),
-  structured: z.boolean().default(false)
-});
-var MemoryRecapSchema = z.object({
-  repo: z.string().min(1).transform(normalizeRepo),
-  limit: z.number().min(1).max(50).default(20),
-  offset: z.number().min(0).default(0),
-  structured: z.boolean().default(false)
-});
-var MemoryDeleteSchema = z.object({
-  repo: z.string().min(1).transform(normalizeRepo).optional(),
-  id: z.string().uuid().optional(),
-  ids: z.array(z.string().uuid()).min(1).optional(),
-  structured: z.boolean().default(false)
-}).refine((data) => data.id !== void 0 || data.ids !== void 0, {
-  message: "Either 'id' or 'ids' must be provided for deletion"
-});
-var MemorySummarizeSchema = z.object({
-  repo: z.string().min(1).transform(normalizeRepo),
-  signals: z.array(z.string().max(200)).min(1),
-  structured: z.boolean().default(false)
-});
-var MemorySynthesizeSchema = z.object({
-  repo: z.string().min(1).transform(normalizeRepo).optional(),
-  objective: z.string().min(5),
-  current_file_path: z.string().optional(),
-  include_summary: z.boolean().default(true),
-  include_tasks: z.boolean().default(true),
-  use_tools: z.boolean().default(true),
-  max_iterations: z.number().int().min(1).max(5).default(3),
-  max_tokens: z.number().int().min(128).max(4e3).default(1200),
-  structured: z.boolean().default(false)
-});
-var TaskStatusSchema = z.enum(["backlog", "pending", "in_progress", "completed", "canceled", "blocked"]);
-var TaskPrioritySchema = z.number().min(1).max(5);
-var SingleTaskCreateSchema = z.object({
-  task_code: z.string().min(1),
-  phase: z.string().min(1),
-  title: z.string().min(3).max(100),
-  description: z.string().min(1),
-  status: TaskStatusSchema.default("backlog"),
-  priority: TaskPrioritySchema.default(3),
-  agent: z.string().optional(),
-  role: z.string().optional(),
-  doc_path: z.string().optional(),
-  tags: z.array(z.string()).optional(),
-  metadata: z.record(z.string(), z.any()).optional(),
-  parent_id: z.string().uuid().optional(),
-  depends_on: z.string().uuid().optional(),
-  est_tokens: z.number().int().min(0).optional()
-});
-var TaskCreateSchema = z.object({
-  repo: z.string().min(1).transform(normalizeRepo),
-  // Allow single task fields at top level (backward compatibility & single use)
-  task_code: z.string().min(1).optional(),
-  phase: z.string().min(1).optional(),
-  title: z.string().min(3).max(100).optional(),
-  description: z.string().min(1).optional(),
-  status: TaskStatusSchema.optional(),
-  priority: TaskPrioritySchema.optional(),
-  agent: z.string().optional(),
-  role: z.string().optional(),
-  doc_path: z.string().optional(),
-  tags: z.array(z.string()).optional(),
-  metadata: z.record(z.string(), z.any()).optional(),
-  parent_id: z.string().uuid().optional(),
-  depends_on: z.string().uuid().optional(),
-  est_tokens: z.number().int().min(0).optional(),
-  // Allow bulk tasks
-  tasks: z.array(SingleTaskCreateSchema).min(1).optional(),
-  structured: z.boolean().default(false)
-}).refine(
-  (data) => {
-    if (data.tasks) return true;
-    return !!(data.task_code && data.phase && data.title && data.description);
-  },
-  { message: "Either 'tasks' array or single task fields (task_code, phase, title, description) must be provided" }
-);
-var TaskCreateInteractiveSchema = SingleTaskCreateSchema.partial().extend({
-  repo: z.string().min(1).transform(normalizeRepo).optional(),
-  structured: z.boolean().default(false)
-});
-var TaskUpdateSchema = z.object({
-  repo: z.string().min(1).transform(normalizeRepo),
-  id: z.string().uuid().optional(),
-  ids: z.array(z.string().uuid()).min(1).optional(),
-  task_code: z.string().optional(),
-  phase: z.string().optional(),
-  title: z.string().min(3).max(100).optional(),
-  description: z.string().optional(),
-  status: TaskStatusSchema.optional(),
-  priority: TaskPrioritySchema.optional(),
-  agent: z.string().min(1, "agent name is required").optional(),
-  role: z.string().min(1, "agent role is required").optional(),
-  model: z.string().optional(),
-  comment: z.string().min(1).optional(),
-  doc_path: z.string().optional(),
-  tags: z.array(z.string()).optional(),
-  metadata: z.record(z.string(), z.any()).optional(),
-  parent_id: z.string().uuid().optional(),
-  depends_on: z.string().uuid().optional(),
-  est_tokens: z.number().int().min(0).optional(),
-  force: z.boolean().optional(),
-  structured: z.boolean().default(false)
-}).refine((data) => data.id !== void 0 || data.ids !== void 0 || 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 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"
-});
-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 StandardStoreSchema = z.object({
-  name: z.string().min(3).max(255),
-  content: z.string().min(10),
-  context: z.string().optional(),
-  version: z.string().optional(),
-  language: z.string().optional(),
-  stack: z.array(z.string()).optional(),
-  repo: z.string().optional(),
-  is_global: z.boolean().optional(),
-  tags: z.array(z.string()).optional(),
-  metadata: z.record(z.string(), z.any()).optional(),
-  agent: z.string().optional(),
-  model: z.string().optional(),
-  structured: z.boolean().default(false)
-});
-var StandardSearchSchema = z.object({
-  query: z.string().optional(),
-  stack: z.array(z.string()).optional(),
-  language: z.string().optional(),
-  version: z.string().optional(),
-  repo: z.string().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
+// 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()
+      }
     },
-    execution: {
-      taskSupport: "optional"
+    {
+      uri: "session://roots",
+      name: "Session Roots",
+      title: "Session Roots",
+      description: session?.roots.length ? "Active workspace roots provided by the MCP client" : "No active workspace roots were provided by the MCP client",
+      mimeType: "application/json",
+      size: Buffer.byteLength(JSON.stringify({ roots: session?.roots ?? [] }), "utf8"),
+      annotations: {
+        audience: ["assistant"],
+        priority: 0.95,
+        lastModified: (/* @__PURE__ */ new Date()).toISOString()
+      }
+    }
+  ];
+  return paginateEntries("resources", resources, params);
+}
+function listResourceTemplates(params) {
+  const templates = [
+    // ── Memory ──────────────────────────────────────────────────────────────
+    {
+      uriTemplate: "repository://{name}/memories",
+      name: "Repository Memories",
+      title: "Repository Memories",
+      description: "All active memory entries for a specific repository",
+      mimeType: "application/json",
+      annotations: { audience: ["assistant"], priority: 0.85 }
     },
-    inputSchema: {
-      type: "object",
-      properties: {
-        repo: { type: "string", description: "Repository name. Optional when a single MCP root is active." },
-        objective: { type: "string", minLength: 5, description: "Question or synthesis objective." },
-        current_file_path: {
-          type: "string",
-          description: "Optional absolute file path for workspace-local grounding."
-        },
-        include_summary: { type: "boolean", default: true },
-        include_tasks: { type: "boolean", default: true },
-        use_tools: {
-          type: "boolean",
-          default: true,
-          description: "Allow the sampled model to call local memory/task tools during synthesis when the client supports sampling.tools."
-        },
-        max_iterations: { type: "number", minimum: 1, maximum: 5, default: 3 },
-        max_tokens: { type: "number", minimum: 128, maximum: 4e3, default: 1200 },
-        structured: { type: "boolean", default: false, description: "If true, returns structured JSON results." }
-      },
-      required: ["objective"]
+    {
+      uriTemplate: "repository://{name}/memories?search={search}&type={type}&tag={tag}",
+      name: "Filtered Repository Memories",
+      title: "Filtered Repository Memories",
+      description: "Filter or search memories within a repository by keyword, type, or tag",
+      mimeType: "application/json",
+      annotations: { audience: ["assistant"], priority: 0.8 }
     },
-    outputSchema: {
-      type: "object",
-      properties: {
-        repo: { type: "string" },
-        objective: { type: "string" },
-        answer: { type: "string" },
-        model: { type: "string" },
-        stopReason: { type: "string" },
-        iterations: { type: "number" },
-        toolCalls: { type: "number" }
-      },
-      required: ["repo", "objective", "answer", "iterations", "toolCalls"]
-    }
-  },
-  {
-    name: "task-create-interactive",
-    title: "Interactive Task Create",
-    description: "Create a task with MCP elicitation fallback for any missing required fields. Best when an agent knows a task is needed but still needs user confirmation for repo, title, or phase.",
-    annotations: {
-      readOnlyHint: false,
-      idempotentHint: false,
-      destructiveHint: false,
-      openWorldHint: false
+    {
+      uriTemplate: "memory://{id}",
+      name: "Memory Detail",
+      title: "Memory Detail",
+      description: "Full content and statistics for a specific memory UUID",
+      mimeType: "application/json",
+      annotations: { audience: ["assistant"], priority: 0.75 }
     },
-    inputSchema: {
-      type: "object",
-      properties: {
-        repo: {
-          type: "string",
-          description: "Repository name. Optional when it can be inferred from MCP roots or elicited from the user."
-        },
-        task_code: { type: "string" },
-        phase: { type: "string" },
-        title: { type: "string", minLength: 3, maxLength: 100 },
-        description: { type: "string", minLength: 1 },
-        status: { type: "string", enum: ["backlog", "pending"], default: "backlog" },
-        priority: { type: "number", minimum: 1, maximum: 5, default: 3 },
-        agent: { type: "string" },
-        role: { type: "string" },
-        doc_path: { type: "string" },
-        structured: { type: "boolean", default: false, description: "If true, returns structured JSON result." }
-      }
+    // ── Tasks ────────────────────────────────────────────────────────────────
+    {
+      uriTemplate: "repository://{name}/tasks",
+      name: "Repository Tasks",
+      title: "Repository Tasks",
+      description: "All active tasks for a specific repository",
+      mimeType: "application/json",
+      annotations: { audience: ["assistant"], priority: 0.9 }
+    },
+    {
+      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 }
     },
-    outputSchema: {
-      type: "object",
-      properties: {
-        repo: { type: "string" },
-        task_code: { type: "string" },
-        phase: { type: "string" },
-        title: { type: "string" },
-        status: { type: "string" },
-        priority: { type: "number" }
-      },
-      required: ["repo", "task_code", "phase", "title", "status", "priority"]
+    {
+      uriTemplate: "repository://{name}/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: "task-detail",
-    title: "Task Detail",
-    description: "Fetch full details of a specific task by ID or task code. Use this when you have a task ID or code and need to read the full description and comments.",
-    inputSchema: {
-      type: "object",
-      properties: {
-        repo: { type: "string", description: "Repository name" },
-        id: { type: "string", format: "uuid", description: "Task ID (optional if task_code is provided)" },
-        task_code: { type: "string", description: "Task code (e.g. TASK-001) (optional if id is provided)" },
-        structured: {
-          type: "boolean",
-          default: false,
-          description: "If true, returns structured JSON without the text content details."
-        }
-      },
-      required: ["repo"]
+  }
+  if (resourceUri === "repository://{name}/memories?search={search}&type={type}&tag={tag}") {
+    if (argumentName === "tag") {
+      return rankCompletionValues(dataSources.tags, argumentValue);
     }
-  },
-  {
-    name: "memory-store",
-    title: "Memory Store",
-    description: "Store a new memory entry. Keep 'title' concise and human-readable; do not embed agent/role/date metadata in the title. Put auxiliary context into 'metadata'. Use 'tags' for tech-stack and 'is_global' for universal rules.",
-    annotations: {
-      readOnlyHint: false,
-      idempotentHint: false,
-      destructiveHint: false,
-      openWorldHint: false
-    },
-    inputSchema: {
-      type: "object",
-      properties: {
-        type: {
-          type: "string",
-          enum: [
-            "code_fact",
-            "decision",
-            "mistake",
-            "pattern",
-            "file_claim",
-            "task_archive"
-          ],
-          description: "Type of memory being stored"
-        },
-        title: {
-          type: "string",
-          minLength: 3,
-          maxLength: 100,
-          description: "Short human-readable title for the memory. Do not embed bracketed metadata like agent/role/date prefixes here."
-        },
-        content: {
-          type: "string",
-          minLength: 10,
-          description: "The memory content"
-        },
-        importance: {
-          type: "number",
-          minimum: 1,
-          maximum: 5,
-          description: "Importance score (1-5)"
-        },
-        agent: {
-          type: "string",
-          description: "Name of the agent creating this memory"
-        },
-        role: {
-          type: "string",
-          description: "Role of the agent creating this memory"
-        },
-        model: {
-          type: "string",
-          description: "AI model used by the agent"
-        },
-        scope: {
-          type: "object",
-          properties: {
-            repo: { type: "string", description: "Repository name" },
-            branch: { type: "string" },
-            folder: { type: "string" },
-            language: { type: "string" }
-          },
-          required: ["repo"]
-        },
-        tags: {
-          type: "array",
-          items: { type: "string" },
-          description: "Technology stack tags (e.g., ['filament', 'laravel'])"
-        },
-        metadata: {
-          type: "object",
-          description: "Structured metadata for non-title context such as source agent, claim fields, or timestamps"
-        },
-        is_global: {
-          type: "boolean",
-          description: "If true, this memory is shared across all repositories"
-        },
-        ttlDays: { type: "number", minimum: 1 },
-        supersedes: { type: "string", format: "uuid" },
-        structured: { type: "boolean", default: false, description: "If true, returns structured JSON of the stored memory." }
-      },
-      required: ["type", "title", "content", "importance", "scope", "agent", "model"]
-    },
-    outputSchema: {
-      type: "object",
-      properties: {
-        success: { type: "boolean" },
-        id: { type: "string" },
-        code: { type: "string" },
-        repo: { type: "string" },
-        type: { type: "string" },
-        title: { type: "string" },
-        error: { type: "string" },
-        message: { type: "string" }
-      },
-      required: ["success"]
+  }
+  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()
+            }
+          }
+        ]
+      };
     }
-  },
-  {
-    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",
-            "file_claim",
-            "task_archive"
-          ]
-        },
-        title: { type: "string", minLength: 3, maxLength: 100 },
-        content: { type: "string", minLength: 10 },
-        importance: { type: "number", minimum: 1, maximum: 5 },
-        agent: { type: "string" },
-        role: { type: "string" },
-        status: { type: "string", enum: ["active", "archived"] },
-        supersedes: { type: "string", format: "uuid" },
-        tags: { type: "array", items: { type: "string" } },
-        metadata: { type: "object" },
-        is_global: { type: "boolean" },
-        completed_at: { type: "string" },
-        structured: { type: "boolean", default: false, description: "If true, returns structured JSON of the updated memory." }
-      },
-      required: ["id"]
-    },
-    outputSchema: {
-      type: "object",
-      properties: {
-        success: { type: "boolean" },
-        id: { type: "string" },
-        repo: { type: "string" },
-        updatedFields: {
-          type: "array",
-          items: { type: "string" }
+    if (repoPath === "tasks") {
+      const status = query.get("status");
+      const priority = query.get("priority");
+      let tasks;
+      if (status && status !== "all") {
+        const statuses = status.split(",").map((s) => s.trim());
+        tasks = db.tasks.getTasksByMultipleStatuses(name, statuses);
+      } else {
+        tasks = db.tasks.getTasksByMultipleStatuses(name, ["backlog", "pending", "in_progress", "blocked"]);
+      }
+      if (priority) {
+        const p = Number(priority);
+        if (!isNaN(p)) {
+          tasks = tasks.filter((t) => t.priority === p);
+        }
+      }
+      const payload = JSON.stringify(tasks, null, 2);
+      return {
+        contents: [
+          {
+            uri,
+            mimeType: "application/json",
+            text: payload,
+            size: Buffer.byteLength(payload, "utf8"),
+            annotations: {
+              audience: ["assistant"],
+              priority: 0.9,
+              lastModified: deriveLastModifiedFromCollection(tasks.map((t) => t.updated_at))
+            }
+          }
+        ]
+      };
+    }
+    if (repoPath === "actions") {
+      const actions = db.actions.getRecentActions(name, 100);
+      const payload = JSON.stringify(actions, null, 2);
+      return {
+        contents: [
+          {
+            uri,
+            mimeType: "application/json",
+            text: payload,
+            size: Buffer.byteLength(payload, "utf8"),
+            annotations: {
+              audience: ["assistant"],
+              priority: 0.6,
+              lastModified: deriveLastModifiedFromCollection(actions.map((a) => a.created_at))
+            }
+          }
+        ]
+      };
+    }
+  }
+  const actionIdMatch = uri.match(/^action:\/\/(\d+)$/);
+  if (actionIdMatch) {
+    const id = Number(actionIdMatch[1]);
+    const action = db.actions.getActionById(id);
+    if (!action) throw resourceNotFound(`Action with ID ${id} not found.`, uri);
+    const payload = JSON.stringify(action, null, 2);
+    return {
+      contents: [
+        {
+          uri,
+          mimeType: "application/json",
+          text: payload,
+          size: Buffer.byteLength(payload, "utf8"),
+          annotations: {
+            audience: ["assistant"],
+            priority: 0.55,
+            lastModified: action.created_at
+          }
+        }
+      ]
+    };
+  }
+  throw resourceNotFound(`Unknown resource URI: ${uri}`, uri);
+}
+function parseRepoUri(uri) {
+  const prefix = "repository://";
+  if (!uri.startsWith(prefix)) return null;
+  const rest = uri.slice(prefix.length);
+  const queryStart = rest.indexOf("?");
+  const withoutQuery = queryStart === -1 ? rest : rest.slice(0, queryStart);
+  const queryString = queryStart === -1 ? "" : rest.slice(queryStart + 1);
+  const slashIdx = withoutQuery.indexOf("/");
+  if (slashIdx === -1) return null;
+  const name = withoutQuery.slice(0, slashIdx);
+  const path6 = withoutQuery.slice(slashIdx + 1);
+  if (!name || !path6) return null;
+  return { name, path: path6, query: new URLSearchParams(queryString) };
+}
+function paginateEntries(key, entries, params) {
+  const limit = normalizeLimit(params?.limit);
+  const offset = decodeCursor(params?.cursor);
+  const sliced = entries.slice(offset, offset + limit);
+  const nextOffset = offset + sliced.length;
+  return {
+    [key]: sliced,
+    nextCursor: nextOffset < entries.length ? encodeCursor(nextOffset) : void 0
+  };
+}
+function normalizeLimit(limit) {
+  if (typeof limit !== "number" || !Number.isFinite(limit)) {
+    return DEFAULT_PAGE_SIZE;
+  }
+  return Math.min(MAX_PAGE_SIZE, Math.max(1, Math.trunc(limit)));
+}
+function deriveLastModifiedFromCollection(values) {
+  const normalized = values.filter((value) => typeof value === "string" && value.length > 0);
+  return normalized.sort().at(-1) ?? (/* @__PURE__ */ new Date()).toISOString();
+}
+function resourceNotFound(message, uri) {
+  const error = new Error(message);
+  error.code = -32002;
+  error.data = { uri };
+  return error;
+}
+function invalidCompletionParams(message) {
+  const error = new Error(message);
+  error.code = -32602;
+  return error;
+}
+
+// src/mcp/prompts/loader.ts
+import fs4 from "fs";
+import path5 from "path";
+import { fileURLToPath as fileURLToPath3 } from "url";
+import matter from "gray-matter";
+var __filename = fileURLToPath3(import.meta.url);
+var __dirname2 = path5.dirname(__filename);
+function findPromptDir() {
+  const candidates = [
+    // Production if chunked into dist/
+    "./prompts",
+    // Production if inlined into dist/mcp/
+    "../prompts",
+    // Dev: /src/mcp/prompts/definitions (next to loader.ts)
+    "./definitions"
+  ].map((relPath) => path5.resolve(__dirname2, relPath));
+  for (const dir of candidates) {
+    if (fs4.existsSync(dir)) {
+      const files = fs4.readdirSync(dir);
+      if (files.some((f) => f.endsWith(".md"))) {
+        return dir;
+      }
+    }
+  }
+  return path5.resolve(__dirname2, "./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 = path5.join(PROMPT_DIR, `${name}.md`);
+  if (!fs4.existsSync(filePath)) {
+    throw new Error(`Prompt file not found: ${filePath}`);
+  }
+  const fileContent = fs4.readFileSync(filePath, "utf-8");
+  const { data, content } = matter(fileContent);
+  return {
+    name: data.name || name,
+    description: data.description || "",
+    arguments: data.arguments || [],
+    agent: data.agent,
+    content: content.trim()
+  };
+}
+
+// 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: ["success", "id", "repo", "updatedFields"]
+      }
+    ]
+  };
+}
+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",
+  "file_claim",
+  "task_archive"
+]);
+var MemoryStoreSchema = z.object({
+  code: z.string().max(20).optional(),
+  type: MemoryTypeSchema,
+  title: z.string().min(3).max(255),
+  content: z.string().min(10),
+  importance: z.number().min(1).max(5),
+  agent: z.string().min(1),
+  role: z.string().optional().default("unknown"),
+  model: z.string().min(1),
+  scope: MemoryScopeSchema,
+  ttlDays: z.number().min(1).optional(),
+  supersedes: z.string().uuid().optional(),
+  tags: z.array(z.string()).optional(),
+  metadata: z.record(z.string(), z.any()).optional(),
+  is_global: z.boolean().default(false),
+  structured: z.boolean().default(false)
+});
+var MemoryUpdateSchema = z.object({
+  id: z.string().uuid(),
+  type: MemoryTypeSchema.optional(),
+  title: z.string().min(3).max(255).optional(),
+  content: z.string().min(10).optional(),
+  importance: z.number().min(1).max(5).optional(),
+  agent: z.string().optional(),
+  role: z.string().optional(),
+  status: z.enum(["active", "archived"]).optional(),
+  supersedes: z.string().uuid().optional(),
+  tags: z.array(z.string()).optional(),
+  metadata: z.record(z.string(), z.any()).optional(),
+  is_global: z.boolean().optional(),
+  completed_at: z.string().optional(),
+  structured: z.boolean().default(false)
+}).refine(
+  (data) => data.type !== void 0 || data.content !== void 0 || data.title !== void 0 || data.importance !== void 0 || data.status !== void 0 || data.supersedes !== void 0 || data.tags !== void 0 || data.metadata !== void 0 || data.is_global !== void 0 || data.agent !== void 0 || data.role !== void 0 || data.completed_at !== void 0,
+  { message: "At least one field must be provided for update" }
+);
+var MemorySearchSchema = z.object({
+  query: z.string().min(3),
+  prompt: z.string().optional(),
+  repo: z.string().min(1).transform(normalizeRepo),
+  types: z.array(MemoryTypeSchema).optional(),
+  minImportance: z.number().min(1).max(5).optional(),
+  limit: z.number().min(1).max(100).default(5),
+  offset: z.number().min(0).default(0),
+  includeRecap: z.boolean().default(false),
+  current_file_path: z.string().optional(),
+  include_archived: z.boolean().default(false),
+  current_tags: z.array(z.string()).optional(),
+  scope: MemoryScopeSchema.partial().optional(),
+  structured: z.boolean().default(false)
+});
+var MemoryAcknowledgeSchema = z.object({
+  memory_id: z.string().uuid(),
+  status: z.enum(["used", "irrelevant", "contradictory"]),
+  application_context: z.string().min(10).optional(),
+  structured: z.boolean().default(false)
+});
+var MemoryRecapSchema = z.object({
+  repo: z.string().min(1).transform(normalizeRepo),
+  limit: z.number().min(1).max(50).default(20),
+  offset: z.number().min(0).default(0),
+  structured: z.boolean().default(false)
+});
+var MemoryDeleteSchema = z.object({
+  repo: z.string().min(1).transform(normalizeRepo).optional(),
+  id: z.string().uuid().optional(),
+  ids: z.array(z.string().uuid()).min(1).optional(),
+  structured: z.boolean().default(false)
+}).refine((data) => data.id !== void 0 || data.ids !== void 0, {
+  message: "Either 'id' or 'ids' must be provided for deletion"
+});
+var MemorySummarizeSchema = z.object({
+  repo: z.string().min(1).transform(normalizeRepo),
+  signals: z.array(z.string().max(200)).min(1),
+  structured: z.boolean().default(false)
+});
+var MemorySynthesizeSchema = z.object({
+  repo: z.string().min(1).transform(normalizeRepo).optional(),
+  objective: z.string().min(5),
+  current_file_path: z.string().optional(),
+  include_summary: z.boolean().default(true),
+  include_tasks: z.boolean().default(true),
+  use_tools: z.boolean().default(true),
+  max_iterations: z.number().int().min(1).max(5).default(3),
+  max_tokens: z.number().int().min(128).max(4e3).default(1200),
+  structured: z.boolean().default(false)
+});
+var TaskStatusSchema = z.enum(["backlog", "pending", "in_progress", "completed", "canceled", "blocked"]);
+var TaskPrioritySchema = z.number().min(1).max(5);
+var SingleTaskCreateSchema = z.object({
+  task_code: z.string().min(1),
+  phase: z.string().min(1),
+  title: z.string().min(3).max(100),
+  description: z.string().min(1),
+  status: TaskStatusSchema.default("backlog"),
+  priority: TaskPrioritySchema.default(3),
+  agent: z.string().optional(),
+  role: z.string().optional(),
+  doc_path: z.string().optional(),
+  tags: z.array(z.string()).optional(),
+  metadata: z.record(z.string(), z.any()).optional(),
+  parent_id: z.string().uuid().optional(),
+  depends_on: z.string().uuid().optional(),
+  est_tokens: z.number().int().min(0).optional()
+});
+var TaskCreateSchema = z.object({
+  repo: z.string().min(1).transform(normalizeRepo),
+  // Allow single task fields at top level (backward compatibility & single use)
+  task_code: z.string().min(1).optional(),
+  phase: z.string().min(1).optional(),
+  title: z.string().min(3).max(100).optional(),
+  description: z.string().min(1).optional(),
+  status: TaskStatusSchema.optional(),
+  priority: TaskPrioritySchema.optional(),
+  agent: z.string().optional(),
+  role: z.string().optional(),
+  doc_path: z.string().optional(),
+  tags: z.array(z.string()).optional(),
+  metadata: z.record(z.string(), z.any()).optional(),
+  parent_id: z.string().uuid().optional(),
+  depends_on: z.string().uuid().optional(),
+  est_tokens: z.number().int().min(0).optional(),
+  // Allow bulk tasks
+  tasks: z.array(SingleTaskCreateSchema).min(1).optional(),
+  structured: z.boolean().default(false)
+}).refine(
+  (data) => {
+    if (data.tasks) return true;
+    return !!(data.task_code && data.phase && data.title && data.description);
   },
+  { message: "Either 'tasks' array or single task fields (task_code, phase, title, description) must be provided" }
+);
+var TaskCreateInteractiveSchema = SingleTaskCreateSchema.partial().extend({
+  repo: z.string().min(1).transform(normalizeRepo).optional(),
+  structured: z.boolean().default(false)
+});
+var TaskUpdateSchema = z.object({
+  repo: z.string().min(1).transform(normalizeRepo),
+  id: z.string().uuid().optional(),
+  ids: z.array(z.string().uuid()).min(1).optional(),
+  task_code: z.string().optional(),
+  phase: z.string().optional(),
+  title: z.string().min(3).max(100).optional(),
+  description: z.string().optional(),
+  status: TaskStatusSchema.optional(),
+  priority: TaskPrioritySchema.optional(),
+  agent: z.string().min(1, "agent name is required").optional(),
+  role: z.string().min(1, "agent role is required").optional(),
+  model: z.string().optional(),
+  comment: z.string().min(1).optional(),
+  doc_path: z.string().optional(),
+  tags: z.array(z.string()).optional(),
+  metadata: z.record(z.string(), z.any()).optional(),
+  parent_id: z.string().uuid().optional(),
+  depends_on: z.string().uuid().optional(),
+  est_tokens: z.number().int().min(0).optional(),
+  force: z.boolean().optional(),
+  structured: z.boolean().default(false)
+}).refine((data) => data.id !== void 0 || data.ids !== void 0 || 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 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"
+});
+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 StandardStoreSchema = z.object({
+  name: z.string().min(3).max(255),
+  content: z.string().min(10),
+  context: z.string().optional(),
+  version: z.string().optional(),
+  language: z.string().optional(),
+  stack: z.array(z.string()).optional(),
+  repo: z.string().optional(),
+  is_global: z.boolean().optional(),
+  tags: z.array(z.string()).optional(),
+  metadata: z.record(z.string(), z.any()).optional(),
+  agent: z.string().optional(),
+  model: z.string().optional(),
+  structured: z.boolean().default(false)
+});
+var StandardSearchSchema = z.object({
+  query: z.string().optional(),
+  stack: z.array(z.string()).optional(),
+  language: z.string().optional(),
+  version: z.string().optional(),
+  repo: z.string().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-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.",
+    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
     },
-    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",
-              "file_claim",
-              "task_archive"
-            ]
-          }
-        },
-        minImportance: { type: "number", minimum: 1, maximum: 5 },
-        limit: { type: "number", minimum: 1, maximum: 100, default: 5 },
-        offset: { type: "number", minimum: 0, default: 0 },
-        includeRecap: { type: "boolean", default: false },
-        current_file_path: { type: "string" },
-        include_archived: { type: "boolean", default: false },
-        scope: {
-          type: "object",
-          properties: {
-            repo: { type: "string" },
-            branch: { type: "string" },
-            folder: { type: "string" },
-            language: { type: "string" }
-          }
-        },
-        structured: {
-          type: "boolean",
-          default: false,
-          description: "If true, returns structured JSON without the text content summary."
-        }
-      },
-      required: ["query", "repo"]
-    },
-    outputSchema: {
-      type: "object",
-      properties: {
-        schema: { type: "string", enum: ["memory-search"] },
-        query: { type: "string" },
-        count: { type: "number", description: "Number of rows returned" },
-        total: { type: "number", description: "Total matching memories" },
-        offset: { type: "number" },
-        limit: { type: "number" },
-        results: {
-          type: "object",
-          properties: {
-            columns: {
-              type: "array",
-              items: { type: "string" },
-              description: "Column names: [id, title, type, importance]"
-            },
-            rows: {
-              type: "array",
-              items: { type: "array" },
-              description: "Each row: [id, title, type, importance]. Fetch full content via memory-detail"
-            }
-          },
-          required: ["columns", "rows"]
-        }
-      },
-      required: ["schema", "query", "count", "total", "offset", "limit", "results"]
-    }
-  },
-  {
-    name: "memory-summarize",
-    title: "Memory Summarize",
-    description: "Update the summary for a repository",
-    annotations: {
-      readOnlyHint: false,
-      idempotentHint: false,
-      openWorldHint: false
+    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."
+        },
+        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."
         },
-        structured: { type: "boolean", default: false, description: "If true, returns structured JSON of the summary." }
+        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 },
+        status: { type: "string", enum: ["backlog", "pending"], default: "backlog" },
+        priority: { type: "number", minimum: 1, maximum: 5, default: 3 },
+        agent: { type: "string" },
+        role: { type: "string" },
+        doc_path: { type: "string" },
         structured: { type: "boolean", default: false, description: "If true, returns structured JSON result." }
       }
     },
     outputSchema: {
       type: "object",
       properties: {
-        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: "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: "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 (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)"
-        },
+        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." }
+      }
+    }
+  },
+  {
+    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 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 memory entry. Keep 'title' concise and human-readable; do not embed agent/role/date metadata in the title. Put auxiliary context into 'metadata'. Use 'tags' for tech-stack and 'is_global' for universal rules.",
     annotations: {
       readOnlyHint: false,
       idempotentHint: false,
+      destructiveHint: false,
       openWorldHint: false
     },
     inputSchema: {
       type: "object",
       properties: {
-        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",
+            "file_claim",
+            "task_archive"
+          ],
+          description: "Type of memory being stored"
+        },
         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."
         },
-        description: { type: "string", description: "Detailed description (Required for single task)" },
-        status: {
+        content: {
           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'."
+          minLength: 10,
+          description: "The memory content"
         },
-        priority: { type: "number", minimum: 1, maximum: 5, default: 3 },
-        agent: { type: "string" },
-        role: { type: "string" },
-        doc_path: { type: "string" },
-        tags: { type: "array", items: { type: "string" } },
-        metadata: { type: "object" },
-        parent_id: { type: "string", format: "uuid" },
-        depends_on: { type: "string", format: "uuid" },
-        est_tokens: { type: "number", minimum: 0, description: "Estimated tokens budget for this task" },
-        tasks: {
-          type: "array",
-          items: {
-            type: "object",
-            properties: {
-              task_code: { type: "string" },
-              phase: { type: "string" },
-              title: { type: "string", minLength: 3, maxLength: 100 },
-              description: { type: "string" },
-              status: { type: "string", enum: ["backlog", "pending"], default: "backlog" },
-              priority: { type: "number", minimum: 1, maximum: 5, default: 3 },
-              agent: { type: "string" },
-              role: { type: "string" },
-              doc_path: { type: "string" },
-              tags: { type: "array", items: { type: "string" } },
-              metadata: { type: "object" },
-              parent_id: { type: "string", format: "uuid" },
-              depends_on: { type: "string", format: "uuid" },
-              est_tokens: { type: "number", minimum: 0 }
-            },
-            required: ["task_code", "phase", "title", "description"]
+        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" }
           },
-          description: "Array of tasks for bulk creation"
+          required: ["repo"]
         },
-        structured: { type: "boolean", default: false, description: "If true, returns structured JSON result." }
+        tags: {
+          type: "array",
+          items: { type: "string" },
+          description: "Technology stack tags (e.g., ['filament', 'laravel'])"
+        },
+        metadata: {
+          type: "object",
+          description: "Structured metadata for non-title context such as source agent, claim fields, or timestamps"
+        },
+        is_global: {
+          type: "boolean",
+          description: "If true, this memory is shared across all repositories"
+        },
+        ttlDays: { type: "number", minimum: 1 },
+        supersedes: { type: "string", format: "uuid" },
+        structured: { type: "boolean", default: false, description: "If true, returns structured JSON of the stored memory." }
       },
-      required: ["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,
@@ -3573,98 +3745,81 @@ 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 },
-        agent: { type: "string" },
-        role: { type: "string" },
-        model: { type: "string" },
-        comment: {
-          type: "string",
-          description: "REQUIRED when changing task status. Explain WHY the status is changing (e.g., 'Starting implementation', 'Blocked by missing API docs', 'Verified fix')."
-        },
-        doc_path: { type: "string" },
-        tags: { type: "array", items: { type: "string" } },
-        metadata: { type: "object" },
-        parent_id: { type: "string", format: "uuid" },
-        depends_on: { type: "string", format: "uuid" },
-        est_tokens: {
-          type: "number",
-          minimum: 0,
-          description: "Estimated total tokens actually used for this task. Required when status changes to 'completed'."
-        },
-        force: {
-          type: "boolean",
-          description: "If true, bypasses status transition validation (e.g. pending -> completed)."
-        },
+        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",
+            "file_claim",
+            "task_archive"
+          ]
+        },
+        title: { type: "string", minLength: 3, maxLength: 100 },
+        content: { type: "string", minLength: 10 },
+        importance: { type: "number", minimum: 1, maximum: 5 },
+        agent: { type: "string" },
+        role: { type: "string" },
+        status: { type: "string", enum: ["active", "archived"] },
+        supersedes: { type: "string", format: "uuid" },
+        tags: { type: "array", items: { type: "string" } },
+        metadata: { type: "object" },
+        is_global: { type: "boolean" },
+        completed_at: { type: "string" },
+        structured: { type: "boolean", default: false, description: "If true, returns structured JSON of the updated memory." }
       },
-      required: ["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,
@@ -3673,35 +3828,42 @@ var TOOL_DEFINITIONS = [
     inputSchema: {
       type: "object",
       properties: {
-        repo: {
-          type: "string",
-          description: "Repository name"
-        },
-        status: {
-          type: "string",
-          default: "in_progress,pending",
-          description: "Comma-separated status filter (backlog, pending, in_progress, completed, canceled, blocked). Defaults to 'in_progress,pending'."
-        },
-        phase: {
-          type: "string",
-          description: "Filter by phase (e.g., 'research', 'implementation')"
-        },
-        query: {
-          type: "string",
-          description: "Search keyword matching task code, title, or description"
+        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",
+              "file_claim",
+              "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",
@@ -3709,84 +3871,111 @@ 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 handoff record when work needs context transfer between agents. Optionally link it to a task by task_id or task_code, and put machine-readable details in context.",
+    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, such as changed files, blockers, verification status, and next steps"
+        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: {
+        success: { type: "boolean" },
+        repo: { type: "string" },
+        summary: { type: "string" },
+        signalCount: { type: "number" }
+      },
+      required: ["success", "repo", "summary", "signalCount"]
+    }
+  },
+  {
+    name: "memory-delete",
+    title: "Memory Delete",
+    description: "Soft-delete one or more memory entries. Supports single 'id' or bulk 'ids'.",
+    annotations: {
+      readOnlyHint: false,
+      idempotentHint: false,
+      destructiveHint: true,
+      openWorldHint: false
+    },
+    inputSchema: {
+      type: "object",
+      properties: {
+        repo: { type: "string", description: "Repository name (optional for single id)" },
+        id: { type: "string", format: "uuid", description: "Memory entry ID to delete" },
+        ids: {
+          type: "array",
+          items: { type: "string", format: "uuid" },
+          minItems: 1,
+          description: "Array of memory IDs to delete"
+        },
+        structured: { type: "boolean", default: false, description: "If true, returns structured JSON result." }
+      }
     },
     outputSchema: {
       type: "object",
       properties: {
+        success: { type: "boolean" },
         id: { type: "string" },
+        ids: { type: "array", items: { type: "string" } },
         repo: { type: "string" },
-        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 }
+        deletedCount: { type: "number" }
       },
-      required: ["id", "repo", "from_agent", "summary", "context", "status", "created_at", "updated_at"]
+      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,
@@ -3795,806 +3984,632 @@ 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, status, created_at, summary]"
+              description: "Column names: [id, code, title, type, importance]"
             },
             rows: {
               type: "array",
               items: { type: "array" },
-              description: "Each row: [id, from_agent, to_agent, task_id, status, created_at, summary]"
+              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: { 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 }
+        task_code: { type: "string", description: "Unique task code (e.g. TASK-001) (Required for single task)" },
+        phase: { type: "string", description: "Project phase (Required for single task)" },
+        title: {
+          type: "string",
+          minLength: 3,
+          maxLength: 100,
+          description: "Task objective (Required for single task)"
+        },
+        description: { type: "string", description: "Detailed description (Required for single task)" },
+        status: {
+          type: "string",
+          enum: ["backlog", "pending"],
+          default: "backlog",
+          description: "New tasks MUST start in 'backlog' if there are already 10 pending tasks. Otherwise can start in 'pending'."
+        },
+        priority: { type: "number", minimum: 1, maximum: 5, default: 3 },
+        agent: { type: "string" },
+        role: { type: "string" },
+        doc_path: { type: "string" },
+        tags: { type: "array", items: { type: "string" } },
+        metadata: { type: "object" },
+        parent_id: { type: "string", format: "uuid" },
+        depends_on: { type: "string", format: "uuid" },
+        est_tokens: { type: "number", minimum: 0, description: "Estimated tokens budget for this task" },
+        tasks: {
+          type: "array",
+          items: {
+            type: "object",
+            properties: {
+              task_code: { type: "string" },
+              phase: { type: "string" },
+              title: { type: "string", minLength: 3, maxLength: 100 },
+              description: { type: "string" },
+              status: { type: "string", enum: ["backlog", "pending"], default: "backlog" },
+              priority: { type: "number", minimum: 1, maximum: 5, default: 3 },
+              agent: { type: "string" },
+              role: { type: "string" },
+              doc_path: { type: "string" },
+              tags: { type: "array", items: { type: "string" } },
+              metadata: { type: "object" },
+              parent_id: { type: "string", format: "uuid" },
+              depends_on: { type: "string", format: "uuid" },
+              est_tokens: { type: "number", minimum: 0 }
+            },
+            required: ["task_code", "phase", "title", "description"]
+          },
+          description: "Array of tasks for bulk creation"
+        },
+        structured: { type: "boolean", default: false, description: "If true, returns structured JSON result." }
       },
-      required: ["repo", "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: "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-update",
+    title: "Task Update",
+    description: "Update one or more tasks. Supports single update via 'id' or bulk update via 'ids'. Provide only the fields that need to be changed. MANDATORY WORKFLOW: You cannot move a task from 'pending' or 'blocked' directly to 'completed'. You MUST move it to 'in_progress' first. When changing status to 'completed', include 'est_tokens' with the estimated total tokens actually used for the task.",
     annotations: {
       readOnlyHint: false,
       idempotentHint: false,
-      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" },
-        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" },
+        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."
         },
-        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"
+        priority: { type: "number", minimum: 1, maximum: 5 },
+        agent: { type: "string" },
+        role: { type: "string" },
+        model: { type: "string" },
+        comment: {
+          type: "string",
+          description: "REQUIRED when changing task status. Explain WHY the status is changing (e.g., 'Starting implementation', 'Blocked by missing API docs', 'Verified fix')."
         },
-        metadata: {
-          type: "object",
-          description: "Additional metadata"
+        doc_path: { type: "string" },
+        tags: { type: "array", items: { type: "string" } },
+        metadata: { type: "object" },
+        parent_id: { type: "string", format: "uuid" },
+        depends_on: { type: "string", format: "uuid" },
+        est_tokens: {
+          type: "number",
+          minimum: 0,
+          description: "Estimated total tokens actually used for this task. Required when status changes to 'completed'."
         },
-        agent: { type: "string", description: "Agent creating the standard" },
-        model: { type: "string", description: "AI model used" },
-        structured: { type: "boolean", default: false }
+        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: ["name", "content"]
-    },
-    outputSchema: {
-      type: "object",
-      properties: {
-        success: { type: "boolean" },
-        standard: {
-          type: "object",
-          properties: {
-            id: { type: "string" },
-            title: { type: "string" },
-            content: { type: "string" },
-            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",
-            "context",
-            "version",
-            "stack",
-            "is_global",
-            "tags",
-            "metadata",
-            "created_at",
-            "updated_at",
-            "agent",
-            "model"
-          ]
+      required: ["repo"]
+    },
+    outputSchema: {
+      type: "object",
+      properties: {
+        success: { type: "boolean" },
+        id: { type: "string" },
+        ids: { type: "array", items: { type: "string" } },
+        repo: { type: "string" },
+        status: { type: "string" },
+        archivedToMemory: { type: "boolean" },
+        updatedFields: {
+          type: "array",
+          items: { type: "string" }
         },
-        message: { type: "string" }
+        updatedCount: { type: "number" }
       },
-      required: ["success", "standard", "message"]
+      required: ["success", "repo"]
     }
   },
   {
-    name: "standard-search",
-    title: "Standard Search",
-    description: "Navigation and lookup layer for coding standards. Query by text, stack, language, version, repo, and global scope before applying or creating standards.",
+    name: "task-delete",
+    title: "Task Delete",
+    description: "Delete one or more tasks from a repository. Supports single 'id' or bulk 'ids'.",
     annotations: {
-      readOnlyHint: true,
-      idempotentHint: true,
+      readOnlyHint: false,
+      idempotentHint: false,
+      destructiveHint: true,
       openWorldHint: false
     },
     inputSchema: {
       type: "object",
       properties: {
-        query: { type: "string", description: "Search query (optional, searches title/content)" },
-        stack: {
-          type: "array",
-          items: { type: "string" },
-          description: "Technology stack to filter by (e.g., ['react', 'nextjs'])"
-        },
-        language: { type: "string", description: "Programming language filter" },
-        version: { type: "string", description: "Version filter" },
-        repo: { type: "string", description: "Repository filter (optional)" },
-        is_global: { type: "boolean", description: "Filter by global/repo-specific" },
-        limit: { type: "number", minimum: 1, maximum: 100, default: 20 },
-        offset: { type: "number", minimum: 0, default: 0 },
-        structured: { type: "boolean", default: false }
+        repo: { type: "string", description: "Repository name" },
+        id: { type: "string", format: "uuid", description: "Task ID (for single deletion)" },
+        ids: { type: "array", items: { type: "string", format: "uuid" }, description: "Task IDs (for bulk deletion)" },
+        structured: { type: "boolean", default: false, description: "If true, returns structured JSON result." }
       },
-      required: []
+      required: ["repo"]
     },
     outputSchema: {
       type: "object",
       properties: {
         success: { type: "boolean" },
-        standards: {
-          type: "array",
-          items: {
-            type: "object",
-            properties: {
-              id: { type: "string" },
-              title: { type: "string" },
-              content: { type: "string" },
-              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" }
-            }
-          },
-          description: "Matching coding standards"
-        },
-        count: { type: "number", description: "Number of results returned" },
-        message: { type: "string" }
-      },
-      required: ["success", "standards", "count", "message"]
-    }
-  }
-];
-
-// src/mcp/utils/pagination.ts
-function encodeCursor(offset) {
-  return Buffer.from(String(offset), "utf8").toString("base64");
-}
-function decodeCursor(cursor) {
-  if (cursor === void 0 || cursor === null || cursor === "") {
-    return 0;
-  }
-  if (typeof cursor !== "string" || cursor.trim() === "") {
-    throw invalidPaginationParams("Invalid cursor");
-  }
-  let decoded;
-  try {
-    decoded = Buffer.from(cursor, "base64").toString("utf8");
-  } catch {
-    throw invalidPaginationParams("Invalid cursor");
-  }
-  if (!/^\d+$/.test(decoded)) {
-    throw invalidPaginationParams("Invalid cursor");
-  }
-  const offset = Number.parseInt(decoded, 10);
-  if (!Number.isFinite(offset) || offset < 0) {
-    throw invalidPaginationParams("Invalid cursor");
-  }
-  return offset;
-}
-function invalidPaginationParams(message) {
-  const error = new Error(message);
-  error.code = -32602;
-  return error;
-}
-
-// src/mcp/utils/completion.ts
-var MAX_COMPLETION_VALUES = 100;
-function rankCompletionValues(candidates, input) {
-  const unique = [...new Set(candidates.filter(Boolean))];
-  const needle = input.trim().toLowerCase();
-  if (!needle) {
-    return unique.slice(0, MAX_COMPLETION_VALUES);
-  }
-  return unique.map((value) => ({ value, score: scoreCompletionValue(value, needle) })).filter((entry) => entry.score > 0).sort((a, b) => b.score - a.score || a.value.localeCompare(b.value)).map((entry) => entry.value);
-}
-function scoreCompletionValue(value, needle) {
-  const haystack = value.toLowerCase();
-  if (haystack === needle) return 100;
-  if (haystack.startsWith(needle)) return 75;
-  if (haystack.includes(needle)) return 50;
-  const compactNeedle = needle.replace(/[\s_-]+/g, "");
-  const compactHaystack = haystack.replace(/[\s_-]+/g, "");
-  if (compactNeedle && compactHaystack.includes(compactNeedle)) return 25;
-  return 0;
-}
-
-// src/mcp/resources/index.ts
-var DEFAULT_PAGE_SIZE = 25;
-var MAX_PAGE_SIZE = 100;
-function listResources(session, params) {
-  const resources = [
-    {
-      uri: "repository://index",
-      name: "Repository Index",
-      title: "Repository Index",
-      description: "List of all known repositories with memory/task counts and last activity",
-      mimeType: "application/json",
-      annotations: {
-        audience: ["assistant"],
-        priority: 1,
-        lastModified: (/* @__PURE__ */ new Date()).toISOString()
-      }
-    },
-    {
-      uri: "session://roots",
-      name: "Session Roots",
-      title: "Session Roots",
-      description: session?.roots.length ? "Active workspace roots provided by the MCP client" : "No active workspace roots were provided by the MCP client",
-      mimeType: "application/json",
-      size: Buffer.byteLength(JSON.stringify({ roots: session?.roots ?? [] }), "utf8"),
-      annotations: {
-        audience: ["assistant"],
-        priority: 0.95,
-        lastModified: (/* @__PURE__ */ new Date()).toISOString()
-      }
-    }
-  ];
-  return paginateEntries("resources", resources, params);
-}
-function listResourceTemplates(params) {
-  const templates = [
-    // ── Memory ──────────────────────────────────────────────────────────────
-    {
-      uriTemplate: "repository://{name}/memories",
-      name: "Repository Memories",
-      title: "Repository Memories",
-      description: "All active memory entries for a specific repository",
-      mimeType: "application/json",
-      annotations: { audience: ["assistant"], priority: 0.85 }
-    },
-    {
-      uriTemplate: "repository://{name}/memories?search={search}&type={type}&tag={tag}",
-      name: "Filtered Repository Memories",
-      title: "Filtered Repository Memories",
-      description: "Filter or search memories within a repository by keyword, type, or tag",
-      mimeType: "application/json",
-      annotations: { audience: ["assistant"], priority: 0.8 }
-    },
-    {
-      uriTemplate: "memory://{id}",
-      name: "Memory Detail",
-      title: "Memory Detail",
-      description: "Full content and statistics for a specific memory UUID",
-      mimeType: "application/json",
-      annotations: { audience: ["assistant"], priority: 0.75 }
-    },
-    // ── Tasks ────────────────────────────────────────────────────────────────
-    {
-      uriTemplate: "repository://{name}/tasks",
-      name: "Repository Tasks",
-      title: "Repository Tasks",
-      description: "All active tasks for a specific repository",
-      mimeType: "application/json",
-      annotations: { audience: ["assistant"], priority: 0.9 }
-    },
-    {
-      uriTemplate: "repository://{name}/tasks?status={status}&priority={priority}",
-      name: "Filtered Repository Tasks",
-      title: "Filtered Repository Tasks",
-      description: "Filter tasks within a repository by status or priority level",
-      mimeType: "application/json",
-      annotations: { audience: ["assistant"], priority: 0.85 }
-    },
-    {
-      uriTemplate: "task://{id}",
-      name: "Task Detail",
-      title: "Task Detail",
-      description: "Full content and comments for a specific task UUID",
-      mimeType: "application/json",
-      annotations: { audience: ["assistant"], priority: 0.8 }
-    },
-    // ── Repository extras ────────────────────────────────────────────────────
-    {
-      uriTemplate: "repository://{name}/summary",
-      name: "Repository Summary",
-      title: "Repository Summary",
-      description: "High-level architectural summary for a repository",
-      mimeType: "text/plain",
-      annotations: { audience: ["assistant"], priority: 0.95 }
-    },
-    {
-      uriTemplate: "repository://{name}/actions",
-      name: "Repository Actions",
-      title: "Repository Actions",
-      description: "Audit log of agent tool actions scoped to a repository",
-      mimeType: "application/json",
-      annotations: { audience: ["assistant"], priority: 0.6 }
-    },
-    // ── Action detail ────────────────────────────────────────────────────────
-    {
-      uriTemplate: "action://{id}",
-      name: "Action Detail",
-      title: "Action Detail",
-      description: "Full details of a specific audit log entry by integer ID",
-      mimeType: "application/json",
-      annotations: { audience: ["assistant"], priority: 0.55 }
-    }
-  ];
-  return paginateEntries("resourceTemplates", templates, params);
-}
-function completeResourceArgument(resourceUri, argumentName, argumentValue, _contextArguments, dataSources) {
-  if (resourceUri === "repository://{name}/memories" || resourceUri === "repository://{name}/memories?search={search}&type={type}&tag={tag}" || resourceUri === "repository://{name}/tasks" || resourceUri === "repository://{name}/tasks?status={status}&priority={priority}" || resourceUri === "repository://{name}/summary" || resourceUri === "repository://{name}/actions") {
-    if (argumentName === "name") {
-      return rankCompletionValues(dataSources.repos, argumentValue);
-    }
-  }
-  if (resourceUri === "repository://{name}/memories?search={search}&type={type}&tag={tag}") {
-    if (argumentName === "tag") {
-      return rankCompletionValues(dataSources.tags, argumentValue);
+        id: { type: "string" },
+        ids: { type: "array", items: { type: "string" } },
+        repo: { type: "string" },
+        deletedCount: { type: "number" }
+      },
+      required: ["success", "repo"]
     }
-  }
-  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
-          }
+  },
+  {
+    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: true,
+      idempotentHint: true,
+      openWorldHint: false
+    },
+    inputSchema: {
+      type: "object",
+      properties: {
+        repo: {
+          type: "string",
+          description: "Repository name"
+        },
+        status: {
+          type: "string",
+          default: "in_progress,pending",
+          description: "Comma-separated status filter (backlog, pending, in_progress, completed, canceled, blocked). Defaults to 'in_progress,pending'."
+        },
+        phase: {
+          type: "string",
+          description: "Filter by phase (e.g., 'research', 'implementation')"
+        },
+        query: {
+          type: "string",
+          description: "Search keyword matching task code, title, or description"
+        },
+        limit: {
+          type: "number",
+          minimum: 1,
+          maximum: 100,
+          default: 5,
+          description: "Maximum rows to return (default 5)"
+        },
+        offset: {
+          type: "number",
+          minimum: 0,
+          default: 0,
+          description: "Offset for pagination"
+        },
+        structured: {
+          type: "boolean",
+          default: false,
+          description: "If true, returns structured JSON without the text content summary."
         }
-      ]
-    };
-  }
-  const repoBase = parseRepoUri(uri);
-  if (repoBase) {
-    const { name, path: repoPath, query } = repoBase;
-    if (repoPath === "summary") {
-      const summary = db.summaries.getSummary(name);
-      const text = summary?.summary || `No summary available for repository: ${name}`;
-      return {
-        contents: [
-          {
-            uri,
-            mimeType: "text/plain",
-            text,
-            size: Buffer.byteLength(text, "utf8"),
-            annotations: {
-              audience: ["assistant"],
-              priority: 0.95,
-              lastModified: summary?.updated_at || (/* @__PURE__ */ new Date()).toISOString()
+      },
+      required: ["repo"]
+    },
+    outputSchema: {
+      type: "object",
+      properties: {
+        schema: { type: "string", enum: ["task-list"] },
+        tasks: {
+          type: "object",
+          properties: {
+            columns: {
+              type: "array",
+              items: { type: "string" },
+              description: "Column names in order: id, task_code, title, status, priority, 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: ["columns", "rows"]
+        },
+        count: { type: "number" },
+        offset: { type: "number" }
+      },
+      required: ["schema", "tasks", "count"]
     }
-    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: "handoff-create",
+    title: "Handoff Create",
+    description: "Create a handoff record when work needs context transfer between agents. Optionally link it to a task by task_id or task_code, and put machine-readable details in context.",
+    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, such as changed files, blockers, verification status, and next steps"
+        },
+        expires_at: { type: "string", description: "Optional expiration timestamp" },
+        structured: { type: "boolean", default: false }
+      },
+      required: ["repo", "from_agent", "summary"]
+    },
+    outputSchema: {
+      type: "object",
+      properties: {
+        id: { 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: ["id", "repo", "from_agent", "summary", "context", "status", "created_at", "updated_at"]
     }
-    if (repoPath === "tasks") {
-      const status = query.get("status");
-      const priority = query.get("priority");
-      let tasks;
-      if (status && status !== "all") {
-        const statuses = status.split(",").map((s) => s.trim());
-        tasks = db.tasks.getTasksByMultipleStatuses(name, statuses);
-      } else {
-        tasks = db.tasks.getTasksByMultipleStatuses(name, ["backlog", "pending", "in_progress", "blocked"]);
-      }
-      if (priority) {
-        const p = Number(priority);
-        if (!isNaN(p)) {
-          tasks = tasks.filter((t) => t.priority === p);
-        }
-      }
-      const payload = JSON.stringify(tasks, null, 2);
-      return {
-        contents: [
-          {
-            uri,
-            mimeType: "application/json",
-            text: payload,
-            size: Buffer.byteLength(payload, "utf8"),
-            annotations: {
-              audience: ["assistant"],
-              priority: 0.9,
-              lastModified: deriveLastModifiedFromCollection(tasks.map((t) => t.updated_at))
+  },
+  {
+    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
+    },
+    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"]
+    },
+    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, status, created_at, summary]"
+            },
+            rows: {
+              type: "array",
+              items: { type: "array" },
+              description: "Each row: [id, from_agent, to_agent, task_id, status, created_at, summary]"
             }
-          }
-        ]
-      };
+          },
+          required: ["columns", "rows"]
+        },
+        count: { type: "number" },
+        offset: { type: "number" }
+      },
+      required: ["schema", "handoffs", "count", "offset"]
     }
-    if (repoPath === "actions") {
-      const actions = db.actions.getRecentActions(name, 100);
-      const payload = JSON.stringify(actions, null, 2);
-      return {
-        contents: [
-          {
-            uri,
-            mimeType: "application/json",
-            text: payload,
-            size: Buffer.byteLength(payload, "utf8"),
-            annotations: {
-              audience: ["assistant"],
-              priority: 0.6,
-              lastModified: deriveLastModifiedFromCollection(actions.map((a) => a.created_at))
-            }
-          }
-        ]
-      };
+  },
+  {
+    name: "task-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"]
     }
-  }
-  const actionIdMatch = uri.match(/^action:\/\/(\d+)$/);
-  if (actionIdMatch) {
-    const id = Number(actionIdMatch[1]);
-    const action = db.actions.getActionById(id);
-    if (!action) throw resourceNotFound(`Action with ID ${id} not found.`, uri);
-    const payload = JSON.stringify(action, null, 2);
-    return {
-      contents: [
-        {
-          uri,
-          mimeType: "application/json",
-          text: payload,
-          size: Buffer.byteLength(payload, "utf8"),
-          annotations: {
-            audience: ["assistant"],
-            priority: 0.55,
-            lastModified: action.created_at
-          }
-        }
-      ]
-    };
-  }
-  throw resourceNotFound(`Unknown resource URI: ${uri}`, uri);
-}
-function parseRepoUri(uri) {
-  const prefix = "repository://";
-  if (!uri.startsWith(prefix)) return null;
-  const rest = uri.slice(prefix.length);
-  const queryStart = rest.indexOf("?");
-  const withoutQuery = queryStart === -1 ? rest : rest.slice(0, queryStart);
-  const queryString = queryStart === -1 ? "" : rest.slice(queryStart + 1);
-  const slashIdx = withoutQuery.indexOf("/");
-  if (slashIdx === -1) return null;
-  const name = withoutQuery.slice(0, slashIdx);
-  const path6 = withoutQuery.slice(slashIdx + 1);
-  if (!name || !path6) return null;
-  return { name, path: path6, query: new URLSearchParams(queryString) };
-}
-function paginateEntries(key, entries, params) {
-  const limit = normalizeLimit(params?.limit);
-  const offset = decodeCursor(params?.cursor);
-  const sliced = entries.slice(offset, offset + limit);
-  const nextOffset = offset + sliced.length;
-  return {
-    [key]: sliced,
-    nextCursor: nextOffset < entries.length ? encodeCursor(nextOffset) : void 0
-  };
-}
-function normalizeLimit(limit) {
-  if (typeof limit !== "number" || !Number.isFinite(limit)) {
-    return DEFAULT_PAGE_SIZE;
-  }
-  return Math.min(MAX_PAGE_SIZE, Math.max(1, Math.trunc(limit)));
-}
-function deriveLastModifiedFromCollection(values) {
-  const normalized = values.filter((value) => typeof value === "string" && value.length > 0);
-  return normalized.sort().at(-1) ?? (/* @__PURE__ */ new Date()).toISOString();
-}
-function resourceNotFound(message, uri) {
-  const error = new Error(message);
-  error.code = -32002;
-  error.data = { uri };
-  return error;
-}
-function invalidCompletionParams(message) {
-  const error = new Error(message);
-  error.code = -32602;
-  return error;
-}
-
-// src/mcp/prompts/loader.ts
-import fs4 from "fs";
-import path5 from "path";
-import { fileURLToPath as fileURLToPath3 } from "url";
-import matter from "gray-matter";
-var __filename = fileURLToPath3(import.meta.url);
-var __dirname2 = path5.dirname(__filename);
-function findPromptDir() {
-  const candidates = [
-    // Production if chunked into dist/
-    "./prompts",
-    // Production if inlined into dist/mcp/
-    "../prompts",
-    // Dev: /src/mcp/prompts/definitions (next to loader.ts)
-    "./definitions"
-  ].map((relPath) => path5.resolve(__dirname2, relPath));
-  for (const dir of candidates) {
-    if (fs4.existsSync(dir)) {
-      const files = fs4.readdirSync(dir);
-      if (files.some((f) => f.endsWith(".md"))) {
-        return dir;
-      }
+  },
+  {
+    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" },
+        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"]
+    },
+    outputSchema: {
+      type: "object",
+      properties: {
+        success: { type: "boolean" },
+        standard: {
+          type: "object",
+          properties: {
+            id: { type: "string" },
+            title: { type: "string" },
+            content: { type: "string" },
+            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",
+            "context",
+            "version",
+            "stack",
+            "is_global",
+            "tags",
+            "metadata",
+            "created_at",
+            "updated_at",
+            "agent",
+            "model"
+          ]
+        },
+        message: { type: "string" }
+      },
+      required: ["success", "standard", "message"]
     }
-  }
-  return path5.resolve(__dirname2, "./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 = path5.join(PROMPT_DIR, `${name}.md`);
-  if (!fs4.existsSync(filePath)) {
-    throw new Error(`Prompt file not found: ${filePath}`);
-  }
-  const fileContent = fs4.readFileSync(filePath, "utf-8");
-  const { data, content } = matter(fileContent);
-  return {
-    name: data.name || name,
-    description: data.description || "",
-    arguments: data.arguments || [],
-    agent: data.agent,
-    content: content.trim()
-  };
-}
-
-// src/mcp/prompts/registry.ts
-function createPromptDefinition(loaded) {
-  return {
-    name: loaded.name,
-    description: loaded.description,
-    arguments: loaded.arguments,
-    agent: loaded.agent,
-    messages: [
-      {
-        role: "user",
-        content: {
-          type: "text",
-          text: loaded.content
-        }
-      }
-    ]
-  };
-}
-var PROMPTS = {};
-var promptFiles = listPromptFiles();
-for (const name of promptFiles) {
-  try {
-    PROMPTS[name] = createPromptDefinition(loadPromptFromMarkdown(name));
-  } catch (e) {
-    logger.warn(`Failed to load prompt ${name}: ${e}`);
-  }
-}
-async function listPrompts(db, session, params) {
-  const allPrompts = Object.values(PROMPTS).map((p) => ({
-    name: p.name,
-    description: p.description,
-    arguments: p.arguments,
-    metadata: p.agent ? { agent: p.agent } : void 0
-  }));
-  const rawLimit = typeof params?.limit === "number" && Number.isInteger(params?.limit) ? params.limit : 25;
-  const limit = Math.max(1, Math.min(100, Math.trunc(rawLimit)));
-  const offset = decodeCursor(params?.cursor);
-  const sliced = allPrompts.slice(offset, offset + limit);
-  const nextOffset = offset + sliced.length;
-  return {
-    prompts: sliced,
-    nextCursor: nextOffset < allPrompts.length ? encodeCursor(nextOffset) : void 0
-  };
-}
-async function getPrompt(name, args = {}, db, session) {
-  const prompt = PROMPTS[name];
-  if (!prompt) {
-    throw new Error(`Prompt not found: ${name}`);
-  }
-  const inferredRepo = inferRepoFromSession(session);
-  const messages = prompt.messages.map((m) => {
-    let text = m.content.text;
-    for (const [key, value] of Object.entries(args)) {
-      text = text.replace(new RegExp(`\\{{${key}\\}}`, "g"), value);
+  },
+  {
+    name: "standard-search",
+    title: "Standard Search",
+    description: "Navigation and lookup layer for coding standards. Query by text, stack, language, version, repo, and global scope before applying or creating standards.",
+    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'])"
+        },
+        language: { type: "string", description: "Programming language 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: {
+        success: { type: "boolean" },
+        standards: {
+          type: "array",
+          items: {
+            type: "object",
+            properties: {
+              id: { type: "string" },
+              title: { type: "string" },
+              content: { type: "string" },
+              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" }
+            }
+          },
+          description: "Matching coding standards"
+        },
+        count: { type: "number", description: "Number of results returned" },
+        message: { type: "string" }
+      },
+      required: ["success", "standards", "count", "message"]
     }
-    text = text.replace(/{{current_repo}}/g, inferredRepo || "unknown-repo");
-    return {
-      ...m,
-      content: {
-        ...m.content,
-        text
-      }
-    };
-  });
-  return {
-    description: prompt.description,
-    messages,
-    metadata: prompt.agent ? { agent: prompt.agent } : void 0
-  };
-}
-async function completePromptArgument(name, argName, value, contextArguments, dataSources) {
-  void name;
-  void contextArguments;
-  if (argName === "task_id") {
-    const values = dataSources.tasks.map((t) => t.id);
-    return rankCompletionValues(values, value);
   }
-  return [];
-}
+];
 
 export {
-  MCP_PROTOCOL_VERSION,
-  CAPABILITIES,
   logger,
   setLogLevel,
   getLogLevel,
   addLogSink,
   LOG_LEVEL_VALUES,
   createFileSink,
+  encodeCursor,
+  decodeCursor,
+  listResources,
+  listResourceTemplates,
+  completeResourceArgument,
+  readResource,
+  createSessionContext,
+  updateSessionFromInitialize,
+  updateSessionRoots,
+  extractRootsFromResult,
+  getFilesystemRoots,
+  isPathWithinRoots,
+  findContainingRoot,
+  inferRepoFromSession,
+  PROMPTS,
+  listPrompts,
+  getPrompt,
+  completePromptArgument,
   normalizeRepo,
-  SQLiteStore,
   MemoryStoreSchema,
   MemoryUpdateSchema,
   MemorySearchSchema,
@@ -4616,22 +4631,7 @@ export {
   StandardStoreSchema,
   StandardSearchSchema,
   TOOL_DEFINITIONS,
-  encodeCursor,
-  decodeCursor,
-  listResources,
-  listResourceTemplates,
-  completeResourceArgument,
-  readResource,
-  createSessionContext,
-  updateSessionFromInitialize,
-  updateSessionRoots,
-  extractRootsFromResult,
-  getFilesystemRoots,
-  isPathWithinRoots,
-  findContainingRoot,
-  inferRepoFromSession,
-  PROMPTS,
-  listPrompts,
-  getPrompt,
-  completePromptArgument
+  SQLiteStore,
+  MCP_PROTOCOL_VERSION,
+  CAPABILITIES
 };