@vheins/local-memory-mcp 0.5.32 → 0.6.0

package/dist/mcp/server.js

@@ -1,338 +1,2154 @@
 #!/usr/bin/env node
-import readline from "node:readline";
-import { createRouter } from "./router.js";
-import { SQLiteStore } from "./storage/sqlite.js";
-import { RealVectorStore } from "./storage/vectors.js";
-import { CAPABILITIES, MCP_PROTOCOL_VERSION } from "./capabilities.js";
-import { createSessionContext, extractRootsFromResult, updateSessionFromInitialize, updateSessionRoots, } from "./session.js";
-import { addLogSink, logger } from "./utils/logger.js";
+import {
+  CAPABILITIES,
+  LOG_LEVEL_VALUES,
+  MCP_PROTOCOL_VERSION,
+  MemoryAcknowledgeSchema,
+  MemoryDeleteSchema,
+  MemoryDetailSchema,
+  MemoryRecapSchema,
+  MemorySearchSchema,
+  MemoryStoreSchema,
+  MemorySummarizeSchema,
+  MemorySynthesizeSchema,
+  MemoryUpdateSchema,
+  SQLiteStore,
+  TOOL_DEFINITIONS,
+  TaskCreateInteractiveSchema,
+  TaskCreateSchema,
+  TaskDeleteSchema,
+  TaskGetSchema,
+  TaskListSchema,
+  TaskUpdateSchema,
+  addLogSink,
+  completePromptArgument,
+  completeResourceArgument,
+  createSessionContext,
+  decodeCursor,
+  encodeCursor,
+  extractRootsFromResult,
+  findContainingRoot,
+  getFilesystemRoots,
+  getLogLevel,
+  getPrompt,
+  inferRepoFromSession,
+  isPathWithinRoots,
+  listPrompts,
+  listResourceTemplates,
+  listResources,
+  logger,
+  normalizeRepo,
+  readResource,
+  setLogLevel,
+  updateSessionFromInitialize,
+  updateSessionRoots
+} from "../chunk-XIJO63UU.js";
+
+// src/mcp/server.ts
+import readline from "readline";
+
+// src/mcp/router.ts
+import path2 from "path";
+
+// src/mcp/completion.ts
 import fs from "fs";
-// --- CLI Doctor Mode ---
-if (process.argv.includes("doctor")) {
-    process.stderr.write("\n🏥 MCP Local Memory - System Diagnosis\n\n");
-    const db = new SQLiteStore();
-    const dbPath = db.getDbPath();
-    process.stderr.write(`📂 Database Path: ${dbPath}\n`);
-    process.stderr.write(`📄 Database Status: ${fs.existsSync(dbPath) ? "✅ Exists" : "❌ Not Found"}\n`);
+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());
+      }
+    }
+  }
+  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;
+    }
+    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/memory.store.ts
+import { randomUUID } from "crypto";
+
+// src/mcp/utils/mcp-response.ts
+import { z } from "zod";
+var McpAnnotationsSchema = z.object({
+  audience: z.array(z.enum(["user", "assistant"])).optional(),
+  priority: z.number().min(0).max(1).optional(),
+  lastModified: z.string().optional()
+}).strict().optional();
+var McpContentSchema = z.discriminatedUnion("type", [
+  z.object({
+    type: z.literal("text"),
+    text: z.string(),
+    annotations: McpAnnotationsSchema
+  }),
+  z.object({
+    type: z.literal("image"),
+    data: z.string(),
+    mimeType: z.string(),
+    annotations: McpAnnotationsSchema
+  }),
+  z.object({
+    type: z.literal("resource_link"),
+    uri: z.string(),
+    name: z.string(),
+    description: z.string().optional(),
+    mimeType: z.string().optional(),
+    annotations: McpAnnotationsSchema
+  }),
+  z.object({
+    type: z.literal("resource"),
+    resource: z.object({
+      uri: z.string(),
+      mimeType: z.string().optional(),
+      text: z.string().optional(),
+      annotations: McpAnnotationsSchema
+    })
+  })
+]);
+function createMcpResponse(data, summary, options) {
+  const {
+    resourceLinks,
+    structuredContentPathHint,
+    contentSummary,
+    includeSerializedStructuredContent = "auto"
+  } = options || {};
+  void includeSerializedStructuredContent;
+  let finalData = data;
+  if (data && typeof data === "object") {
+    const cloned = JSON.parse(JSON.stringify(data));
+    finalData = cloned;
+    const arrayKeys = ["results", "tasks", "memories", "items"];
+    let foundArray = false;
+    for (const key of arrayKeys) {
+      const value = cloned[key];
+      if (Array.isArray(value)) {
+        cloned[key] = value.map(
+          (item) => pruneMetadata(item)
+        );
+        foundArray = true;
+      }
+    }
+    if (Array.isArray(cloned)) {
+      finalData = cloned.map((item) => pruneMetadata(item));
+    } else if (!foundArray) {
+      finalData = pruneMetadata(cloned);
+    }
+  }
+  const content = [];
+  if (contentSummary?.trim().length) {
+    content.push({
+      type: "text",
+      text: contentSummary.trim()
+    });
+  } else if (summary.trim().length > 0) {
+    const pointerText = structuredContentPathHint ? `Read structuredContent.${structuredContentPathHint} for details.` : `Read structuredContent for machine-readable results.`;
+    content.push({
+      type: "text",
+      text: `${summary.trim()} ${pointerText}`
+    });
+  }
+  for (const link of resourceLinks || []) {
+    content.push({
+      type: "resource_link",
+      uri: link.uri,
+      name: link.name,
+      mimeType: link.mimeType,
+      annotations: link.annotations
+    });
+  }
+  const response = {
+    structuredContent: finalData,
+    isError: false
+  };
+  response.content = content;
+  return response;
+}
+function pruneMetadata(item) {
+  if (!item || typeof item !== "object") return item;
+  const pruned = { ...item };
+  const toRemove = [
+    "hit_count",
+    "recall_count",
+    "last_used_at",
+    "expires_at",
+    "agent",
+    "role",
+    "model",
+    "recall_rate",
+    "vector_version",
+    "similarity"
+    // Similarity is useful but adds noise if many results
+  ];
+  for (const field of toRemove) {
+    delete pruned[field];
+  }
+  return pruned;
+}
+function getPrimaryTextContent(response) {
+  if (!Array.isArray(response.content)) return "";
+  const textItem = response.content.find((item) => item.type === "text");
+  return textItem?.type === "text" ? textItem.text : "";
+}
+
+// src/mcp/tools/memory.store.ts
+function hasMetadataLikeTitle(title) {
+  const normalized = title.trim();
+  return /^\[[^\]]{0,200}(agent:|role:|model:|\d{4}-\d{2}-\d{2}|source_)[^\]]*\]/i.test(normalized);
+}
+async function handleMemoryStore(params, db2, vectors2) {
+  const validated = MemoryStoreSchema.parse(params);
+  if (hasMetadataLikeTitle(validated.title)) {
+    throw new Error(
+      "Title appears to contain metadata. Keep title concise and move agent/role/date details into metadata or dedicated fields."
+    );
+  }
+  const now = (/* @__PURE__ */ new Date()).toISOString();
+  const expires_at = validated.ttlDays != null ? new Date(Date.now() + validated.ttlDays * 864e5).toISOString() : null;
+  if (!validated.supersedes && validated.type !== "task_archive") {
+    const conflict = await db2.memories.checkConflicts(
+      validated.content,
+      validated.scope.repo,
+      validated.type,
+      vectors2,
+      0.55
+    );
+    if (conflict) {
+      return createMcpResponse(
+        {
+          success: false,
+          error: "MEMORY_CONFLICT",
+          message: `This memory content overlaps significantly with an existing memory (ID: ${conflict.id}).`,
+          conflicting_memory: {
+            id: conflict.id,
+            title: conflict.title,
+            content: conflict.content
+          },
+          instruction: "Use 'memory-update' on the existing ID, or provide 'supersedes' if this new memory replaces it. If the old memory is no longer relevant, you can delete it first."
+        },
+        `Rejected due to conflict with ${conflict.id}. Hint: Use 'supersedes' if this replaces the old memory, or 'memory-update' if you're updating it. If the old memory is no longer relevant, delete it first using 'memory-delete'.`,
+        {
+          structuredContentPathHint: "conflicting_memory"
+        }
+      );
+    }
+  }
+  if (validated.supersedes) {
+    const oldMemory = db2.memories.getById(validated.supersedes);
+    if (oldMemory) {
+      db2.memories.update(oldMemory.id, { status: "archived" });
+      logger.info("[MCP] memory.store - archived superseded memory", {
+        oldId: oldMemory.id,
+        newId: validated.supersedes
+      });
+    }
+  }
+  const tags = validated.tags ?? [];
+  if (validated.scope.language && !tags.includes(validated.scope.language.toLowerCase())) {
+    tags.push(validated.scope.language.toLowerCase());
+  }
+  const entry = {
+    id: randomUUID(),
+    type: validated.type,
+    title: validated.title,
+    content: validated.content,
+    importance: validated.importance,
+    agent: validated.agent,
+    role: validated.role,
+    model: validated.model,
+    scope: validated.scope,
+    created_at: now,
+    updated_at: now,
+    completed_at: null,
+    hit_count: 0,
+    recall_count: 0,
+    last_used_at: null,
+    expires_at,
+    supersedes: validated.supersedes ?? null,
+    status: "active",
+    tags,
+    metadata: validated.metadata ?? {},
+    is_global: validated.is_global
+  };
+  db2.memories.insert(entry);
+  try {
+    await vectors2.upsert(entry.id, entry.content);
+  } catch (error) {
+    logger.warn("Failed to generate vector embedding", { error: String(error) });
+  }
+  logger.info("[MCP] memory.store", {
+    repo: validated.scope.repo,
+    id: entry.id,
+    title: entry.title,
+    type: entry.type,
+    importance: entry.importance
+  });
+  return createMcpResponse(
+    {
+      success: true,
+      id: entry.id,
+      repo: entry.scope.repo,
+      type: entry.type,
+      title: entry.title
+    },
+    `Stored memory "${entry.title}" in repo "${entry.scope.repo}".`,
+    {
+      structuredContentPathHint: "id",
+      resourceLinks: [
+        {
+          uri: `memory://${entry.id}`,
+          name: entry.title,
+          description: `Stored memory in repo ${entry.scope.repo}`,
+          mimeType: "application/json",
+          annotations: {
+            audience: ["assistant"],
+            priority: 0.9,
+            lastModified: entry.updated_at
+          }
+        },
+        {
+          uri: `repository://${encodeURIComponent(entry.scope.repo)}/memories`,
+          name: `Memory Index (${entry.scope.repo})`,
+          description: "Repository memory index",
+          mimeType: "application/json",
+          annotations: {
+            audience: ["assistant"],
+            priority: 0.6
+          }
+        }
+      ]
+    }
+  );
+}
+
+// src/mcp/tools/memory.update.ts
+function hasMetadataLikeTitle2(title) {
+  const normalized = title.trim();
+  return /^\[[^\]]{0,200}(agent:|role:|model:|\d{4}-\d{2}-\d{2}|source_)[^\]]*\]/i.test(normalized);
+}
+async function handleMemoryUpdate(params, db2, vectors2) {
+  const validated = MemoryUpdateSchema.parse(params);
+  const existing = db2.memories.getById(validated.id);
+  if (!existing) {
+    throw new Error(`Memory not found: ${validated.id}`);
+  }
+  const repoFilter = params?.repo || params?.scope?.repo;
+  if (repoFilter && repoFilter !== existing.scope.repo) {
+    throw new Error(
+      `Repository mismatch: provided repo "${repoFilter}" does not match memory repo "${existing.scope.repo}"`
+    );
+  }
+  if (validated.title !== void 0 && hasMetadataLikeTitle2(validated.title)) {
+    throw new Error(
+      "Title appears to contain metadata. Keep title concise and move agent/role/date details into metadata or dedicated fields."
+    );
+  }
+  const updates = {};
+  if (validated.type !== void 0) updates.type = validated.type;
+  if (validated.title !== void 0) updates.title = validated.title;
+  if (validated.content !== void 0) updates.content = validated.content;
+  if (validated.importance !== void 0) updates.importance = validated.importance;
+  if (validated.agent !== void 0) updates.agent = validated.agent;
+  if (validated.role !== void 0) updates.role = validated.role;
+  if (validated.status !== void 0) updates.status = validated.status;
+  if (validated.supersedes !== void 0) updates.supersedes = validated.supersedes;
+  if (validated.tags !== void 0) updates.tags = validated.tags;
+  if (validated.metadata !== void 0) updates.metadata = validated.metadata;
+  if (validated.is_global !== void 0) updates.is_global = validated.is_global;
+  if (validated.completed_at !== void 0) updates.completed_at = validated.completed_at;
+  db2.memories.update(validated.id, updates);
+  if (validated.content !== void 0) {
+    await vectors2.upsert(validated.id, validated.content);
+  }
+  db2.actions.logAction("update", existing.scope.repo, { memoryId: validated.id, resultCount: 1 });
+  logger.info("[MCP] memory.update", { repo: existing.scope.repo, id: validated.id, fields: Object.keys(updates) });
+  return createMcpResponse(
+    {
+      success: true,
+      id: validated.id,
+      repo: existing.scope.repo,
+      updatedFields: Object.keys(updates)
+    },
+    `Updated memory ${validated.id} in repo "${existing.scope.repo}". Fields: ${Object.keys(updates).join(", ") || "none"}.`,
+    {
+      structuredContentPathHint: "updatedFields",
+      resourceLinks: [
+        {
+          uri: `memory://${validated.id}`,
+          name: existing.title || validated.id,
+          description: `Updated memory in repo ${existing.scope.repo}`,
+          mimeType: "application/json",
+          annotations: {
+            audience: ["assistant"],
+            priority: 0.9
+          }
+        }
+      ]
+    }
+  );
+}
+
+// src/mcp/utils/query-expander.ts
+var TECH_SYNONYMS = {
+  update: ["migrate", "change", "alter", "modify", "patch", "upgrade"],
+  database: ["db", "sql", "schema", "persistence", "storage", "sqlite", "postgres"],
+  auth: ["login", "security", "token", "session", "permission", "authorization", "authentication", "system"],
+  authentication: ["auth", "login", "security", "token", "session", "permission"],
+  system: ["architecture", "structure", "design", "security"],
+  error: ["bug", "issue", "failure", "mistake", "fix", "exception"],
+  ui: ["frontend", "component", "styling", "css", "layout", "view"],
+  deploy: ["publish", "release", "ci", "cd", "pipeline"]
+};
+function expandQuery(query, prompt) {
+  const baseText = prompt ? `${query} ${prompt}` : query;
+  const words = baseText.toLowerCase().split(/\s+/);
+  const expansions = new Set(words);
+  for (const word of words) {
+    const cleanWord = word.replace(/[?.!,]/g, "");
+    if (TECH_SYNONYMS[cleanWord]) {
+      TECH_SYNONYMS[cleanWord].forEach((syn) => expansions.add(syn));
+    }
+  }
+  return Array.from(expansions).join(" ");
+}
+
+// src/mcp/tools/memory.search.ts
+var HYBRID_WEIGHTS_VECTOR = {
+  similarity: 0.4,
+  vector: 0.4,
+  importance: 0.2
+};
+async function handleMemorySearch(params, db2, vectors2) {
+  const validated = MemorySearchSchema.parse(params);
+  const searchQuery = expandQuery(validated.query, validated.prompt);
+  const fetchLimit = (validated.offset + validated.limit) * 3;
+  const similarityResults = db2.memories.searchBySimilarity(
+    searchQuery,
+    validated.repo,
+    fetchLimit,
+    validated.include_archived,
+    validated.current_tags ?? []
+  );
+  let candidates = similarityResults.map((r) => ({
+    memory: r,
+    similarityScore: r.similarity
+  }));
+  if (candidates.length > 0) {
+    const currentPath = validated.current_file_path?.toLowerCase();
+    const currentTags = (validated.current_tags || []).map((t) => t.toLowerCase());
+    const currentBranch = validated.scope?.branch;
+    candidates = candidates.map((c) => {
+      let boost = 0;
+      if (currentBranch && c.memory.scope.branch === currentBranch) {
+        boost += 0.1;
+      }
+      if (currentPath && c.memory.scope.folder && currentPath.includes(c.memory.scope.folder.toLowerCase())) {
+        boost += 0.15;
+      }
+      if (currentPath && c.memory.scope.language) {
+        const ext = currentPath.split(".").pop();
+        if (ext && ext.includes(c.memory.scope.language.toLowerCase())) boost += 0.1;
+      }
+      if (currentTags.length > 0 && c.memory.tags.some((t) => currentTags.includes(t.toLowerCase()))) {
+        boost += 0.2;
+      }
+      return { ...c, similarityScore: Math.min(1, c.similarityScore + boost) };
+    });
+  }
+  let scoredMemories = [];
+  try {
+    const vectorResults = await vectors2.search(searchQuery, candidates.length || 10, validated.repo);
+    const vectorScoreMap = new Map(vectorResults.map((vr) => [vr.id, vr.score]));
+    if (candidates.length > 0) {
+      scoredMemories = candidates.map((c) => {
+        const vScore = vectorScoreMap.get(c.memory.id) ?? 0;
+        const impBoost = c.memory.importance / 5;
+        const finalScore = c.similarityScore * HYBRID_WEIGHTS_VECTOR.similarity + vScore * HYBRID_WEIGHTS_VECTOR.vector + impBoost * HYBRID_WEIGHTS_VECTOR.importance;
+        return { ...c, vectorScore: vScore, finalScore };
+      });
+    } else if (vectorResults.length > 0) {
+      const vectorIds = vectorResults.map((vr) => vr.id);
+      const fetchedMemories = db2.memories.getByIds(vectorIds);
+      const memoryMap = new Map(fetchedMemories.map((m) => [m.id, m]));
+      for (const vr of vectorResults) {
+        const mem = memoryMap.get(vr.id);
+        if (mem) {
+          const impBoost = mem.importance / 5;
+          scoredMemories.push({
+            memory: mem,
+            similarityScore: 0,
+            vectorScore: vr.score,
+            finalScore: vr.score * 0.8 + impBoost * 0.2
+          });
+        }
+      }
+    }
+  } catch (error) {
+    logger.warn("Vector search failed, using similarity only", { error: String(error) });
+    scoredMemories = candidates.map((c) => ({
+      ...c,
+      vectorScore: 0,
+      finalScore: c.similarityScore * 0.8 + c.memory.importance / 5 * 0.2
+    }));
+  }
+  scoredMemories.sort((a, b) => b.finalScore - a.finalScore);
+  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];
+  }
+  const total = allMatches.length;
+  const paginatedResults = allMatches.slice(validated.offset, validated.offset + validated.limit);
+  db2.memories.incrementHitCounts(paginatedResults.map((m) => m.id));
+  logger.info("[MCP] memory.search", {
+    repo: validated.repo,
+    query: validated.query,
+    total,
+    offset: validated.offset,
+    returned: paginatedResults.length
+  });
+  const COLUMNS = ["id", "title", "type", "importance"];
+  const rows = paginatedResults.map((m) => [m.id, m.title ?? "Untitled", m.type, m.importance]);
+  const structuredContent = {
+    schema: "memory-search",
+    query: validated.query,
+    count: paginatedResults.length,
+    total,
+    offset: validated.offset,
+    limit: validated.limit,
+    results: {
+      columns: [...COLUMNS],
+      rows
+    }
+  };
+  const memoryList = paginatedResults.map((m) => `"${m.title}" (ID: ${m.id})`).join(", ");
+  const contentSummary = paginatedResults.length > 0 ? `Found ${total} memories for "${validated.query}" (showing ${paginatedResults.length} at offset ${validated.offset}): ${memoryList}. Use memory-detail to read full content.` : `No memories found for "${validated.query}" in repo "${validated.repo}".`;
+  return createMcpResponse(structuredContent, contentSummary, {
+    contentSummary,
+    includeSerializedStructuredContent: false
+  });
+}
+
+// src/mcp/tools/memory.summarize.ts
+async function handleMemorySummarize(params, db2) {
+  const validated = MemorySummarizeSchema.parse(params);
+  const summary = validated.signals.join("\n- ");
+  const fullSummary = `Project summary:
+- ${summary}`;
+  db2.summaries.upsertSummary(validated.repo, fullSummary);
+  return createMcpResponse(
+    {
+      success: true,
+      repo: validated.repo,
+      summary: fullSummary,
+      signalCount: validated.signals.length
+    },
+    `Updated summary for repo "${validated.repo}" with ${validated.signals.length} signals.`,
+    {
+      structuredContentPathHint: "summary",
+      resourceLinks: [
+        {
+          uri: `repository://${encodeURIComponent(validated.repo)}/summary`,
+          name: `Repository Summary (${validated.repo})`,
+          description: "Repository summary resource",
+          mimeType: "text/plain",
+          annotations: {
+            audience: ["assistant"],
+            priority: 0.9
+          }
+        }
+      ]
+    }
+  );
+}
+
+// src/mcp/sampling.ts
+function asArray(value) {
+  return Array.isArray(value) ? value : [value];
+}
+function extractTextFromContent(content) {
+  return asArray(content).filter((entry) => entry.type === "text").map((entry) => entry.text).join("\n");
+}
+function extractToolUses(content) {
+  return asArray(content).filter(
+    (entry) => entry.type === "tool_use"
+  );
+}
+
+// src/mcp/elicitation.ts
+function extractAcceptedElicitationContent(result) {
+  if (result?.action === "accept" && result.content && typeof result.content === "object") {
+    return result.content;
+  }
+  if (result?.action === "decline") {
+    throw new Error("User declined the elicitation request");
+  }
+  if (result?.action === "cancel") {
+    throw new Error("User canceled the elicitation request");
+  }
+  throw new Error("Elicitation did not return accepted content");
+}
+
+// src/mcp/tools/memory.recap.ts
+async function handleMemoryRecap(params, db2) {
+  const validated = MemoryRecapSchema.parse(params);
+  logger.info("[MCP] memory.recap", { repo: validated.repo, limit: validated.limit, offset: validated.offset });
+  const stats = db2.memories.getStats(validated.repo);
+  const total = db2.memories.getTotalCount(validated.repo, false, ["task_archive"]);
+  const rows = db2.memories.getRecentMemories(validated.repo, validated.limit, validated.offset, false, [
+    "task_archive"
+  ]);
+  const COLUMNS = ["id", "title", "type", "importance"];
+  const topRows = rows.map((row) => [row.id, row.title ?? "Untitled", row.type, row.importance]);
+  const byType = {};
+  for (const [type, count] of Object.entries(stats.byType)) {
+    if (type !== "task_archive") {
+      byType[type] = count;
+    }
+  }
+  const structuredContent = {
+    schema: "memory-recap",
+    repo: validated.repo,
+    count: rows.length,
+    total,
+    offset: validated.offset,
+    limit: validated.limit,
+    stats: {
+      by_type: byType
+    },
+    top: {
+      columns: [...COLUMNS],
+      rows: topRows
+    }
+  };
+  const memoryList = rows.map((row) => `"${row.title}" (ID: ${row.id})`).join(", ");
+  const contentSummary = total > 0 ? `Repo "${validated.repo}" has ${total} active memories. Showing ${rows.length} at offset ${validated.offset}: ${memoryList}. Use memory-detail to read full content.` : `No memories found for repo "${validated.repo}".`;
+  return createMcpResponse(structuredContent, contentSummary, {
+    contentSummary,
+    includeSerializedStructuredContent: false
+  });
+}
+
+// src/mcp/tools/task.manage.ts
+import { randomUUID as randomUUID2 } from "crypto";
+function describeTaskListFilter(status) {
+  if (!status) return "active";
+  if (status === "all") return "all";
+  const labels = status.split(",").map((part) => part.trim()).filter(Boolean).map((part) => {
+    switch (part) {
+      case "in_progress":
+        return "in progress";
+      default:
+        return part;
+    }
+  });
+  if (labels.length === 0) return "active";
+  if (labels.length === 1) return labels[0];
+  if (labels.length === 2) return `${labels[0]} and ${labels[1]}`;
+  return `${labels.slice(0, -1).join(", ")}, and ${labels[labels.length - 1]}`;
+}
+function buildTaskListSummary(repo, count, status, phase, search, stats) {
+  const filterLabel = describeTaskListFilter(status);
+  const taskLabel = count === 1 ? "task" : "tasks";
+  const parts = [`Found ${count} ${filterLabel} ${taskLabel} in repo "${repo}".`];
+  if (phase) {
+    parts.push(`Phase filter: ${phase}.`);
+  }
+  if (search) {
+    parts.push(`Search filter: "${search}".`);
+  }
+  parts.push(`Pending: ${stats?.todo ?? 0}.`);
+  parts.push(`In progress: ${stats?.inProgress ?? 0}.`);
+  parts.push(`Use task-detail with Task ID or task_code to read full details.`);
+  return parts.join(" ");
+}
+function deriveTaskStatusTimestamps(status, now, existingTask) {
+  const timestamps = {
+    in_progress_at: null,
+    finished_at: null,
+    canceled_at: null
+  };
+  if (status === "in_progress" && existingTask?.status !== "in_progress") {
+    timestamps.in_progress_at = now;
+  }
+  if (status === "completed") {
+    timestamps.finished_at = now;
+  }
+  if (status === "canceled") {
+    timestamps.canceled_at = now;
+  }
+  return timestamps;
+}
+async function archiveTaskToMemory(taskId, repo, storage, vectors2) {
+  const task = storage.tasks.getTaskById(taskId);
+  if (!task) return;
+  const comments = storage.tasks.getTaskCommentsByTaskId(taskId);
+  let content = `Task: [${task.task_code}] ${task.title}
+`;
+  content += `Phase: ${task.phase}
+`;
+  content += `Description: ${task.description || "No description"}
+`;
+  if (comments && comments.length > 0) {
+    content += `
+Comments & History:
+`;
+    const chronComments = [...comments].reverse();
+    for (const c of chronComments) {
+      const statusInfo = c.next_status ? ` (Status: ${c.previous_status} -> ${c.next_status})` : "";
+      content += `- [${c.created_at}] ${c.agent}${statusInfo}: ${c.comment}
+`;
+    }
+  }
+  const metadata = {
+    task_id: taskId,
+    task_code: task.task_code,
+    original_metadata: task.metadata
+  };
+  const title = `Completed Task: ${task.title}`;
+  const truncatedTitle = title.length > 100 ? title.substring(0, 97) + "..." : title;
+  try {
+    await handleMemoryStore(
+      {
+        type: "task_archive",
+        title: truncatedTitle,
+        content,
+        importance: Math.min(5, task.priority + 1),
+        // Slightly higher importance for archived tasks
+        agent: task.agent || "system",
+        role: task.role || "unknown",
+        model: "system",
+        scope: { repo },
+        tags: ["task-archive", ...task.tags],
+        metadata
+      },
+      storage,
+      vectors2
+    );
+  } catch (error) {
+    console.error("Failed to archive task to memory", error);
+  }
+}
+async function handleTaskList(args, storage) {
+  const {
+    repo,
+    status = "backlog,pending,in_progress,blocked",
+    phase,
+    query,
+    limit,
+    offset
+  } = TaskListSchema.parse(args);
+  let statuses = [];
+  if (status !== "all") {
+    statuses = status.split(",").map((s) => s.trim()).filter(Boolean);
+  }
+  const tasks = storage.tasks.getTasksByMultipleStatuses(repo, statuses, limit, offset, query);
+  const filteredTasks = phase ? tasks.filter((t) => t.phase.toLowerCase() === phase.toLowerCase()) : tasks;
+  const COLUMNS = ["id", "task_code", "title", "status", "priority", "comments_count"];
+  const rows = filteredTasks.map((t) => [
+    t.id,
+    t.task_code,
+    t.title,
+    t.status,
+    t.priority,
+    t.comments_count || 0
+  ]);
+  const structured = {
+    schema: "task-list",
+    tasks: {
+      columns: [...COLUMNS],
+      rows
+    },
+    count: rows.length,
+    offset
+  };
+  const _taskList = filteredTasks.map((t) => `[${t.task_code}] ${t.title} (ID: ${t.id})`).join(", ");
+  const taskStats = storage.tasks.getTaskStats(repo);
+  const summary = buildTaskListSummary(repo, rows.length, status, phase, query, taskStats);
+  return createMcpResponse(structured, summary, {
+    contentSummary: summary,
+    includeSerializedStructuredContent: false
+  });
+}
+async function handleTaskCreate(args, storage) {
+  const parsed = TaskCreateSchema.parse(args);
+  const { repo, tasks: bulkTasks, ...singleTask } = parsed;
+  if (bulkTasks) {
+    const createdTasks = [];
+    const now2 = (/* @__PURE__ */ new Date()).toISOString();
+    const codesInRequest = /* @__PURE__ */ new Set();
+    for (const taskData of bulkTasks) {
+      if (codesInRequest.has(taskData.task_code)) {
+        throw new Error(`Duplicate task_code in request: '${taskData.task_code}'`);
+      }
+      if (storage.tasks.isTaskCodeDuplicate(repo, taskData.task_code)) {
+        throw new Error(`Duplicate task_code: '${taskData.task_code}' already exists in repository '${repo}'`);
+      }
+      codesInRequest.add(taskData.task_code);
+      const normalizedStatus = taskData.status || "backlog";
+      if (normalizedStatus !== "backlog" && normalizedStatus !== "pending") {
+        throw new Error(`New tasks must be 'backlog' or 'pending'. Task '${taskData.task_code}' has status '${normalizedStatus}'.`);
+      }
+      if (normalizedStatus === "pending") {
+        const stats = storage.tasks.getTaskStats(repo);
+        const pendingInRequest = createdTasks.filter((c) => {
+          const t = bulkTasks.find((bt) => bt.task_code === c);
+          return t?.status === "pending";
+        }).length;
+        if (stats.todo + pendingInRequest >= 10) {
+          throw new Error(`Cannot create task '${taskData.task_code}' as 'pending'. Maximum of 10 pending tasks reached.`);
+        }
+      }
+      const statusTimestamps2 = deriveTaskStatusTimestamps(normalizedStatus, now2);
+      const task2 = {
+        id: randomUUID2(),
+        repo,
+        task_code: taskData.task_code,
+        phase: taskData.phase,
+        title: taskData.title,
+        description: taskData.description,
+        status: normalizedStatus,
+        priority: taskData.priority || 3,
+        agent: taskData.agent || singleTask.agent || "unknown",
+        role: taskData.role || singleTask.role || "unknown",
+        doc_path: taskData.doc_path || null,
+        created_at: now2,
+        updated_at: now2,
+        in_progress_at: statusTimestamps2.in_progress_at,
+        finished_at: statusTimestamps2.finished_at,
+        canceled_at: statusTimestamps2.canceled_at,
+        est_tokens: taskData.est_tokens ?? 0,
+        tags: taskData.tags || [],
+        metadata: taskData.metadata || {},
+        parent_id: taskData.parent_id || null,
+        depends_on: taskData.depends_on || null
+      };
+      storage.tasks.insertTask(task2);
+      createdTasks.push(task2.task_code);
+    }
+    return createMcpResponse(
+      { success: true, repo, createdCount: bulkTasks.length, taskCodes: createdTasks },
+      `Created ${bulkTasks.length} tasks in repo "${repo}".`
+    );
+  }
+  const { task_code, phase, title, description, status, priority, agent, role, doc_path, tags, metadata, parent_id, depends_on, est_tokens } = singleTask;
+  if (!task_code || !phase || !title || !description) {
+    throw new Error("Missing required fields for single task creation (task_code, phase, title, description)");
+  }
+  if (storage.tasks.isTaskCodeDuplicate(repo, task_code)) {
+    throw new Error(`Duplicate task_code: '${task_code}' already exists in repository '${repo}'`);
+  }
+  if (status !== "backlog" && status !== "pending" && status !== void 0) {
+    throw new Error("New tasks must be created with status 'backlog' or 'pending'.");
+  }
+  if (status === "pending") {
+    const stats = storage.tasks.getTaskStats(repo);
+    if (stats.todo >= 10) {
+      throw new Error(`Cannot create task as 'pending'. Maximum of 10 pending tasks reached.`);
+    }
+  }
+  const taskId = randomUUID2();
+  const now = (/* @__PURE__ */ new Date()).toISOString();
+  const statusTimestamps = deriveTaskStatusTimestamps(status || "backlog", now);
+  const task = {
+    id: taskId,
+    repo,
+    task_code,
+    phase,
+    title,
+    description,
+    status: status || "backlog",
+    priority: priority || 3,
+    agent: agent || "unknown",
+    role: role || "unknown",
+    doc_path: doc_path || null,
+    created_at: now,
+    updated_at: now,
+    in_progress_at: statusTimestamps.in_progress_at,
+    finished_at: statusTimestamps.finished_at,
+    canceled_at: statusTimestamps.canceled_at,
+    est_tokens: est_tokens ?? 0,
+    tags: tags || [],
+    metadata: metadata || {},
+    parent_id: parent_id || null,
+    depends_on: depends_on || null
+  };
+  storage.tasks.insertTask(task);
+  return createMcpResponse(
+    {
+      success: true,
+      id: task.id,
+      repo: task.repo,
+      task_code: task.task_code,
+      phase: task.phase,
+      title: task.title,
+      status: task.status,
+      priority: task.priority,
+      depends_on: task.depends_on
+    },
+    `Created task [${task.task_code}] ${task.title} in repo "${task.repo}" with status "${task.status}".`
+  );
+}
+async function handleTaskCreateInteractive(args, storage, options = {}) {
+  const partialTaskData = TaskCreateInteractiveSchema.parse(args ?? {});
+  const inferredRepo = partialTaskData.repo ?? inferRepoFromSession(options.session);
+  const draft = {
+    ...partialTaskData,
+    repo: inferredRepo
+  };
+  const requestedSchema = buildMissingTaskSchema(draft);
+  let completedDraft = draft;
+  if (Object.keys(requestedSchema.properties).length > 0) {
+    if (!options.session?.supportsElicitationForm || !options.elicit) {
+      throw new Error("Client does not advertise MCP elicitation form support");
+    }
+    const elicited = extractAcceptedElicitationContent(
+      await options.elicit({
+        mode: "form",
+        message: "Please complete the missing task details to create a new task.",
+        requestedSchema
+      })
+    );
+    completedDraft = {
+      ...draft,
+      ...elicited
+    };
+  }
+  return await handleTaskCreate(
+    {
+      ...completedDraft,
+      status: completedDraft.status ?? "backlog",
+      priority: completedDraft.priority ?? 3
+    },
+    storage
+  );
+}
+function buildMissingTaskSchema(task) {
+  const properties = {};
+  const required = [];
+  addRequiredStringField(properties, required, task, "repo", {
+    title: "Repository",
+    description: "Name of the repository for this task.",
+    minLength: 1
+  });
+  addRequiredStringField(properties, required, task, "task_code", {
+    title: "Task Code",
+    description: "Unique task code in this repository.",
+    minLength: 1
+  });
+  addRequiredStringField(properties, required, task, "phase", {
+    title: "Phase",
+    description: "Project phase or milestone for this task.",
+    minLength: 1
+  });
+  addRequiredStringField(properties, required, task, "title", {
+    title: "Title",
+    description: "Short task title.",
+    minLength: 3,
+    maxLength: 100
+  });
+  addRequiredStringField(properties, required, task, "description", {
+    title: "Description",
+    description: "Detailed description of the task.",
+    minLength: 1
+  });
+  if (!task.status) {
+    properties.status = {
+      type: "string",
+      title: "Status",
+      description: "Initial task status.",
+      enum: ["backlog", "pending"],
+      default: "backlog"
+    };
+  }
+  if (task.priority === void 0) {
+    properties.priority = {
+      type: "integer",
+      title: "Priority",
+      description: "Task priority from 1 to 5.",
+      minimum: 1,
+      maximum: 5,
+      default: 3
+    };
+  }
+  return {
+    type: "object",
+    properties,
+    required
+  };
+}
+function addRequiredStringField(properties, required, task, field, schema) {
+  if (typeof task[field] === "string" && task[field].trim()) {
+    return;
+  }
+  properties[field] = {
+    type: "string",
+    ...schema
+  };
+  required.push(field);
+}
+async function handleTaskUpdate(args, storage, vectors2) {
+  const updateData = TaskUpdateSchema.parse(args);
+  const { repo, id, ids, comment, force, ...updates } = updateData;
+  const targetIds = ids || (id ? [id] : []);
+  if (targetIds.length === 0) {
+    throw new Error("Either 'id' or 'ids' must be provided for update");
+  }
+  let updatedCount = 0;
+  const now = (/* @__PURE__ */ new Date()).toISOString();
+  const isStatusChangingGlobal = updates.status !== void 0;
+  for (const targetId of targetIds) {
+    const existingTask = storage.tasks.getTaskById(targetId);
+    if (!existingTask) {
+      if (id) throw new Error(`Task not found: ${targetId}`);
+      continue;
+    }
+    const isStatusChanging = isStatusChangingGlobal && updates.status !== existingTask.status;
+    if (isStatusChanging && !force) {
+      if (!comment || comment.trim() === "") {
+        throw new Error("comment is required when changing task status");
+      }
+      if ((existingTask.status === "backlog" || existingTask.status === "pending" || existingTask.status === "blocked") && updates.status === "completed") {
+        throw new Error(`Cannot transition task ${targetId} from '${existingTask.status}' directly to 'completed'. Must be 'in_progress' first.`);
+      }
+    }
+    if (updates.status === "completed" && isStatusChanging && updates.est_tokens === void 0) {
+      throw new Error("est_tokens is required when changing task status to completed");
+    }
+    if (updates.task_code && storage.tasks.isTaskCodeDuplicate(repo, updates.task_code, targetId)) {
+      throw new Error(`Duplicate task_code: '${updates.task_code}' already exists`);
+    }
+    const finalUpdates = { ...updates };
+    if (updates.status === "completed") finalUpdates.finished_at = now;
+    else if (updates.status === "canceled") finalUpdates.canceled_at = now;
+    else if (updates.status === "in_progress" && existingTask.status !== "in_progress") finalUpdates.in_progress_at = now;
+    storage.tasks.updateTask(targetId, finalUpdates);
+    if (comment !== void 0 || isStatusChanging) {
+      storage.tasks.insertTaskComment({
+        id: randomUUID2(),
+        task_id: targetId,
+        repo,
+        comment: comment || `Status updated to ${updates.status}`,
+        agent: updates.agent || existingTask.agent || "unknown",
+        role: updates.role || existingTask.role || "unknown",
+        model: updates.model || "unknown",
+        previous_status: isStatusChanging ? existingTask.status : null,
+        next_status: isStatusChanging ? updates.status : null,
+        created_at: now
+      });
+    }
+    if (updates.status === "completed" && existingTask.status !== "completed") {
+      await archiveTaskToMemory(targetId, repo, storage, vectors2);
+    }
+    updatedCount++;
+  }
+  return createMcpResponse(
+    {
+      success: true,
+      id: id || void 0,
+      ids: ids || void 0,
+      repo,
+      status: updates.status,
+      updatedCount,
+      updatedFields: Object.keys(updates)
+    },
+    `Updated ${updatedCount} task(s) in repo "${repo}".`
+  );
+}
+async function handleTaskDelete(args, storage) {
+  const { repo, id, ids } = TaskDeleteSchema.parse(args);
+  const targetIds = ids || (id ? [id] : []);
+  if (targetIds.length === 0) {
+    throw new Error("Either 'id' or 'ids' must be provided for deletion");
+  }
+  for (const targetId of targetIds) {
+    storage.tasks.deleteTask(targetId);
+  }
+  return createMcpResponse(
+    {
+      success: true,
+      id: id || void 0,
+      ids: ids || void 0,
+      repo,
+      deletedCount: targetIds.length
+    },
+    `Deleted ${targetIds.length} task(s) from repo "${repo}".`
+  );
+}
+
+// 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) {
+    throw new Error("Client does not advertise MCP sampling support");
+  }
+  const repo = await resolveRepository(validated.repo, session2, options.elicit);
+  if (!repo) {
+    throw new Error("repo is required when repo cannot be inferred from active MCP roots");
+  }
+  const recap = await handleMemoryRecap({ repo, limit: 8, offset: 0 }, db2);
+  const recapText = getPrimaryTextContent(recap);
+  const summary = validated.include_summary ? db2.summaries.getSummary(repo)?.summary : "";
+  const taskSnapshot = validated.include_tasks ? await handleTaskList({ repo, status: "backlog,pending,in_progress,blocked", limit: 15, offset: 0 }, db2) : null;
+  const taskText = taskSnapshot ? getPrimaryTextContent(taskSnapshot) : "";
+  const systemPrompt = [
+    "You are a repository memory synthesizer.",
+    "Answer strictly from grounded MCP context and tool results.",
+    "If memory is insufficient, say so explicitly instead of inventing details.",
+    "Prefer concise, technical answers with explicit caveats when evidence is incomplete."
+  ].join(" ");
+  const contextBlock = [
+    `Repository: ${repo}`,
+    validated.current_file_path ? `Current file: ${validated.current_file_path}` : "",
+    summary ? `Summary:
+${summary}` : "",
+    recapText ? `Recent context:
+${recapText}` : "",
+    taskText ? `Active tasks:
+${taskText}` : ""
+  ].filter(Boolean).join("\n\n");
+  const messages = [
+    {
+      role: "user",
+      content: {
+        type: "text",
+        text: `Objective: ${validated.objective}
+
+Grounding context:
+${contextBlock || "No additional context provided."}`
+      }
+    }
+  ];
+  const toolDefinitions = buildSamplingTools(session2, validated.use_tools);
+  let lastResponse = null;
+  let totalToolCalls = 0;
+  let iterations = 0;
+  while (iterations < validated.max_iterations) {
+    iterations += 1;
+    const response = await options.sampleMessage({
+      messages,
+      systemPrompt,
+      maxTokens: validated.max_tokens,
+      tools: toolDefinitions.length > 0 ? toolDefinitions : void 0,
+      toolChoice: toolDefinitions.length > 0 ? { mode: iterations === validated.max_iterations ? "none" : "auto" } : void 0,
+      modelPreferences: {
+        intelligencePriority: 0.9,
+        speedPriority: 0.4
+      }
+    });
+    lastResponse = response;
+    messages.push({
+      role: "assistant",
+      content: response.content
+    });
+    const toolUses = extractToolUses(response.content);
+    if (toolUses.length === 0) {
+      break;
+    }
+    totalToolCalls += toolUses.length;
+    const toolResults = await Promise.all(
+      toolUses.map(async (toolUse) => ({
+        type: "tool_result",
+        toolUseId: toolUse.id,
+        content: [
+          {
+            type: "text",
+            text: await executeSamplingTool(toolUse.name, toolUse.input, db2, vectors2)
+          }
+        ]
+      }))
+    );
+    messages.push({
+      role: "user",
+      content: toolResults
+    });
+  }
+  const answer = lastResponse ? extractTextFromContent(lastResponse.content).trim() : "";
+  if (!answer) {
+    throw new Error("Sampling did not return a final text answer");
+  }
+  logger.info("[MCP] memory.synthesize", {
+    repo,
+    objective: validated.objective,
+    iterations,
+    toolCalls: totalToolCalls
+  });
+  return createMcpResponse(
+    {
+      repo,
+      objective: validated.objective,
+      answer,
+      model: lastResponse?.model,
+      stopReason: lastResponse?.stopReason,
+      iterations,
+      toolCalls: totalToolCalls
+    },
+    `Synthesized answer for "${validated.objective}" using repository "${repo}".`,
+    {
+      structuredContentPathHint: "answer"
+    }
+  );
+}
+async function resolveRepository(repo, session2, elicit) {
+  if (repo) return normalizeRepo(repo);
+  const inferredRepo = inferRepoFromSession(session2);
+  if (inferredRepo) return normalizeRepo(inferredRepo);
+  if (!session2?.supportsElicitationForm || !elicit) {
+    return void 0;
+  }
+  const elicited = extractAcceptedElicitationContent(
+    await elicit({
+      mode: "form",
+      message: "Repository tidak bisa diinfer dari roots aktif. Pilih repository yang ingin disintesis.",
+      requestedSchema: {
+        type: "object",
+        properties: {
+          repo: {
+            type: "string",
+            title: "Repository",
+            description: "Nama repository yang akan dipakai untuk sintesis memori.",
+            minLength: 1
+          }
+        },
+        required: ["repo"]
+      }
+    })
+  );
+  return typeof elicited.repo === "string" && elicited.repo.trim() ? normalizeRepo(elicited.repo.trim()) : void 0;
+}
+function buildSamplingTools(session2, useTools) {
+  if (!useTools || !session2?.supportsSamplingTools) {
+    return [];
+  }
+  return [
+    {
+      name: "memory_search",
+      description: "Search local repository memories for relevant context.",
+      inputSchema: {
+        type: "object",
+        properties: {
+          repo: { type: "string" },
+          query: { type: "string" },
+          limit: { type: "number", minimum: 1, maximum: 10 }
+        },
+        required: ["repo", "query"]
+      }
+    },
+    {
+      name: "memory_recap",
+      description: "Fetch a recap of the most recent memories and active tasks.",
+      inputSchema: {
+        type: "object",
+        properties: {
+          repo: { type: "string" },
+          limit: { type: "number", minimum: 1, maximum: 20 }
+        },
+        required: ["repo"]
+      }
+    },
+    {
+      name: "task_list",
+      description: "List tasks by status or search term for the repository.",
+      inputSchema: {
+        type: "object",
+        properties: {
+          repo: { type: "string" },
+          status: { type: "string" },
+          search: { type: "string" },
+          limit: { type: "number", minimum: 1, maximum: 20 }
+        },
+        required: ["repo"]
+      }
+    }
+  ];
+}
+async function executeSamplingTool(toolName, rawInput, db2, vectors2) {
+  switch (toolName) {
+    case "memory_search": {
+      const response = await handleMemorySearch(
+        {
+          repo: rawInput.repo,
+          query: rawInput.query,
+          limit: rawInput.limit ?? 5
+        },
+        db2,
+        vectors2
+      );
+      return getPrimaryTextContent(response);
+    }
+    case "memory_recap": {
+      const response = await handleMemoryRecap(
+        {
+          repo: rawInput.repo,
+          limit: rawInput.limit ?? 8,
+          offset: 0
+        },
+        db2
+      );
+      return getPrimaryTextContent(response);
+    }
+    case "task_list": {
+      const response = await handleTaskList(
+        {
+          repo: rawInput.repo,
+          status: rawInput.status,
+          search: rawInput.search,
+          limit: rawInput.limit ?? 10,
+          offset: 0
+        },
+        db2
+      );
+      return getPrimaryTextContent(response);
+    }
+    default:
+      throw new Error(`Unsupported sampling tool: ${toolName}`);
+  }
+}
+
+// src/mcp/tools/memory.delete.ts
+async function handleMemoryDelete(params, db2, vectors2, onProgress) {
+  const { id, ids, repo } = MemoryDeleteSchema.parse(params);
+  const targetIds = ids || (id ? [id] : []);
+  if (targetIds.length === 0) {
+    throw new Error("Either 'id' or 'ids' must be provided for deletion");
+  }
+  let deletedCount = 0;
+  let lastRepo = repo || "unknown";
+  const total = targetIds.length;
+  let progress = 0;
+  for (const targetId of targetIds) {
+    if (onProgress) {
+      onProgress(progress, total);
+    }
+    const existing = db2.memories.getById(targetId);
+    if (existing) {
+      lastRepo = existing.scope.repo;
+      db2.memories.delete(targetId);
+      await vectors2.remove(targetId);
+      deletedCount++;
+    } else if (id) {
+      throw new Error(`Memory not found: ${targetId}`);
+    }
+    progress++;
+  }
+  if (onProgress) {
+    onProgress(progress, total);
+  }
+  logger.info("[MCP] memory.delete", { repo: lastRepo, count: deletedCount });
+  return createMcpResponse(
+    {
+      success: true,
+      id: id || void 0,
+      ids: ids || void 0,
+      repo: lastRepo,
+      deletedCount
+    },
+    `Deleted ${deletedCount} memory entry(ies) from repo "${lastRepo}".`,
+    {
+      structuredContentPathHint: "deletedCount",
+      resourceLinks: [
+        {
+          uri: `repository://${encodeURIComponent(lastRepo)}/memories`,
+          name: `Memory Index (${lastRepo})`,
+          description: "Repository memory index after deletion",
+          mimeType: "application/json",
+          annotations: {
+            audience: ["assistant"],
+            priority: 0.5
+          }
+        }
+      ]
+    }
+  );
+}
+
+// src/mcp/tools/memory.acknowledge.ts
+async function handleMemoryAcknowledge(params, db2) {
+  const validated = MemoryAcknowledgeSchema.parse(params);
+  const memory = db2.memories.getById(validated.memory_id);
+  if (!memory) {
+    throw new Error(`Memory with ID ${validated.memory_id} not found.`);
+  }
+  if (validated.status === "used") {
+    db2.memories.incrementRecallCount(memory.id);
+    logger.info("[MCP] memory.acknowledge - used", { id: memory.id, context: validated.application_context });
+  } else if (validated.status === "contradictory") {
+    logger.warn("[MCP] memory.acknowledge - contradiction reported", {
+      id: memory.id,
+      context: validated.application_context
+    });
+  } else {
+    logger.info("[MCP] memory.acknowledge - irrelevant", { id: memory.id, context: validated.application_context });
+  }
+  return createMcpResponse(
+    {
+      success: true,
+      id: memory.id,
+      status: validated.status
+    },
+    `Acknowledged memory ${memory.id} as "${validated.status}".`,
+    {
+      structuredContentPathHint: "status"
+    }
+  );
+}
+
+// src/mcp/tools/memory.detail.ts
+async function handleMemoryDetail(args, storage) {
+  const { id } = MemoryDetailSchema.parse(args);
+  const memory = storage.memories.getById(id);
+  if (!memory) {
+    throw new Error(`Memory not found: ${id}`);
+  }
+  storage.memories.incrementHitCount(id);
+  const summary = `Memory [${memory.type}] ${memory.title}: ${memory.content.substring(0, 100)}${memory.content.length > 100 ? "..." : ""}`;
+  return createMcpResponse(memory, summary, {
+    contentSummary: summary,
+    includeSerializedStructuredContent: true,
+    resourceLinks: [
+      {
+        uri: `memory://${id}`,
+        name: `Memory: ${memory.title}`,
+        mimeType: "application/json"
+      }
+    ]
+  });
+}
+
+// src/mcp/tools/task.get.ts
+async function handleTaskGet(args, storage) {
+  const { repo, id, task_code } = TaskGetSchema.parse(args);
+  let task;
+  if (id) {
+    task = storage.tasks.getTaskById(id);
+  } else if (task_code) {
+    task = storage.tasks.getTaskByCode(repo, task_code);
+  } else {
+    throw new Error("Either id or task_code must be provided");
+  }
+  if (!task) {
+    throw new Error(`Task not found: ${id || task_code} in repo ${repo}`);
+  }
+  const summary = `Task [${task.task_code}] ${task.title} (${task.status})`;
+  return createMcpResponse(task, summary, {
+    contentSummary: summary,
+    includeSerializedStructuredContent: true,
+    resourceLinks: [
+      {
+        uri: `task://${task.id}`,
+        name: `Task: ${task.title}`,
+        mimeType: "application/json"
+      }
+    ]
+  });
+}
+
+// src/mcp/router.ts
+function createRouter(db2, vectors2, options) {
+  const getSessionContext = options?.getSessionContext;
+  async function handleMethod2(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":
+        return readResource(params?.uri, db2, getSessionContext?.());
+      // ---- 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}`);
+    }
+  }
+  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";
+    switch (toolName) {
+      case "memory-store":
+        result = await handleMemoryStore(args, db2, vectors2);
+        break;
+      case "memory-acknowledge":
+        result = await handleMemoryAcknowledge(args, db2);
+        break;
+      case "memory-update":
+        result = await handleMemoryUpdate(args, db2, vectors2);
+        break;
+      case "memory-recap":
+        result = await handleMemoryRecap(args, db2);
+        break;
+      case "memory-search":
+        result = await handleMemorySearch(args, db2, vectors2);
+        break;
+      case "memory-summarize":
+        result = await handleMemorySummarize(args, db2);
+        break;
+      case "memory-synthesize":
+        result = await handleMemorySynthesize(args, db2, vectors2, {
+          session: getSessionContext?.(),
+          sampleMessage: options?.sampleMessage,
+          elicit: options?.elicit
+        });
+        break;
+      case "memory-delete":
+      case "memory-bulk-delete":
+        result = await handleMemoryDelete(args, db2, vectors2, onProgress);
+        break;
+      case "memory-detail":
+        result = await handleMemoryDetail(args, db2);
+        break;
+      case "task-create":
+        result = await handleTaskCreate(args, db2);
+        break;
+      case "task-create-interactive":
+        result = await handleTaskCreateInteractive(args, db2, {
+          session: getSessionContext?.(),
+          elicit: options?.elicit
+        });
+        break;
+      case "task-update":
+        result = await handleTaskUpdate(args, db2, vectors2);
+        break;
+      case "task-delete":
+        result = await handleTaskDelete(args, db2);
+        break;
+      case "task-list":
+        result = await handleTaskList(args, db2);
+        break;
+      case "task-detail":
+        result = await handleTaskGet(args, db2);
+        break;
+      default:
+        throw new Error(`Unknown tool: ${name}`);
+    }
+    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
+      };
+      db2.actions.logAction(actionType, repo, logOptions);
+    } catch (e) {
+      logger.error("Failed to log action", { toolName, error: String(e) });
+    }
+    const affectedResources = collectAffectedResourceUris(toolName, args, result);
+    if (affectedResources.length > 0) {
+      options?.onResourcesMutated?.(affectedResources);
+    }
+    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 };
+  });
+  const page = compliantTools.slice(start, start + limit);
+  const nextCursor = start + limit < tools.length ? encodeCursor(start + limit) : void 0;
+  return {
+    tools: page,
+    nextCursor
+  };
+}
+function getAvailableToolDefinitions(session2) {
+  return TOOL_DEFINITIONS.filter((tool) => {
+    if (tool.name === "memory-synthesize" && !session2?.supportsSampling) {
+      return false;
+    }
+    if (tool.name === "task-create-interactive" && !session2?.supportsElicitationForm) {
+      return false;
+    }
+    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`);
+  }
+  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 normalizeToolArguments(args, session2) {
+  if (!args || typeof args !== "object") {
+    return args;
+  }
+  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);
+  if (!nextArgs.repo) {
+    nextArgs.repo = inferRepoFromSession(session2);
+  }
+  const scope = nextArgs.scope;
+  if (scope && !scope.repo) {
+    scope.repo = nextArgs.repo ?? inferRepoFromSession(session2);
+  }
+  if (typeof nextArgs.current_file_path === "string" && scope) {
+    const containingRoot = path2.isAbsolute(nextArgs.current_file_path) ? findContainingRoot(nextArgs.current_file_path, session2) : null;
+    if (containingRoot) {
+      const relativePath = path2.relative(containingRoot, path2.resolve(nextArgs.current_file_path));
+      const relativeFolder = path2.dirname(relativePath);
+      if (relativeFolder && relativeFolder !== "." && !scope.folder) {
+        scope.folder = relativeFolder;
+      }
+    }
+  }
+  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);
+}
+
+// src/mcp/storage/vectors.ts
+import { pipeline } from "@xenova/transformers";
+var RealVectorStore = class {
+  db;
+  extractor = null;
+  modelName = "Xenova/all-MiniLM-L6-v2";
+  constructor(db2) {
+    this.db = db2;
+  }
+  /**
+   * Triggers background loading of the vector model.
+   * Useful for avoiding timeouts on the first search/upsert request.
+   */
+  async initialize() {
+    await this.getExtractor();
+  }
+  async getExtractor() {
+    if (!this.extractor) {
+      this.extractor = await pipeline("feature-extraction", this.modelName);
+    }
+    return this.extractor;
+  }
+  cosineSimilarity(v1, v2) {
+    let dotProduct = 0;
+    let mag1 = 0;
+    let mag2 = 0;
+    for (let i = 0; i < v1.length; i++) {
+      dotProduct += v1[i] * v2[i];
+      mag1 += v1[i] * v1[i];
+      mag2 += v2[i] * v2[i];
+    }
+    const mag = Math.sqrt(mag1) * Math.sqrt(mag2);
+    return mag === 0 ? 0 : dotProduct / mag;
+  }
+  async upsert(id, text) {
+    try {
+      const extractor = await this.getExtractor();
+      const output = await extractor(text, { pooling: "mean", normalize: true });
+      const vector = Array.from(output.data);
+      this.db.memories.upsertVectorEmbedding(id, vector);
+    } catch (error) {
+      logger.error("[Vectors] Error during upsert", { id, error: String(error) });
+      throw error;
+    }
+  }
+  async remove(id) {
+    if (!id) return;
+  }
+  async search(query, limit, repo) {
     try {
-        const stats = db.getStats();
-        process.stderr.write(`📊 Memory Count: ${stats.total} entries\n`);
-        process.stderr.write(`✅ SQLite Connection: Functional\n`);
-    }
-    catch (err) {
-        process.stderr.write(`❌ SQLite Connection: Failed (${String(err)})\n`);
-    }
-    process.stderr.write(`🤖 AI Model: Xenova/all-MiniLM-L6-v2\n`);
-    process.stderr.write(`⚙️  Mode: Local-First (ONNX Runtime)\n`);
-    const isAutoArchive = process.env.ENABLE_AUTO_ARCHIVE === "true";
-    process.stderr.write(`📉 Auto-Archive: ${isAutoArchive ? "Enabled" : "Disabled (Default)"}\n`);
-    process.stderr.write("\n✨ Diagnosis complete.\n\n");
-    process.exit(0);
-}
-// Create storage instances
-const db = new SQLiteStore();
-const vectors = new RealVectorStore(db);
-// Pre-load vector model in background to avoid initial request timeout
-vectors.initialize().catch(err => {
-    logger.warn("[Server] Initial vector model loading failed. Will retry on first use.", { error: String(err) });
+      const extractor = await this.getExtractor();
+      const output = await extractor(query, { pooling: "mean", normalize: true });
+      const queryVector = Array.from(output.data);
+      const rows = this.db.memories.getVectorCandidates(repo, 100);
+      const results = rows.map((row) => {
+        const memoryVector = JSON.parse(row.vector);
+        return {
+          id: row.memory_id,
+          score: this.cosineSimilarity(queryVector, memoryVector)
+        };
+      });
+      return results.sort((a, b) => b.score - a.score).slice(0, limit);
+    } catch (error) {
+      logger.error("[Vectors] Error during search", { error: String(error) });
+      return [];
+    }
+  }
+};
+
+// src/mcp/server.ts
+import fs2 from "fs";
+if (process.argv.includes("doctor")) {
+  process.stderr.write("\n\u{1F3E5} MCP Local Memory - System Diagnosis\n\n");
+  const db2 = new SQLiteStore();
+  const dbPath = db2.getDbPath();
+  process.stderr.write(`\u{1F4C2} Database Path: ${dbPath}
+`);
+  process.stderr.write(`\u{1F4C4} Database Status: ${fs2.existsSync(dbPath) ? "\u2705 Exists" : "\u274C Not Found"}
+`);
+  try {
+    const stats = db2.system.getStats();
+    process.stderr.write(`\u{1F4CA} Memory Count: ${stats.total} entries
+`);
+    process.stderr.write(`\u2705 SQLite Connection: Functional
+`);
+  } catch (err) {
+    process.stderr.write(`\u274C SQLite Connection: Failed (${String(err)})
+`);
+  }
+  process.stderr.write(`\u{1F916} AI Model: Xenova/all-MiniLM-L6-v2
+`);
+  process.stderr.write(`\u2699\uFE0F  Mode: Local-First (ONNX Runtime)
+`);
+  const isAutoArchive = process.env.ENABLE_AUTO_ARCHIVE === "true";
+  process.stderr.write(`\u{1F4C9} Auto-Archive: ${isAutoArchive ? "Enabled" : "Disabled (Default)"}
+`);
+  process.stderr.write("\n\u2728 Diagnosis complete.\n\n");
+  process.exit(0);
+}
+var db = new SQLiteStore();
+var vectors = new RealVectorStore(db);
+vectors.initialize().catch((err) => {
+  logger.warn("[Server] Initial vector model loading failed. Will retry on first use.", { error: String(err) });
 });
-// Optional: Automatic cleanup of expired/low-utility memories (default: disabled)
-// ... (rest of cleanup code) ...
-const expiredArchived = db.archiveExpiredMemories();
-const lowScoreArchived = db.archiveLowScoreMemories();
-const totalArchived = (expiredArchived || 0) + (lowScoreArchived || 0);
+var expiredArchived = db.memories.archiveExpiredMemories();
+var lowScoreArchived = db.memories.archiveLowScoreMemories();
+var totalArchived = (expiredArchived || 0) + (lowScoreArchived || 0);
 if (totalArchived > 0) {
-    logger.info(`[Server] Archived ${totalArchived} memories (expired: ${expiredArchived}, low-score: ${lowScoreArchived}) on startup.`);
+  logger.info(
+    `[Server] Archived ${totalArchived} memories (expired: ${expiredArchived}, low-score: ${lowScoreArchived}) on startup.`
+  );
 }
-// Ignore EPIPE errors on stdout/stderr (e.g. if the client disconnects prematurely)
-process.stdout.on('error', (err) => {
-    if (err.code === 'EPIPE')
-        return;
-    logger.error("stdout error", { error: String(err) });
+process.stdout.on("error", (err) => {
+  if (err.code === "EPIPE") return;
+  logger.error("stdout error", { error: String(err) });
 });
-process.stderr.on('error', (err) => {
-    if (err.code === 'EPIPE')
-        return;
-    logger.error("stderr error", { error: String(err) });
+process.stderr.on("error", (err) => {
+  if (err.code === "EPIPE") return;
+  logger.error("stderr error", { error: String(err) });
 });
-// Wire router with injected storage
-const session = createSessionContext();
-const resourceSubscriptions = new Set();
-let logNotificationsEnabled = false;
-const handleMethod = createRouter(db, vectors, {
-    getSessionContext: () => session,
-    sampleMessage: (params) => requestClient("sampling/createMessage", params),
-    elicit: (params) => requestClient("elicitation/create", params),
-    onResourcesMutated: (uris) => notifyUpdatedResources(uris),
+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,
-    });
+  if (!logNotificationsEnabled) {
+    return;
+  }
+  reply({
+    jsonrpc: "2.0",
+    method: "notifications/message",
+    params: payload
+  });
 });
-// Cleanup on exit
 process.on("SIGINT", () => {
-    for (const pending of pendingClientRequests.values()) {
-        pending.reject(new Error("Server stopped"));
-    }
-    pendingClientRequests.clear();
-    db.close();
-    process.exit(0);
+  for (const pending of pendingClientRequests.values()) {
+    pending.reject(new Error("Server stopped"));
+  }
+  pendingClientRequests.clear();
+  db.close();
+  process.exit(0);
 });
 process.on("SIGTERM", () => {
-    for (const pending of pendingClientRequests.values()) {
-        pending.reject(new Error("Server stopped"));
-    }
-    pendingClientRequests.clear();
-    db.close();
-    process.exit(0);
+  for (const pending of pendingClientRequests.values()) {
+    pending.reject(new Error("Server stopped"));
+  }
+  pendingClientRequests.clear();
+  db.close();
+  process.exit(0);
 });
-const rl = readline.createInterface({
-    input: process.stdin,
-    output: process.stdout,
-    terminal: false
+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) {
-        // Other errors still logged
-        logger.error("Reply error", { error: String(err) });
-    }
+  try {
+    process.stdout.write(JSON.stringify(payload) + "\n");
+  } catch (err) {
+    logger.error("Reply error", { error: String(err) });
+  }
 }
-let isInitialized = false;
-const activeRequests = new Map();
-const pendingClientRequests = new Map();
-let outgoingRequestId = 0;
+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 });
-    });
+  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),
-        });
+  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 = 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 },
-        });
+  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 === undefined || id === null;
-    if ((method === undefined || method === null) && id !== undefined && 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;
-    }
-    // --- initialize (Request) ---
-    if (method === "initialize" && !isNotification) {
-        updateSessionFromInitialize(session, params);
-        reply({
-            jsonrpc: "2.0",
-            id,
-            result: {
-                protocolVersion: MCP_PROTOCOL_VERSION,
-                serverInfo: CAPABILITIES.serverInfo,
-                capabilities: CAPABILITIES.capabilities
-            }
-        });
-        return;
-    }
-    // --- notifications ---
-    if (isNotification) {
-        // We ignore all notifications by default, especially standard ones
-        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 !== undefined && 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;
-    }
-    // --- ping (Request) ---
-    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;
-    }
-    // --- Ensure initialized before processing other requests ---
-    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 !== undefined ? (progress, total) => {
-        reply({
-            jsonrpc: "2.0",
-            method: "notifications/progress",
-            params: {
-                progressToken,
-                progress,
-                total
-            }
-        });
-    } : undefined;
-    // --- route request ---
-    try {
-        const result = await handleMethod(method, params, abortController.signal, onProgress);
-        if (!abortController.signal.aborted) {
-            reply({
-                jsonrpc: "2.0",
-                id,
-                result
-            });
+  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;
     }
-    catch (err) {
-        if (!abortController.signal.aborted) {
-            logger.error("Method handler error", { method, id, message: err.message });
-            reply({
-                jsonrpc: "2.0",
-                id,
-                error: {
-                    code: typeof err?.code === "number" ? err.code : -32603,
-                    message: err.message || "Internal error"
-                }
-            });
+    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;
     }
-    finally {
-        activeRequests.delete(id);
+    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);
+  }
 });
-//# sourceMappingURL=server.js.map