@vheins/local-memory-mcp 0.18.13 → 0.19.0

package/dist/mcp/server.js

@@ -1,8 +1,12 @@
 #!/usr/bin/env node
 import {
-  CAPABILITIES,
-  LOG_LEVEL_VALUES,
-  MCP_PROTOCOL_VERSION,
+  AgentContextSchema,
+  CreateEntitySchema,
+  CreateRelationSchema,
+  DecisionLogSchema,
+  DeleteEntitySchema,
+  DeleteObservationSchema,
+  DeleteRelationSchema,
   MemoryAcknowledgeSchema,
   MemoryDeleteSchema,
   MemoryDetailSchema,
@@ -14,6 +18,7 @@ import {
   MemoryUpdateSchema,
   RealVectorStore,
   SQLiteStore,
+  SessionSummarizeSchema,
   StandardDeleteSchema,
   StandardDetailSchema,
   StandardSearchSchema,
@@ -35,14 +40,9 @@ import {
   createFileSink,
   createMcpResponse,
   createSessionContext,
-  decodeCursor,
-  encodeCursor,
-  extractRootsFromResult,
   findContainingRoot,
   getFilesystemRoots,
-  getLogLevel,
   getPrimaryTextContent,
-  getPrompt,
   handleClaimList,
   handleClaimRelease,
   handleHandoffCreate,
@@ -52,146 +52,73 @@ import {
   inferOwnerFromSession,
   inferRepoFromSession,
   isPathWithinRoots,
-  listPrompts,
-  listResourceTemplates,
-  listResources,
+  listPromptFiles,
+  loadPromptFromMarkdown,
+  loadServerInstructions,
   logger,
   normalizeRepo,
   parseRepoInput,
-  readResource,
-  setLogLevel,
-  toContextSlug,
-  updateSessionFromInitialize,
-  updateSessionRoots
-} from "../chunk-BK2QIQXS.js";
+  rankCompletionValues,
+  toContextSlug
+} from "../chunk-AKFMCVQ4.js";
 
 // src/mcp/server.ts
-import readline from "readline";
+import { serveStdio } from "@modelcontextprotocol/server/stdio";
 
-// src/mcp/router.ts
-import path2 from "path";
+// src/mcp/mcp-server.ts
+import { McpServer as McpServer2 } from "@modelcontextprotocol/server";
 
-// src/mcp/completion.ts
-import fs from "fs";
+// src/mcp/capabilities.ts
 import path from "path";
-var MAX_COMPLETION_VALUES = 100;
-var MAX_FILE_SCAN_RESULTS = 300;
-async function complete(params, db2, session2) {
-  const refType = params?.ref?.type;
-  const argumentName = typeof params?.argument?.name === "string" ? params.argument.name : "";
-  const argumentValue = typeof params?.argument?.value === "string" ? params.argument.value : "";
-  const contextArguments = params?.context?.arguments ?? {};
-  if (!refType || !argumentName) {
-    throw invalidCompletionParams("completion/complete requires ref.type and argument.name");
-  }
-  const dataSources = {
-    repos: getSuggestedRepos(db2, session2),
-    tags: getSuggestedTags(db2),
-    filePaths: getSuggestedFilePaths(session2),
-    tasks: getSuggestedTasks(db2, session2, contextArguments)
-  };
-  if (refType === "ref/prompt") {
-    const promptName = typeof params?.ref?.name === "string" ? params.ref.name : "";
-    if (!promptName) {
-      throw invalidCompletionParams("Prompt completion requires ref.name");
-    }
-    return {
-      completion: buildCompletionResult(
-        await completePromptArgument(promptName, argumentName, argumentValue, contextArguments, dataSources)
-      )
-    };
-  }
-  if (refType === "ref/resource") {
-    const resourceUri = typeof params?.ref?.uri === "string" ? params.ref.uri : "";
-    if (!resourceUri) {
-      throw invalidCompletionParams("Resource completion requires ref.uri");
-    }
-    return {
-      completion: buildCompletionResult(
-        completeResourceArgument(resourceUri, argumentName, argumentValue, contextArguments, dataSources)
-      )
-    };
-  }
-  throw invalidCompletionParams(`Unsupported completion ref type: ${refType}`);
-}
-function buildCompletionResult(values) {
-  const capped = values.slice(0, MAX_COMPLETION_VALUES);
-  return {
-    values: capped,
-    total: values.length,
-    hasMore: values.length > capped.length
-  };
-}
-function getSuggestedRepos(db2, session2) {
-  const values = /* @__PURE__ */ new Set();
-  const inferredRepo = inferRepoFromSession(session2);
-  if (inferredRepo) values.add(inferredRepo);
-  for (const rootPath of getFilesystemRoots(session2)) {
-    values.add(path.basename(rootPath));
-  }
-  for (const repo of db2.system.listRepos()) {
-    values.add(repo);
-  }
-  return [...values].sort((a, b) => a.localeCompare(b));
-}
-function getSuggestedTags(db2) {
-  const values = /* @__PURE__ */ new Set();
-  const memories = db2.memories.getRecentMemories("", "", 1e3);
-  for (const memory of memories) {
-    for (const tag of memory.tags || []) {
-      if (typeof tag === "string" && tag.trim()) {
-        values.add(tag.trim());
+import { fileURLToPath } from "url";
+var __dirname = path.dirname(fileURLToPath(import.meta.url));
+var pkgVersion = "0.1.0";
+if ("0.19.0") {
+  pkgVersion = "0.19.0";
+} 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);
   }
-  return [...values].sort((a, b) => a.localeCompare(b));
-}
-function getSuggestedTasks(db2, session2, contextArguments) {
-  const repo = typeof contextArguments.repo === "string" && contextArguments.repo.trim() ? contextArguments.repo.trim() : inferRepoFromSession(session2);
-  if (!repo) return [];
-  return db2.tasks.getTasksByRepo("", repo, void 0, 100).map((task) => ({
-    id: task.id,
-    task_code: task.task_code,
-    title: task.title
-  }));
 }
-function getSuggestedFilePaths(session2) {
-  const roots = getFilesystemRoots(session2);
-  const results = [];
-  for (const rootPath of roots) {
-    collectFiles(rootPath, rootPath, results);
-    if (results.length >= MAX_FILE_SCAN_RESULTS) break;
-  }
-  return results.sort((a, b) => a.localeCompare(b));
-}
-function collectFiles(rootPath, currentPath, results) {
-  if (results.length >= MAX_FILE_SCAN_RESULTS) return;
-  let entries;
-  try {
-    entries = fs.readdirSync(currentPath, { withFileTypes: true });
-  } catch {
-    return;
-  }
-  for (const entry of entries) {
-    if (results.length >= MAX_FILE_SCAN_RESULTS) return;
-    if (entry.name === "node_modules" || entry.name === ".git" || entry.name === "dist") continue;
-    const fullPath = path.join(currentPath, entry.name);
-    if (entry.isDirectory()) {
-      collectFiles(rootPath, fullPath, results);
-      continue;
+var CAPABILITIES = {
+  serverInfo: {
+    name: "local-memory-mcp",
+    version: pkgVersion
+  },
+  capabilities: {
+    completions: {},
+    logging: {},
+    resources: {
+      subscribe: true,
+      listChanged: true
+    },
+    tools: {
+      listChanged: false
+    },
+    prompts: {
+      listChanged: true
     }
-    if (!entry.isFile()) continue;
-    results.push(path.relative(rootPath, fullPath) || entry.name);
   }
-}
-function invalidCompletionParams(message) {
-  const error = new Error(message);
-  error.code = -32602;
-  return error;
-}
+};
+
+// src/mcp/tools/index.ts
+import path2 from "path";
+import { z } from "zod";
 
 // src/mcp/tools/memory.store.ts
-import { randomUUID } from "crypto";
+import { randomUUID as randomUUID2 } from "crypto";
 
 // src/mcp/utils/code-generator.ts
 var ENTITY_CONFIG = {
@@ -224,6 +151,275 @@ function generateNextCode(owner, repo, entityType, storage, batchCodes) {
   return `${config.prefix}-${String(nextSeq).padStart(3, "0")}`;
 }
 
+// src/mcp/tools/kg-archivist.ts
+import { randomUUID } from "crypto";
+import nlp from "compromise";
+var MAX_CONTENT_LENGTH = 5e3;
+var PRONOUNS = /* @__PURE__ */ new Set([
+  "i",
+  "me",
+  "my",
+  "myself",
+  "we",
+  "us",
+  "our",
+  "ours",
+  "ourselves",
+  "you",
+  "your",
+  "yours",
+  "yourself",
+  "yourselves",
+  "he",
+  "him",
+  "his",
+  "himself",
+  "she",
+  "her",
+  "hers",
+  "herself",
+  "it",
+  "its",
+  "itself",
+  "they",
+  "them",
+  "their",
+  "theirs",
+  "themselves",
+  "this",
+  "that",
+  "these",
+  "those",
+  "someone",
+  "somebody",
+  "something",
+  "anyone",
+  "anybody",
+  "anything",
+  "everyone",
+  "everybody",
+  "everything",
+  "nobody",
+  "nothing"
+]);
+var STOPWORDS = /* @__PURE__ */ new Set([
+  "a",
+  "an",
+  "the",
+  "and",
+  "but",
+  "or",
+  "if",
+  "because",
+  "as",
+  "until",
+  "while",
+  "of",
+  "at",
+  "by",
+  "for",
+  "with",
+  "about",
+  "against",
+  "between",
+  "into",
+  "through",
+  "during",
+  "before",
+  "after",
+  "above",
+  "below",
+  "to",
+  "from",
+  "up",
+  "down",
+  "in",
+  "out",
+  "on",
+  "off",
+  "over",
+  "under",
+  "again",
+  "further",
+  "then",
+  "once",
+  "here",
+  "there",
+  "when",
+  "where",
+  "why",
+  "how",
+  "all",
+  "each",
+  "every",
+  "both",
+  "few",
+  "more",
+  "most",
+  "other",
+  "some",
+  "such",
+  "no",
+  "nor",
+  "not",
+  "only",
+  "own",
+  "same",
+  "so",
+  "than",
+  "too",
+  "very",
+  "just",
+  "also",
+  "any",
+  "thing",
+  "things",
+  "way",
+  "ways",
+  "person",
+  "people",
+  "man",
+  "woman",
+  "child",
+  "time",
+  "year",
+  "day",
+  "number",
+  "world",
+  "life",
+  "hand",
+  "part",
+  "place",
+  "case",
+  "week",
+  "company",
+  "system",
+  "program",
+  "work",
+  "group",
+  "problem",
+  "fact",
+  "example",
+  "member",
+  "car",
+  "city",
+  "state",
+  "country",
+  "area",
+  "water",
+  "air",
+  "money",
+  "data",
+  "information",
+  "software",
+  "code",
+  "file",
+  "server",
+  "database",
+  "application",
+  "user",
+  "users",
+  "project",
+  "task",
+  "memory",
+  "value",
+  "name",
+  "type",
+  "list",
+  "set",
+  "number",
+  "id",
+  "key",
+  "text",
+  "content",
+  "title",
+  "description",
+  "status",
+  "time"
+]);
+var DETERMINERS = /^(a|an|the)\s+/i;
+var TRAILING_PUNCTUATION = /[.,!?;:()"'[\]]+$/g;
+function cleanText(raw) {
+  return raw.replace(TRAILING_PUNCTUATION, "").trim();
+}
+function stripLeadingDeterminer(phrase) {
+  return phrase.replace(DETERMINERS, "").trim();
+}
+function isExcludedNoun(candidate) {
+  const lower = candidate.toLowerCase();
+  if (lower.length < 2) return true;
+  if (PRONOUNS.has(lower)) return true;
+  if (STOPWORDS.has(lower)) return true;
+  if (/^\d+$/.test(candidate)) return true;
+  return false;
+}
+function extractEntities(content) {
+  if (!content || content.trim().length === 0) return [];
+  const text = content.length > MAX_CONTENT_LENGTH ? content.slice(0, MAX_CONTENT_LENGTH) : content;
+  const doc = nlp(text);
+  const seen = /* @__PURE__ */ new Set();
+  const entities = [];
+  function add(name, type) {
+    const trimmed = name.trim();
+    if (!trimmed || trimmed.length < 2) return;
+    const key = trimmed.toLowerCase();
+    if (seen.has(key)) return;
+    seen.add(key);
+    entities.push({ name: trimmed, type });
+  }
+  for (const match of doc.people().json()) {
+    add(cleanText(match.text), "person");
+  }
+  for (const match of doc.places().json()) {
+    add(cleanText(match.text), "place");
+  }
+  for (const match of doc.organizations().json()) {
+    add(cleanText(match.text), "organization");
+  }
+  for (const match of doc.nouns().json()) {
+    const raw = cleanText(match.text);
+    const candidate = stripLeadingDeterminer(raw);
+    if (!isExcludedNoun(candidate)) {
+      add(candidate, "concept");
+    }
+  }
+  return entities;
+}
+function saveExtractions(content, title, owner, repo, db2) {
+  if (!content || content.trim().length === 0) return;
+  let entities;
+  try {
+    entities = extractEntities(content);
+  } catch (err) {
+    logger.warn("[KG-Archivist] Entity extraction failed, skipping", {
+      error: String(err)
+    });
+    return;
+  }
+  if (entities.length === 0) return;
+  const now = (/* @__PURE__ */ new Date()).toISOString();
+  const observationText = `Mentioned in memory: ${title}`;
+  const insertEntity = db2.db.prepare(
+    `INSERT OR IGNORE INTO entities (name, type, description, repo, owner, created_at, updated_at)
+		 VALUES (?, ?, ?, ?, ?, ?, ?)`
+  );
+  const insertObservation = db2.db.prepare(
+    `INSERT INTO observations (id, entity_name, observation, repo, owner, created_at)
+		 VALUES (?, ?, ?, ?, ?, ?)`
+  );
+  for (const entity of entities) {
+    try {
+      insertEntity.run(entity.name, entity.type, null, repo, owner ?? "", now, now);
+      insertObservation.run(randomUUID(), entity.name, observationText, repo, owner ?? "", now);
+    } catch (err) {
+      logger.warn("[KG-Archivist] Failed to save extraction for entity", {
+        error: String(err),
+        entity: entity.name
+      });
+    }
+  }
+}
+
 // src/mcp/tools/memory.store.ts
 var UUID_REGEX = /^[0-9a-f]{8}-[0-9a-f]{4}-[0-9a-f]{4}-[0-9a-f]{4}-[0-9a-f]{12}$/i;
 function hasMetadataLikeTitle(title) {
@@ -280,7 +476,7 @@ async function storeSingleMemory(params, db2, vectors2) {
     tags.push(params.scope.language.toLowerCase());
   }
   const entry = {
-    id: randomUUID(),
+    id: randomUUID2(),
     code: params.code || generateNextCode(params.scope.owner ?? "", params.scope.repo, "memory", db2),
     type: params.type,
     title: params.title,
@@ -309,6 +505,13 @@ async function storeSingleMemory(params, db2, vectors2) {
   } catch (error) {
     logger.warn("Failed to generate vector embedding", { error: String(error) });
   }
+  try {
+    saveExtractions(entry.content, entry.title, entry.scope.owner, entry.scope.repo, db2);
+  } catch (error) {
+    logger.warn("[KG-Archivist] NLP extraction failed, memory stored without KG enrichment", {
+      error: String(error)
+    });
+  }
   return createMcpResponse(
     {
       success: true,
@@ -377,7 +580,7 @@ async function handleMemoryStore(params, db2, vectors2) {
       const code = mem.code || generateNextCode(mem.scope.owner ?? "", mem.scope.repo, "memory", db2, batchCodes);
       batchCodes.add(code);
       entries.push({
-        id: randomUUID(),
+        id: randomUUID2(),
         code,
         type: mem.type,
         title: mem.title,
@@ -409,6 +612,13 @@ async function handleMemoryStore(params, db2, vectors2) {
       } catch (error) {
         logger.warn("Failed to generate vector embedding", { error: String(error) });
       }
+      try {
+        saveExtractions(entry.content, entry.title, entry.scope.owner, entry.scope.repo, db2);
+      } catch (error) {
+        logger.warn("[KG-Archivist] NLP extraction failed, memory stored without KG enrichment", {
+          error: String(error)
+        });
+      }
     }
     const codesStr = storedCodes.length > 0 ? `: ${storedCodes.join(", ")}` : "";
     return createMcpResponse(
@@ -543,6 +753,134 @@ function expandQuery(query, prompt) {
   return Array.from(expansions).join(" ");
 }
 
+// src/mcp/tools/time-tunnel.ts
+function startOfDay(d) {
+  return new Date(d.getFullYear(), d.getMonth(), d.getDate());
+}
+function endOfDay(d) {
+  return new Date(d.getFullYear(), d.getMonth(), d.getDate(), 23, 59, 59, 999);
+}
+function currentWeekMonday(now) {
+  const day = now.getDay();
+  const offset = day === 0 ? -6 : 1 - day;
+  return startOfDay(new Date(now.getFullYear(), now.getMonth(), now.getDate() + offset));
+}
+var PATTERNS = [
+  // Order matters: more specific phrases first to avoid partial matches.
+  // "last month" — full previous calendar month
+  {
+    regex: /\blast month\b/i,
+    handler: (_match, now) => {
+      const startOfLastMonth = new Date(now.getFullYear(), now.getMonth() - 1, 1);
+      const endOfLastMonth = new Date(now.getFullYear(), now.getMonth(), 0, 23, 59, 59, 999);
+      return {
+        since: startOfLastMonth.toISOString(),
+        until: endOfLastMonth.toISOString()
+      };
+    }
+  },
+  // "last week" — full previous calendar week (Mon–Sun)
+  {
+    regex: /\blast week\b/i,
+    handler: (_match, now) => {
+      const thisMonday = currentWeekMonday(now);
+      const startOfLastWeek = new Date(thisMonday.getTime() - 7 * 24 * 60 * 60 * 1e3);
+      const _endOfLastWeek = new Date(thisMonday.getTime() - 1);
+      const endOfSunday = new Date(
+        startOfLastWeek.getFullYear(),
+        startOfLastWeek.getMonth(),
+        startOfLastWeek.getDate() + 6,
+        23,
+        59,
+        59,
+        999
+      );
+      return {
+        since: startOfLastWeek.toISOString(),
+        until: endOfSunday.toISOString()
+      };
+    }
+  },
+  // "this week" — current week from Monday to today (no until bound)
+  {
+    regex: /\bthis week\b/i,
+    handler: (_match, now) => {
+      const monday = currentWeekMonday(now);
+      return {
+        since: monday.toISOString()
+      };
+    }
+  },
+  // "yesterday"
+  {
+    regex: /\byesterday\b/i,
+    handler: (_match, now) => {
+      const yesterday = new Date(now.getFullYear(), now.getMonth(), now.getDate() - 1);
+      return {
+        since: startOfDay(yesterday).toISOString(),
+        until: endOfDay(yesterday).toISOString()
+      };
+    }
+  },
+  // "today"
+  {
+    regex: /\btoday\b/i,
+    handler: (_match, now) => {
+      return {
+        since: startOfDay(now).toISOString(),
+        until: endOfDay(now).toISOString()
+      };
+    }
+  },
+  // "last N weeks" / "past N weeks"
+  {
+    regex: /\b(?:last|past)\s+(\d+)\s+weeks?\b/i,
+    handler: (match, now) => {
+      const n = parseInt(match[1], 10);
+      const since = new Date(now.getFullYear(), now.getMonth(), now.getDate() - n * 7);
+      return {
+        since: startOfDay(since).toISOString()
+      };
+    }
+  },
+  // "last N days" / "past N days"
+  {
+    regex: /\b(?:last|past)\s+(\d+)\s+days?\b/i,
+    handler: (match, now) => {
+      const n = parseInt(match[1], 10);
+      const since = new Date(now.getFullYear(), now.getMonth(), now.getDate() - n);
+      return {
+        since: startOfDay(since).toISOString()
+      };
+    }
+  },
+  // "last_hour" / "past_hour"
+  {
+    regex: /\b(?:last|past)_hour\b/i,
+    handler: (_match, now) => {
+      const since = new Date(now.getTime() - 60 * 60 * 1e3);
+      return {
+        since: since.toISOString()
+      };
+    }
+  }
+];
+function parseRelativeDate(query) {
+  if (!query || query.trim().length === 0) {
+    return null;
+  }
+  const now = /* @__PURE__ */ new Date();
+  for (const { regex, handler } of PATTERNS) {
+    const match = query.match(regex);
+    if (match) {
+      const cleanedQuery = query.replace(regex, "").trim().replace(/\s+/g, " ");
+      const { since, until } = handler(match, now);
+      return { cleanedQuery, since, until };
+    }
+  }
+  return null;
+}
+
 // src/mcp/tools/memory.search.ts
 var HYBRID_WEIGHTS_VECTOR = {
   similarity: 0.4,
@@ -551,7 +889,9 @@ var HYBRID_WEIGHTS_VECTOR = {
 };
 async function handleMemorySearch(params, db2, vectors2) {
   const validated = MemorySearchSchema.parse(params);
-  const searchQuery = expandQuery(validated.query, validated.prompt);
+  const timeTunnel = parseRelativeDate(validated.query);
+  const effectiveQuery = timeTunnel ? timeTunnel.cleanedQuery : validated.query;
+  const searchQuery = expandQuery(effectiveQuery, validated.prompt);
   const fetchLimit = (validated.offset + validated.limit) * 3;
   const similarityResults = db2.memoryVectors.searchBySimilarity(
     searchQuery,
@@ -622,6 +962,9 @@ async function handleMemorySearch(params, db2, vectors2) {
   const threshold = scoredMemories.length <= 5 ? 0.1 : 0.4;
   let allMatches = scoredMemories.filter((sm) => sm.finalScore >= threshold).map((sm) => sm.memory);
   if (allMatches.length === 0 && scoredMemories.length > 0) allMatches = [scoredMemories[0].memory];
+  if (timeTunnel) {
+    allMatches = applyTimeFilter(allMatches, timeTunnel);
+  }
   const total = allMatches.length;
   const paginatedResults = allMatches.slice(validated.offset, validated.offset + validated.limit);
   db2.memories.incrementHitCounts(paginatedResults.map((m) => m.id));
@@ -678,6 +1021,56 @@ async function handleMemorySearch(params, db2, vectors2) {
 function capitalize(str) {
   return str.charAt(0).toUpperCase() + str.slice(1);
 }
+function applyTimeFilter(memories, tunnel) {
+  const sinceMs = tunnel.since ? new Date(tunnel.since).getTime() : 0;
+  const untilMs = tunnel.until ? new Date(tunnel.until).getTime() : Infinity;
+  return memories.filter((m) => {
+    const createdAtMs = new Date(m.created_at).getTime();
+    if (sinceMs > 0 && createdAtMs < sinceMs) return false;
+    if (untilMs < Infinity && createdAtMs >= untilMs) return false;
+    return true;
+  });
+}
+
+// src/mcp/tools/memory.acknowledge.ts
+async function handleMemoryAcknowledge(params, db2) {
+  const validated = MemoryAcknowledgeSchema.parse(params);
+  let memoryId = validated.memory_id;
+  if (!memoryId && validated.code) {
+    const byCode = db2.memories.getByCode(validated.code, validated.owner, validated.repo);
+    if (!byCode) throw new Error(`Memory not found: ${validated.code}`);
+    memoryId = byCode.id;
+  } else if (!memoryId) {
+    throw new Error("Either memory_id or code must be provided");
+  }
+  const memory = db2.memories.getById(memoryId);
+  if (!memory) {
+    throw new Error(`Memory with ID ${memoryId} not found.`);
+  }
+  if (validated.status === "used") {
+    db2.memories.incrementRecallCount(memory.id);
+    logger.info("[Tool] memory.acknowledge - used", { id: memory.id, context: validated.application_context });
+  } else if (validated.status === "contradictory") {
+    logger.warn("[Tool] memory.acknowledge - contradiction reported", {
+      id: memory.id,
+      context: validated.application_context
+    });
+  } else {
+    logger.info("[Tool] memory.acknowledge - irrelevant", { id: memory.id, context: validated.application_context });
+  }
+  return createMcpResponse(
+    {
+      success: true,
+      id: memory.id,
+      status: validated.status
+    },
+    `Acknowledged memory [${memory.code}] as "${validated.status}".`,
+    {
+      structuredContentPathHint: "status",
+      includeSerializedStructuredContent: validated.structured
+    }
+  );
+}
 
 // src/mcp/tools/memory.summarize.ts
 async function handleMemorySummarize(params, db2) {
@@ -895,11 +1288,11 @@ async function handleTaskList(args, storage) {
 // src/mcp/tools/memory.synthesize.ts
 async function handleMemorySynthesize(params, db2, vectors2, options = {}) {
   const validated = MemorySynthesizeSchema.parse(params);
-  const session2 = options.session;
-  if (!options.sampleMessage || !session2?.supportsSampling) {
+  const session = options.session;
+  if (!options.sampleMessage || !session?.supportsSampling) {
     throw new Error("Client does not advertise MCP sampling support");
   }
-  const repo = await resolveRepository(validated.repo, session2, options.elicit);
+  const repo = await resolveRepository(validated.repo, session, options.elicit);
   if (!repo) {
     throw new Error("repo is required when repo cannot be inferred from active MCP roots");
   }
@@ -940,7 +1333,7 @@ ${contextBlock || "No additional context provided."}`
       }
     }
   ];
-  const toolDefinitions = buildSamplingTools(session2, validated.use_tools);
+  const toolDefinitions = buildSamplingTools(session, validated.use_tools);
   let lastResponse = null;
   let totalToolCalls = 0;
   let iterations = 0;
@@ -1011,11 +1404,11 @@ ${contextBlock || "No additional context provided."}`
     }
   );
 }
-async function resolveRepository(repo, session2, elicit) {
+async function resolveRepository(repo, session, elicit) {
   if (repo) return normalizeRepo(repo);
-  const inferredRepo = inferRepoFromSession(session2);
+  const inferredRepo = inferRepoFromSession(session);
   if (inferredRepo) return normalizeRepo(inferredRepo);
-  if (!session2?.supportsElicitationForm || !elicit) {
+  if (!session?.supportsElicitationForm || !elicit) {
     return void 0;
   }
   const elicited = extractAcceptedElicitationContent(
@@ -1038,8 +1431,8 @@ async function resolveRepository(repo, session2, elicit) {
   );
   return typeof elicited.repo === "string" && elicited.repo.trim() ? normalizeRepo(elicited.repo.trim()) : void 0;
 }
-function buildSamplingTools(session2, useTools) {
-  if (!useTools || !session2?.supportsSamplingTools) {
+function buildSamplingTools(session, useTools) {
+  if (!useTools || !session?.supportsSamplingTools) {
     return [];
   }
   return [
@@ -1203,58 +1596,18 @@ async function handleMemoryDelete(params, db2, vectors2, onProgress) {
   );
 }
 
-// src/mcp/tools/memory.acknowledge.ts
-async function handleMemoryAcknowledge(params, db2) {
-  const validated = MemoryAcknowledgeSchema.parse(params);
-  let memoryId = validated.memory_id;
-  if (!memoryId && validated.code) {
-    const byCode = db2.memories.getByCode(validated.code, validated.owner, validated.repo);
-    if (!byCode) throw new Error(`Memory not found: ${validated.code}`);
-    memoryId = byCode.id;
-  } else if (!memoryId) {
-    throw new Error("Either memory_id or code must be provided");
+// src/mcp/tools/memory.detail.ts
+async function handleMemoryDetail(args, storage) {
+  const validated = MemoryDetailSchema.parse(args);
+  const { id, code, owner, repo } = validated;
+  let memory;
+  if (id) {
+    memory = storage.memories.getById(id);
+  } else if (code) {
+    memory = storage.memories.getByCode(code, owner, repo);
   }
-  const memory = db2.memories.getById(memoryId);
   if (!memory) {
-    throw new Error(`Memory with ID ${memoryId} not found.`);
-  }
-  if (validated.status === "used") {
-    db2.memories.incrementRecallCount(memory.id);
-    logger.info("[Tool] memory.acknowledge - used", { id: memory.id, context: validated.application_context });
-  } else if (validated.status === "contradictory") {
-    logger.warn("[Tool] memory.acknowledge - contradiction reported", {
-      id: memory.id,
-      context: validated.application_context
-    });
-  } else {
-    logger.info("[Tool] memory.acknowledge - irrelevant", { id: memory.id, context: validated.application_context });
-  }
-  return createMcpResponse(
-    {
-      success: true,
-      id: memory.id,
-      status: validated.status
-    },
-    `Acknowledged memory [${memory.code}] as "${validated.status}".`,
-    {
-      structuredContentPathHint: "status",
-      includeSerializedStructuredContent: validated.structured
-    }
-  );
-}
-
-// src/mcp/tools/memory.detail.ts
-async function handleMemoryDetail(args, storage) {
-  const validated = MemoryDetailSchema.parse(args);
-  const { id, code, owner, repo } = validated;
-  let memory;
-  if (id) {
-    memory = storage.memories.getById(id);
-  } else if (code) {
-    memory = storage.memories.getByCode(code, owner, repo);
-  }
-  if (!memory) {
-    throw new Error(`Memory not found: ${id || code}`);
+    throw new Error(`Memory not found: ${id || code}`);
   }
   storage.memories.incrementHitCount(memory.id);
   const lines = [
@@ -1278,7 +1631,7 @@ async function handleMemoryDetail(args, storage) {
 }
 
 // src/mcp/tools/standard.store.ts
-import { randomUUID as randomUUID2 } from "crypto";
+import { randomUUID as randomUUID3 } from "crypto";
 var UUID_REGEX3 = /^[0-9a-f]{8}-[0-9a-f]{4}-[0-9a-f]{4}-[0-9a-f]{4}-[0-9a-f]{12}$/i;
 function resolveStandardParentId(value, db2, owner, repo) {
   if (!value) return null;
@@ -1321,7 +1674,7 @@ async function storeSingleStandard(params, db2, vectors2) {
   }
   const now = (/* @__PURE__ */ new Date()).toISOString();
   const entry = {
-    id: randomUUID2(),
+    id: randomUUID3(),
     code: generateNextCode(params.owner, params.repo || "__global__", "standard", db2),
     title: params.name,
     content: params.content,
@@ -1404,7 +1757,7 @@ async function handleStandardStore(params, db2, vectors2) {
       const code = generateNextCode(validated.owner ?? "", standardRepo, "standard", db2, batchCodes);
       batchCodes.add(code);
       entries.push({
-        id: randomUUID2(),
+        id: randomUUID3(),
         code,
         title: std.name,
         content: std.content,
@@ -1845,7 +2198,7 @@ async function handleStandardDelete(params, db2, vectors2) {
 }
 
 // src/mcp/tools/task.create.ts
-import { randomUUID as randomUUID3 } from "crypto";
+import { randomUUID as randomUUID4 } from "crypto";
 
 // src/mcp/tools/task.helpers.ts
 var UUID_REGEX5 = /^[0-9a-f]{8}-[0-9a-f]{4}-[0-9a-f]{4}-[0-9a-f]{4}-[0-9a-f]{12}$/i;
@@ -1964,7 +2317,7 @@ async function handleTaskCreate(args, storage) {
     let pendingInRequestCount = 0;
     const localCodeMap = /* @__PURE__ */ new Map();
     for (const taskData of bulkTasks) {
-      localCodeMap.set(taskData.task_code, randomUUID3());
+      localCodeMap.set(taskData.task_code, randomUUID4());
     }
     for (const taskData of bulkTasks) {
       const code = taskData.task_code;
@@ -2067,7 +2420,7 @@ async function handleTaskCreate(args, storage) {
       );
     }
   }
-  const taskId = randomUUID3();
+  const taskId = randomUUID4();
   const now = (/* @__PURE__ */ new Date()).toISOString();
   const statusTimestamps = deriveTaskStatusTimestamps(status || "backlog", now);
   const finalTags = [...singleTask.tags || []];
@@ -2215,7 +2568,7 @@ function addRequiredStringField(properties, required, task, field, schema) {
 }
 
 // src/mcp/tools/task.update.ts
-import { randomUUID as randomUUID4 } from "crypto";
+import { randomUUID as randomUUID5 } from "crypto";
 async function handleTaskUpdate(args, storage, vectors2) {
   const updateData = TaskUpdateSchema.parse(args);
   const { owner, repo, id, ids, comment, force, ...updates } = updateData;
@@ -2301,7 +2654,7 @@ async function handleTaskUpdate(args, storage, vectors2) {
     storage.tasks.updateTask(targetId, finalUpdates);
     if (comment !== void 0 || isStatusChanging) {
       storage.taskComments.insertTaskComment({
-        id: randomUUID4(),
+        id: randomUUID5(),
         task_id: targetId,
         owner,
         repo,
@@ -2565,284 +2918,565 @@ async function handleTaskSearch(args, storage) {
   });
 }
 
-// src/mcp/router.ts
-function createRouter(db2, vectors2, options) {
-  const getSessionContext = options?.getSessionContext;
-  async function handleMethod2(method, params, signal, onProgress) {
-    const t0 = Date.now();
-    try {
-      const result = await _dispatch(method, params, signal, onProgress);
-      logger.debug(`[Router] ${method}`, { ms: Date.now() - t0 });
-      return result;
-    } catch (err) {
-      logger.error(`[Router] ${method} failed`, { ms: Date.now() - t0, error: String(err) });
-      throw err;
-    }
-  }
-  async function _dispatch(method, params, signal, onProgress) {
-    switch (method) {
-      // ---- tools ----
-      case "tools/list":
-        return listTools(getSessionContext?.(), params);
-      case "tools/call":
-        return await handleToolCall(
-          params,
-          params?.signal,
-          onProgress
-        );
-      // ---- resources ----
-      case "resources/list":
-        return listResources(getSessionContext?.(), params);
-      case "resources/templates/list":
-        return listResourceTemplates(params);
-      case "resources/read": {
-        const result = readResource(params?.uri, db2, getSessionContext?.());
-        if (result && Array.isArray(result.contents) && !result.content) {
-          result.content = result.contents;
-        }
-        return result;
-      }
-      // ---- prompts ----
-      case "prompts/list":
-        return listPrompts(db2, getSessionContext?.(), params);
-      case "logging/setLevel": {
-        const requestedLevel = typeof params?.level === "string" ? params.level : "";
-        const previousLevel = getLogLevel();
-        const level = setLogLevel(requestedLevel);
-        return {
-          level,
-          supportedLevels: LOG_LEVEL_VALUES,
-          previousLevel
-        };
-      }
-      case "prompts/get": {
-        return getPrompt(
-          params?.name,
-          params?.arguments || {},
-          db2,
-          getSessionContext?.()
-        );
-      }
-      case "completion/complete":
-        return complete(params, db2, getSessionContext?.());
-      default:
-        throw new Error(`Unsupported method: ${method}`);
-    }
-  }
-  const WRITE_TOOLS = /* @__PURE__ */ new Set([
-    "memory-store",
-    "memory-acknowledge",
-    "memory-update",
-    "memory-delete",
-    "memory-bulk-delete",
-    "memory-summarize",
-    "handoff-create",
-    "handoff-update",
-    "standard-store",
-    "standard-update",
-    "standard-delete",
-    "task-create",
-    "task-create-interactive",
-    "task-claim",
-    "claim-release",
-    "task-update",
-    "task-delete"
-  ]);
-  async function handleToolCall(params, signal, onProgress) {
-    const { name } = params || {};
-    const args = normalizeToolArguments(params?.arguments, getSessionContext?.());
-    const toolName = String(name).replace(/\./g, "-");
-    let result;
-    const repo = args?.repo || args?.scope?.repo || "unknown";
-    const isWrite = WRITE_TOOLS.has(toolName);
-    logger.info(`[Tool] ${toolName}`, { repo, write: isWrite });
-    const executeToolLogic = async () => {
-      switch (toolName) {
-        case "memory-store":
-          return await handleMemoryStore(args, db2, vectors2);
-        case "memory-acknowledge":
-          return await handleMemoryAcknowledge(args, db2);
-        case "memory-update":
-          return await handleMemoryUpdate(args, db2, vectors2);
-        case "memory-recap":
-          return await handleMemoryRecap(args, db2);
-        case "memory-search":
-          return await handleMemorySearch(args, db2, vectors2);
-        case "memory-summarize":
-          return await handleMemorySummarize(args, db2);
-        case "memory-synthesize":
-          return await handleMemorySynthesize(args, db2, vectors2, {
-            session: getSessionContext?.(),
-            sampleMessage: options?.sampleMessage,
-            elicit: options?.elicit
-          });
-        case "memory-delete":
-        case "memory-bulk-delete":
-          return await handleMemoryDelete(args, db2, vectors2, onProgress);
-        case "memory-detail":
-          return await handleMemoryDetail(args, db2);
-        case "handoff-create":
-          return await handleHandoffCreate(args, db2);
-        case "handoff-list":
-          return await handleHandoffList(args, db2);
-        case "handoff-update":
-          return await handleHandoffUpdate(args, db2);
-        case "task-claim":
-          return await handleTaskClaim(args, db2);
-        case "claim-list":
-          return await handleClaimList(args, db2);
-        case "claim-release":
-          return await handleClaimRelease(args, db2);
-        case "standard-store":
-          return await handleStandardStore(args, db2, vectors2);
-        case "standard-update":
-          return await handleStandardUpdate(args, db2, vectors2);
-        case "standard-detail":
-          return await handleStandardDetail(args, db2);
-        case "standard-delete":
-          return await handleStandardDelete(args, db2, vectors2);
-        case "standard-search":
-          return await handleStandardSearch(args, db2, vectors2);
-        case "task-create":
-          return await handleTaskCreate(args, db2);
-        case "task-create-interactive":
-          return await handleTaskCreateInteractive(args, db2, {
-            session: getSessionContext?.(),
-            elicit: options?.elicit
-          });
-        case "task-update":
-          return await handleTaskUpdate(args, db2, vectors2);
-        case "task-delete":
-          return await handleTaskDelete(args, db2);
-        case "task-list":
-          return await handleTaskList(args, db2);
-        case "task-search":
-          return await handleTaskSearch(args, db2);
-        case "task-detail":
-          return await handleTaskGet(args, db2);
-        default:
-          throw new Error(`Unknown tool: ${name}`);
-      }
-    };
-    if (isWrite) {
-      result = await db2.withWrite(executeToolLogic);
-    } else {
-      result = await executeToolLogic();
+// src/mcp/tools/agent-context.ts
+var ACTIVE_TASK_STATUSES = ["in_progress", "pending", "backlog", "blocked"];
+async function handleAgentContext(args, db2, _vectors) {
+  const validated = AgentContextSchema.parse(args);
+  const { owner, repo, objective, type_filter, limit, structured: isStructuredRequest } = validated;
+  let memories;
+  let decisionMemories = [];
+  const shouldFetchDecisions = !type_filter || type_filter === "decision";
+  if (objective) {
+    memories = db2.memories.searchByRepo(owner, repo, objective, type_filter, limit);
+    if (shouldFetchDecisions) {
+      decisionMemories = db2.memories.searchByRepo(owner, repo, "", "decision", limit);
     }
-    logger.info(`[Tool] ${toolName} result`, { repo, result });
-    try {
-      const actionType = toolName.split("-")[1] || toolName;
-      const res = result;
-      const sc = res?.structuredData;
-      const logOptions = {
-        query: args?.query || args?.title || args?.task_code || (toolName === "memory-recap" ? `Offset: ${args?.offset || 0}` : void 0),
-        response: result,
-        memoryId: args?.id || args?.memory_id || sc?.id,
-        taskId: args?.id || args?.task_id || sc?.id,
-        resultCount: Array.isArray(sc?.results) ? sc.results.length : sc?.count || 0
-      };
-      if (isWrite) {
-        db2.actions.logAction(actionType, "", repo, logOptions);
-      } else {
-        await db2.withWrite(() => db2.actions.logAction(actionType, "", repo, logOptions));
-      }
-    } catch (e) {
-      logger.error("Failed to log action", { toolName, error: String(e) });
+  } else {
+    const excludeTypes = type_filter ? [] : ["decision"];
+    memories = db2.memories.getRecentMemories(owner, repo, limit, 0, false, excludeTypes);
+    if (shouldFetchDecisions) {
+      decisionMemories = db2.memories.searchByRepo(owner, repo, "", "decision", limit);
+    }
+  }
+  const activeTasks = db2.tasks.getTasksByMultipleStatuses(owner, repo, ACTIVE_TASK_STATUSES, 10, 0);
+  const memoryIds = new Set(memories.map((m) => m.id));
+  const uniqueDecisions = decisionMemories.filter((d) => !memoryIds.has(d.id));
+  const sections = [];
+  sections.push(`--- Active Context for ${repo} ---`);
+  sections.push("");
+  sections.push("== Relevant Memories ==");
+  if (memories.length === 0) {
+    sections.push("(No relevant memories found)");
+  } else {
+    for (const m of memories) {
+      const code = m.code || "-";
+      const snippet = m.content.length > 120 ? m.content.slice(0, 120) + "..." : m.content;
+      sections.push(`- [${code}] (${m.type}, importance: ${m.importance}) ${m.title}`);
+      sections.push(`  ${snippet}`);
     }
-    const affectedResources = collectAffectedResourceUris(toolName, args, result);
-    if (affectedResources.length > 0) {
-      options?.onResourcesMutated?.(affectedResources);
+  }
+  sections.push("");
+  sections.push("== Active Tasks ==");
+  if (activeTasks.length === 0) {
+    sections.push("(No active tasks)");
+  } else {
+    for (const t of activeTasks) {
+      sections.push(`- ${t.task_code} | ${t.status} | priority: ${t.priority} | ${t.title}`);
     }
-    return result;
   }
-  return handleMethod2;
-}
-function listTools(session2, params) {
-  const tools = getAvailableToolDefinitions(session2);
-  const limit = normalizePageLimit(params?.limit, tools.length || 1);
-  const start = decodeCursor(params?.cursor);
-  const compliantTools = tools.map((tool) => {
-    const { name, description, inputSchema } = tool;
-    return { name, description, inputSchema };
+  sections.push("");
+  sections.push("== Recent Decisions ==");
+  if (uniqueDecisions.length === 0) {
+    sections.push("(No recent decision memories)");
+  } else {
+    for (const d of uniqueDecisions) {
+      const code = d.code || "-";
+      const snippet = d.content.length > 150 ? d.content.slice(0, 150) + "..." : d.content;
+      sections.push(`- [${code}] (importance: ${d.importance}) ${d.title}`);
+      sections.push(`  ${snippet}`);
+    }
+  }
+  sections.push("");
+  sections.push("Use memory-detail with a memory code for full content.");
+  const contentSummary = sections.join("\n").trim();
+  const structuredData = {
+    schema: "agent-context",
+    repo,
+    objective: objective || null,
+    memories: memories.map((m) => ({
+      id: m.id,
+      code: m.code || null,
+      title: m.title,
+      type: m.type,
+      importance: m.importance
+    })),
+    decisions: uniqueDecisions.map((d) => ({
+      id: d.id,
+      code: d.code || null,
+      title: d.title,
+      importance: d.importance
+    })),
+    tasks: activeTasks.map((t) => ({
+      task_code: t.task_code,
+      title: t.title,
+      status: t.status,
+      priority: t.priority
+    }))
+  };
+  logger.info("[Tool] agent-context", {
+    repo,
+    memories: memories.length,
+    decisions: uniqueDecisions.length,
+    tasks: activeTasks.length
   });
-  const page = compliantTools.slice(start, start + limit);
-  const nextCursor = start + limit < tools.length ? encodeCursor(start + limit) : void 0;
-  return {
-    tools: page,
-    nextCursor
+  return createMcpResponse(structuredData, contentSummary, {
+    contentSummary,
+    includeSerializedStructuredContent: isStructuredRequest
+  });
+}
+
+// src/mcp/tools/decision-log.ts
+async function handleDecisionLog(args, db2, vectors2) {
+  const validated = DecisionLogSchema.parse(args);
+  const owner = validated.owner ?? "";
+  const repo = validated.repo ?? "";
+  if (!owner || !repo) {
+    return createMcpResponse(
+      {
+        success: false,
+        error: "MISSING_SCOPE",
+        message: "Both owner and repo are required. They can be provided explicitly or auto-detected from the session context."
+      },
+      "Failed to log decision: owner and repo could not be determined."
+    );
+  }
+  const alternativesStr = validated.alternatives && validated.alternatives.length > 0 ? validated.alternatives.join(", ") : "None";
+  const formattedContent = [
+    `Decision: ${validated.summary}`,
+    `Context: ${validated.context}`,
+    `Rationale: ${validated.rationale}`,
+    `Alternatives considered: ${alternativesStr}`
+  ].join("\n");
+  const tags = ["decision", ...validated.tags ?? []];
+  const memoryStoreParams = {
+    type: "decision",
+    title: validated.summary,
+    content: formattedContent,
+    importance: 4,
+    agent: "agent",
+    role: "unknown",
+    model: "unknown",
+    scope: {
+      owner,
+      repo
+    },
+    tags,
+    structured: validated.structured
   };
+  return handleMemoryStore(memoryStoreParams, db2, vectors2);
 }
-function getAvailableToolDefinitions(session2) {
-  return TOOL_DEFINITIONS.filter((tool) => {
-    if (tool.name === "memory-synthesize" && !session2?.supportsSampling) {
-      return false;
+
+// src/mcp/tools/session-summarize.ts
+async function handleSessionSummarize(args, db2, vectors2) {
+  const validated = SessionSummarizeSchema.parse(args);
+  const owner = validated.owner ?? "";
+  const repo = validated.repo ?? "";
+  if (!owner || !repo) {
+    return createMcpResponse(
+      {
+        success: false,
+        error: "MISSING_SCOPE",
+        message: "Both owner and repo are required. They can be provided explicitly or auto-detected from the session context."
+      },
+      "Failed to log session summary: owner and repo could not be determined."
+    );
+  }
+  const decisionsStr = validated.key_decisions && validated.key_decisions.length > 0 ? validated.key_decisions.map((d) => `- ${d}`).join("\n") : "None";
+  const nextStepsStr = validated.next_steps && validated.next_steps.length > 0 ? validated.next_steps.map((s) => `- ${s}`).join("\n") : "None";
+  const formattedContent = [
+    `Session Summary: ${validated.summary}`,
+    ``,
+    `Key Decisions:`,
+    decisionsStr,
+    ``,
+    `Next Steps:`,
+    nextStepsStr
+  ].join("\n");
+  const tags = ["session-summary", ...validated.tags ?? []];
+  const memoryStoreParams = {
+    type: "task_archive",
+    title: validated.summary.length > 100 ? validated.summary.slice(0, 97) + "..." : validated.summary,
+    content: formattedContent,
+    importance: 3,
+    agent: "agent",
+    role: "unknown",
+    model: "unknown",
+    scope: {
+      owner,
+      repo
+    },
+    tags,
+    structured: validated.structured
+  };
+  return handleMemoryStore(memoryStoreParams, db2, vectors2);
+}
+
+// src/mcp/tools/kg.crud.ts
+async function handleCreateEntity(params, db2, _vectors) {
+  const validated = CreateEntitySchema.parse(params);
+  const { name, type, description, owner, repo, structured } = validated;
+  const now = (/* @__PURE__ */ new Date()).toISOString();
+  try {
+    const txn = db2.db.transaction(() => {
+      db2.db.prepare(
+        `INSERT INTO entities (name, type, description, repo, owner, created_at, updated_at)
+         VALUES (?, ?, ?, ?, ?, ?, ?)`
+      ).run(name, type, description ?? null, repo ?? "", owner ?? "", now, now);
+    });
+    txn();
+  } catch (error) {
+    const err = error;
+    if (err.code === "SQLITE_CONSTRAINT_PRIMARYKEY") {
+      const response = createMcpResponse(
+        {
+          success: false,
+          error: "ENTITY_ALREADY_EXISTS",
+          message: `Entity '${name}' already exists in this repo.`
+        },
+        `Entity '${name}' already exists.`,
+        { includeSerializedStructuredContent: structured }
+      );
+      response.isError = true;
+      return response;
     }
-    if (tool.name === "task-create-interactive" && !session2?.supportsElicitationForm) {
-      return false;
+    logger.error("[Tool] create_entity failed", { error: String(error) });
+    throw error;
+  }
+  logger.info("[Tool] create_entity", { repo: repo ?? "", entity: name });
+  return createMcpResponse(
+    {
+      success: true,
+      entity: { name, type, description, repo: repo ?? "", owner: owner ?? "" }
+    },
+    `Created entity '${name}' (${type}) in repo "${repo ?? ""}".`,
+    {
+      structuredContentPathHint: "entity",
+      includeSerializedStructuredContent: structured
     }
-    return true;
-  });
+  );
 }
-function collectAffectedResourceUris(toolName, args, result) {
-  const res = result;
-  const repo = args?.repo || args?.scope?.repo || res?.data?.repo;
-  const uris = /* @__PURE__ */ new Set();
-  const touchesMemory = toolName.startsWith("memory-") || toolName === "task-update" || toolName === "task-delete";
-  const touchesTasks = toolName.startsWith("task-");
-  if (touchesMemory && repo) {
-    uris.add(`repository://${encodeURIComponent(repo)}/memories`);
+async function handleDeleteEntity(params, db2, _vectors) {
+  const validated = DeleteEntitySchema.parse(params);
+  const { name, owner: _owner, repo, structured } = validated;
+  let changes = 0;
+  try {
+    const txn = db2.db.transaction(() => {
+      const result = db2.db.prepare(`DELETE FROM entities WHERE name = ?`).run(name);
+      changes = result.changes;
+    });
+    txn();
+  } catch (error) {
+    const err = error;
+    logger.error("[Tool] delete_entity failed", { error: String(error) });
+    if (err.code === "SQLITE_CONSTRAINT_FOREIGNKEY" || err.code === "SQLITE_CONSTRAINT") {
+      const response2 = createMcpResponse(
+        {
+          success: false,
+          error: "ENTITY_IN_USE",
+          message: `Entity '${name}' is referenced by existing relations and cannot be deleted.`
+        },
+        `Entity '${name}' is in use and cannot be deleted.`,
+        { includeSerializedStructuredContent: structured }
+      );
+      response2.isError = true;
+      return response2;
+    }
+    const response = createMcpResponse(
+      {
+        success: false,
+        error: "DELETE_FAILED",
+        message: `Failed to delete entity '${name}'.`
+      },
+      `Failed to delete entity '${name}'.`,
+      { includeSerializedStructuredContent: structured }
+    );
+    response.isError = true;
+    return response;
   }
-  if (touchesTasks && repo) {
-    uris.add(`repository://${encodeURIComponent(repo)}/tasks`);
+  logger.info("[Tool] delete_entity", { repo: repo ?? "", entity: name, changes });
+  if (changes === 0) {
+    return createMcpResponse(
+      {
+        success: false,
+        error: "ENTITY_NOT_FOUND",
+        message: `Entity '${name}' not found.`
+      },
+      `Entity '${name}' not found.`,
+      { includeSerializedStructuredContent: structured }
+    );
   }
-  if (repo) {
-    uris.add("repository://index");
+  return createMcpResponse(
+    {
+      success: true,
+      deletedCount: changes
+    },
+    `Deleted entity '${name}' and its cascade (relations, observations).`,
+    {
+      structuredContentPathHint: "deletedCount",
+      includeSerializedStructuredContent: structured
+    }
+  );
+}
+async function handleCreateRelation(params, db2, _vectors) {
+  const validated = CreateRelationSchema.parse(params);
+  const { from_entity, to_entity, relation_type, owner, repo, structured } = validated;
+  const now = (/* @__PURE__ */ new Date()).toISOString();
+  try {
+    const txn = db2.db.transaction(() => {
+      const fromExists = db2.db.prepare(`SELECT 1 FROM entities WHERE name = ?`).get(from_entity);
+      if (!fromExists) {
+        throw new Error("FROM_ENTITY_NOT_FOUND");
+      }
+      const toExists = db2.db.prepare(`SELECT 1 FROM entities WHERE name = ?`).get(to_entity);
+      if (!toExists) {
+        throw new Error("TO_ENTITY_NOT_FOUND");
+      }
+      db2.db.prepare(
+        `INSERT INTO relations (from_entity, to_entity, relation_type, repo, owner, created_at)
+         VALUES (?, ?, ?, ?, ?, ?)`
+      ).run(from_entity, to_entity, relation_type, repo ?? "", owner ?? "", now);
+    });
+    txn();
+  } catch (error) {
+    const err = error;
+    if (err.message === "FROM_ENTITY_NOT_FOUND") {
+      const response = createMcpResponse(
+        {
+          success: false,
+          error: "FROM_ENTITY_NOT_FOUND",
+          message: `Source entity '${from_entity}' not found. Create it first.`
+        },
+        `Source entity '${from_entity}' not found.`,
+        { includeSerializedStructuredContent: structured }
+      );
+      response.isError = true;
+      return response;
+    }
+    if (err.message === "TO_ENTITY_NOT_FOUND") {
+      const response = createMcpResponse(
+        {
+          success: false,
+          error: "TO_ENTITY_NOT_FOUND",
+          message: `Target entity '${to_entity}' not found. Create it first.`
+        },
+        `Target entity '${to_entity}' not found.`,
+        { includeSerializedStructuredContent: structured }
+      );
+      response.isError = true;
+      return response;
+    }
+    if (err.code === "SQLITE_CONSTRAINT_PRIMARYKEY") {
+      const response = createMcpResponse(
+        {
+          success: false,
+          error: "RELATION_ALREADY_EXISTS",
+          message: `Relation '${from_entity} \u2192[${relation_type}]\u2192 ${to_entity}' already exists.`
+        },
+        `Relation already exists.`,
+        { includeSerializedStructuredContent: structured }
+      );
+      response.isError = true;
+      return response;
+    }
+    if (err.code === "SQLITE_CONSTRAINT_FOREIGNKEY" || err.code === "SQLITE_CONSTRAINT") {
+      const response = createMcpResponse(
+        {
+          success: false,
+          error: "ENTITY_NOT_FOUND",
+          message: `Entity not found \u2014 cannot create relation.`
+        },
+        `Entity not found \u2014 cannot create relation.`,
+        { includeSerializedStructuredContent: structured }
+      );
+      response.isError = true;
+      return response;
+    }
+    logger.error("[Tool] create_relation failed", { error: String(error) });
+    throw error;
+  }
+  logger.info("[Tool] create_relation", {
+    repo: repo ?? "",
+    from: from_entity,
+    to: to_entity,
+    type: relation_type
+  });
+  return createMcpResponse(
+    {
+      success: true,
+      relation: { from_entity, to_entity, relation_type }
+    },
+    `Created relation '${from_entity} \u2014[${relation_type}]\u2192 ${to_entity}' in repo "${repo ?? ""}".`,
+    {
+      structuredContentPathHint: "relation",
+      includeSerializedStructuredContent: structured
+    }
+  );
+}
+async function handleDeleteRelation(params, db2, _vectors) {
+  const validated = DeleteRelationSchema.parse(params);
+  const { from_entity, to_entity, relation_type, owner: _owner, repo, structured } = validated;
+  let changes = 0;
+  try {
+    const txn = db2.db.transaction(() => {
+      const result = db2.db.prepare(`DELETE FROM relations WHERE from_entity = ? AND to_entity = ? AND relation_type = ?`).run(from_entity, to_entity, relation_type);
+      changes = result.changes;
+    });
+    txn();
+  } catch (error) {
+    logger.error("[Tool] delete_relation failed", { error: String(error) });
+    const response = createMcpResponse(
+      {
+        success: false,
+        error: "DELETE_FAILED",
+        message: `Failed to delete relation '${from_entity} \u2192[${relation_type}]\u2192 ${to_entity}'.`
+      },
+      `Failed to delete relation.`,
+      { includeSerializedStructuredContent: structured }
+    );
+    response.isError = true;
+    return response;
+  }
+  logger.info("[Tool] delete_relation", {
+    repo: repo ?? "",
+    from: from_entity,
+    to: to_entity,
+    type: relation_type,
+    changes
+  });
+  if (changes === 0) {
+    return createMcpResponse(
+      {
+        success: false,
+        error: "RELATION_NOT_FOUND",
+        message: `Relation '${from_entity} \u2192[${relation_type}]\u2192 ${to_entity}' not found.`
+      },
+      `Relation not found.`,
+      { includeSerializedStructuredContent: structured }
+    );
   }
-  const memoryId = args?.id || args?.memory_id || res?.data?.id;
-  if (typeof memoryId === "string" && /^[0-9a-f-]{36}$/i.test(memoryId) && toolName.startsWith("memory-")) {
-    uris.add(`memory://${memoryId}`);
+  return createMcpResponse(
+    {
+      success: true,
+      deletedCount: changes
+    },
+    `Deleted relation '${from_entity} \u2014[${relation_type}]\u2192 ${to_entity}'.`,
+    {
+      structuredContentPathHint: "deletedCount",
+      includeSerializedStructuredContent: structured
+    }
+  );
+}
+async function handleDeleteObservation(params, db2, _vectors) {
+  const validated = DeleteObservationSchema.parse(params);
+  const { id, owner: _owner, repo, structured } = validated;
+  let changes = 0;
+  try {
+    const txn = db2.db.transaction(() => {
+      const result = db2.db.prepare(`DELETE FROM observations WHERE id = ?`).run(id);
+      changes = result.changes;
+    });
+    txn();
+  } catch (error) {
+    logger.error("[Tool] delete_observation failed", { error: String(error) });
+    const response = createMcpResponse(
+      {
+        success: false,
+        error: "DELETE_FAILED",
+        message: `Failed to delete observation '${id}'.`
+      },
+      `Failed to delete observation '${id}'.`,
+      { includeSerializedStructuredContent: structured }
+    );
+    response.isError = true;
+    return response;
   }
-  const taskId = args?.id || args?.task_id || res?.structuredData?.id;
-  if (typeof taskId === "string" && /^[0-9a-f-]{36}$/i.test(taskId) && toolName.startsWith("task-")) {
-    uris.add(`task://${taskId}`);
+  logger.info("[Tool] delete_observation", { repo: repo ?? "", id, changes });
+  if (changes === 0) {
+    return createMcpResponse(
+      {
+        success: false,
+        error: "OBSERVATION_NOT_FOUND",
+        message: `Observation '${id}' not found.`
+      },
+      `Observation '${id}' not found.`,
+      { includeSerializedStructuredContent: structured }
+    );
   }
-  return [...uris];
+  return createMcpResponse(
+    {
+      success: true,
+      deletedCount: changes
+    },
+    `Deleted observation '${id}'.`,
+    {
+      structuredContentPathHint: "deletedCount",
+      includeSerializedStructuredContent: structured
+    }
+  );
 }
-function normalizeToolArguments(args, session2) {
-  if (!args || typeof args !== "object") {
-    return args;
+
+// src/mcp/tools/index.ts
+var WRITE_TOOLS = /* @__PURE__ */ new Set([
+  "memory-store",
+  "memory-acknowledge",
+  "memory-update",
+  "memory-delete",
+  "memory-bulk-delete",
+  "memory-summarize",
+  "handoff-create",
+  "handoff-update",
+  "standard-store",
+  "standard-update",
+  "standard-delete",
+  "task-create",
+  "task-create-interactive",
+  "task-claim",
+  "claim-release",
+  "task-update",
+  "task-delete",
+  "decision-log",
+  "session-summarize",
+  // Upstream alias tools (write)
+  "remember_fact",
+  "remember_facts",
+  "forget",
+  // Knowledge graph tools (write)
+  "create_entity",
+  "delete_entity",
+  "create_relation",
+  "delete_relation",
+  "delete_observation"
+]);
+function validateRootBoundPath(value, field, session) {
+  if (typeof value !== "string" || !path2.isAbsolute(value)) {
+    return;
   }
+  if (!isPathWithinRoots(value, session)) {
+    throw new Error(`${field} must stay within the active MCP roots`);
+  }
+}
+function normalizeToolArgs(args, session) {
   const anyArgs = args;
   const nextArgs = {
     ...anyArgs,
     scope: anyArgs.scope ? { ...anyArgs.scope } : void 0
   };
-  validateRootBoundPath(nextArgs.current_file_path, "current_file_path", session2);
-  validateRootBoundPath(nextArgs.doc_path, "doc_path", session2);
+  validateRootBoundPath(nextArgs.current_file_path, "current_file_path", session);
+  validateRootBoundPath(nextArgs.doc_path, "doc_path", session);
   if (!nextArgs.repo) {
-    nextArgs.repo = inferRepoFromSession(session2);
+    nextArgs.repo = inferRepoFromSession(session);
   }
   const scope = nextArgs.scope;
   if (scope && !scope.repo) {
-    scope.repo = nextArgs.repo ?? inferRepoFromSession(session2);
+    scope.repo = nextArgs.repo ?? inferRepoFromSession(session);
   }
   if (!nextArgs.owner) {
     const repoVal2 = nextArgs.repo || "";
     const parsed = parseRepoInput(repoVal2, void 0);
-    nextArgs.owner = parsed.owner || inferOwnerFromSession(session2) || "";
+    nextArgs.owner = parsed.owner || inferOwnerFromSession(session) || "";
     if (nextArgs.owner && !repoVal2.includes("/")) {
       logger.warn(
-        `[router] owner inferred from session (${nextArgs.owner}) \u2014 may be incorrect. Agents should pass explicit owner/repo.`
+        `[tools] owner inferred from session (${nextArgs.owner}) \u2014 may be incorrect. Agents should pass explicit owner/repo.`
       );
     }
   }
   if (scope && !scope.owner) {
     const repoVal2 = scope.repo || nextArgs.repo || "";
     const parsed = parseRepoInput(repoVal2, void 0);
-    scope.owner = parsed.owner || nextArgs.owner || inferOwnerFromSession(session2) || "";
+    scope.owner = parsed.owner || nextArgs.owner || inferOwnerFromSession(session) || "";
   }
-  const ownerVal = nextArgs.owner || inferOwnerFromSession(session2) || "";
-  const repoVal = nextArgs.repo || inferRepoFromSession(session2) || "";
+  const ownerVal = nextArgs.owner || inferOwnerFromSession(session) || "";
+  const repoVal = nextArgs.repo || inferRepoFromSession(session) || "";
   const memories = nextArgs.memories;
   if (memories) {
     for (const mem of memories) {
@@ -2855,7 +3489,7 @@ function normalizeToolArguments(args, session2) {
     }
   }
   if (typeof nextArgs.current_file_path === "string" && scope) {
-    const containingRoot = path2.isAbsolute(nextArgs.current_file_path) ? findContainingRoot(nextArgs.current_file_path, session2) : null;
+    const containingRoot = path2.isAbsolute(nextArgs.current_file_path) ? findContainingRoot(nextArgs.current_file_path, session) : null;
     if (containingRoot) {
       const relativePath = path2.relative(containingRoot, path2.resolve(nextArgs.current_file_path));
       const relativeFolder = path2.dirname(relativePath);
@@ -2866,24 +3500,835 @@ function normalizeToolArguments(args, session2) {
   }
   return nextArgs;
 }
-function validateRootBoundPath(value, field, session2) {
-  if (typeof value !== "string" || !path2.isAbsolute(value)) {
-    return;
-  }
-  if (!isPathWithinRoots(value, session2)) {
-    throw new Error(`${field} must stay within the active MCP roots`);
-  }
-}
-function normalizePageLimit(value, fallback) {
-  if (typeof value !== "number" || !Number.isInteger(value) || value <= 0) {
-    return Math.max(1, fallback);
-  }
-  return Math.min(value, 100);
-}
-
+function collectAffectedResourceUris(toolName, args, result) {
+  const res = result;
+  const repo = args?.repo || args?.scope?.repo || res?.data?.repo;
+  const uris = /* @__PURE__ */ new Set();
+  const touchesMemory = toolName.startsWith("memory-") || toolName === "task-update" || toolName === "task-delete";
+  const touchesTasks = toolName.startsWith("task-");
+  if (touchesMemory && repo) {
+    uris.add(`repository://${encodeURIComponent(repo)}/memories`);
+  }
+  if (touchesTasks && repo) {
+    uris.add(`repository://${encodeURIComponent(repo)}/tasks`);
+  }
+  if (repo) {
+    uris.add("repository://index");
+  }
+  const memoryId = args?.id || args?.memory_id || res?.data?.id;
+  if (typeof memoryId === "string" && /^[0-9a-f-]{36}$/i.test(memoryId) && toolName.startsWith("memory-")) {
+    uris.add(`memory://${memoryId}`);
+  }
+  const taskId = args?.id || args?.task_id || res?.structuredData?.id;
+  if (typeof taskId === "string" && /^[0-9a-f-]{36}$/i.test(taskId) && toolName.startsWith("task-")) {
+    uris.add(`task://${taskId}`);
+  }
+  return [...uris];
+}
+function logToolAction(toolName, args, result, db2, isWrite) {
+  try {
+    const actionType = toolName.split("-")[1] || toolName;
+    const res = result;
+    const sc = res?.structuredData;
+    const repo = args?.repo || args?.scope?.repo || "unknown";
+    const logOptions = {
+      query: args?.query || args?.title || args?.task_code || (toolName === "memory-recap" ? `Offset: ${args?.offset || 0}` : void 0),
+      response: res,
+      memoryId: args?.id || args?.memory_id || sc?.id,
+      taskId: args?.id || args?.task_id || sc?.id,
+      resultCount: Array.isArray(sc?.results) ? sc.results.length : sc?.count || 0
+    };
+    if (isWrite) {
+      db2.actions.logAction(actionType, "", repo, logOptions);
+    } else {
+      void db2.withWrite(() => {
+        db2.actions.logAction(actionType, "", repo, logOptions);
+      });
+    }
+  } catch (e) {
+    logger.error("Failed to log action", { toolName, error: String(e) });
+  }
+}
+function makePublicSchema() {
+  return z.object({}).catchall(z.unknown());
+}
+function toCallToolResult(response) {
+  const content = Array.isArray(response.content) ? response.content.map((item) => {
+    if (item.type === "image") {
+      return { type: "image", data: item.data, mimeType: item.mimeType };
+    }
+    if (item.type === "resource") {
+      return {
+        type: "text",
+        text: item.resource.text ?? JSON.stringify(item.resource)
+      };
+    }
+    return { type: "text", text: item.text ?? "" };
+  }) : [];
+  return {
+    content,
+    isError: response.isError ?? false,
+    ...response.structuredContent !== void 0 ? { structuredContent: response.structuredContent } : {}
+  };
+}
+function buildExecutors(session, options) {
+  const sampleMessage = options?.sampleMessage;
+  const elicit = options?.elicit;
+  return {
+    "memory-store": (args, db2, vectors2, _extra) => handleMemoryStore(args, db2, vectors2),
+    "memory-acknowledge": (args, db2, _vectors, _extra) => handleMemoryAcknowledge(args, db2),
+    "memory-update": (args, db2, vectors2, _extra) => handleMemoryUpdate(args, db2, vectors2),
+    "memory-recap": (args, db2, _vectors, _extra) => handleMemoryRecap(args, db2),
+    "memory-search": (args, db2, vectors2, _extra) => handleMemorySearch(args, db2, vectors2),
+    "memory-summarize": (args, db2, _vectors, _extra) => handleMemorySummarize(args, db2),
+    "memory-synthesize": (args, db2, vectors2, _extra) => handleMemorySynthesize(args, db2, vectors2, {
+      session,
+      sampleMessage,
+      elicit
+    }),
+    "memory-delete": (args, db2, vectors2, extra) => handleMemoryDelete(args, db2, vectors2, extra?.onProgress),
+    "memory-detail": (args, db2, _vectors, _extra) => handleMemoryDetail(args, db2),
+    "handoff-create": (args, db2, _vectors, _extra) => handleHandoffCreate(args, db2),
+    "handoff-list": (args, db2, _vectors, _extra) => handleHandoffList(args, db2),
+    "handoff-update": (args, db2, _vectors, _extra) => handleHandoffUpdate(args, db2),
+    "task-claim": (args, db2, _vectors, _extra) => handleTaskClaim(args, db2),
+    "claim-list": (args, db2, _vectors, _extra) => handleClaimList(args, db2),
+    "claim-release": (args, db2, _vectors, _extra) => handleClaimRelease(args, db2),
+    "standard-store": (args, db2, vectors2, _extra) => handleStandardStore(args, db2, vectors2),
+    "standard-update": (args, db2, vectors2, _extra) => handleStandardUpdate(args, db2, vectors2),
+    "standard-detail": (args, db2, _vectors, _extra) => handleStandardDetail(args, db2),
+    "standard-delete": (args, db2, vectors2, _extra) => handleStandardDelete(args, db2, vectors2),
+    "standard-search": (args, db2, vectors2, _extra) => handleStandardSearch(args, db2, vectors2),
+    "task-create": (args, db2, _vectors, _extra) => handleTaskCreate(args, db2),
+    "task-create-interactive": (args, db2, _vectors, _extra) => handleTaskCreateInteractive(args, db2, { session, elicit }),
+    "task-update": (args, db2, vectors2, _extra) => handleTaskUpdate(args, db2, vectors2),
+    "task-delete": (args, db2, _vectors, _extra) => handleTaskDelete(args, db2),
+    "task-list": (args, db2, _vectors, _extra) => handleTaskList(args, db2),
+    "task-search": (args, db2, _vectors, _extra) => handleTaskSearch(args, db2),
+    "task-detail": (args, db2, _vectors, _extra) => handleTaskGet(args, db2),
+    "agent-context": (args, db2, vectors2, _extra) => handleAgentContext(args, db2, vectors2),
+    "decision-log": (args, db2, vectors2, _extra) => handleDecisionLog(args, db2, vectors2),
+    "session-summarize": (args, db2, vectors2, _extra) => handleSessionSummarize(args, db2, vectors2),
+    // Upstream alias tools
+    remember_fact: (args, db2, vectors2, _extra) => handleMemoryStore(args, db2, vectors2),
+    remember_facts: (args, db2, vectors2, _extra) => handleMemoryStore(args, db2, vectors2),
+    recall: (args, db2, vectors2, _extra) => handleMemorySearch(args, db2, vectors2),
+    forget: (args, db2, vectors2, _extra) => handleMemoryDelete(args, db2, vectors2),
+    // Knowledge graph tools
+    create_entity: (args, db2, _vectors, _extra) => handleCreateEntity(args, db2, _vectors),
+    delete_entity: (args, db2, _vectors, _extra) => handleDeleteEntity(args, db2, _vectors),
+    create_relation: (args, db2, _vectors, _extra) => handleCreateRelation(args, db2, _vectors),
+    delete_relation: (args, db2, _vectors, _extra) => handleDeleteRelation(args, db2, _vectors),
+    delete_observation: (args, db2, _vectors, _extra) => handleDeleteObservation(args, db2, _vectors)
+  };
+}
+function registerAllTools(server, store, vectors2, session, options) {
+  const executors = buildExecutors(session, options);
+  const definitions = TOOL_DEFINITIONS.filter((def) => {
+    if (def.name === "memory-synthesize" && !session.supportsSampling) {
+      return false;
+    }
+    if (def.name === "task-create-interactive" && !session.supportsElicitationForm) {
+      return false;
+    }
+    return true;
+  });
+  const publicSchema = makePublicSchema();
+  for (const def of definitions) {
+    const toolName = def.name;
+    const executor = executors[toolName];
+    if (!executor) {
+      logger.warn(`[registerAllTools] No executor for tool: ${toolName} \u2014 skipping`);
+      continue;
+    }
+    const isWrite = WRITE_TOOLS.has(toolName);
+    server.registerTool(
+      toolName,
+      {
+        description: def.description ?? "",
+        inputSchema: publicSchema
+      },
+      async (args, extra) => {
+        const rawArgs = args ?? {};
+        const normalizedArgs = normalizeToolArgs(rawArgs, session);
+        logger.info(`[Tool] ${toolName}`, {
+          repo: normalizedArgs?.repo || "unknown",
+          write: isWrite
+        });
+        const progressToken = extra?.mcpReq?._meta?.progressToken;
+        const executorExtra = {
+          onProgress: progressToken !== void 0 ? (progress, total) => {
+            void extra.mcpReq.notify({
+              method: "notifications/progress",
+              params: { progressToken, progress, total }
+            }).catch(() => {
+            });
+          } : void 0,
+          signal: extra?.mcpReq?.signal
+        };
+        const executeFn = () => executor(normalizedArgs, store, vectors2, executorExtra);
+        let result;
+        try {
+          if (isWrite) {
+            result = await store.withWrite(executeFn);
+          } else {
+            result = await executeFn();
+          }
+        } catch (err) {
+          logger.error(`[Tool] ${toolName} failed`, { error: String(err) });
+          return {
+            content: [{ type: "text", text: `Error: ${err.message}` }],
+            isError: true
+          };
+        }
+        logger.info(`[Tool] ${toolName} result`, {
+          repo: normalizedArgs?.repo || "unknown"
+        });
+        logToolAction(toolName, normalizedArgs, result, store, isWrite);
+        const affectedUris = collectAffectedResourceUris(toolName, normalizedArgs, result);
+        if (affectedUris.length > 0) {
+          options?.onResourcesMutated?.(affectedUris);
+        }
+        return toCallToolResult(result);
+      }
+    );
+    logger.debug(`[registerAllTools] Registered tool: ${toolName}`);
+  }
+}
+
+// src/mcp/resources/sdk-index.ts
+import { ResourceTemplate } from "@modelcontextprotocol/server";
+function registerAllResources(server, store, _vectors, session) {
+  const db2 = store;
+  function getRepos() {
+    const values = /* @__PURE__ */ new Set();
+    for (const repo of db2.system.listRepos()) {
+      values.add(repo);
+    }
+    if (session.roots.length > 0) {
+      for (const root of session.roots) {
+        const name = root.name || root.uri.split("/").filter(Boolean).pop() || "";
+        if (name) values.add(name);
+      }
+    }
+    return [...values].sort((a, b) => a.localeCompare(b));
+  }
+  function getTags() {
+    const values = /* @__PURE__ */ new Set();
+    const memories = db2.memories.getRecentMemories("", "", 1e3);
+    for (const memory of memories) {
+      for (const tag of memory.tags || []) {
+        if (typeof tag === "string" && tag.trim()) {
+          values.add(tag.trim());
+        }
+      }
+    }
+    return [...values].sort((a, b) => a.localeCompare(b));
+  }
+  function _deriveLastModified(values) {
+    const normalized = values.filter((v) => typeof v === "string" && v.length > 0);
+    return normalized.sort().at(-1) ?? (/* @__PURE__ */ new Date()).toISOString();
+  }
+  server.registerResource(
+    "repository-index",
+    "repository://index",
+    {
+      title: "Repository Index",
+      description: "List of all known repositories with memory/task counts and last activity",
+      mimeType: "application/json"
+    },
+    async (uri, _extra) => {
+      const repos2 = db2.system.listRepoNavigation();
+      const payload = JSON.stringify(repos2, null, 2);
+      return {
+        contents: [
+          {
+            uri: uri.toString(),
+            mimeType: "application/json",
+            text: payload
+          }
+        ]
+      };
+    }
+  );
+  server.registerResource(
+    "session-roots",
+    "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"
+    },
+    async (uri, _extra) => {
+      const payload = JSON.stringify({ roots: session?.roots ?? [] }, null, 2);
+      return {
+        contents: [
+          {
+            uri: uri.toString(),
+            mimeType: "application/json",
+            text: payload
+          }
+        ]
+      };
+    }
+  );
+  const repos = getRepos();
+  const tags = getTags();
+  server.registerResource(
+    "repository-memories",
+    new ResourceTemplate("repository://{name}/memories{?search,type,tag,limit,offset}", {
+      list: void 0,
+      complete: {
+        name: async (value) => rankCompletionValues(repos, value),
+        tag: async (value) => rankCompletionValues(tags, value)
+      }
+    }),
+    {
+      title: "Repository Memories",
+      description: "All active memory entries for a specific repository, optionally filtered by search, type, or tag",
+      mimeType: "application/json"
+    },
+    async (uri, variables, _extra) => {
+      const name = variables.name;
+      const search = variables.search || "";
+      const type = variables.type;
+      const tag = variables.tag;
+      const result = db2.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: uri.toString(),
+            mimeType: "application/json",
+            text: payload
+          }
+        ]
+      };
+    }
+  );
+  server.registerResource(
+    "memory-detail",
+    new ResourceTemplate("memory://{id}", { list: void 0 }),
+    {
+      title: "Memory Detail",
+      description: "Full content and statistics for a specific memory UUID",
+      mimeType: "application/json"
+    },
+    async (uri, variables, _extra) => {
+      const id = variables.id;
+      const entry = db2.memories.getByIdWithStats(id);
+      if (!entry) {
+        throw new Error(`Memory with ID ${id} not found.`);
+      }
+      const payload = JSON.stringify(entry, null, 2);
+      return {
+        contents: [
+          {
+            uri: uri.toString(),
+            mimeType: "application/json",
+            text: payload
+          }
+        ]
+      };
+    }
+  );
+  server.registerResource(
+    "repository-tasks",
+    new ResourceTemplate("repository://{name}/tasks{?status,priority,limit,offset}", {
+      list: void 0,
+      complete: {
+        name: async (value) => rankCompletionValues(repos, value)
+      }
+    }),
+    {
+      title: "Repository Tasks",
+      description: "All active tasks for a specific repository, optionally filtered by status or priority",
+      mimeType: "application/json"
+    },
+    async (uri, variables, _extra) => {
+      const name = variables.name;
+      const status = variables.status;
+      const priority = variables.priority;
+      const owner = parseRepoInput(name).owner;
+      let tasks;
+      if (status && status !== "all") {
+        const statuses = status.split(",").map((s) => s.trim());
+        tasks = db2.tasks.getTasksByMultipleStatuses(owner, name, statuses);
+      } else {
+        tasks = db2.tasks.getTasksByMultipleStatuses(owner, name, ["backlog", "pending", "in_progress", "blocked"]);
+      }
+      if (priority) {
+        const p = Number(priority);
+        if (!isNaN(p)) {
+          tasks = tasks.filter((t) => t.priority === p);
+        }
+      }
+      const payload = JSON.stringify(tasks, null, 2);
+      return {
+        contents: [
+          {
+            uri: uri.toString(),
+            mimeType: "application/json",
+            text: payload
+          }
+        ]
+      };
+    }
+  );
+  server.registerResource(
+    "task-detail",
+    new ResourceTemplate("task://{id}", { list: void 0 }),
+    {
+      title: "Task Detail",
+      description: "Full content and comments for a specific task UUID",
+      mimeType: "application/json"
+    },
+    async (uri, variables, _extra) => {
+      const id = variables.id;
+      const task = db2.tasks.getTaskById(id);
+      if (!task) {
+        throw new Error(`Task with ID ${id} not found.`);
+      }
+      const payload = JSON.stringify(task, null, 2);
+      return {
+        contents: [
+          {
+            uri: uri.toString(),
+            mimeType: "application/json",
+            text: payload
+          }
+        ]
+      };
+    }
+  );
+  server.registerResource(
+    "repository-summary",
+    new ResourceTemplate("repository://{name}/summary", {
+      list: void 0,
+      complete: {
+        name: async (value) => rankCompletionValues(repos, value)
+      }
+    }),
+    {
+      title: "Repository Summary",
+      description: "High-level architectural summary for a repository",
+      mimeType: "text/plain"
+    },
+    async (uri, variables, _extra) => {
+      const name = variables.name;
+      const summary = db2.summaries.getSummary("", name);
+      const text = summary?.summary || `No summary available for repository: ${name}`;
+      return {
+        contents: [
+          {
+            uri: uri.toString(),
+            mimeType: "text/plain",
+            text
+          }
+        ]
+      };
+    }
+  );
+  server.registerResource(
+    "repository-actions",
+    new ResourceTemplate("repository://{name}/actions{?limit,offset}", {
+      list: void 0,
+      complete: {
+        name: async (value) => rankCompletionValues(repos, value)
+      }
+    }),
+    {
+      title: "Repository Actions",
+      description: "Audit log of agent tool actions scoped to a repository",
+      mimeType: "application/json"
+    },
+    async (uri, variables, _extra) => {
+      const name = variables.name;
+      const actions = db2.actions.getRecentActions("", name, 100);
+      const payload = JSON.stringify(actions, null, 2);
+      return {
+        contents: [
+          {
+            uri: uri.toString(),
+            mimeType: "application/json",
+            text: payload
+          }
+        ]
+      };
+    }
+  );
+  server.registerResource(
+    "action-detail",
+    new ResourceTemplate("action://{id}", { list: void 0 }),
+    {
+      title: "Action Detail",
+      description: "Full details of a specific audit log entry by integer ID",
+      mimeType: "application/json"
+    },
+    async (uri, variables, _extra) => {
+      const idStr = variables.id;
+      const id = Number(idStr);
+      const action = db2.actions.getActionById(id);
+      if (!action) {
+        throw new Error(`Action with ID ${id} not found.`);
+      }
+      const payload = JSON.stringify(action, null, 2);
+      return {
+        contents: [
+          {
+            uri: uri.toString(),
+            mimeType: "application/json",
+            text: payload
+          }
+        ]
+      };
+    }
+  );
+}
+
+// src/mcp/prompts/sdk-index.ts
+function registerAllPrompts(server, store, _vectors, session) {
+  const _db = store;
+  const promptNames = listPromptFiles();
+  for (const name of promptNames) {
+    let loaded;
+    try {
+      loaded = loadPromptFromMarkdown(name);
+    } catch (e) {
+      logger.warn(`[prompts] Failed to load prompt ${name}: ${e}`);
+      continue;
+    }
+    server.registerPrompt(
+      loaded.name,
+      {
+        title: loaded.name,
+        description: loaded.description
+      },
+      async (_args, _extra) => {
+        const inferredRepo = inferRepoFromSession(session);
+        const inferredOwner = inferOwnerFromSession(session);
+        let text = loaded.content;
+        text = text.replace(/\{\{current_repo\}\}/g, inferredRepo || "unknown-repo");
+        text = text.replace(/\{\{current_owner\}\}/g, inferredOwner || "unknown-owner");
+        return {
+          description: loaded.description,
+          messages: [
+            {
+              role: "user",
+              content: {
+                type: "text",
+                text
+              }
+            }
+          ],
+          ...loaded.agent ? { _meta: { agent: loaded.agent } } : {}
+        };
+      }
+    );
+    logger.debug(`[prompts] Registered prompt: ${loaded.name}`);
+  }
+}
+
+// src/mcp/completion.ts
+import fs from "fs";
+import path3 from "path";
+var MAX_COMPLETION_VALUES = 100;
+var MAX_FILE_SCAN_RESULTS = 300;
+async function complete(params, db2, session) {
+  const refType = params?.ref?.type;
+  const argumentName = typeof params?.argument?.name === "string" ? params.argument.name : "";
+  const argumentValue = typeof params?.argument?.value === "string" ? params.argument.value : "";
+  const contextArguments = params?.context?.arguments ?? {};
+  if (!refType || !argumentName) {
+    throw invalidCompletionParams("completion/complete requires ref.type and argument.name");
+  }
+  const dataSources = {
+    repos: getSuggestedRepos(db2, session),
+    tags: getSuggestedTags(db2),
+    filePaths: getSuggestedFilePaths(session),
+    tasks: getSuggestedTasks(db2, session, contextArguments)
+  };
+  if (refType === "ref/prompt") {
+    const promptName = typeof params?.ref?.name === "string" ? params.ref.name : "";
+    if (!promptName) {
+      throw invalidCompletionParams("Prompt completion requires ref.name");
+    }
+    return {
+      completion: buildCompletionResult(
+        await completePromptArgument(promptName, argumentName, argumentValue, contextArguments, dataSources)
+      )
+    };
+  }
+  if (refType === "ref/resource") {
+    const resourceUri = typeof params?.ref?.uri === "string" ? params.ref.uri : "";
+    if (!resourceUri) {
+      throw invalidCompletionParams("Resource completion requires ref.uri");
+    }
+    return {
+      completion: buildCompletionResult(
+        completeResourceArgument(resourceUri, argumentName, argumentValue, contextArguments, dataSources)
+      )
+    };
+  }
+  throw invalidCompletionParams(`Unsupported completion ref type: ${refType}`);
+}
+function buildCompletionResult(values) {
+  const capped = values.slice(0, MAX_COMPLETION_VALUES);
+  return {
+    values: capped,
+    total: values.length,
+    hasMore: values.length > capped.length
+  };
+}
+function getSuggestedRepos(db2, session) {
+  const values = /* @__PURE__ */ new Set();
+  const inferredRepo = inferRepoFromSession(session);
+  if (inferredRepo) values.add(inferredRepo);
+  for (const rootPath of getFilesystemRoots(session)) {
+    values.add(path3.basename(rootPath));
+  }
+  for (const repo of db2.system.listRepos()) {
+    values.add(repo);
+  }
+  return [...values].sort((a, b) => a.localeCompare(b));
+}
+function getSuggestedTags(db2) {
+  const values = /* @__PURE__ */ new Set();
+  const memories = db2.memories.getRecentMemories("", "", 1e3);
+  for (const memory of memories) {
+    for (const tag of memory.tags || []) {
+      if (typeof tag === "string" && tag.trim()) {
+        values.add(tag.trim());
+      }
+    }
+  }
+  return [...values].sort((a, b) => a.localeCompare(b));
+}
+function getSuggestedTasks(db2, session, contextArguments) {
+  const repo = typeof contextArguments.repo === "string" && contextArguments.repo.trim() ? contextArguments.repo.trim() : inferRepoFromSession(session);
+  if (!repo) return [];
+  return db2.tasks.getTasksByRepo("", repo, void 0, 100).map((task) => ({
+    id: task.id,
+    task_code: task.task_code,
+    title: task.title
+  }));
+}
+function getSuggestedFilePaths(session) {
+  const roots = getFilesystemRoots(session);
+  const results = [];
+  for (const rootPath of roots) {
+    collectFiles(rootPath, rootPath, results);
+    if (results.length >= MAX_FILE_SCAN_RESULTS) break;
+  }
+  return results.sort((a, b) => a.localeCompare(b));
+}
+function collectFiles(rootPath, currentPath, results) {
+  if (results.length >= MAX_FILE_SCAN_RESULTS) return;
+  let entries;
+  try {
+    entries = fs.readdirSync(currentPath, { withFileTypes: true });
+  } catch {
+    return;
+  }
+  for (const entry of entries) {
+    if (results.length >= MAX_FILE_SCAN_RESULTS) return;
+    if (entry.name === "node_modules" || entry.name === ".git" || entry.name === "dist") continue;
+    const fullPath = path3.join(currentPath, entry.name);
+    if (entry.isDirectory()) {
+      collectFiles(rootPath, fullPath, results);
+      continue;
+    }
+    if (!entry.isFile()) continue;
+    results.push(path3.relative(rootPath, fullPath) || entry.name);
+  }
+}
+function invalidCompletionParams(message) {
+  const error = new Error(message);
+  error.code = -32602;
+  return error;
+}
+
+// src/mcp/mcp-server.ts
+function createMcpServer(store, vectors2, session) {
+  const instructions = loadServerInstructions();
+  const ctx = session ?? createSessionContext();
+  const server = new McpServer2(
+    {
+      name: "local-memory-mcp",
+      version: CAPABILITIES.serverInfo.version
+    },
+    {
+      instructions,
+      capabilities: CAPABILITIES.capabilities
+    }
+  );
+  registerAllTools(server, store, vectors2, ctx);
+  registerAllResources(server, store, vectors2, ctx);
+  registerAllPrompts(server, store, vectors2, ctx);
+  const _removeLogSink = addLogSink((payload) => {
+    void server.sendLoggingMessage({
+      level: payload.level,
+      data: payload.data,
+      logger: payload.logger
+    }).catch(() => {
+    });
+  });
+  server.server.setRequestHandler("completion/complete", async (request, _serverCtx) => {
+    const params = request.params;
+    const completionResult = await complete(
+      {
+        ref: {
+          type: params.ref.type,
+          name: params.ref.name,
+          uri: params.ref.uri
+        },
+        argument: {
+          name: params.argument.name,
+          value: params.argument.value
+        },
+        context: {
+          arguments: params.context?.arguments
+        }
+      },
+      store,
+      ctx
+    );
+    return {
+      completion: completionResult.completion
+    };
+  });
+  return server;
+}
+
+// src/mcp/services/soul-maintenance.ts
+function applyDecay(db2, options) {
+  const { immunizedTags = [], decayAfterDays = 7, decayRate = 0.5, archiveThreshold = 1 } = options ?? {};
+  const now = (/* @__PURE__ */ new Date()).toISOString();
+  const cutoff = new Date(Date.now() - decayAfterDays * 24 * 60 * 60 * 1e3).toISOString();
+  const rows = db2.prepare(
+    `SELECT id, importance, tags FROM memories
+       WHERE status = 'active'
+         AND (last_used_at IS NULL OR last_used_at < ?)`
+  ).all(cutoff);
+  if (rows.length === 0) {
+    logger.debug("[SoulMaintenance] No memories eligible for decay");
+    return { decayed: 0, archived: 0, immunizedSkipped: 0 };
+  }
+  let decayed = 0;
+  let archivedCount = 0;
+  let immunizedSkipped = 0;
+  const toDecay = [];
+  const toArchive = [];
+  for (const row of rows) {
+    let tags = [];
+    if (row.tags) {
+      try {
+        tags = JSON.parse(row.tags);
+      } catch {
+        tags = [];
+      }
+    }
+    if (immunizedTags.length > 0 && tags.some((t) => immunizedTags.includes(t))) {
+      immunizedSkipped++;
+      continue;
+    }
+    const newImportance = Math.max(1, Math.floor(row.importance - decayRate));
+    toDecay.push({ id: row.id, newImportance });
+    if (newImportance < archiveThreshold) {
+      toArchive.push(row.id);
+    }
+  }
+  if (toDecay.length > 0) {
+    const updateStmt = db2.prepare("UPDATE memories SET importance = ?, updated_at = ? WHERE id = ?");
+    for (const item of toDecay) {
+      updateStmt.run(item.newImportance, now, item.id);
+    }
+    decayed = toDecay.length;
+  }
+  if (toArchive.length > 0) {
+    const placeholders = toArchive.map(() => "?").join(",");
+    const archiveResult = db2.prepare(`UPDATE memories SET status = 'archived', updated_at = ? WHERE id IN (${placeholders})`).run(now, ...toArchive);
+    archivedCount = archiveResult.changes;
+  }
+  if (decayed > 0 || archivedCount > 0 || immunizedSkipped > 0) {
+    logger.info("[SoulMaintenance] Decay cycle complete", {
+      decayed,
+      archived: archivedCount,
+      immunizedSkipped
+    });
+  }
+  return { decayed, archived: archivedCount, immunizedSkipped };
+}
+
+// src/mcp/services/maintenance-job.ts
+var MAINTENANCE_OWNER = "__soul__";
+var MAINTENANCE_REPO = "__maintenance__";
+var MAINTENANCE_INTERVAL_MS = 24 * 60 * 60 * 1e3;
+function wasMaintenanceRunRecent(db2) {
+  try {
+    const row = db2.db.prepare("SELECT updated_at FROM memory_summary WHERE owner = ? AND repo = ?").get(MAINTENANCE_OWNER, MAINTENANCE_REPO);
+    if (!row?.updated_at) return false;
+    const lastRun = new Date(row.updated_at).getTime();
+    return Date.now() - lastRun < MAINTENANCE_INTERVAL_MS;
+  } catch (err) {
+    logger.warn("[MaintenanceJob] Failed to check last maintenance time", { error: String(err) });
+    return false;
+  }
+}
+function recordMaintenanceRun(db2) {
+  const now = (/* @__PURE__ */ new Date()).toISOString();
+  try {
+    db2.db.prepare(
+      `INSERT INTO memory_summary (owner, repo, summary, updated_at)
+         VALUES (?, ?, ?, ?)
+         ON CONFLICT(owner, repo) DO UPDATE SET summary = excluded.summary, updated_at = excluded.updated_at`
+    ).run(MAINTENANCE_OWNER, MAINTENANCE_REPO, now, now);
+  } catch (err) {
+    logger.warn("[MaintenanceJob] Failed to record maintenance run time", { error: String(err) });
+  }
+}
+async function runStartupMaintenance(db2, decayOptions) {
+  if (wasMaintenanceRunRecent(db2)) {
+    logger.info("[MaintenanceJob] Skipping \u2014 maintenance already ran within the last 24 hours");
+    return {
+      decay: { decayed: 0, archived: 0, immunizedSkipped: 0 },
+      expiredArchived: 0,
+      lowScoreArchived: 0,
+      skipped: true
+    };
+  }
+  logger.info("[MaintenanceJob] Starting startup maintenance sweep");
+  const decay = applyDecay(db2.db, decayOptions);
+  const expiredArchived = db2.memoryArchives.archiveExpiredMemories(true);
+  const lowScoreArchived = db2.memoryArchives.archiveLowScoreMemories(true);
+  recordMaintenanceRun(db2);
+  const totalArchived = (expiredArchived || 0) + (lowScoreArchived || 0) + (decay.archived || 0);
+  logger.info("[MaintenanceJob] Startup maintenance complete", {
+    decayed: decay.decayed,
+    immunizedSkipped: decay.immunizedSkipped,
+    expiredArchived,
+    lowScoreArchived,
+    decayArchived: decay.archived,
+    totalArchived
+  });
+  return {
+    decay,
+    expiredArchived: expiredArchived || 0,
+    lowScoreArchived: lowScoreArchived || 0,
+    skipped: false
+  };
+}
+
 // src/mcp/server.ts
 import fs2 from "fs";
-import path3 from "path";
+import path4 from "path";
 process.env.MCP_SERVER = "true";
 if (process.argv.includes("doctor")) {
   process.stderr.write("\n\u{1F3E5} MCP Local Memory - System Diagnosis\n\n");
@@ -2915,19 +4360,19 @@ if (process.argv.includes("doctor")) {
 }
 var db = await SQLiteStore.create();
 var vectors = new RealVectorStore(db);
-addLogSink(createFileSink(path3.dirname(db.getDbPath())));
+addLogSink(createFileSink(path4.dirname(db.getDbPath())));
 logger.info("[Server] startup", { pid: process.pid, version: CAPABILITIES.serverInfo.version, db: db.getDbPath() });
 vectors.initialize().catch((err) => {
   logger.warn("[Server] Initial vector model loading failed. Will retry on first use.", { error: String(err) });
 });
-var expiredArchived = db.memoryArchives.archiveExpiredMemories();
-var lowScoreArchived = db.memoryArchives.archiveLowScoreMemories();
-var totalArchived = (expiredArchived || 0) + (lowScoreArchived || 0);
-if (totalArchived > 0) {
-  logger.info(
-    `[Server] Archived ${totalArchived} memories (expired: ${expiredArchived}, low-score: ${lowScoreArchived}) on startup.`
-  );
-}
+runStartupMaintenance(db).then((result) => {
+  if (!result.skipped) {
+    logger.info("[Server] Startup maintenance complete", {
+      decayed: result.decay.decayed,
+      archived: result.expiredArchived + result.lowScoreArchived + result.decay.archived
+    });
+  }
+});
 process.stdout.on("error", (err) => {
   if (err.code === "EPIPE") return;
   logger.error("stdout error", { error: String(err) });
@@ -2936,265 +4381,12 @@ process.stderr.on("error", (err) => {
   if (err.code === "EPIPE") return;
   logger.error("stderr error", { error: String(err) });
 });
-var session = createSessionContext();
-var resourceSubscriptions = /* @__PURE__ */ new Set();
-var logNotificationsEnabled = false;
-var handleMethod = createRouter(db, vectors, {
-  getSessionContext: () => session,
-  sampleMessage: (params) => requestClient("sampling/createMessage", params),
-  elicit: (params) => requestClient("elicitation/create", params),
-  onResourcesMutated: (uris) => notifyUpdatedResources(uris)
-});
-addLogSink((payload) => {
-  if (!logNotificationsEnabled) {
-    return;
-  }
-  reply({
-    jsonrpc: "2.0",
-    method: "notifications/message",
-    params: payload
-  });
-});
-process.on("SIGINT", () => {
-  logger.info("[Server] shutdown", { signal: "SIGINT", pid: process.pid });
-  for (const pending of pendingClientRequests.values()) {
-    pending.reject(new Error("Server stopped"));
-  }
-  pendingClientRequests.clear();
+var shutdown = async (signal) => {
+  logger.info("[Server] shutdown", { signal, pid: process.pid });
+  await handle?.close();
   db.close();
   process.exit(0);
-});
-process.on("SIGTERM", () => {
-  logger.info("[Server] shutdown", { signal: "SIGTERM", pid: process.pid });
-  for (const pending of pendingClientRequests.values()) {
-    pending.reject(new Error("Server stopped"));
-  }
-  pendingClientRequests.clear();
-  db.close();
-  process.exit(0);
-});
-var rl = readline.createInterface({
-  input: process.stdin,
-  output: process.stdout,
-  terminal: false
-});
-function reply(payload) {
-  try {
-    process.stdout.write(JSON.stringify(payload) + "\n");
-  } catch (err) {
-    logger.error("Reply error", { error: String(err) });
-  }
-}
-var isInitialized = false;
-var activeRequests = /* @__PURE__ */ new Map();
-var pendingClientRequests = /* @__PURE__ */ new Map();
-var outgoingRequestId = 0;
-function requestClient(method, params = {}) {
-  const id = `server:${++outgoingRequestId}`;
-  reply({
-    jsonrpc: "2.0",
-    id,
-    method,
-    params
-  });
-  return new Promise((resolve, reject) => {
-    pendingClientRequests.set(id, { method, resolve, reject });
-  });
-}
-async function refreshRoots(trigger) {
-  if (!session.supportsRoots) return;
-  try {
-    const result = await requestClient("roots/list");
-    const changed = updateSessionRoots(session, extractRootsFromResult(result));
-    logger.info("[Server] Refreshed client roots", {
-      trigger,
-      count: session.roots.length,
-      changed
-    });
-    if (changed) {
-      reply({
-        jsonrpc: "2.0",
-        method: "notifications/resources/list_changed"
-      });
-      reply({
-        jsonrpc: "2.0",
-        method: "notifications/prompts/list_changed"
-      });
-    }
-  } catch (error) {
-    logger.warn("[Server] Failed to refresh client roots", {
-      trigger,
-      error: String(error)
-    });
-  }
-}
-function notifyUpdatedResources(uris) {
-  const seen = /* @__PURE__ */ new Set();
-  for (const uri of uris) {
-    if (seen.has(uri)) continue;
-    seen.add(uri);
-    if (!resourceSubscriptions.has(uri)) {
-      continue;
-    }
-    reply({
-      jsonrpc: "2.0",
-      method: "notifications/resources/updated",
-      params: { uri }
-    });
-  }
-}
-rl.on("line", async (line) => {
-  if (!line.trim()) return;
-  let msg;
-  try {
-    msg = JSON.parse(line);
-  } catch {
-    return;
-  }
-  const { id, method, params } = msg;
-  const isNotification = id === void 0 || id === null;
-  if ((method === void 0 || method === null) && id !== void 0 && pendingClientRequests.has(id)) {
-    const pending = pendingClientRequests.get(id);
-    pendingClientRequests.delete(id);
-    if (msg.error) {
-      pending.reject(new Error(msg.error.message || `Client request failed: ${pending.method}`));
-    } else {
-      pending.resolve(msg.result);
-    }
-    return;
-  }
-  if (method === "initialize" && !isNotification) {
-    updateSessionFromInitialize(session, params);
-    reply({
-      jsonrpc: "2.0",
-      id,
-      result: {
-        protocolVersion: MCP_PROTOCOL_VERSION,
-        serverInfo: CAPABILITIES.serverInfo,
-        capabilities: CAPABILITIES.capabilities
-      }
-    });
-    return;
-  }
-  if (isNotification) {
-    if (method === "notifications/initialized") {
-      isInitialized = true;
-      logNotificationsEnabled = true;
-      logger.debug("[Server] Client initialized");
-      void refreshRoots("initialized");
-    } else if (method === "notifications/roots/list_changed") {
-      logger.debug("[Server] Client roots changed");
-      void refreshRoots("roots/list_changed");
-    } else if (method === "notifications/cancelled") {
-      const requestId = params?.requestId;
-      if (requestId !== void 0 && activeRequests.has(requestId)) {
-        activeRequests.get(requestId).abort();
-        activeRequests.delete(requestId);
-        logger.debug(`[Server] Request ${requestId} cancelled`);
-      } else {
-        logger.debug(`[Server] Cancelled notification for unknown or completed request ${requestId}`);
-      }
-    }
-    return;
-  }
-  if (method === "ping") {
-    reply({
-      jsonrpc: "2.0",
-      id,
-      result: {}
-    });
-    return;
-  }
-  if (method === "resources/subscribe") {
-    const uri = typeof params?.uri === "string" ? params.uri : "";
-    if (!uri) {
-      reply({
-        jsonrpc: "2.0",
-        id,
-        error: {
-          code: -32602,
-          message: "resources/subscribe requires a uri"
-        }
-      });
-      return;
-    }
-    resourceSubscriptions.add(uri);
-    reply({
-      jsonrpc: "2.0",
-      id,
-      result: {}
-    });
-    return;
-  }
-  if (method === "resources/unsubscribe") {
-    const uri = typeof params?.uri === "string" ? params.uri : "";
-    if (!uri) {
-      reply({
-        jsonrpc: "2.0",
-        id,
-        error: {
-          code: -32602,
-          message: "resources/unsubscribe requires a uri"
-        }
-      });
-      return;
-    }
-    resourceSubscriptions.delete(uri);
-    reply({
-      jsonrpc: "2.0",
-      id,
-      result: {}
-    });
-    return;
-  }
-  if (!isInitialized) {
-    reply({
-      jsonrpc: "2.0",
-      id,
-      error: {
-        code: -32002,
-        message: "Server is not fully initialized yet. Please send notifications/initialized."
-      }
-    });
-    return;
-  }
-  const abortController = new AbortController();
-  activeRequests.set(id, abortController);
-  const progressToken = params?._meta?.progressToken;
-  const onProgress = progressToken !== void 0 ? (progress, total) => {
-    reply({
-      jsonrpc: "2.0",
-      method: "notifications/progress",
-      params: {
-        progressToken,
-        progress,
-        total
-      }
-    });
-  } : void 0;
-  try {
-    const result = await handleMethod(method, params, abortController.signal, onProgress);
-    if (!abortController.signal.aborted) {
-      reply({
-        jsonrpc: "2.0",
-        id,
-        result
-      });
-    }
-  } catch (err) {
-    if (!abortController.signal.aborted) {
-      const error = err;
-      logger.error("Method handler error", { method, id, message: error.message });
-      reply({
-        jsonrpc: "2.0",
-        id,
-        error: {
-          code: typeof error?.code === "number" ? error.code : -32603,
-          message: error.message || "Internal error"
-        }
-      });
-    }
-  } finally {
-    activeRequests.delete(id);
-  }
-});
+};
+process.on("SIGINT", () => void shutdown("SIGINT"));
+process.on("SIGTERM", () => void shutdown("SIGTERM"));
+var handle = serveStdio(() => createMcpServer(db, vectors));