@vheins/local-memory-mcp 0.5.32 → 0.6.0

package/dist/chunk-XIJO63UU.js

@@ -0,0 +1,3618 @@
+// src/mcp/capabilities.ts
+import { fileURLToPath } from "url";
+import path from "path";
+import fs from "fs";
+var __dirname = path.dirname(fileURLToPath(import.meta.url));
+var pkgPath = path.join(__dirname, "../../package.json");
+var pkgVersion = "0.1.0";
+try {
+  if (fs.existsSync(pkgPath)) {
+    const pkg = JSON.parse(fs.readFileSync(pkgPath, "utf8"));
+    pkgVersion = pkg.version;
+  }
+} catch {
+}
+var MCP_PROTOCOL_VERSION = "2025-11-25";
+var CAPABILITIES = {
+  serverInfo: {
+    name: "mcp-memory-local",
+    version: pkgVersion
+  },
+  capabilities: {
+    completions: {},
+    logging: {},
+    resources: {
+      subscribe: true,
+      listChanged: true
+    },
+    tools: {
+      listChanged: false
+    },
+    prompts: {
+      listChanged: true
+    }
+  }
+};
+
+// src/mcp/utils/logger.ts
+var LEVELS = {
+  debug: 0,
+  info: 1,
+  notice: 2,
+  warning: 3,
+  error: 4,
+  critical: 5,
+  alert: 6,
+  emergency: 7
+};
+var LEVEL_ALIASES = {
+  warn: "warning"
+};
+var currentLevel = parseLevel(process.env.LOG_LEVEL?.toLowerCase());
+var sinks = /* @__PURE__ */ new Set();
+function parseLevel(raw) {
+  if (!raw) return "info";
+  const normalized = LEVEL_ALIASES[raw] || raw;
+  if (normalized in LEVELS) return normalized;
+  return "info";
+}
+function normalizeMethodLevel(level) {
+  return level === "warn" ? "warning" : level;
+}
+function formatContextForStderr(context) {
+  if (!context || Object.keys(context).length === 0) return "";
+  return ` ${JSON.stringify(context)}`;
+}
+function getMcpIcon(message) {
+  if (message.includes("search")) return "\u{1F50D}";
+  if (message.includes("store") || message.includes("write")) return "\u{1F4BE}";
+  if (message.includes("read") || message.includes("resource")) return "\u{1F4D6}";
+  if (message.includes("delete")) return "\u{1F5D1}\uFE0F";
+  if (message.includes("update")) return "\u{1F504}";
+  if (message.includes("acknowledge")) return "\u2705";
+  if (message.includes("recap")) return "\u{1F4CB}";
+  if (message.includes("task")) return "\u26A1";
+  return "\u{1F916}";
+}
+function deriveLoggerName(message) {
+  if (message.startsWith("[Server]")) return "server";
+  if (message.startsWith("[Vectors]")) return "vectors";
+  if (message.startsWith("[MCP]")) return "mcp";
+  if (message.startsWith("[Dashboard]")) return "dashboard";
+  return "app";
+}
+function emitToStderr(level, message, context) {
+  const timestamp = (/* @__PURE__ */ new Date()).toISOString();
+  if (message.startsWith("[MCP]")) {
+    const icon = getMcpIcon(message);
+    const action = message.replace("[MCP] ", "").trim();
+    process.stderr.write(`${timestamp} ${icon} [MCP] ${action.padEnd(7)}${formatContextForStderr(context)}
+`);
+    return;
+  }
+  const levelStr = level.toUpperCase().padEnd(9);
+  process.stderr.write(`${timestamp} [${levelStr}] ${message}${formatContextForStderr(context)}
+`);
+}
+function sanitizeLogData(message, context) {
+  return {
+    message,
+    ...context ?? {}
+  };
+}
+function emitToSinks(level, message, context) {
+  const payload = {
+    level,
+    logger: deriveLoggerName(message),
+    data: sanitizeLogData(message, context)
+  };
+  for (const sink of sinks) {
+    try {
+      sink(payload);
+    } catch {
+    }
+  }
+}
+function log(level, message, context) {
+  const normalizedLevel = normalizeMethodLevel(level);
+  if (LEVELS[normalizedLevel] < LEVELS[currentLevel]) return;
+  emitToStderr(normalizedLevel, message, context);
+  emitToSinks(normalizedLevel, message, context);
+}
+var logger = {
+  debug(message, context) {
+    log("debug", message, context);
+  },
+  info(message, context) {
+    log("info", message, context);
+  },
+  notice(message, context) {
+    log("notice", message, context);
+  },
+  warn(message, context) {
+    log("warn", message, context);
+  },
+  warning(message, context) {
+    log("warning", message, context);
+  },
+  error(message, context) {
+    log("error", message, context);
+  },
+  critical(message, context) {
+    log("critical", message, context);
+  },
+  alert(message, context) {
+    log("alert", message, context);
+  },
+  emergency(message, context) {
+    log("emergency", message, context);
+  }
+};
+function setLogLevel(level) {
+  const raw = level.toLowerCase();
+  const normalized = LEVEL_ALIASES[raw] || raw;
+  if (!(normalized in LEVELS)) {
+    const error = new Error(`Invalid log level: ${level}`);
+    error.code = -32602;
+    throw error;
+  }
+  currentLevel = normalized;
+  return currentLevel;
+}
+function getLogLevel() {
+  return currentLevel;
+}
+function addLogSink(sink) {
+  sinks.add(sink);
+  return () => sinks.delete(sink);
+}
+var LOG_LEVEL_VALUES = Object.keys(LEVELS);
+
+// src/mcp/storage/sqlite.ts
+import Database from "better-sqlite3";
+import path2 from "path";
+import fs2 from "fs";
+import os from "os";
+
+// src/mcp/storage/migrations.ts
+var MigrationManager = class {
+  constructor(db) {
+    this.db = db;
+  }
+  db;
+  migrate() {
+    this.db.exec(`
+      CREATE TABLE IF NOT EXISTS memories (
+        id TEXT PRIMARY KEY,
+        repo TEXT NOT NULL,
+        type TEXT NOT NULL,
+        title TEXT,
+        content TEXT NOT NULL,
+        importance INTEGER NOT NULL CHECK (importance BETWEEN 1 AND 5),
+        folder TEXT,
+        language TEXT,
+        created_at TEXT NOT NULL,
+        updated_at TEXT NOT NULL,
+        hit_count INTEGER NOT NULL DEFAULT 0,
+        recall_count INTEGER NOT NULL DEFAULT 0,
+        last_used_at TEXT,
+        agent TEXT NOT NULL DEFAULT 'unknown',
+        role TEXT NOT NULL DEFAULT 'unknown',
+        model TEXT NOT NULL DEFAULT 'unknown',
+        completed_at TEXT
+      );
+
+      CREATE INDEX IF NOT EXISTS idx_memories_repo ON memories(repo);
+      CREATE INDEX IF NOT EXISTS idx_memories_type ON memories(type);
+      CREATE INDEX IF NOT EXISTS idx_memories_importance ON memories(importance);
+      CREATE INDEX IF NOT EXISTS idx_memories_hit_count ON memories(hit_count);
+      CREATE INDEX IF NOT EXISTS idx_memories_created_at ON memories(created_at);
+      CREATE INDEX IF NOT EXISTS idx_memories_updated_at ON memories(updated_at);
+      CREATE INDEX IF NOT EXISTS idx_memories_repo_created_at ON memories(repo, created_at DESC);
+      CREATE INDEX IF NOT EXISTS idx_memories_repo_hit_count ON memories(repo, hit_count DESC);
+      CREATE INDEX IF NOT EXISTS idx_memories_title ON memories(title);
+
+      CREATE TABLE IF NOT EXISTS memory_summary (
+        repo TEXT PRIMARY KEY,
+        summary TEXT NOT NULL,
+        updated_at TEXT NOT NULL
+      );
+
+      CREATE TABLE IF NOT EXISTS memory_vectors (
+        memory_id TEXT PRIMARY KEY,
+        vector TEXT NOT NULL,
+        updated_at TEXT NOT NULL,
+        FOREIGN KEY (memory_id) REFERENCES memories(id) ON DELETE CASCADE
+      );
+
+      CREATE TABLE IF NOT EXISTS tasks (
+        id TEXT PRIMARY KEY,
+        repo TEXT NOT NULL,
+        task_code TEXT NOT NULL,
+        phase TEXT,
+        title TEXT NOT NULL,
+        description TEXT,
+        status TEXT NOT NULL DEFAULT 'backlog',
+        priority INTEGER NOT NULL DEFAULT 3,
+        agent TEXT NOT NULL DEFAULT 'unknown',
+        role TEXT NOT NULL DEFAULT 'unknown',
+        doc_path TEXT,
+        created_at TEXT NOT NULL,
+        updated_at TEXT NOT NULL,
+        finished_at TEXT,
+        canceled_at TEXT,
+        tags TEXT,
+        metadata TEXT,
+        parent_id TEXT,
+        depends_on TEXT,
+        est_tokens INTEGER NOT NULL DEFAULT 0,
+        in_progress_at TEXT,
+        FOREIGN KEY (parent_id) REFERENCES tasks(id) ON DELETE SET NULL,
+        FOREIGN KEY (depends_on) REFERENCES tasks(id) ON DELETE SET NULL
+      );
+
+      CREATE INDEX IF NOT EXISTS idx_tasks_repo ON tasks(repo);
+      CREATE INDEX IF NOT EXISTS idx_tasks_code ON tasks(task_code);
+      CREATE INDEX IF NOT EXISTS idx_tasks_status ON tasks(status);
+      CREATE INDEX IF NOT EXISTS idx_tasks_phase ON tasks(phase);
+      CREATE INDEX IF NOT EXISTS idx_tasks_priority ON tasks(priority);
+      CREATE INDEX IF NOT EXISTS idx_tasks_created_at ON tasks(created_at);
+
+      CREATE TABLE IF NOT EXISTS task_comments (
+        id TEXT PRIMARY KEY,
+        task_id TEXT NOT NULL,
+        repo TEXT NOT NULL,
+        comment TEXT NOT NULL,
+        agent TEXT NOT NULL DEFAULT 'unknown',
+        role TEXT NOT NULL DEFAULT 'unknown',
+        model TEXT NOT NULL DEFAULT 'unknown',
+        previous_status TEXT,
+        next_status TEXT,
+        created_at TEXT NOT NULL,
+        FOREIGN KEY (task_id) REFERENCES tasks(id) ON DELETE CASCADE
+      );
+
+      CREATE INDEX IF NOT EXISTS idx_task_comments_task_id ON task_comments(task_id);
+      CREATE INDEX IF NOT EXISTS idx_task_comments_repo ON task_comments(repo);
+      CREATE INDEX IF NOT EXISTS idx_task_comments_created_at ON task_comments(created_at DESC);
+
+      CREATE TABLE IF NOT EXISTS memories_archive (
+        id TEXT PRIMARY KEY,
+        repo TEXT NOT NULL,
+        type TEXT NOT NULL,
+        content TEXT NOT NULL,
+        importance INTEGER NOT NULL,
+        folder TEXT,
+        language TEXT,
+        created_at TEXT NOT NULL,
+        updated_at TEXT NOT NULL,
+        hit_count INTEGER NOT NULL DEFAULT 0,
+        recall_count INTEGER NOT NULL DEFAULT 0,
+        last_used_at TEXT,
+        expires_at TEXT,
+        archived_at TEXT NOT NULL,
+        agent TEXT NOT NULL DEFAULT 'unknown',
+        role TEXT NOT NULL DEFAULT 'unknown',
+        model TEXT NOT NULL DEFAULT 'unknown',
+        completed_at TEXT
+      );
+
+      CREATE TABLE IF NOT EXISTS action_log (
+        id INTEGER PRIMARY KEY AUTOINCREMENT,
+        action TEXT NOT NULL,
+        query TEXT,
+        response TEXT,
+        memory_id TEXT,
+        task_id TEXT,
+        repo TEXT NOT NULL,
+        result_count INTEGER NOT NULL DEFAULT 0,
+        created_at TEXT NOT NULL
+      );
+
+      CREATE INDEX IF NOT EXISTS idx_action_log_repo ON action_log(repo);
+      CREATE INDEX IF NOT EXISTS idx_action_log_created_at ON action_log(created_at);
+
+      -- FTS5 Virtual Table for Memories
+      -- Note: Only using id, title, and content for search indexing
+      CREATE VIRTUAL TABLE IF NOT EXISTS memories_fts USING fts5(
+        id UNINDEXED,
+        repo,
+        type,
+        title,
+        content,
+        metadata UNINDEXED,
+        content='memories',
+        content_rowid='id'
+      );
+
+      -- Triggers to keep FTS index in sync with base table
+      CREATE TRIGGER IF NOT EXISTS memories_ai AFTER INSERT ON memories BEGIN
+        INSERT INTO memories_fts(id, repo, type, title, content, metadata) 
+        VALUES (new.id, new.repo, new.type, new.title, new.content, new.metadata);
+      END;
+      CREATE TRIGGER IF NOT EXISTS memories_ad AFTER DELETE ON memories BEGIN
+        INSERT INTO memories_fts(memories_fts, id, repo, type, title, content, metadata) 
+        VALUES ('delete', old.id, old.repo, old.type, old.title, old.content, old.metadata);
+      END;
+      CREATE TRIGGER IF NOT EXISTS memories_au AFTER UPDATE ON memories BEGIN
+        INSERT INTO memories_fts(memories_fts, id, repo, type, title, content, metadata) 
+        VALUES ('delete', old.id, old.repo, old.type, old.title, old.content, old.metadata);
+        INSERT INTO memories_fts(id, repo, type, title, content, metadata) 
+        VALUES (new.id, new.repo, new.type, new.title, new.content, new.metadata);
+      END;
+    `);
+    const columnsToAdd = [
+      { name: "title", table: "memories", definition: "ALTER TABLE memories ADD COLUMN title TEXT" },
+      {
+        name: "hit_count",
+        table: "memories",
+        definition: "ALTER TABLE memories ADD COLUMN hit_count INTEGER NOT NULL DEFAULT 0"
+      },
+      {
+        name: "recall_count",
+        table: "memories",
+        definition: "ALTER TABLE memories ADD COLUMN recall_count INTEGER NOT NULL DEFAULT 0"
+      },
+      { name: "last_used_at", table: "memories", definition: "ALTER TABLE memories ADD COLUMN last_used_at TEXT" },
+      { name: "expires_at", table: "memories", definition: "ALTER TABLE memories ADD COLUMN expires_at TEXT" },
+      { name: "supersedes", table: "memories", definition: "ALTER TABLE memories ADD COLUMN supersedes TEXT" },
+      {
+        name: "status",
+        table: "memories",
+        definition: "ALTER TABLE memories ADD COLUMN status TEXT NOT NULL DEFAULT 'active'"
+      },
+      {
+        name: "is_global",
+        table: "memories",
+        definition: "ALTER TABLE memories ADD COLUMN is_global INTEGER NOT NULL DEFAULT 0"
+      },
+      { name: "tags", table: "memories", definition: "ALTER TABLE memories ADD COLUMN tags TEXT" },
+      { name: "metadata", table: "memories", definition: "ALTER TABLE memories ADD COLUMN metadata TEXT" },
+      {
+        name: "vector_version",
+        table: "memory_vectors",
+        definition: "ALTER TABLE memory_vectors ADD COLUMN vector_version INTEGER NOT NULL DEFAULT 1"
+      },
+      { name: "depends_on", table: "tasks", definition: "ALTER TABLE tasks ADD COLUMN depends_on TEXT" },
+      {
+        name: "est_tokens",
+        table: "tasks",
+        definition: "ALTER TABLE tasks ADD COLUMN est_tokens INTEGER NOT NULL DEFAULT 0"
+      },
+      { name: "in_progress_at", table: "tasks", definition: "ALTER TABLE tasks ADD COLUMN in_progress_at TEXT" },
+      { name: "task_code", table: "tasks", definition: "ALTER TABLE tasks ADD COLUMN task_code TEXT" },
+      { name: "task_id", table: "action_log", definition: "ALTER TABLE action_log ADD COLUMN task_id TEXT" },
+      {
+        name: "agent",
+        table: "memories",
+        definition: "ALTER TABLE memories ADD COLUMN agent TEXT NOT NULL DEFAULT 'unknown'"
+      },
+      {
+        name: "role",
+        table: "memories",
+        definition: "ALTER TABLE memories ADD COLUMN role TEXT NOT NULL DEFAULT 'unknown'"
+      },
+      {
+        name: "model",
+        table: "memories",
+        definition: "ALTER TABLE memories ADD COLUMN model TEXT NOT NULL DEFAULT 'unknown'"
+      },
+      { name: "completed_at", table: "memories", definition: "ALTER TABLE memories ADD COLUMN completed_at TEXT" },
+      {
+        name: "agent",
+        table: "tasks",
+        definition: "ALTER TABLE tasks ADD COLUMN agent TEXT NOT NULL DEFAULT 'unknown'"
+      },
+      { name: "role", table: "tasks", definition: "ALTER TABLE tasks ADD COLUMN role TEXT NOT NULL DEFAULT 'unknown'" },
+      { name: "doc_path", table: "tasks", definition: "ALTER TABLE tasks ADD COLUMN doc_path TEXT" },
+      { name: "response", table: "action_log", definition: "ALTER TABLE action_log ADD COLUMN response TEXT" }
+    ];
+    for (const col of columnsToAdd) {
+      try {
+        const tableInfo = this.db.prepare(`PRAGMA table_info(${col.table})`).all();
+        const existingTableColumns = tableInfo.map((c) => c.name);
+        if (tableInfo.length > 0 && !existingTableColumns.includes(col.name)) {
+          this.db.exec(col.definition);
+        }
+      } catch (e) {
+        logger.error(
+          `Migration step failed for ${col.table}.${col.name}: ${e instanceof Error ? e.message : String(e)}`
+        );
+      }
+    }
+    this.ensureMemoryTypeConstraint();
+    this.ensureTaskStatusConstraintRemoved();
+    this.ensureMemoryStatusConstraintRemoved();
+    this.db.exec(`
+      CREATE INDEX IF NOT EXISTS idx_memories_status ON memories(status);
+      CREATE INDEX IF NOT EXISTS idx_memories_supersedes ON memories(supersedes);
+      CREATE INDEX IF NOT EXISTS idx_memories_is_global ON memories(is_global);
+    `);
+    try {
+      this.db.exec("UPDATE tasks SET task_code = substr(id, 1, 8) WHERE task_code IS NULL");
+    } catch (e) {
+      logger.error(`Legacy backfill task_code failed: ${e instanceof Error ? e.message : String(e)}`);
+    }
+  }
+  ensureMemoryTypeConstraint() {
+    const tableSql = this.db.prepare("SELECT sql FROM sqlite_master WHERE type = 'table' AND name = 'memories'").get();
+    if (!tableSql?.sql || !tableSql.sql.includes("CHECK (type IN")) {
+      return;
+    }
+    this.db.exec(`
+      BEGIN TRANSACTION;
+
+      CREATE TABLE memories__migrated (
+        id TEXT PRIMARY KEY,
+        repo TEXT NOT NULL,
+        type TEXT NOT NULL,
+        title TEXT,
+        content TEXT NOT NULL,
+        importance INTEGER NOT NULL CHECK (importance BETWEEN 1 AND 5),
+        folder TEXT,
+        language TEXT,
+        created_at TEXT NOT NULL,
+        updated_at TEXT NOT NULL,
+        hit_count INTEGER NOT NULL DEFAULT 0,
+        recall_count INTEGER NOT NULL DEFAULT 0,
+        last_used_at TEXT,
+        expires_at TEXT,
+        supersedes TEXT,
+        status TEXT NOT NULL DEFAULT 'active',
+        is_global INTEGER NOT NULL DEFAULT 0,
+        tags TEXT,
+        metadata TEXT,
+        agent TEXT NOT NULL DEFAULT 'unknown',
+        role TEXT NOT NULL DEFAULT 'unknown',
+        model TEXT NOT NULL DEFAULT 'unknown',
+        completed_at TEXT
+      );
+
+      INSERT INTO memories__migrated (
+        id, repo, type, title, content, importance, folder, language,
+        created_at, updated_at, hit_count, recall_count, last_used_at, expires_at,
+        supersedes, status, is_global, tags, metadata, agent, role, model, completed_at
+      )
+      SELECT
+        id, repo, type, title, content, importance, folder, language,
+        created_at, updated_at, hit_count, recall_count, last_used_at, expires_at,
+        supersedes, status, is_global, tags, metadata, agent, role, model, completed_at
+      FROM memories;
+
+      DROP TABLE memories;
+      ALTER TABLE memories__migrated RENAME TO memories;
+
+      COMMIT;
+    `);
+  }
+  ensureTaskStatusConstraintRemoved() {
+    const tableSql = this.db.prepare("SELECT sql FROM sqlite_master WHERE type = 'table' AND name = 'tasks'").get();
+    if (!tableSql?.sql || !tableSql.sql.includes("CHECK (status IN") && !tableSql.sql.includes("DEFAULT 'pending'")) {
+      return;
+    }
+    this.db.exec(`
+      BEGIN TRANSACTION;
+
+      CREATE TABLE tasks__migrated (
+        id TEXT PRIMARY KEY,
+        repo TEXT NOT NULL,
+        task_code TEXT NOT NULL,
+        phase TEXT,
+        title TEXT NOT NULL,
+        description TEXT,
+        status TEXT NOT NULL DEFAULT 'backlog',
+        priority INTEGER NOT NULL DEFAULT 3,
+        agent TEXT NOT NULL DEFAULT 'unknown',
+        role TEXT NOT NULL DEFAULT 'unknown',
+        doc_path TEXT,
+        created_at TEXT NOT NULL,
+        updated_at TEXT NOT NULL,
+        finished_at TEXT,
+        canceled_at TEXT,
+        tags TEXT,
+        metadata TEXT,
+        parent_id TEXT,
+        depends_on TEXT,
+        est_tokens INTEGER NOT NULL DEFAULT 0,
+        in_progress_at TEXT,
+        FOREIGN KEY (parent_id) REFERENCES tasks(id) ON DELETE SET NULL,
+        FOREIGN KEY (depends_on) REFERENCES tasks(id) ON DELETE SET NULL
+      );
+
+      INSERT INTO tasks__migrated (
+        id, repo, task_code, phase, title, description, status, priority,
+        agent, role, doc_path, created_at, updated_at, finished_at, canceled_at, tags, metadata, parent_id, depends_on, est_tokens, in_progress_at
+      )
+      SELECT
+        id, repo, task_code, phase, title, description, status, priority,
+        agent, role, doc_path, created_at, updated_at, finished_at, canceled_at, tags, metadata, parent_id, depends_on, est_tokens, in_progress_at
+      FROM tasks;
+
+      DROP TABLE tasks;
+      ALTER TABLE tasks__migrated RENAME TO tasks;
+
+      COMMIT;
+    `);
+  }
+  ensureMemoryStatusConstraintRemoved() {
+    const tableSql = this.db.prepare("SELECT sql FROM sqlite_master WHERE type = 'table' AND name = 'memories'").get();
+    if (tableSql?.sql?.includes("status TEXT NOT NULL DEFAULT 'active' CHECK")) {
+      this.ensureMemoryTypeConstraint();
+    }
+  }
+};
+
+// src/mcp/utils/normalize.ts
+var STOPWORDS = /* @__PURE__ */ new Set([
+  // English stopwords
+  "a",
+  "an",
+  "the",
+  "and",
+  "or",
+  "but",
+  "in",
+  "on",
+  "at",
+  "to",
+  "for",
+  "of",
+  "with",
+  "by",
+  "from",
+  "up",
+  "about",
+  "into",
+  "through",
+  "during",
+  "is",
+  "are",
+  "was",
+  "were",
+  "be",
+  "been",
+  "being",
+  "have",
+  "has",
+  "had",
+  "do",
+  "does",
+  "did",
+  "will",
+  "would",
+  "could",
+  "should",
+  "may",
+  "might",
+  "shall",
+  "can",
+  "need",
+  "dare",
+  "ought",
+  "used",
+  "i",
+  "me",
+  "my",
+  "myself",
+  "we",
+  "our",
+  "ours",
+  "ourselves",
+  "you",
+  "your",
+  "yours",
+  "yourself",
+  "yourselves",
+  "he",
+  "him",
+  "his",
+  "himself",
+  "she",
+  "her",
+  "hers",
+  "herself",
+  "it",
+  "its",
+  "itself",
+  "they",
+  "them",
+  "their",
+  "theirs",
+  "themselves",
+  "what",
+  "which",
+  "who",
+  "whom",
+  "this",
+  "that",
+  "these",
+  "those",
+  "am",
+  "if",
+  "then",
+  "else",
+  "when",
+  "where",
+  "why",
+  "how",
+  "all",
+  "both",
+  "each",
+  "few",
+  "more",
+  "most",
+  "other",
+  "some",
+  "such",
+  "no",
+  "not",
+  "only",
+  "same",
+  "so",
+  "than",
+  "too",
+  "very",
+  "just",
+  "because",
+  "as",
+  "until",
+  "while",
+  "although",
+  "though",
+  "after",
+  "before",
+  "since",
+  "between",
+  "out",
+  "off",
+  "over",
+  "under",
+  "again",
+  "further",
+  "once",
+  "here",
+  "there",
+  "any",
+  "also",
+  // Indonesian stopwords
+  "yang",
+  "dan",
+  "di",
+  "ke",
+  "dari",
+  "ini",
+  "itu",
+  "dengan",
+  "untuk",
+  "pada",
+  "adalah",
+  "dalam",
+  "tidak",
+  "akan",
+  "juga",
+  "ada",
+  "saya",
+  "kita",
+  "kami",
+  "mereka",
+  "dia",
+  "ia",
+  "anda",
+  "kamu",
+  "aku",
+  "bisa",
+  "dapat",
+  "harus",
+  "sudah",
+  "telah",
+  "sedang",
+  "masih",
+  "lebih",
+  "sangat",
+  "paling",
+  "hanya",
+  "jika",
+  "kalau",
+  "karena",
+  "sehingga",
+  "namun",
+  "tetapi",
+  "tapi",
+  "atau",
+  "maupun",
+  "bahwa",
+  "oleh",
+  "seperti",
+  "antara",
+  "setelah",
+  "sebelum",
+  "ketika",
+  "saat",
+  "semua",
+  "setiap",
+  "beberapa",
+  "banyak",
+  "sedikit",
+  "lain",
+  "lainnya",
+  "tersebut",
+  "nya",
+  "pun",
+  "lah",
+  "kah",
+  "dah",
+  "agar",
+  "supaya",
+  "maka",
+  "meski",
+  "walaupun",
+  "meskipun",
+  "selain",
+  "selama",
+  "sejak",
+  "hingga",
+  "sampai",
+  "tentang",
+  "terhadap",
+  "melalui",
+  "tanpa",
+  "bagi",
+  "atas",
+  "bawah",
+  "depan",
+  "belakang",
+  "kiri",
+  "kanan",
+  "sini",
+  "sana",
+  "situ",
+  "begitu",
+  "begini",
+  "demikian",
+  "hal",
+  "cara",
+  "waktu",
+  "tempat"
+]);
+function normalize(text) {
+  return text.toLowerCase().replace(/[^a-z0-9\s_\-.]/g, " ").replace(/\s+/g, " ").trim();
+}
+function normalizeRepo(repo) {
+  if (!repo) return "";
+  const parts = repo.split("/");
+  return parts[parts.length - 1].trim();
+}
+function tokenize(text) {
+  return normalize(text).split(" ").filter((token) => token.length > 0 && !STOPWORDS.has(token));
+}
+
+// src/mcp/storage/base.ts
+var BaseEntity = class {
+  constructor(db) {
+    this.db = db;
+  }
+  db;
+  /**
+   * Safe JSON parsing helper to avoid crashes on corrupt data
+   */
+  safeJSONParse(json, defaultValue) {
+    if (!json) return defaultValue;
+    try {
+      return JSON.parse(json);
+    } catch {
+      return defaultValue;
+    }
+  }
+  /**
+   * Mapping helper for MemoryEntry
+   */
+  rowToMemoryEntry(row) {
+    const r = row;
+    return {
+      id: r.id,
+      type: r.type,
+      title: r.title || "Untitled",
+      content: r.content,
+      importance: r.importance,
+      agent: r.agent || "unknown",
+      role: r.role || "unknown",
+      model: r.model || "unknown",
+      scope: {
+        repo: r.repo,
+        folder: r.folder || void 0,
+        language: r.language || void 0
+      },
+      created_at: r.created_at,
+      updated_at: r.updated_at,
+      completed_at: r.completed_at || null,
+      hit_count: r.hit_count ?? 0,
+      recall_count: r.recall_count ?? 0,
+      last_used_at: r.last_used_at ?? null,
+      expires_at: r.expires_at ?? null,
+      supersedes: r.supersedes ?? null,
+      status: r.status || "active",
+      is_global: r.is_global === 1,
+      tags: this.safeJSONParse(r.tags, []),
+      metadata: this.safeJSONParse(r.metadata, {})
+    };
+  }
+  /**
+   * Mapping helper for Task
+   */
+  rowToTask(row) {
+    const r = row;
+    return {
+      id: r.id,
+      repo: r.repo,
+      task_code: r.task_code,
+      phase: r.phase || "",
+      title: r.title,
+      description: r.description || null,
+      status: r.status || "backlog",
+      priority: r.priority || 3,
+      agent: r.agent || "unknown",
+      role: r.role || "unknown",
+      doc_path: r.doc_path || null,
+      created_at: r.created_at,
+      updated_at: r.updated_at,
+      in_progress_at: r.in_progress_at || null,
+      finished_at: r.finished_at || null,
+      canceled_at: r.canceled_at || null,
+      est_tokens: r.est_tokens || 0,
+      tags: this.safeJSONParse(r.tags, []),
+      metadata: this.safeJSONParse(r.metadata, {}),
+      parent_id: r.parent_id || null,
+      depends_on: r.depends_on || null,
+      comments_count: r.comments_count || 0
+    };
+  }
+  /**
+   * Vector math utilities (simple bag-of-words implementation)
+   */
+  computeVector(text) {
+    const tokens = tokenize(text);
+    const vector = {};
+    tokens.forEach((token) => {
+      vector[token] = (vector[token] || 0) + 1;
+    });
+    return vector;
+  }
+  cosineSimilarity(v1, v2) {
+    const keys1 = Object.keys(v1);
+    const keys2 = Object.keys(v2);
+    if (!keys1.length || !keys2.length) return 0;
+    let dotProduct = 0;
+    for (const key of keys1) {
+      if (v2[key]) dotProduct += v1[key] * v2[key];
+    }
+    let mag1 = 0;
+    for (const key of keys1) mag1 += v1[key] * v1[key];
+    let mag2 = 0;
+    for (const key of keys2) mag2 += v2[key] * v2[key];
+    const mag = Math.sqrt(mag1) * Math.sqrt(mag2);
+    return mag === 0 ? 0 : dotProduct / mag;
+  }
+};
+
+// src/mcp/entities/memory.ts
+var MemoryEntity = class extends BaseEntity {
+  insert(entry) {
+    const stmt = this.db.prepare(`
+      INSERT INTO memories (
+        id, repo, type, title, content, importance, folder, language,
+        created_at, updated_at, hit_count, recall_count, last_used_at, expires_at,
+        supersedes, status, is_global, tags, metadata, agent, role, model, completed_at
+      ) VALUES (?, ?, ?, ?, ?, ?, ?, ?, ?, ?, 0, 0, NULL, ?, ?, ?, ?, ?, ?, ?, ?, ?, ?)
+    `);
+    stmt.run(
+      entry.id,
+      entry.scope.repo,
+      entry.type,
+      entry.title || null,
+      entry.content,
+      entry.importance,
+      entry.scope.folder || null,
+      entry.scope.language || null,
+      entry.created_at,
+      entry.updated_at,
+      entry.expires_at ?? null,
+      entry.supersedes ?? null,
+      entry.status || "active",
+      entry.is_global ? 1 : 0,
+      entry.tags ? JSON.stringify(entry.tags) : null,
+      entry.metadata ? JSON.stringify(entry.metadata) : null,
+      entry.agent || "unknown",
+      entry.role || "unknown",
+      entry.model || "unknown",
+      entry.completed_at || null
+    );
+  }
+  update(id, updates) {
+    const fields = [];
+    const values = [];
+    Object.keys(updates).forEach((key) => {
+      const k = key;
+      const val = updates[k];
+      if (val !== void 0) {
+        if (k === "scope") {
+          const scope = updates.scope;
+          if (scope?.repo) {
+            fields.push("repo = ?");
+            values.push(scope.repo);
+          }
+          if (scope?.folder !== void 0) {
+            fields.push("folder = ?");
+            values.push(scope.folder);
+          }
+          if (scope?.language !== void 0) {
+            fields.push("language = ?");
+            values.push(scope.language);
+          }
+        } else if (k === "tags" || k === "metadata") {
+          fields.push(`${k} = ?`);
+          values.push(JSON.stringify(val));
+        } else if (k === "is_global") {
+          fields.push(`${k} = ?`);
+          values.push(val ? 1 : 0);
+        } else if (k !== "id" && k !== "created_at") {
+          fields.push(`${k} = ?`);
+          values.push(val);
+        }
+      }
+    });
+    if (fields.length === 0) return;
+    fields.push("updated_at = ?");
+    values.push((/* @__PURE__ */ new Date()).toISOString());
+    values.push(id);
+    const stmt = this.db.prepare(`UPDATE memories SET ${fields.join(", ")} WHERE id = ?`);
+    stmt.run(...values);
+  }
+  delete(id) {
+    this.db.prepare("DELETE FROM memories WHERE id = ?").run(id);
+  }
+  getById(id) {
+    const row = this.db.prepare("SELECT * FROM memories WHERE id = ?").get(id);
+    return row ? this.rowToMemoryEntry(row) : null;
+  }
+  getByIdWithStats(id) {
+    const row = this.db.prepare(
+      `
+      SELECT *, CASE WHEN hit_count > 0 THEN CAST(recall_count AS REAL) / hit_count ELSE 0 END AS recall_rate
+      FROM memories WHERE id = ?
+    `
+    ).get(id);
+    if (!row) return null;
+    return {
+      ...this.rowToMemoryEntry(row),
+      recall_rate: row.recall_rate ?? 0
+    };
+  }
+  getByIds(ids, options = {}) {
+    if (ids.length === 0) return [];
+    let sql = `SELECT * FROM memories WHERE id IN (${ids.map(() => "?").join(",")})`;
+    const params = [...ids];
+    if (options.type) {
+      sql += " AND type = ?";
+      params.push(options.type);
+    }
+    if (options.status) {
+      sql += " AND status = ?";
+      params.push(options.status);
+    }
+    const rows = this.db.prepare(sql).all(...params);
+    return rows.map((row) => this.rowToMemoryEntry(row));
+  }
+  getStats(repo) {
+    let sql = "SELECT type, COUNT(*) as count FROM memories";
+    const params = [];
+    if (repo) {
+      sql += " WHERE repo = ?";
+      params.push(repo);
+    }
+    sql += " GROUP BY type";
+    const rows = this.db.prepare(sql).all(...params);
+    const byType = {};
+    let total = 0;
+    rows.forEach((row) => {
+      byType[row.type] = row.count;
+      total += row.count;
+    });
+    return { total, byType };
+  }
+  searchByRepo(repo, query = "", type, limit = 5) {
+    const now = (/* @__PURE__ */ new Date()).toISOString();
+    if (query && query.length >= 3) {
+      try {
+        let sql2 = `
+					SELECT m.* 
+					FROM memories m
+					JOIN memories_fts f ON m.id = f.id
+					WHERE m.repo = ? AND memories_fts MATCH ? AND m.status = 'active' 
+					AND (m.expires_at IS NULL OR m.expires_at > ?)
+				`;
+        const params2 = [repo, query, now];
+        if (type) {
+          sql2 += " AND m.type = ?";
+          params2.push(type);
+        }
+        sql2 += " ORDER BY rank, m.importance DESC, m.created_at DESC LIMIT ?";
+        params2.push(limit);
+        const rows2 = this.db.prepare(sql2).all(...params2);
+        return rows2.map((row) => this.rowToMemoryEntry(row));
+      } catch (e) {
+        logger.warn("FTS5 similarity search failed, falling back to LIKE", {
+          error: e instanceof Error ? e.message : String(e),
+          repo,
+          query
+        });
+      }
+    }
+    let sql = "SELECT * FROM memories WHERE repo = ? AND (content LIKE ? OR title LIKE ? OR tags LIKE ?) AND status = 'active' AND (expires_at IS NULL OR expires_at > ?)";
+    const params = [repo, `%${query}%`, `%${query}%`, `%${query}%`, now];
+    if (type) {
+      sql += " AND type = ?";
+      params.push(type);
+    }
+    sql += " ORDER BY importance DESC, created_at DESC LIMIT ?";
+    params.push(limit);
+    const rows = this.db.prepare(sql).all(...params);
+    return rows.map((row) => this.rowToMemoryEntry(row));
+  }
+  bulkInsertMemories(entries) {
+    const insert = this.db.prepare(`
+      INSERT INTO memories (
+        id, repo, type, title, content, importance, folder, language,
+        created_at, updated_at, hit_count, recall_count, last_used_at, expires_at,
+        supersedes, status, is_global, tags, metadata, agent, role, model, completed_at
+      ) VALUES (?, ?, ?, ?, ?, ?, ?, ?, ?, ?, 0, 0, NULL, ?, ?, ?, ?, ?, ?, ?, ?, ?, ?)
+    `);
+    const insertMany = this.db.transaction((entries2) => {
+      let count = 0;
+      for (const entry of entries2) {
+        insert.run(
+          entry.id,
+          entry.scope.repo,
+          entry.type,
+          entry.title || null,
+          entry.content,
+          entry.importance,
+          entry.scope.folder || null,
+          entry.scope.language || null,
+          entry.created_at,
+          entry.updated_at,
+          entry.expires_at ?? null,
+          entry.supersedes ?? null,
+          entry.status || "active",
+          entry.is_global ? 1 : 0,
+          entry.tags ? JSON.stringify(entry.tags) : null,
+          entry.metadata ? JSON.stringify(entry.metadata) : null,
+          entry.agent || "unknown",
+          entry.role || "unknown",
+          entry.model || "unknown",
+          entry.completed_at || null
+        );
+        count++;
+      }
+      return count;
+    });
+    return insertMany(entries);
+  }
+  bulkUpdateMemories(ids, updates) {
+    if (ids.length === 0) return 0;
+    const fields = [];
+    const values = [];
+    Object.keys(updates).forEach((key) => {
+      const value = updates[key];
+      if (value !== void 0) {
+        if (key === "tags" || key === "metadata") {
+          fields.push(`${key} = ?`);
+          values.push(JSON.stringify(value));
+        } else if (key === "is_global") {
+          fields.push(`${key} = ?`);
+          values.push(value ? 1 : 0);
+        } else {
+          fields.push(`${key} = ?`);
+          values.push(value);
+        }
+      }
+    });
+    if (fields.length === 0) return 0;
+    fields.push("updated_at = ?");
+    values.push((/* @__PURE__ */ new Date()).toISOString());
+    const updateMany = this.db.transaction((ids2, fields2, values2) => {
+      let count = 0;
+      const chunkSize = 500;
+      for (let i = 0; i < ids2.length; i += chunkSize) {
+        const chunk = ids2.slice(i, i + chunkSize);
+        const stmt = this.db.prepare(
+          `UPDATE memories SET ${fields2.join(", ")} WHERE id IN (${chunk.map(() => "?").join(",")})`
+        );
+        const result = stmt.run(...values2, ...chunk);
+        count += result.changes;
+      }
+      return count;
+    });
+    return updateMany(ids, fields, values);
+  }
+  bulkDeleteMemories(ids) {
+    if (ids.length === 0) return 0;
+    const deleteMany = this.db.transaction((ids2) => {
+      let count = 0;
+      const chunkSize = 500;
+      for (let i = 0; i < ids2.length; i += chunkSize) {
+        const chunk = ids2.slice(i, i + chunkSize);
+        const stmt = this.db.prepare(`DELETE FROM memories WHERE id IN (${chunk.map(() => "?").join(",")})`);
+        const result = stmt.run(...chunk);
+        count += result.changes;
+      }
+      return count;
+    });
+    return deleteMany(ids);
+  }
+  getRecentMemories(repo, limit, offset = 0, includeArchived = false, excludeTypes = []) {
+    let query = "SELECT * FROM memories WHERE repo = ?";
+    const params = [repo];
+    if (!includeArchived) {
+      query += " AND status = 'active'";
+    }
+    if (excludeTypes.length > 0) {
+      query += ` AND type NOT IN (${excludeTypes.map(() => "?").join(",")})`;
+      params.push(...excludeTypes);
+    }
+    query += " ORDER BY created_at DESC LIMIT ? OFFSET ?";
+    params.push(limit, offset);
+    const rows = this.db.prepare(query).all(...params);
+    return rows.map((row) => this.rowToMemoryEntry(row));
+  }
+  getTotalCount(repo, includeArchived = false, excludeTypes = []) {
+    let sql = "SELECT COUNT(*) as count FROM memories WHERE repo = ?";
+    const params = [repo];
+    if (!includeArchived) sql += " AND status = 'active'";
+    if (excludeTypes.length > 0) {
+      sql += ` AND type NOT IN (${excludeTypes.map(() => "?").join(",")})`;
+      params.push(...excludeTypes);
+    }
+    const row = this.db.prepare(sql).get(...params);
+    return row.count;
+  }
+  incrementHitCount(id) {
+    this.db.prepare("UPDATE memories SET hit_count = hit_count + 1, last_used_at = ? WHERE id = ?").run((/* @__PURE__ */ new Date()).toISOString(), id);
+  }
+  incrementHitCounts(ids) {
+    if (!ids || ids.length === 0) return;
+    const stmt = this.db.prepare("UPDATE memories SET hit_count = hit_count + 1, last_used_at = ? WHERE id = ?");
+    const now = (/* @__PURE__ */ new Date()).toISOString();
+    const transaction = this.db.transaction((idsToUpdate) => {
+      for (const id of idsToUpdate) {
+        stmt.run(now, id);
+      }
+    });
+    transaction(ids);
+  }
+  incrementRecallCount(id) {
+    this.db.prepare("UPDATE memories SET recall_count = recall_count + 1, last_used_at = ? WHERE id = ?").run((/* @__PURE__ */ new Date()).toISOString(), id);
+  }
+  getVectorCandidates(repo, limit = 100) {
+    let sql = `SELECT mv.memory_id, mv.vector FROM memory_vectors mv JOIN memories m ON mv.memory_id = m.id`;
+    const params = [];
+    if (repo) {
+      sql += " WHERE m.repo = ?";
+      params.push(repo);
+    }
+    sql += " LIMIT ?";
+    params.push(limit);
+    return this.db.prepare(sql).all(...params);
+  }
+  upsertVectorEmbedding(memoryId, vector) {
+    this.db.prepare(
+      `
+      INSERT INTO memory_vectors (memory_id, vector, updated_at) VALUES (?, ?, ?)
+      ON CONFLICT(memory_id) DO UPDATE SET vector = excluded.vector, updated_at = excluded.updated_at
+    `
+    ).run(memoryId, JSON.stringify(vector), (/* @__PURE__ */ new Date()).toISOString());
+  }
+  getSummary(repo) {
+    const row = this.db.prepare("SELECT summary, updated_at FROM memory_summary WHERE repo = ?").get(repo);
+    return row;
+  }
+  getAllMemoriesWithStats(repo) {
+    const rows = this.db.prepare(
+      `
+SELECT *, CASE WHEN hit_count > 0 THEN CAST(recall_count AS REAL) / hit_count ELSE 0 END AS recall_rate 
+FROM memories 
+WHERE repo = ?
+ORDER BY created_at DESC
+`
+    ).all(repo);
+    return rows.map((row) => ({
+      ...this.rowToMemoryEntry(row),
+      recall_rate: row.recall_rate || 0
+    }));
+  }
+  upsertSummary(repo, summary) {
+    this.db.prepare(
+      `
+      INSERT INTO memory_summary (repo, summary, updated_at) VALUES (?, ?, ?)
+      ON CONFLICT(repo) DO UPDATE SET summary = excluded.summary, updated_at = excluded.updated_at
+    `
+    ).run(repo, summary, (/* @__PURE__ */ new Date()).toISOString());
+  }
+  listMemoriesForDashboard(options) {
+    const {
+      repo,
+      type,
+      tag,
+      isGlobal,
+      minImportance,
+      maxImportance,
+      search,
+      offset = 0,
+      limit = 50,
+      sortBy = "created_at",
+      sortOrder = "DESC"
+    } = options;
+    const where = ["1=1"];
+    const params = [];
+    if (repo) {
+      where.push("repo = ?");
+      params.push(repo);
+    }
+    if (type) {
+      where.push("type = ?");
+      params.push(type);
+    }
+    if (tag) {
+      where.push("tags LIKE ?");
+      params.push(`%${tag}%`);
+    }
+    if (isGlobal !== void 0) {
+      where.push("is_global = ?");
+      params.push(isGlobal ? 1 : 0);
+    }
+    if (minImportance !== void 0) {
+      where.push("importance >= ?");
+      params.push(minImportance);
+    }
+    if (maxImportance !== void 0) {
+      where.push("importance <= ?");
+      params.push(maxImportance);
+    }
+    if (search) {
+      where.push("(title LIKE ? OR content LIKE ?)");
+      params.push(`%${search}%`, `%${search}%`);
+    }
+    const countSql = `SELECT COUNT(*) as count FROM memories WHERE ${where.join(" AND ")}`;
+    const total = this.db.prepare(countSql).get(...params).count;
+    const dataSql = `SELECT *, CASE WHEN hit_count > 0 THEN CAST(recall_count AS REAL) / hit_count ELSE 0 END AS recall_rate FROM memories WHERE ${where.join(" AND ")} ORDER BY ${sortBy} ${sortOrder} LIMIT ? OFFSET ?`;
+    const rows = this.db.prepare(dataSql).all(...params, limit, offset);
+    const items = rows.map((row) => ({
+      ...this.rowToMemoryEntry(row),
+      recall_rate: row.recall_rate || 0
+    }));
+    return { items, memories: items, total, limit, offset };
+  }
+  searchBySimilarity(query, repo, limit = 10, includeArchived = false, currentTags = []) {
+    const queryVector = this.computeVector(query);
+    const now = /* @__PURE__ */ new Date();
+    const where = ["(repo = ? OR is_global = 1)"];
+    const params = [repo];
+    if (currentTags.length > 0) {
+      const tagConditions = currentTags.map(() => "tags LIKE ?").join(" OR ");
+      where.push(`(${tagConditions})`);
+      currentTags.forEach((tag) => params.push(`%${tag}%`));
+    }
+    let sql = `SELECT * FROM memories WHERE (${where.join(" AND ")}) AND (expires_at IS NULL OR expires_at > ?)`;
+    if (!includeArchived) sql += " AND status = 'active'";
+    sql += ` ORDER BY CASE WHEN repo = ? THEN 0 ELSE 1 END, importance DESC, created_at DESC LIMIT 100`;
+    const candidates = this.db.prepare(sql).all(...params, now.toISOString(), repo);
+    if (candidates.length < 5) {
+      const recentSql = `SELECT * FROM memories WHERE (${where.join(" OR ")}) AND status = 'active' AND (expires_at IS NULL OR expires_at > ?) ORDER BY created_at DESC LIMIT 10`;
+      const recent = this.db.prepare(recentSql).all(...params, now.toISOString());
+      for (const r of recent) {
+        if (!candidates.find((c) => c.id === r.id)) candidates.push(r);
+      }
+    }
+    return candidates.map((row) => {
+      const memory = this.rowToMemoryEntry(row);
+      const isExpired = row.expires_at && new Date(row.expires_at) <= now;
+      const isArchived = row.status === "archived" && !includeArchived;
+      if (isExpired || isArchived) {
+        return { ...memory, similarity: 0 };
+      }
+      const similarity = this.cosineSimilarity(queryVector, this.computeVector(memory.content)) || 0;
+      let score = similarity;
+      if (!score) {
+        score = 0.16;
+      }
+      if (row.repo === repo) score += 0.1;
+      return { ...memory, similarity: score };
+    }).filter((r) => r.similarity > 0).sort((a, b) => b.similarity - a.similarity).slice(0, limit);
+  }
+  async checkConflicts(content, repo, _type, _vectors, threshold = 0.55) {
+    const results = await this.searchBySimilarity(content, repo, 1, false);
+    if (results.length > 0 && results[0].similarity >= threshold) {
+      return results[0];
+    }
+    return null;
+  }
+  archiveExpiredMemories(force = false) {
+    if (process.env.ENABLE_AUTO_ARCHIVE !== "true" && !force) return 0;
+    const now = (/* @__PURE__ */ new Date()).toISOString();
+    const result = this.db.prepare(
+      `
+      UPDATE memories SET status = 'archived', updated_at = ? 
+      WHERE expires_at IS NOT NULL AND expires_at <= ? AND status = 'active'
+    `
+    ).run(now, now);
+    return result.changes;
+  }
+  archiveLowScoreMemories(force = false) {
+    if (process.env.ENABLE_AUTO_ARCHIVE !== "true" && !force) return 0;
+    const result = this.db.prepare(
+      `
+      UPDATE memories SET status = 'archived', updated_at = ? 
+      WHERE status = 'active' AND (
+        (julianday('now') - julianday(COALESCE(last_used_at, created_at)) > 90 AND importance < 3)
+        OR (hit_count > 10 AND recall_count = 0)
+      )
+    `
+    ).run((/* @__PURE__ */ new Date()).toISOString());
+    return result.changes;
+  }
+};
+
+// src/mcp/entities/task.ts
+var TaskEntity = class extends BaseEntity {
+  insertTask(task) {
+    const stmt = this.db.prepare(`
+      INSERT INTO tasks (
+        id, repo, task_code, phase, title, description, status, priority,
+        agent, role, doc_path, created_at, updated_at, finished_at, canceled_at, tags, metadata, parent_id, depends_on, est_tokens, in_progress_at
+      ) VALUES (?, ?, ?, ?, ?, ?, ?, ?, ?, ?, ?, ?, ?, ?, ?, ?, ?, ?, ?, ?, ?)
+    `);
+    stmt.run(
+      task.id,
+      task.repo,
+      task.task_code,
+      task.phase || null,
+      task.title,
+      task.description || null,
+      task.status || "backlog",
+      task.priority || 3,
+      task.agent || "unknown",
+      task.role || "unknown",
+      task.doc_path || null,
+      task.created_at,
+      task.updated_at,
+      task.finished_at || null,
+      task.canceled_at || null,
+      task.tags ? JSON.stringify(task.tags) : null,
+      task.metadata ? JSON.stringify(task.metadata) : null,
+      task.parent_id || null,
+      task.depends_on || null,
+      task.est_tokens || 0,
+      task.in_progress_at || null
+    );
+  }
+  updateTask(id, updates) {
+    const fields = [];
+    const values = [];
+    const anyUpdates = updates;
+    Object.keys(updates).forEach((key) => {
+      if (key !== "comment" && key !== "model" && anyUpdates[key] !== void 0) {
+        if (key === "tags" || key === "metadata") {
+          fields.push(`${key} = ?`);
+          values.push(JSON.stringify(anyUpdates[key]));
+        } else {
+          fields.push(`${key} = ?`);
+          values.push(anyUpdates[key]);
+        }
+      }
+    });
+    if (fields.length === 0) return;
+    fields.push("updated_at = ?");
+    values.push((/* @__PURE__ */ new Date()).toISOString());
+    values.push(id);
+    const stmt = this.db.prepare(`UPDATE tasks SET ${fields.join(", ")} WHERE id = ?`);
+    stmt.run(...values);
+  }
+  deleteTask(id) {
+    this.db.prepare("DELETE FROM task_comments WHERE task_id = ?").run(id);
+    this.db.prepare("DELETE FROM tasks WHERE id = ?").run(id);
+  }
+  getTaskById(id) {
+    const row = this.db.prepare(
+      `
+      SELECT t.*, d.task_code as depends_on_code 
+      FROM tasks t 
+      LEFT JOIN tasks d ON t.depends_on = d.id 
+      WHERE t.id = ?
+    `
+    ).get(id);
+    return row ? { ...this.rowToTask(row), comments: this.getTaskCommentsByTaskId(id) } : null;
+  }
+  getTaskByCode(repo, taskCode) {
+    const row = this.db.prepare(
+      `
+      SELECT t.*, d.task_code as depends_on_code 
+      FROM tasks t 
+      LEFT JOIN tasks d ON t.depends_on = d.id 
+      WHERE t.repo = ? AND t.task_code = ?
+    `
+    ).get(repo, taskCode);
+    return row ? { ...this.rowToTask(row), comments: this.getTaskCommentsByTaskId(row.id) } : null;
+  }
+  getTasksByRepo(repo, status, limit, offset, search) {
+    let query = `
+      SELECT t.*, d.task_code as depends_on_code,
+             (SELECT COUNT(*) FROM task_comments WHERE task_id = t.id) as comments_count
+      FROM tasks t 
+      LEFT JOIN tasks d ON t.depends_on = d.id 
+      WHERE t.repo = ?
+    `;
+    const params = [repo];
+    if (status) {
+      query += " AND t.status = ?";
+      params.push(status);
+    }
+    if (search) {
+      query += " AND (t.title LIKE ? OR t.description LIKE ? OR t.task_code LIKE ?)";
+      const searchPattern = `%${search}%`;
+      params.push(searchPattern, searchPattern, searchPattern);
+    }
+    query += ` ORDER BY 
+      CASE WHEN t.status = 'completed' THEN 1 ELSE 0 END ASC,
+      CASE WHEN t.status = 'completed' THEN t.updated_at ELSE NULL END DESC,
+      CASE WHEN t.status = 'in_progress' THEN 0
+           WHEN t.status = 'pending' THEN 1
+           WHEN t.status = 'backlog' THEN 2
+           WHEN t.status = 'blocked' THEN 3
+           WHEN t.status = 'canceled' THEN 4
+           ELSE 5 END ASC,
+      t.priority DESC, 
+      t.created_at ASC`;
+    if (limit !== void 0) {
+      query += " LIMIT ?";
+      params.push(limit);
+      if (offset !== void 0) {
+        query += " OFFSET ?";
+        params.push(offset);
+      }
+    }
+    const rows = this.db.prepare(query).all(...params);
+    return rows.map((r) => this.rowToTask(r));
+  }
+  listRecentTasks(limit = 50, offset = 0) {
+    const query = `
+      SELECT t.*, d.task_code as depends_on_code,
+             (SELECT COUNT(*) FROM task_comments WHERE task_id = t.id) as comments_count
+      FROM tasks t 
+      LEFT JOIN tasks d ON t.depends_on = d.id 
+      ORDER BY 
+        CASE WHEN t.status = 'completed' THEN 1 ELSE 0 END ASC,
+        CASE WHEN t.status = 'completed' THEN t.updated_at ELSE NULL END DESC,
+        CASE WHEN t.status = 'in_progress' THEN 0
+             WHEN t.status = 'pending' THEN 1
+             WHEN t.status = 'backlog' THEN 2
+             WHEN t.status = 'blocked' THEN 3
+             WHEN t.status = 'canceled' THEN 4
+             ELSE 5 END ASC,
+        t.priority DESC, 
+        t.created_at ASC
+      LIMIT ? OFFSET ?
+    `;
+    const rows = this.db.prepare(query).all(limit, offset);
+    return rows.map((r) => this.rowToTask(r));
+  }
+  getTasksByMultipleStatuses(repo, statuses, limit, offset, search) {
+    if (!statuses.length) return this.getTasksByRepo(repo, void 0, limit, offset, search);
+    let query = `
+      SELECT t.*, d.task_code as depends_on_code,
+             (SELECT COUNT(*) FROM task_comments WHERE task_id = t.id) as comments_count
+      FROM tasks t 
+      LEFT JOIN tasks d ON t.depends_on = d.id 
+      WHERE t.repo = ? AND t.status IN (${statuses.map(() => "?").join(",")})
+    `;
+    const params = [repo, ...statuses];
+    if (search) {
+      query += " AND (t.title LIKE ? OR t.description LIKE ? OR t.task_code LIKE ?)";
+      const searchPattern = `%${search}%`;
+      params.push(searchPattern, searchPattern, searchPattern);
+    }
+    query += ` ORDER BY 
+      CASE WHEN t.status = 'completed' THEN 1 ELSE 0 END ASC,
+      CASE WHEN t.status = 'completed' THEN t.updated_at ELSE NULL END DESC,
+      CASE WHEN t.status = 'in_progress' THEN 0
+           WHEN t.status = 'pending' THEN 1
+           WHEN t.status = 'backlog' THEN 2
+           WHEN t.status = 'blocked' THEN 3
+           WHEN t.status = 'canceled' THEN 4
+           ELSE 5 END ASC,
+      t.priority DESC, 
+      t.created_at ASC`;
+    if (limit !== void 0) {
+      query += " LIMIT ?";
+      params.push(limit);
+      if (offset !== void 0) {
+        query += " OFFSET ?";
+        params.push(offset);
+      }
+    }
+    const rows = this.db.prepare(query).all(...params);
+    return rows.map((r) => this.rowToTask(r));
+  }
+  isTaskCodeDuplicate(repo, task_code, excludeId) {
+    let query = "SELECT COUNT(*) as count FROM tasks WHERE repo = ? AND task_code = ?";
+    const params = [repo, task_code];
+    if (excludeId) {
+      query += " AND id != ?";
+      params.push(excludeId);
+    }
+    const row = this.db.prepare(query).get(...params);
+    return row.count > 0;
+  }
+  bulkInsertTasks(tasks) {
+    const insert = this.db.prepare(`
+      INSERT INTO tasks (
+        id, repo, task_code, phase, title, description, status, priority,
+        agent, role, doc_path, created_at, updated_at, finished_at, canceled_at, tags, metadata, parent_id, depends_on, est_tokens, in_progress_at
+      ) VALUES (?, ?, ?, ?, ?, ?, ?, ?, ?, ?, ?, ?, ?, ?, ?, ?, ?, ?, ?, ?, ?)
+    `);
+    const insertMany = this.db.transaction((tasks2) => {
+      let count = 0;
+      for (const task of tasks2) {
+        insert.run(
+          task.id,
+          task.repo,
+          task.task_code,
+          task.phase || null,
+          task.title,
+          task.description || null,
+          task.status || "backlog",
+          task.priority || 3,
+          task.agent || "unknown",
+          task.role || "unknown",
+          task.doc_path || null,
+          task.created_at,
+          task.updated_at,
+          task.finished_at || null,
+          task.canceled_at || null,
+          task.tags ? JSON.stringify(task.tags) : null,
+          task.metadata ? JSON.stringify(task.metadata) : null,
+          task.parent_id || null,
+          task.depends_on || null,
+          task.est_tokens || 0,
+          task.in_progress_at || null
+        );
+        count++;
+      }
+      return count;
+    });
+    return insertMany(tasks);
+  }
+  insertTaskComment(comment) {
+    this.db.prepare(
+      `
+      INSERT INTO task_comments (
+        id, task_id, repo, comment, agent, role, model, previous_status, next_status, created_at
+      ) VALUES (?, ?, ?, ?, ?, ?, ?, ?, ?, ?)
+    `
+    ).run(
+      comment.id,
+      comment.task_id,
+      comment.repo,
+      comment.comment,
+      comment.agent || "unknown",
+      comment.role || "unknown",
+      comment.model || "unknown",
+      comment.previous_status || null,
+      comment.next_status || null,
+      comment.created_at
+    );
+  }
+  updateTaskComment(id, updates) {
+    const fields = [];
+    const values = [];
+    const anyUpdates = updates;
+    Object.keys(updates).forEach((key) => {
+      if (anyUpdates[key] !== void 0) {
+        fields.push(`${key} = ?`);
+        values.push(anyUpdates[key]);
+      }
+    });
+    if (fields.length === 0) return;
+    values.push(id);
+    const stmt = this.db.prepare(`UPDATE task_comments SET ${fields.join(", ")} WHERE id = ?`);
+    stmt.run(...values);
+  }
+  deleteTaskComment(id) {
+    this.db.prepare("DELETE FROM task_comments WHERE id = ?").run(id);
+  }
+  getTaskCommentById(id) {
+    return this.db.prepare("SELECT * FROM task_comments WHERE id = ?").get(id);
+  }
+  getTaskCommentsByTaskId(taskId) {
+    return this.db.prepare(
+      `
+      SELECT * FROM task_comments
+      WHERE task_id = ?
+      ORDER BY created_at DESC, id DESC
+    `
+    ).all(taskId);
+  }
+  getAllTaskCommentsByRepo(repo) {
+    return this.db.prepare(
+      `
+      SELECT * FROM task_comments
+      WHERE repo = ?
+      ORDER BY created_at DESC, id DESC
+    `
+    ).all(repo);
+  }
+  getTaskStats(repo) {
+    const rows = this.db.prepare("SELECT status, COUNT(*) as count FROM tasks WHERE repo = ? GROUP BY status").all(repo);
+    const stats = { total: 0, backlog: 0, todo: 0, inProgress: 0, completed: 0, blocked: 0, canceled: 0 };
+    rows.forEach((r) => {
+      const count = r.count;
+      stats.total += count;
+      if (r.status === "backlog") stats.backlog = count;
+      else if (r.status === "pending") stats.todo = count;
+      else if (r.status === "in_progress") stats.inProgress = count;
+      else if (r.status === "completed") stats.completed = count;
+      else if (r.status === "blocked") stats.blocked = count;
+      else if (r.status === "canceled") stats.canceled = count;
+    });
+    return stats;
+  }
+  getTaskTimeStats(repo, period) {
+    let dateFilter = "";
+    if (period === "daily") dateFilter = "AND date(COALESCE(finished_at, updated_at)) = date('now')";
+    else if (period === "weekly") dateFilter = "AND date(COALESCE(finished_at, updated_at)) >= date('now', '-7 days')";
+    else if (period === "monthly")
+      dateFilter = "AND date(COALESCE(finished_at, updated_at)) >= date('now', '-30 days')";
+    const stats = this.db.prepare(
+      `
+      SELECT 
+        COUNT(*) as completed_count,
+        SUM(est_tokens) as total_tokens,
+        AVG(
+          CASE 
+            WHEN in_progress_at IS NOT NULL AND finished_at IS NOT NULL 
+            THEN (julianday(finished_at) - julianday(in_progress_at)) * 86400.0 
+            ELSE NULL 
+          END
+        ) as avg_duration_seconds
+      FROM tasks 
+      WHERE repo = ? 
+      AND status = 'completed' 
+      ${dateFilter}
+    `
+    ).get(repo);
+    let addedDateFilter = "";
+    if (period === "daily") addedDateFilter = "AND date(created_at) = date('now')";
+    else if (period === "weekly") addedDateFilter = "AND date(created_at) >= date('now', '-7 days')";
+    else if (period === "monthly") addedDateFilter = "AND date(created_at) >= date('now', '-30 days')";
+    const added = this.db.prepare(
+      `
+      SELECT COUNT(*) as count FROM tasks 
+      WHERE repo = ? 
+      ${addedDateFilter}
+    `
+    ).get(repo);
+    return {
+      completed: stats?.completed_count || 0,
+      tokens: stats?.total_tokens || 0,
+      avgDuration: stats?.avg_duration_seconds || 0,
+      added: added?.count || 0
+    };
+  }
+  getTaskComparisonSeries(repo, period) {
+    let labelFormat;
+    let dateFilter;
+    if (period === "daily") {
+      labelFormat = "%H:00";
+      dateFilter = "date(COALESCE(finished_at, created_at)) = date('now')";
+    } else if (period === "weekly") {
+      labelFormat = "%Y-%m-%d";
+      dateFilter = "date(COALESCE(finished_at, created_at)) >= date('now', '-6 days')";
+    } else if (period === "monthly") {
+      labelFormat = "W%W";
+      dateFilter = "date(COALESCE(finished_at, created_at)) >= date('now', '-30 days')";
+    } else {
+      labelFormat = "%Y-%m";
+      dateFilter = "1=1";
+    }
+    const query = `
+      SELECT label, SUM(created) as created, SUM(completed) as completed
+      FROM (
+        SELECT strftime(?, created_at) as label, 1 as created, 0 as completed 
+        FROM tasks 
+        WHERE repo = ? AND ${dateFilter.replace("COALESCE(finished_at, created_at)", "created_at")}
+        UNION ALL
+        SELECT strftime(?, COALESCE(finished_at, updated_at)) as label, 0 as created, 1 as completed 
+        FROM tasks 
+        WHERE repo = ? AND status = 'completed' AND ${dateFilter.replace("COALESCE(finished_at, created_at)", "COALESCE(finished_at, updated_at)")}
+      )
+      GROUP BY label
+      ORDER BY label ASC
+      LIMIT 100
+    `;
+    return this.db.prepare(query).all(labelFormat, repo, labelFormat, repo);
+  }
+};
+
+// src/mcp/entities/action.ts
+var ActionEntity = class extends BaseEntity {
+  constructor(db) {
+    super(db);
+  }
+  /**
+   * Log an action to the audit trail.
+   * Supports both object-based options (modern) and positional arguments (legacy/internal).
+   */
+  logAction(action, repo, optionsOrQuery, response, memoryId, taskId, resultCount = 0) {
+    let query = typeof optionsOrQuery === "string" ? optionsOrQuery : void 0;
+    let finalResponse = response;
+    let finalMemoryId = memoryId;
+    let finalTaskId = taskId;
+    let finalResultCount = resultCount;
+    if (optionsOrQuery && typeof optionsOrQuery === "object") {
+      query = optionsOrQuery.query || query;
+      const res = optionsOrQuery.response;
+      finalResponse = (typeof res === "object" ? JSON.stringify(res) : res) || finalResponse;
+      finalMemoryId = optionsOrQuery.memoryId || finalMemoryId;
+      finalTaskId = optionsOrQuery.taskId || finalTaskId;
+      finalResultCount = optionsOrQuery.resultCount !== void 0 ? optionsOrQuery.resultCount : finalResultCount;
+    }
+    const stmt = this.db.prepare(`
+      INSERT INTO action_log (repo, action, query, response, memory_id, task_id, result_count, created_at)
+      VALUES (:repo, :action, :query, :response, :memory_id, :task_id, :result_count, :created_at)
+    `);
+    stmt.run({
+      repo: repo || "",
+      action: action || "unknown",
+      query: query || null,
+      response: finalResponse ? typeof finalResponse === "string" ? finalResponse : JSON.stringify(finalResponse) : null,
+      memory_id: finalMemoryId || null,
+      task_id: finalTaskId || null,
+      result_count: finalResultCount ?? 0,
+      created_at: (/* @__PURE__ */ new Date()).toISOString()
+    });
+  }
+  getLastActionId() {
+    const row = this.db.prepare("SELECT MAX(id) as id FROM action_log").get();
+    return row?.id || 0;
+  }
+  getActionsAfter(id) {
+    return this.db.prepare(
+      `
+      SELECT a.*, m.title as memory_title, m.type as memory_type 
+      FROM action_log a LEFT JOIN memories m ON a.memory_id = m.id 
+      WHERE a.id > ? ORDER BY a.created_at ASC
+    `
+    ).all(id);
+  }
+  getRecentActions(repo, limit = 10, offset = 0) {
+    let query = `
+      SELECT a.*, m.title as memory_title, m.type as memory_type 
+      FROM action_log a LEFT JOIN memories m ON a.memory_id = m.id
+    `;
+    const params = [];
+    if (repo) {
+      query += " WHERE a.repo = ?";
+      params.push(repo);
+    }
+    query += " ORDER BY a.created_at DESC, a.id DESC LIMIT ? OFFSET ?";
+    params.push(limit, offset);
+    return this.db.prepare(query).all(...params);
+  }
+  getActionStatsByDate(repo) {
+    return this.db.prepare(
+      `
+      SELECT date(created_at) as date, count(*) as count 
+      FROM action_log 
+      WHERE repo = ? AND created_at > date('now', '-30 days')
+      GROUP BY date(created_at)
+      ORDER BY date ASC
+    `
+    ).all(repo);
+  }
+  getActionDistribution(repo) {
+    return this.db.prepare(
+      `
+      SELECT action, count(*) as count 
+      FROM action_log 
+      WHERE repo = ?
+      GROUP BY action
+    `
+    ).all(repo);
+  }
+  getActionById(id) {
+    return this.db.prepare(
+      `
+      SELECT a.*, m.title as memory_title, m.type as memory_type 
+      FROM action_log a LEFT JOIN memories m ON a.memory_id = m.id 
+      WHERE a.id = ?
+    `
+    ).get(id);
+  }
+};
+
+// src/mcp/entities/system.ts
+var SystemEntity = class extends BaseEntity {
+  listRepos() {
+    const rows = this.db.prepare("SELECT DISTINCT repo FROM memories UNION SELECT DISTINCT repo FROM tasks").all();
+    return rows.map((r) => r.repo);
+  }
+  listRepoNavigation() {
+    const repos = this.listRepos();
+    return repos.map((repo) => {
+      const memoryCount = this.db.prepare("SELECT COUNT(*) as count FROM memories WHERE repo = ?").get(repo).count;
+      const taskCount = this.db.prepare("SELECT COUNT(*) as count FROM tasks WHERE repo = ?").get(repo).count;
+      const lastActivity = this.db.prepare(
+        `SELECT MAX(created_at) as last FROM (SELECT created_at FROM memories WHERE repo = ? UNION ALL SELECT created_at FROM tasks WHERE repo = ? UNION ALL SELECT created_at FROM action_log WHERE repo = ?)`
+      ).get(repo, repo, repo).last;
+      return {
+        repo,
+        memoryCount,
+        taskCount,
+        lastActivity
+      };
+    });
+  }
+  getDashboardStats(repo) {
+    const memoryStats = this.db.prepare("SELECT type, COUNT(*) as count FROM memories WHERE repo = ? GROUP BY type").all(repo);
+    const taskStats = this.db.prepare("SELECT status, COUNT(*) as count FROM tasks WHERE repo = ? GROUP BY status").all(repo);
+    const recentMemories = this.db.prepare("SELECT * FROM memories WHERE repo = ? ORDER BY created_at DESC LIMIT 5").all(repo).map((r) => this.rowToMemoryEntry(r));
+    const activeTasks = this.db.prepare(
+      "SELECT * FROM tasks WHERE repo = ? AND status IN ('in_progress', 'pending', 'backlog') ORDER BY priority DESC, created_at ASC LIMIT 5"
+    ).all(repo).map((r) => this.rowToTask(r));
+    return {
+      memoryStats,
+      taskStats,
+      recentMemories,
+      activeTasks
+    };
+  }
+  getGlobalStats() {
+    const totalMemories = this.db.prepare("SELECT COUNT(*) as count FROM memories").get().count;
+    const totalTasks = this.db.prepare("SELECT COUNT(*) as count FROM tasks").get().count;
+    const totalRepos = this.listRepos().length;
+    return {
+      totalMemories,
+      totalTasks,
+      totalRepos
+    };
+  }
+  getRepoDetails(repo) {
+    const memoryCount = this.db.prepare("SELECT COUNT(*) as count FROM memories WHERE repo = ?").get(repo).count;
+    const taskCount = this.db.prepare("SELECT COUNT(*) as count FROM tasks WHERE repo = ?").get(repo).count;
+    const languages = this.db.prepare("SELECT DISTINCT language FROM memories WHERE repo = ? AND language IS NOT NULL").all(repo).map((r) => r.language);
+    return {
+      repo,
+      memoryCount,
+      taskCount,
+      languages
+    };
+  }
+};
+
+// src/mcp/entities/summary.ts
+var SummaryEntity = class extends BaseEntity {
+  getSummary(repo) {
+    const row = this.db.prepare("SELECT summary, updated_at FROM memory_summary WHERE repo = ?").get(repo);
+    return row || null;
+  }
+  upsertSummary(repo, summary) {
+    this.db.prepare(
+      `
+      INSERT INTO memory_summary (repo, summary, updated_at) VALUES (?, ?, ?)
+      ON CONFLICT(repo) DO UPDATE SET summary = excluded.summary, updated_at = excluded.updated_at
+    `
+    ).run(repo, summary, (/* @__PURE__ */ new Date()).toISOString());
+  }
+};
+
+// src/mcp/storage/sqlite.ts
+function resolveDbPath() {
+  if (process.env.MEMORY_DB_PATH) return process.env.MEMORY_DB_PATH;
+  const standardConfigDir = process.platform === "win32" ? path2.join(os.homedir(), ".local-memory-mcp") : process.platform === "darwin" ? path2.join(os.homedir(), "Library", "Application Support", "local-memory-mcp") : path2.join(os.homedir(), ".config", "local-memory-mcp");
+  const standardPath = path2.join(standardConfigDir, "memory.db");
+  if (fs2.existsSync(standardPath)) return standardPath;
+  const legacyPath = path2.join(os.homedir(), ".config", "local-memory-mcp", "memory.db");
+  if (fs2.existsSync(legacyPath)) return legacyPath;
+  const localCwdFile = path2.join(process.cwd(), "storage", "memory.db");
+  if (fs2.existsSync(localCwdFile)) return localCwdFile;
+  return standardPath;
+}
+var DB_PATH = resolveDbPath();
+var SQLiteStore = class {
+  db;
+  memories;
+  tasks;
+  actions;
+  system;
+  summaries;
+  constructor(dbPath) {
+    const finalPath = dbPath ?? DB_PATH;
+    const dbDir = path2.dirname(finalPath);
+    if (!fs2.existsSync(dbDir)) {
+      fs2.mkdirSync(dbDir, { recursive: true });
+    }
+    this.db = new Database(finalPath);
+    this.db.pragma("journal_mode = WAL");
+    this.db.pragma("synchronous = NORMAL");
+    this.db.pragma("busy_timeout = 5000");
+    const migrator = new MigrationManager(this.db);
+    migrator.migrate();
+    this.memories = new MemoryEntity(this.db);
+    this.tasks = new TaskEntity(this.db);
+    this.actions = new ActionEntity(this.db);
+    this.system = new SystemEntity(this.db);
+    this.summaries = new SummaryEntity(this.db);
+    logger.info(`SQLiteStore initialized at ${finalPath}`);
+  }
+  /**
+   * Returns the current database file path.
+   */
+  getDbPath() {
+    return this.db.name;
+  }
+  /**
+   * Closes the database connection.
+   */
+  close() {
+    this.db.close();
+  }
+};
+
+// src/mcp/session.ts
+import path3 from "path";
+import { fileURLToPath as fileURLToPath2 } from "url";
+function createSessionContext() {
+  return {
+    roots: [],
+    supportsRoots: false,
+    supportsSampling: false,
+    supportsSamplingTools: false,
+    supportsElicitation: false,
+    supportsElicitationForm: false,
+    supportsElicitationUrl: false
+  };
+}
+function updateSessionFromInitialize(session, params) {
+  const capabilities = params?.capabilities || {};
+  session.clientInfo = params?.clientInfo;
+  session.clientCapabilities = capabilities;
+  session.supportsRoots = Boolean(capabilities.roots);
+  session.supportsSampling = Boolean(capabilities.sampling);
+  session.supportsSamplingTools = Boolean(capabilities.sampling?.tools);
+  session.supportsElicitation = Boolean(capabilities.elicitation);
+  session.supportsElicitationForm = supportsElicitationMode(capabilities.elicitation, "form");
+  session.supportsElicitationUrl = supportsElicitationMode(capabilities.elicitation, "url");
+}
+function supportsElicitationMode(capability, mode) {
+  if (!capability || typeof capability !== "object") {
+    return false;
+  }
+  const cap = capability;
+  if (mode === "form") {
+    return Object.keys(cap).length === 0 || typeof cap.form === "object";
+  }
+  return typeof cap.url === "object";
+}
+function updateSessionRoots(session, roots) {
+  const normalized = normalizeRoots(roots);
+  const previous = JSON.stringify(session.roots);
+  const next = JSON.stringify(normalized);
+  session.roots = normalized;
+  return previous !== next;
+}
+function normalizeRoots(roots) {
+  if (!Array.isArray(roots)) return [];
+  const seen = /* @__PURE__ */ new Set();
+  const normalized = [];
+  for (const root of roots) {
+    if (!root || typeof root !== "object") continue;
+    const r = root;
+    const uri = typeof r.uri === "string" ? r.uri : void 0;
+    const name = typeof r.name === "string" ? r.name : void 0;
+    if (!uri || seen.has(uri)) continue;
+    seen.add(uri);
+    normalized.push({ uri, name });
+  }
+  return normalized;
+}
+function extractRootsFromResult(result) {
+  return normalizeRoots(result?.roots);
+}
+function getFilesystemRoots(session) {
+  if (!session) return [];
+  const resolved = [];
+  for (const root of session.roots) {
+    if (!root.uri.startsWith("file://")) continue;
+    try {
+      resolved.push(path3.resolve(fileURLToPath2(root.uri)));
+    } catch {
+    }
+  }
+  return resolved;
+}
+function isPathWithinRoots(targetPath, session) {
+  const roots = getFilesystemRoots(session);
+  if (roots.length === 0) return true;
+  const normalizedTarget = path3.resolve(targetPath);
+  return roots.some((rootPath) => {
+    const relative = path3.relative(rootPath, normalizedTarget);
+    return relative === "" || !relative.startsWith("..") && !path3.isAbsolute(relative);
+  });
+}
+function findContainingRoot(targetPath, session) {
+  const roots = getFilesystemRoots(session);
+  if (roots.length === 0) return null;
+  const normalizedTarget = path3.resolve(targetPath);
+  for (const rootPath of roots) {
+    const relative = path3.relative(rootPath, normalizedTarget);
+    if (relative === "" || !relative.startsWith("..") && !path3.isAbsolute(relative)) {
+      return rootPath;
+    }
+  }
+  return null;
+}
+function inferRepoFromSession(session) {
+  const roots = getFilesystemRoots(session);
+  if (roots.length === 1) {
+    return path3.basename(roots[0]);
+  }
+  return void 0;
+}
+
+// src/mcp/tools/schemas.ts
+import { z } from "zod";
+var MemoryScopeSchema = z.object({
+  repo: z.string().min(1).transform(normalizeRepo),
+  branch: z.string().optional(),
+  folder: z.string().optional(),
+  language: z.string().optional()
+});
+var MemoryTypeSchema = z.enum([
+  "code_fact",
+  "decision",
+  "mistake",
+  "pattern",
+  "agent_handoff",
+  "agent_registered",
+  "file_claim",
+  "task_archive"
+]);
+var MemoryStoreSchema = z.object({
+  type: MemoryTypeSchema,
+  title: z.string().min(3).max(100),
+  content: z.string().min(10),
+  importance: z.number().min(1).max(5),
+  agent: z.string().min(1),
+  role: z.string().optional().default("unknown"),
+  model: z.string().min(1),
+  scope: MemoryScopeSchema,
+  ttlDays: z.number().min(1).optional(),
+  supersedes: z.string().uuid().optional(),
+  tags: z.array(z.string()).optional(),
+  metadata: z.record(z.string(), z.any()).optional(),
+  is_global: z.boolean().default(false)
+});
+var MemoryUpdateSchema = z.object({
+  id: z.string().uuid(),
+  type: MemoryTypeSchema.optional(),
+  title: z.string().min(3).max(100).optional(),
+  content: z.string().min(10).optional(),
+  importance: z.number().min(1).max(5).optional(),
+  agent: z.string().optional(),
+  role: z.string().optional(),
+  status: z.enum(["active", "archived"]).optional(),
+  supersedes: z.string().uuid().optional(),
+  tags: z.array(z.string()).optional(),
+  metadata: z.record(z.string(), z.any()).optional(),
+  is_global: z.boolean().optional(),
+  completed_at: z.string().optional()
+}).refine(
+  (data) => data.type !== void 0 || data.content !== void 0 || data.title !== void 0 || data.importance !== void 0 || data.status !== void 0 || data.supersedes !== void 0 || data.tags !== void 0 || data.metadata !== void 0 || data.is_global !== void 0 || data.agent !== void 0 || data.role !== void 0 || data.completed_at !== void 0,
+  { message: "At least one field must be provided for update" }
+);
+var MemorySearchSchema = z.object({
+  query: z.string().min(3),
+  prompt: z.string().optional(),
+  repo: z.string().min(1).transform(normalizeRepo),
+  types: z.array(MemoryTypeSchema).optional(),
+  minImportance: z.number().min(1).max(5).optional(),
+  limit: z.number().min(1).max(100).default(5),
+  offset: z.number().min(0).default(0),
+  includeRecap: z.boolean().default(false),
+  current_file_path: z.string().optional(),
+  include_archived: z.boolean().default(false),
+  current_tags: z.array(z.string()).optional(),
+  scope: MemoryScopeSchema.partial().optional()
+});
+var MemoryAcknowledgeSchema = z.object({
+  memory_id: z.string().uuid(),
+  status: z.enum(["used", "irrelevant", "contradictory"]),
+  application_context: z.string().min(10).optional()
+});
+var MemoryRecapSchema = z.object({
+  repo: z.string().min(1).transform(normalizeRepo),
+  limit: z.number().min(1).max(50).default(20),
+  offset: z.number().min(0).default(0)
+});
+var MemoryDeleteSchema = z.object({
+  repo: z.string().min(1).transform(normalizeRepo).optional(),
+  id: z.string().uuid().optional(),
+  ids: z.array(z.string().uuid()).min(1).optional()
+}).refine((data) => data.id !== void 0 || data.ids !== void 0, {
+  message: "Either 'id' or 'ids' must be provided for deletion"
+});
+var MemorySummarizeSchema = z.object({
+  repo: z.string().min(1).transform(normalizeRepo),
+  signals: z.array(z.string().max(200)).min(1)
+});
+var MemorySynthesizeSchema = z.object({
+  repo: z.string().min(1).transform(normalizeRepo).optional(),
+  objective: z.string().min(5),
+  current_file_path: z.string().optional(),
+  include_summary: z.boolean().default(true),
+  include_tasks: z.boolean().default(true),
+  use_tools: z.boolean().default(true),
+  max_iterations: z.number().int().min(1).max(5).default(3),
+  max_tokens: z.number().int().min(128).max(4e3).default(1200)
+});
+var TaskStatusSchema = z.enum(["backlog", "pending", "in_progress", "completed", "canceled", "blocked"]);
+var TaskPrioritySchema = z.number().min(1).max(5);
+var SingleTaskCreateSchema = z.object({
+  task_code: z.string().min(1),
+  phase: z.string().min(1),
+  title: z.string().min(3).max(100),
+  description: z.string().min(1),
+  status: TaskStatusSchema.default("backlog"),
+  priority: TaskPrioritySchema.default(3),
+  agent: z.string().optional(),
+  role: z.string().optional(),
+  doc_path: z.string().optional(),
+  tags: z.array(z.string()).optional(),
+  metadata: z.record(z.string(), z.any()).optional(),
+  parent_id: z.string().uuid().optional(),
+  depends_on: z.string().uuid().optional(),
+  est_tokens: z.number().int().min(0).optional()
+});
+var TaskCreateSchema = z.object({
+  repo: z.string().min(1).transform(normalizeRepo),
+  // Allow single task fields at top level (backward compatibility & single use)
+  task_code: z.string().min(1).optional(),
+  phase: z.string().min(1).optional(),
+  title: z.string().min(3).max(100).optional(),
+  description: z.string().min(1).optional(),
+  status: TaskStatusSchema.optional(),
+  priority: TaskPrioritySchema.optional(),
+  agent: z.string().optional(),
+  role: z.string().optional(),
+  doc_path: z.string().optional(),
+  tags: z.array(z.string()).optional(),
+  metadata: z.record(z.string(), z.any()).optional(),
+  parent_id: z.string().uuid().optional(),
+  depends_on: z.string().uuid().optional(),
+  est_tokens: z.number().int().min(0).optional(),
+  // Allow bulk tasks
+  tasks: z.array(SingleTaskCreateSchema).min(1).optional()
+}).refine((data) => {
+  if (data.tasks) return true;
+  return !!(data.task_code && data.phase && data.title && data.description);
+}, { message: "Either 'tasks' array or single task fields (task_code, phase, title, description) must be provided" });
+var TaskCreateInteractiveSchema = SingleTaskCreateSchema.partial().extend({
+  repo: z.string().min(1).transform(normalizeRepo).optional()
+});
+var TaskUpdateSchema = z.object({
+  repo: z.string().min(1).transform(normalizeRepo),
+  id: z.string().uuid().optional(),
+  ids: z.array(z.string().uuid()).min(1).optional(),
+  task_code: z.string().optional(),
+  phase: z.string().optional(),
+  title: z.string().min(3).max(100).optional(),
+  description: z.string().optional(),
+  status: TaskStatusSchema.optional(),
+  priority: TaskPrioritySchema.optional(),
+  agent: z.string().min(1, "agent name is required").optional(),
+  role: z.string().min(1, "agent role is required").optional(),
+  model: z.string().optional(),
+  comment: z.string().min(1).optional(),
+  doc_path: z.string().optional(),
+  tags: z.array(z.string()).optional(),
+  metadata: z.record(z.string(), z.any()).optional(),
+  parent_id: z.string().uuid().optional(),
+  depends_on: z.string().uuid().optional(),
+  est_tokens: z.number().int().min(0).optional(),
+  force: z.boolean().optional()
+}).refine((data) => data.id !== void 0 || data.ids !== void 0, {
+  message: "Either 'id' or 'ids' must be provided for update"
+}).refine((data) => Object.keys(data).length > 2, {
+  message: "At least one field besides repo and id/ids must be provided for update"
+});
+var TaskListSchema = z.object({
+  repo: z.string().min(1).transform(normalizeRepo),
+  status: z.string().optional(),
+  phase: z.string().optional(),
+  query: z.string().optional(),
+  limit: z.number().min(1).max(100).default(15),
+  offset: z.number().min(0).default(0)
+});
+var TaskSearchSchema = z.object({
+  repo: z.string().min(1).transform(normalizeRepo),
+  query: z.string().min(1),
+  status: z.string().optional(),
+  limit: z.number().min(1).max(100).default(10),
+  offset: z.number().min(0).default(0)
+});
+var TaskDeleteSchema = z.object({
+  repo: z.string().min(1).transform(normalizeRepo),
+  id: z.string().uuid().optional(),
+  ids: z.array(z.string().uuid()).min(1).optional()
+}).refine((data) => data.id !== void 0 || data.ids !== void 0, {
+  message: "Either 'id' or 'ids' must be provided for deletion"
+});
+var MemoryDetailSchema = z.object({
+  id: z.string().uuid()
+});
+var TaskGetSchema = z.object({
+  repo: z.string().min(1).transform(normalizeRepo),
+  id: z.string().uuid().optional(),
+  task_code: z.string().optional()
+}).refine((data) => data.id !== void 0 || data.task_code !== void 0, {
+  message: "Either id or task_code must be provided"
+});
+var TOOL_DEFINITIONS = [
+  {
+    name: "memory-synthesize",
+    title: "Memory Synthesize",
+    description: "Use client sampling to synthesize a grounded answer from local memory and tasks. Best for project briefings, tradeoff summaries, and context-aware answers.",
+    annotations: {
+      readOnlyHint: true,
+      idempotentHint: true,
+      openWorldHint: false
+    },
+    execution: {
+      taskSupport: "optional"
+    },
+    inputSchema: {
+      type: "object",
+      properties: {
+        repo: { type: "string", description: "Repository name. Optional when a single MCP root is active." },
+        objective: { type: "string", minLength: 5, description: "Question or synthesis objective." },
+        current_file_path: {
+          type: "string",
+          description: "Optional absolute file path for workspace-local grounding."
+        },
+        include_summary: { type: "boolean", default: true },
+        include_tasks: { type: "boolean", default: true },
+        use_tools: {
+          type: "boolean",
+          default: true,
+          description: "Allow the sampled model to call local memory/task tools during synthesis when the client supports sampling.tools."
+        },
+        max_iterations: { type: "number", minimum: 1, maximum: 5, default: 3 },
+        max_tokens: { type: "number", minimum: 128, maximum: 4e3, default: 1200 }
+      },
+      required: ["objective"]
+    },
+    outputSchema: {
+      type: "object",
+      properties: {
+        repo: { type: "string" },
+        objective: { type: "string" },
+        answer: { type: "string" },
+        model: { type: "string" },
+        stopReason: { type: "string" },
+        iterations: { type: "number" },
+        toolCalls: { type: "number" }
+      },
+      required: ["repo", "objective", "answer", "iterations", "toolCalls"]
+    }
+  },
+  {
+    name: "task-create-interactive",
+    title: "Interactive Task Create",
+    description: "Create a task with MCP elicitation fallback for any missing required fields. Best when an agent knows a task is needed but still needs user confirmation for repo, title, or phase.",
+    annotations: {
+      readOnlyHint: false,
+      idempotentHint: false,
+      destructiveHint: false,
+      openWorldHint: false
+    },
+    inputSchema: {
+      type: "object",
+      properties: {
+        repo: {
+          type: "string",
+          description: "Repository name. Optional when it can be inferred from MCP roots or elicited from the user."
+        },
+        task_code: { type: "string" },
+        phase: { type: "string" },
+        title: { type: "string", minLength: 3, maxLength: 100 },
+        description: { type: "string", minLength: 1 },
+        status: { type: "string", enum: ["backlog", "pending"], default: "backlog" },
+        priority: { type: "number", minimum: 1, maximum: 5, default: 3 },
+        agent: { type: "string" },
+        role: { type: "string" },
+        doc_path: { type: "string" }
+      }
+    },
+    outputSchema: {
+      type: "object",
+      properties: {
+        repo: { type: "string" },
+        task_code: { type: "string" },
+        phase: { type: "string" },
+        title: { type: "string" },
+        status: { type: "string" },
+        priority: { type: "number" }
+      },
+      required: ["repo", "task_code", "phase", "title", "status", "priority"]
+    }
+  },
+  {
+    name: "memory-detail",
+    title: "Memory Detail",
+    description: "Fetch full details of a specific memory by ID. Use this when you have a memory ID (e.g. from search results) and need to read the full content.",
+    inputSchema: {
+      type: "object",
+      properties: {
+        id: { type: "string", format: "uuid", description: "Memory entry ID" }
+      },
+      required: ["id"]
+    }
+  },
+  {
+    name: "task-detail",
+    title: "Task Detail",
+    description: "Fetch full details of a specific task by ID or task code. Use this when you have a task ID or code and need to read the full description and comments.",
+    inputSchema: {
+      type: "object",
+      properties: {
+        repo: { type: "string", description: "Repository name" },
+        id: { type: "string", format: "uuid", description: "Task ID (optional if task_code is provided)" },
+        task_code: { type: "string", description: "Task code (e.g. TASK-001) (optional if id is provided)" }
+      },
+      required: ["repo"]
+    }
+  },
+  {
+    name: "memory-store",
+    title: "Memory Store",
+    description: "Store a new memory entry. Keep 'title' concise and human-readable; do not embed agent/role/date metadata in the title. Put auxiliary context into 'metadata'. Use 'tags' for tech-stack and 'is_global' for universal rules.",
+    annotations: {
+      readOnlyHint: false,
+      idempotentHint: false,
+      destructiveHint: false,
+      openWorldHint: false
+    },
+    inputSchema: {
+      type: "object",
+      properties: {
+        type: {
+          type: "string",
+          enum: [
+            "code_fact",
+            "decision",
+            "mistake",
+            "pattern",
+            "agent_handoff",
+            "agent_registered",
+            "file_claim",
+            "task_archive"
+          ],
+          description: "Type of memory being stored"
+        },
+        title: {
+          type: "string",
+          minLength: 3,
+          maxLength: 100,
+          description: "Short human-readable title for the memory. Do not embed bracketed metadata like agent/role/date prefixes here."
+        },
+        content: {
+          type: "string",
+          minLength: 10,
+          description: "The memory content"
+        },
+        importance: {
+          type: "number",
+          minimum: 1,
+          maximum: 5,
+          description: "Importance score (1-5)"
+        },
+        agent: {
+          type: "string",
+          description: "Name of the agent creating this memory"
+        },
+        role: {
+          type: "string",
+          description: "Role of the agent creating this memory"
+        },
+        model: {
+          type: "string",
+          description: "AI model used by the agent"
+        },
+        scope: {
+          type: "object",
+          properties: {
+            repo: { type: "string", description: "Repository name" },
+            branch: { type: "string" },
+            folder: { type: "string" },
+            language: { type: "string" }
+          },
+          required: ["repo"]
+        },
+        tags: {
+          type: "array",
+          items: { type: "string" },
+          description: "Technology stack tags (e.g., ['filament', 'laravel'])"
+        },
+        metadata: {
+          type: "object",
+          description: "Structured metadata for non-title context such as source agent, claim fields, or timestamps"
+        },
+        is_global: {
+          type: "boolean",
+          description: "If true, this memory is shared across all repositories"
+        },
+        ttlDays: { type: "number", minimum: 1 },
+        supersedes: { type: "string", format: "uuid" }
+      },
+      required: ["type", "title", "content", "importance", "scope", "agent", "model"]
+    },
+    outputSchema: {
+      type: "object",
+      properties: {
+        success: { type: "boolean" },
+        id: { type: "string" },
+        repo: { type: "string" },
+        type: { type: "string" },
+        title: { type: "string" },
+        error: { type: "string" },
+        message: { type: "string" }
+      },
+      required: ["success"]
+    }
+  },
+  {
+    name: "memory-acknowledge",
+    title: "Memory Acknowledge",
+    description: "Acknowledge the use of a memory or report its irrelevance/contradiction. Mandatory after using memory to generate code.",
+    annotations: {
+      readOnlyHint: false,
+      idempotentHint: false,
+      openWorldHint: false
+    },
+    inputSchema: {
+      type: "object",
+      properties: {
+        memory_id: { type: "string", format: "uuid" },
+        status: { type: "string", enum: ["used", "irrelevant", "contradictory"] },
+        application_context: { type: "string", minLength: 10 }
+      },
+      required: ["memory_id", "status"]
+    },
+    outputSchema: {
+      type: "object",
+      properties: {
+        success: { type: "boolean" },
+        id: { type: "string" },
+        status: { type: "string" }
+      },
+      required: ["success", "id", "status"]
+    }
+  },
+  {
+    name: "memory-update",
+    title: "Memory Update",
+    description: "Update an existing memory entry. Keep 'title' concise and move agent/role/date or claim context into 'metadata' instead of the title.",
+    annotations: {
+      readOnlyHint: false,
+      idempotentHint: false,
+      destructiveHint: false,
+      openWorldHint: false
+    },
+    inputSchema: {
+      type: "object",
+      properties: {
+        id: { type: "string", format: "uuid" },
+        type: {
+          type: "string",
+          enum: [
+            "code_fact",
+            "decision",
+            "mistake",
+            "pattern",
+            "agent_handoff",
+            "agent_registered",
+            "file_claim",
+            "task_archive"
+          ]
+        },
+        title: { type: "string", minLength: 3, maxLength: 100 },
+        content: { type: "string", minLength: 10 },
+        importance: { type: "number", minimum: 1, maximum: 5 },
+        agent: { type: "string" },
+        role: { type: "string" },
+        status: { type: "string", enum: ["active", "archived"] },
+        supersedes: { type: "string", format: "uuid" },
+        tags: { type: "array", items: { type: "string" } },
+        metadata: { type: "object" },
+        is_global: { type: "boolean" },
+        completed_at: { type: "string" }
+      },
+      required: ["id"]
+    },
+    outputSchema: {
+      type: "object",
+      properties: {
+        success: { type: "boolean" },
+        id: { type: "string" },
+        repo: { type: "string" },
+        updatedFields: {
+          type: "array",
+          items: { type: "string" }
+        }
+      },
+      required: ["success", "id", "repo", "updatedFields"]
+    }
+  },
+  {
+    name: "memory-search",
+    title: "Memory Search",
+    description: "NAVIGATION LAYER: Returns a pointer table of matching memory IDs only. Returns columns [id, title, type, importance] \u2014 NO content. Retrieve full memory via memory-detail. Use 'current_tags' to find tech-stack specific knowledge from other projects.",
+    annotations: {
+      readOnlyHint: true,
+      idempotentHint: true,
+      openWorldHint: false
+    },
+    inputSchema: {
+      type: "object",
+      properties: {
+        query: { type: "string", minLength: 3 },
+        prompt: { type: "string" },
+        repo: { type: "string" },
+        current_tags: {
+          type: "array",
+          items: { type: "string" },
+          description: "Active tech stack tags (e.g., ['filament', 'react'])"
+        },
+        types: {
+          type: "array",
+          items: {
+            type: "string",
+            enum: [
+              "code_fact",
+              "decision",
+              "mistake",
+              "pattern",
+              "agent_handoff",
+              "agent_registered",
+              "file_claim",
+              "task_archive"
+            ]
+          }
+        },
+        minImportance: { type: "number", minimum: 1, maximum: 5 },
+        limit: { type: "number", minimum: 1, maximum: 100, default: 5 },
+        offset: { type: "number", minimum: 0, default: 0 },
+        includeRecap: { type: "boolean", default: false },
+        current_file_path: { type: "string" },
+        include_archived: { type: "boolean", default: false },
+        scope: {
+          type: "object",
+          properties: {
+            repo: { type: "string" },
+            branch: { type: "string" },
+            folder: { type: "string" },
+            language: { type: "string" }
+          }
+        }
+      },
+      required: ["query", "repo"]
+    },
+    outputSchema: {
+      type: "object",
+      properties: {
+        schema: { type: "string", enum: ["memory-search"] },
+        query: { type: "string" },
+        count: { type: "number", description: "Number of rows returned" },
+        total: { type: "number", description: "Total matching memories" },
+        offset: { type: "number" },
+        limit: { type: "number" },
+        results: {
+          type: "object",
+          properties: {
+            columns: {
+              type: "array",
+              items: { type: "string" },
+              description: "Column names: [id, title, type, importance]"
+            },
+            rows: {
+              type: "array",
+              items: { type: "array" },
+              description: "Each row: [id, title, type, importance]. Fetch full content via memory-detail"
+            }
+          },
+          required: ["columns", "rows"]
+        }
+      },
+      required: ["schema", "query", "count", "total", "offset", "limit", "results"]
+    }
+  },
+  {
+    name: "memory-summarize",
+    title: "Memory Summarize",
+    description: "Update the summary for a repository",
+    annotations: {
+      readOnlyHint: false,
+      idempotentHint: false,
+      openWorldHint: false
+    },
+    inputSchema: {
+      type: "object",
+      properties: {
+        repo: { type: "string", description: "Repository name" },
+        signals: {
+          type: "array",
+          items: { type: "string", maxLength: 200 },
+          minItems: 1,
+          description: "High-level signals to include in summary"
+        }
+      },
+      required: ["repo", "signals"]
+    },
+    outputSchema: {
+      type: "object",
+      properties: {
+        success: { type: "boolean" },
+        repo: { type: "string" },
+        summary: { type: "string" },
+        signalCount: { type: "number" }
+      },
+      required: ["success", "repo", "summary", "signalCount"]
+    }
+  },
+  {
+    name: "memory-delete",
+    title: "Memory Delete",
+    description: "Soft-delete one or more memory entries. Supports single 'id' or bulk 'ids'.",
+    annotations: {
+      readOnlyHint: false,
+      idempotentHint: false,
+      destructiveHint: true,
+      openWorldHint: false
+    },
+    inputSchema: {
+      type: "object",
+      properties: {
+        repo: { type: "string", description: "Repository name (optional for single id)" },
+        id: { type: "string", format: "uuid", description: "Memory entry ID to delete" },
+        ids: {
+          type: "array",
+          items: { type: "string", format: "uuid" },
+          minItems: 1,
+          description: "Array of memory IDs to delete"
+        }
+      }
+    },
+    outputSchema: {
+      type: "object",
+      properties: {
+        success: { type: "boolean" },
+        id: { type: "string" },
+        ids: { type: "array", items: { type: "string" } },
+        repo: { type: "string" },
+        deletedCount: { type: "number" }
+      },
+      required: ["success"]
+    }
+  },
+  {
+    name: "memory-recap",
+    title: "Memory Recap",
+    description: "AGGREGATED OVERVIEW LAYER: Returns stats (counts by type) and a pointer table of top memories [id, title, type, importance]. NO content. Use for orientation only \u2014 retrieve full memory via memory-detail.",
+    annotations: {
+      readOnlyHint: true,
+      idempotentHint: true,
+      openWorldHint: false
+    },
+    inputSchema: {
+      type: "object",
+      properties: {
+        repo: { type: "string", description: "Repository name (required)" },
+        limit: {
+          type: "number",
+          minimum: 1,
+          maximum: 50,
+          default: 20,
+          description: "Maximum number of top memories to return in the pointer table"
+        },
+        offset: {
+          type: "number",
+          minimum: 0,
+          default: 0,
+          description: "Number of memories to skip for pagination (optional, default 0)"
+        }
+      },
+      required: ["repo"]
+    },
+    outputSchema: {
+      type: "object",
+      properties: {
+        schema: { type: "string", enum: ["memory-recap"] },
+        repo: { type: "string" },
+        count: { type: "number", description: "Number of rows in the top pointer table" },
+        total: { type: "number", description: "Total active memories in repo" },
+        offset: { type: "number" },
+        limit: { type: "number" },
+        stats: {
+          type: "object",
+          properties: {
+            by_type: {
+              type: "object",
+              description: "Count of active memories per type (e.g. { decision: 3, code_fact: 7 })"
+            }
+          },
+          required: ["by_type"]
+        },
+        top: {
+          type: "object",
+          properties: {
+            columns: {
+              type: "array",
+              items: { type: "string" },
+              description: "Column names: [id, title, type, importance]"
+            },
+            rows: {
+              type: "array",
+              items: { type: "array" },
+              description: "Each row: [id, title, type, importance]. Fetch full content via memory-detail"
+            }
+          },
+          required: ["columns", "rows"]
+        }
+      },
+      required: ["schema", "repo", "count", "total", "offset", "limit", "stats", "top"]
+    }
+  },
+  {
+    name: "task-create",
+    title: "Task Create",
+    description: "Register one or more new tasks in a repository. task_code must be unique within the repository. Supports single task object or an array of tasks for bulk creation.",
+    annotations: {
+      readOnlyHint: false,
+      idempotentHint: false,
+      openWorldHint: false
+    },
+    inputSchema: {
+      type: "object",
+      properties: {
+        repo: { type: "string", description: "Repository name" },
+        task_code: { type: "string", description: "Unique task code (e.g. TASK-001) (Required for single task)" },
+        phase: { type: "string", description: "Project phase (Required for single task)" },
+        title: { type: "string", minLength: 3, maxLength: 100, description: "Task objective (Required for single task)" },
+        description: { type: "string", description: "Detailed description (Required for single task)" },
+        status: {
+          type: "string",
+          enum: ["backlog", "pending"],
+          default: "backlog",
+          description: "New tasks MUST start in 'backlog' if there are already 10 pending tasks. Otherwise can start in 'pending'."
+        },
+        priority: { type: "number", minimum: 1, maximum: 5, default: 3 },
+        agent: { type: "string" },
+        role: { type: "string" },
+        doc_path: { type: "string" },
+        tags: { type: "array", items: { type: "string" } },
+        metadata: { type: "object" },
+        parent_id: { type: "string", format: "uuid" },
+        depends_on: { type: "string", format: "uuid" },
+        est_tokens: { type: "number", minimum: 0, description: "Estimated tokens budget for this task" },
+        tasks: {
+          type: "array",
+          items: {
+            type: "object",
+            properties: {
+              task_code: { type: "string" },
+              phase: { type: "string" },
+              title: { type: "string", minLength: 3, maxLength: 100 },
+              description: { type: "string" },
+              status: { type: "string", enum: ["backlog", "pending"], default: "backlog" },
+              priority: { type: "number", minimum: 1, maximum: 5, default: 3 },
+              agent: { type: "string" },
+              role: { type: "string" },
+              doc_path: { type: "string" },
+              tags: { type: "array", items: { type: "string" } },
+              metadata: { type: "object" },
+              parent_id: { type: "string", format: "uuid" },
+              depends_on: { type: "string", format: "uuid" },
+              est_tokens: { type: "number", minimum: 0 }
+            },
+            required: ["task_code", "phase", "title", "description"]
+          },
+          description: "Array of tasks for bulk creation"
+        }
+      },
+      required: ["repo"]
+    },
+    outputSchema: {
+      type: "object",
+      properties: {
+        success: { type: "boolean" },
+        id: { type: "string" },
+        repo: { type: "string" },
+        task_code: { type: "string" },
+        phase: { type: "string" },
+        title: { type: "string" },
+        status: { type: "string" },
+        priority: { type: "number" },
+        createdCount: { type: "number" },
+        taskCodes: { type: "array", items: { type: "string" } }
+      },
+      required: ["success", "repo"]
+    }
+  },
+  {
+    name: "task-update",
+    title: "Task Update",
+    description: "Update one or more tasks. Supports single update via 'id' or bulk update via 'ids'. Provide only the fields that need to be changed. MANDATORY WORKFLOW: You cannot move a task from 'pending' or 'blocked' directly to 'completed'. You MUST move it to 'in_progress' first. When changing status to 'completed', include 'est_tokens' with the estimated total tokens actually used for the task.",
+    annotations: {
+      readOnlyHint: false,
+      idempotentHint: false,
+      openWorldHint: false
+    },
+    inputSchema: {
+      type: "object",
+      properties: {
+        repo: { type: "string", description: "Repository name" },
+        id: { type: "string", format: "uuid", description: "Task ID (for single update)" },
+        ids: { type: "array", items: { type: "string", format: "uuid" }, description: "Task IDs (for bulk update)" },
+        task_code: { type: "string" },
+        phase: { type: "string" },
+        title: { type: "string", minLength: 3, maxLength: 100 },
+        description: { type: "string" },
+        status: {
+          type: "string",
+          enum: ["backlog", "pending", "in_progress", "completed", "canceled", "blocked"],
+          description: "New status. Transitions from 'backlog', 'pending' or 'blocked' to 'completed' are NOT allowed."
+        },
+        priority: { type: "number", minimum: 1, maximum: 5 },
+        agent: { type: "string" },
+        role: { type: "string" },
+        model: { type: "string" },
+        comment: {
+          type: "string",
+          description: "REQUIRED when changing task status. Explain WHY the status is changing (e.g., 'Starting implementation', 'Blocked by missing API docs', 'Verified fix')."
+        },
+        doc_path: { type: "string" },
+        tags: { type: "array", items: { type: "string" } },
+        metadata: { type: "object" },
+        parent_id: { type: "string", format: "uuid" },
+        depends_on: { type: "string", format: "uuid" },
+        est_tokens: {
+          type: "number",
+          minimum: 0,
+          description: "Estimated total tokens actually used for this task. Required when status changes to 'completed'."
+        },
+        force: { type: "boolean", description: "If true, bypasses status transition validation (e.g. pending -> completed)." }
+      },
+      required: ["repo"]
+    },
+    outputSchema: {
+      type: "object",
+      properties: {
+        success: { type: "boolean" },
+        id: { type: "string" },
+        ids: { type: "array", items: { type: "string" } },
+        repo: { type: "string" },
+        status: { type: "string" },
+        archivedToMemory: { type: "boolean" },
+        updatedFields: {
+          type: "array",
+          items: { type: "string" }
+        },
+        updatedCount: { type: "number" }
+      },
+      required: ["success", "repo"]
+    }
+  },
+  {
+    name: "task-delete",
+    title: "Task Delete",
+    description: "Delete one or more tasks from a repository. Supports single 'id' or bulk 'ids'.",
+    annotations: {
+      readOnlyHint: false,
+      idempotentHint: false,
+      destructiveHint: true,
+      openWorldHint: false
+    },
+    inputSchema: {
+      type: "object",
+      properties: {
+        repo: { type: "string", description: "Repository name" },
+        id: { type: "string", format: "uuid", description: "Task ID (for single deletion)" },
+        ids: { type: "array", items: { type: "string", format: "uuid" }, description: "Task IDs (for bulk deletion)" }
+      },
+      required: ["repo"]
+    },
+    outputSchema: {
+      type: "object",
+      properties: {
+        success: { type: "boolean" },
+        id: { type: "string" },
+        ids: { type: "array", items: { type: "string" } },
+        repo: { type: "string" },
+        deletedCount: { type: "number" }
+      },
+      required: ["success", "repo"]
+    }
+  },
+  {
+    name: "task-list",
+    title: "Task List",
+    description: "PRIMARY navigation and search tool for tasks. Returns a compact tabular list of tasks (id, task_code, title, status, priority). Defaults to in_progress and pending tasks. Use 'query' to filter by code, title, or description. Use 'status' (comma-separated) for specific filters. AGENTS: call this once at start, pick ONE task, then call task-detail.",
+    annotations: {
+      readOnlyHint: true,
+      idempotentHint: true,
+      openWorldHint: false
+    },
+    inputSchema: {
+      type: "object",
+      properties: {
+        repo: {
+          type: "string",
+          description: "Repository name"
+        },
+        status: {
+          type: "string",
+          default: "in_progress,pending",
+          description: "Comma-separated status filter (backlog, pending, in_progress, completed, canceled, blocked). Defaults to 'in_progress,pending'."
+        },
+        phase: {
+          type: "string",
+          description: "Filter by phase (e.g., 'research', 'implementation')"
+        },
+        query: {
+          type: "string",
+          description: "Search keyword matching task code, title, or description"
+        },
+        limit: {
+          type: "number",
+          minimum: 1,
+          maximum: 100,
+          default: 5,
+          description: "Maximum rows to return (default 5)"
+        },
+        offset: {
+          type: "number",
+          minimum: 0,
+          default: 0,
+          description: "Offset for pagination"
+        }
+      },
+      required: ["repo"]
+    },
+    outputSchema: {
+      type: "object",
+      properties: {
+        schema: { type: "string", enum: ["task-list"] },
+        tasks: {
+          type: "object",
+          properties: {
+            columns: {
+              type: "array",
+              items: { type: "string" },
+              description: "Column names in order: id, task_code, title, status, priority, comments_count"
+            },
+            rows: {
+              type: "array",
+              items: { type: "array" },
+              description: "Each row: [id, task_code, title, status, priority, comments_count]. Use task-detail to fetch full task."
+            }
+          },
+          required: ["columns", "rows"]
+        },
+        count: { type: "number" },
+        offset: { type: "number" }
+      },
+      required: ["schema", "tasks", "count"]
+    }
+  }
+];
+
+// src/mcp/utils/pagination.ts
+function encodeCursor(offset) {
+  return Buffer.from(String(offset), "utf8").toString("base64");
+}
+function decodeCursor(cursor) {
+  if (cursor === void 0 || cursor === null || cursor === "") {
+    return 0;
+  }
+  if (typeof cursor !== "string" || cursor.trim() === "") {
+    throw invalidPaginationParams("Invalid cursor");
+  }
+  let decoded;
+  try {
+    decoded = Buffer.from(cursor, "base64").toString("utf8");
+  } catch {
+    throw invalidPaginationParams("Invalid cursor");
+  }
+  if (!/^\d+$/.test(decoded)) {
+    throw invalidPaginationParams("Invalid cursor");
+  }
+  const offset = Number.parseInt(decoded, 10);
+  if (!Number.isFinite(offset) || offset < 0) {
+    throw invalidPaginationParams("Invalid cursor");
+  }
+  return offset;
+}
+function invalidPaginationParams(message) {
+  const error = new Error(message);
+  error.code = -32602;
+  return error;
+}
+
+// src/mcp/utils/completion.ts
+var MAX_COMPLETION_VALUES = 100;
+function rankCompletionValues(candidates, input) {
+  const unique = [...new Set(candidates.filter(Boolean))];
+  const needle = input.trim().toLowerCase();
+  if (!needle) {
+    return unique.slice(0, MAX_COMPLETION_VALUES);
+  }
+  return unique.map((value) => ({ value, score: scoreCompletionValue(value, needle) })).filter((entry) => entry.score > 0).sort((a, b) => b.score - a.score || a.value.localeCompare(b.value)).map((entry) => entry.value);
+}
+function scoreCompletionValue(value, needle) {
+  const haystack = value.toLowerCase();
+  if (haystack === needle) return 100;
+  if (haystack.startsWith(needle)) return 75;
+  if (haystack.includes(needle)) return 50;
+  const compactNeedle = needle.replace(/[\s_-]+/g, "");
+  const compactHaystack = haystack.replace(/[\s_-]+/g, "");
+  if (compactNeedle && compactHaystack.includes(compactNeedle)) return 25;
+  return 0;
+}
+
+// src/mcp/resources/index.ts
+var DEFAULT_PAGE_SIZE = 25;
+var MAX_PAGE_SIZE = 100;
+function listResources(session, params) {
+  const resources = [
+    {
+      uri: "repository://index",
+      name: "Repository Index",
+      title: "Repository Index",
+      description: "List of all known repositories with memory/task counts and last activity",
+      mimeType: "application/json",
+      annotations: {
+        audience: ["assistant"],
+        priority: 1,
+        lastModified: (/* @__PURE__ */ new Date()).toISOString()
+      }
+    },
+    {
+      uri: "session://roots",
+      name: "Session Roots",
+      title: "Session Roots",
+      description: session?.roots.length ? "Active workspace roots provided by the MCP client" : "No active workspace roots were provided by the MCP client",
+      mimeType: "application/json",
+      size: Buffer.byteLength(JSON.stringify({ roots: session?.roots ?? [] }), "utf8"),
+      annotations: {
+        audience: ["assistant"],
+        priority: 0.95,
+        lastModified: (/* @__PURE__ */ new Date()).toISOString()
+      }
+    }
+  ];
+  return paginateEntries("resources", resources, params);
+}
+function listResourceTemplates(params) {
+  const templates = [
+    // ── Memory ──────────────────────────────────────────────────────────────
+    {
+      uriTemplate: "repository://{name}/memories",
+      name: "Repository Memories",
+      title: "Repository Memories",
+      description: "All active memory entries for a specific repository",
+      mimeType: "application/json",
+      annotations: { audience: ["assistant"], priority: 0.85 }
+    },
+    {
+      uriTemplate: "repository://{name}/memories?search={search}&type={type}&tag={tag}",
+      name: "Filtered Repository Memories",
+      title: "Filtered Repository Memories",
+      description: "Filter or search memories within a repository by keyword, type, or tag",
+      mimeType: "application/json",
+      annotations: { audience: ["assistant"], priority: 0.8 }
+    },
+    {
+      uriTemplate: "memory://{id}",
+      name: "Memory Detail",
+      title: "Memory Detail",
+      description: "Full content and statistics for a specific memory UUID",
+      mimeType: "application/json",
+      annotations: { audience: ["assistant"], priority: 0.75 }
+    },
+    // ── Tasks ────────────────────────────────────────────────────────────────
+    {
+      uriTemplate: "repository://{name}/tasks",
+      name: "Repository Tasks",
+      title: "Repository Tasks",
+      description: "All active tasks for a specific repository",
+      mimeType: "application/json",
+      annotations: { audience: ["assistant"], priority: 0.9 }
+    },
+    {
+      uriTemplate: "repository://{name}/tasks?status={status}&priority={priority}",
+      name: "Filtered Repository Tasks",
+      title: "Filtered Repository Tasks",
+      description: "Filter tasks within a repository by status or priority level",
+      mimeType: "application/json",
+      annotations: { audience: ["assistant"], priority: 0.85 }
+    },
+    {
+      uriTemplate: "task://{id}",
+      name: "Task Detail",
+      title: "Task Detail",
+      description: "Full content and comments for a specific task UUID",
+      mimeType: "application/json",
+      annotations: { audience: ["assistant"], priority: 0.8 }
+    },
+    // ── Repository extras ────────────────────────────────────────────────────
+    {
+      uriTemplate: "repository://{name}/summary",
+      name: "Repository Summary",
+      title: "Repository Summary",
+      description: "High-level architectural summary for a repository",
+      mimeType: "text/plain",
+      annotations: { audience: ["assistant"], priority: 0.95 }
+    },
+    {
+      uriTemplate: "repository://{name}/actions",
+      name: "Repository Actions",
+      title: "Repository Actions",
+      description: "Audit log of agent tool actions scoped to a repository",
+      mimeType: "application/json",
+      annotations: { audience: ["assistant"], priority: 0.6 }
+    },
+    // ── Action detail ────────────────────────────────────────────────────────
+    {
+      uriTemplate: "action://{id}",
+      name: "Action Detail",
+      title: "Action Detail",
+      description: "Full details of a specific audit log entry by integer ID",
+      mimeType: "application/json",
+      annotations: { audience: ["assistant"], priority: 0.55 }
+    }
+  ];
+  return paginateEntries("resourceTemplates", templates, params);
+}
+function completeResourceArgument(resourceUri, argumentName, argumentValue, _contextArguments, dataSources) {
+  if (resourceUri === "repository://{name}/memories" || resourceUri === "repository://{name}/memories?search={search}&type={type}&tag={tag}" || resourceUri === "repository://{name}/tasks" || resourceUri === "repository://{name}/tasks?status={status}&priority={priority}" || resourceUri === "repository://{name}/summary" || resourceUri === "repository://{name}/actions") {
+    if (argumentName === "name") {
+      return rankCompletionValues(dataSources.repos, argumentValue);
+    }
+  }
+  if (resourceUri === "repository://{name}/memories?search={search}&type={type}&tag={tag}") {
+    if (argumentName === "tag") {
+      return rankCompletionValues(dataSources.tags, argumentValue);
+    }
+  }
+  throw invalidCompletionParams(`Unknown resource template or argument: ${resourceUri} (${argumentName})`);
+}
+function readResource(uri, db, session) {
+  logger.info("[MCP] resource.read", { uri });
+  if (uri === "repository://index") {
+    const repos = db.system.listRepoNavigation();
+    const payload = JSON.stringify(repos, null, 2);
+    return {
+      contents: [
+        {
+          uri,
+          mimeType: "application/json",
+          text: payload,
+          size: Buffer.byteLength(payload, "utf8"),
+          annotations: {
+            audience: ["assistant"],
+            priority: 1,
+            lastModified: (/* @__PURE__ */ new Date()).toISOString()
+          }
+        }
+      ]
+    };
+  }
+  if (uri === "session://roots") {
+    const payload = JSON.stringify({ roots: session?.roots ?? [] }, null, 2);
+    return {
+      contents: [
+        {
+          uri,
+          mimeType: "application/json",
+          text: payload,
+          size: Buffer.byteLength(payload, "utf8"),
+          annotations: {
+            audience: ["assistant"],
+            priority: 0.95,
+            lastModified: (/* @__PURE__ */ new Date()).toISOString()
+          }
+        }
+      ]
+    };
+  }
+  const memoryIdMatch = uri.match(/^memory:\/\/([0-9a-f-]{36})$/i);
+  if (memoryIdMatch) {
+    const id = memoryIdMatch[1];
+    const entry = db.memories.getByIdWithStats(id);
+    if (!entry) throw resourceNotFound(`Memory with ID ${id} not found.`, uri);
+    const payload = JSON.stringify(entry, null, 2);
+    return {
+      contents: [
+        {
+          uri,
+          mimeType: "application/json",
+          text: payload,
+          size: Buffer.byteLength(payload, "utf8"),
+          annotations: {
+            audience: ["assistant"],
+            priority: 0.75,
+            lastModified: entry.updated_at || entry.created_at
+          }
+        }
+      ]
+    };
+  }
+  const taskIdMatch = uri.match(/^task:\/\/([0-9a-f-]{36})$/i);
+  if (taskIdMatch) {
+    const id = taskIdMatch[1];
+    const task = db.tasks.getTaskById(id);
+    if (!task) throw resourceNotFound(`Task with ID ${id} not found.`, uri);
+    const payload = JSON.stringify(task, null, 2);
+    return {
+      contents: [
+        {
+          uri,
+          mimeType: "application/json",
+          text: payload,
+          size: Buffer.byteLength(payload, "utf8"),
+          annotations: {
+            audience: ["assistant"],
+            priority: 0.8,
+            lastModified: task.updated_at || task.created_at
+          }
+        }
+      ]
+    };
+  }
+  const repoBase = parseRepoUri(uri);
+  if (repoBase) {
+    const { name, path: repoPath, query } = repoBase;
+    if (repoPath === "summary") {
+      const summary = db.summaries.getSummary(name);
+      const text = summary?.summary || `No summary available for repository: ${name}`;
+      return {
+        contents: [
+          {
+            uri,
+            mimeType: "text/plain",
+            text,
+            size: Buffer.byteLength(text, "utf8"),
+            annotations: {
+              audience: ["assistant"],
+              priority: 0.95,
+              lastModified: summary?.updated_at || (/* @__PURE__ */ new Date()).toISOString()
+            }
+          }
+        ]
+      };
+    }
+    if (repoPath === "memories") {
+      const search = query.get("search") || "";
+      const type = query.get("type");
+      const tag = query.get("tag");
+      const result = db.memories.listMemoriesForDashboard({
+        repo: name,
+        type: type || void 0,
+        tag: tag || void 0,
+        search: search || void 0,
+        limit: 50
+      });
+      const entries = result.items;
+      const payload = JSON.stringify(entries, null, 2);
+      return {
+        contents: [
+          {
+            uri,
+            mimeType: "application/json",
+            text: payload,
+            size: Buffer.byteLength(payload, "utf8"),
+            annotations: {
+              audience: ["assistant"],
+              priority: 0.85,
+              lastModified: deriveLastModifiedFromCollection(
+                entries.map((e) => e.updated_at || e.created_at)
+              )
+            }
+          }
+        ]
+      };
+    }
+    if (repoPath === "tasks") {
+      const status = query.get("status");
+      const priority = query.get("priority");
+      let tasks;
+      if (status && status !== "all") {
+        const statuses = status.split(",").map((s) => s.trim());
+        tasks = db.tasks.getTasksByMultipleStatuses(name, statuses);
+      } else {
+        tasks = db.tasks.getTasksByMultipleStatuses(name, ["backlog", "pending", "in_progress", "blocked"]);
+      }
+      if (priority) {
+        const p = Number(priority);
+        if (!isNaN(p)) {
+          tasks = tasks.filter((t) => t.priority === p);
+        }
+      }
+      const payload = JSON.stringify(tasks, null, 2);
+      return {
+        contents: [
+          {
+            uri,
+            mimeType: "application/json",
+            text: payload,
+            size: Buffer.byteLength(payload, "utf8"),
+            annotations: {
+              audience: ["assistant"],
+              priority: 0.9,
+              lastModified: deriveLastModifiedFromCollection(tasks.map((t) => t.updated_at))
+            }
+          }
+        ]
+      };
+    }
+    if (repoPath === "actions") {
+      const actions = db.actions.getRecentActions(name, 100);
+      const payload = JSON.stringify(actions, null, 2);
+      return {
+        contents: [
+          {
+            uri,
+            mimeType: "application/json",
+            text: payload,
+            size: Buffer.byteLength(payload, "utf8"),
+            annotations: {
+              audience: ["assistant"],
+              priority: 0.6,
+              lastModified: deriveLastModifiedFromCollection(actions.map((a) => a.created_at))
+            }
+          }
+        ]
+      };
+    }
+  }
+  const actionIdMatch = uri.match(/^action:\/\/(\d+)$/);
+  if (actionIdMatch) {
+    const id = Number(actionIdMatch[1]);
+    const action = db.actions.getActionById(id);
+    if (!action) throw resourceNotFound(`Action with ID ${id} not found.`, uri);
+    const payload = JSON.stringify(action, null, 2);
+    return {
+      contents: [
+        {
+          uri,
+          mimeType: "application/json",
+          text: payload,
+          size: Buffer.byteLength(payload, "utf8"),
+          annotations: {
+            audience: ["assistant"],
+            priority: 0.55,
+            lastModified: action.created_at
+          }
+        }
+      ]
+    };
+  }
+  throw resourceNotFound(`Unknown resource URI: ${uri}`, uri);
+}
+function parseRepoUri(uri) {
+  const prefix = "repository://";
+  if (!uri.startsWith(prefix)) return null;
+  const rest = uri.slice(prefix.length);
+  const queryStart = rest.indexOf("?");
+  const withoutQuery = queryStart === -1 ? rest : rest.slice(0, queryStart);
+  const queryString = queryStart === -1 ? "" : rest.slice(queryStart + 1);
+  const slashIdx = withoutQuery.indexOf("/");
+  if (slashIdx === -1) return null;
+  const name = withoutQuery.slice(0, slashIdx);
+  const path5 = withoutQuery.slice(slashIdx + 1);
+  if (!name || !path5) return null;
+  return { name, path: path5, query: new URLSearchParams(queryString) };
+}
+function paginateEntries(key, entries, params) {
+  const limit = normalizeLimit(params?.limit);
+  const offset = decodeCursor(params?.cursor);
+  const sliced = entries.slice(offset, offset + limit);
+  const nextOffset = offset + sliced.length;
+  return {
+    [key]: sliced,
+    nextCursor: nextOffset < entries.length ? encodeCursor(nextOffset) : void 0
+  };
+}
+function normalizeLimit(limit) {
+  if (typeof limit !== "number" || !Number.isFinite(limit)) {
+    return DEFAULT_PAGE_SIZE;
+  }
+  return Math.min(MAX_PAGE_SIZE, Math.max(1, Math.trunc(limit)));
+}
+function deriveLastModifiedFromCollection(values) {
+  const normalized = values.filter((value) => typeof value === "string" && value.length > 0);
+  return normalized.sort().at(-1) ?? (/* @__PURE__ */ new Date()).toISOString();
+}
+function resourceNotFound(message, uri) {
+  const error = new Error(message);
+  error.code = -32002;
+  error.data = { uri };
+  return error;
+}
+function invalidCompletionParams(message) {
+  const error = new Error(message);
+  error.code = -32602;
+  return error;
+}
+
+// src/mcp/prompts/loader.ts
+import fs3 from "fs";
+import path4 from "path";
+import { fileURLToPath as fileURLToPath3 } from "url";
+import matter from "gray-matter";
+var __filename = fileURLToPath3(import.meta.url);
+var __dirname2 = path4.dirname(__filename);
+var PROMPT_DIR = path4.join(__dirname2, "definitions");
+function listPromptFiles() {
+  if (!fs3.existsSync(PROMPT_DIR)) return [];
+  return fs3.readdirSync(PROMPT_DIR).filter((file) => file.endsWith(".md")).map((file) => file.replace(/\.md$/, "")).sort();
+}
+function loadPromptFromMarkdown(name) {
+  const filePath = path4.join(PROMPT_DIR, `${name}.md`);
+  if (!fs3.existsSync(filePath)) {
+    throw new Error(`Prompt file not found: ${filePath}`);
+  }
+  const fileContent = fs3.readFileSync(filePath, "utf-8");
+  const { data, content } = matter(fileContent);
+  return {
+    name: data.name || name,
+    description: data.description || "",
+    arguments: data.arguments || [],
+    agent: data.agent,
+    content: content.trim()
+  };
+}
+
+// src/mcp/prompts/registry.ts
+function createPromptDefinition(loaded) {
+  return {
+    name: loaded.name,
+    description: loaded.description,
+    arguments: loaded.arguments,
+    agent: loaded.agent,
+    messages: [
+      {
+        role: "user",
+        content: {
+          type: "text",
+          text: loaded.content
+        }
+      }
+    ]
+  };
+}
+var PROMPTS = {};
+var promptFiles = listPromptFiles();
+for (const name of promptFiles) {
+  try {
+    PROMPTS[name] = createPromptDefinition(loadPromptFromMarkdown(name));
+  } catch (e) {
+    console.warn(`Failed to load prompt ${name}: ${e}`);
+  }
+}
+async function listPrompts(db, session, params) {
+  const allPrompts = Object.values(PROMPTS).map((p) => ({
+    name: p.name,
+    description: p.description,
+    arguments: p.arguments,
+    metadata: p.agent ? { agent: p.agent } : void 0
+  }));
+  const rawLimit = typeof params?.limit === "number" && Number.isInteger(params?.limit) ? params.limit : 25;
+  const limit = Math.max(1, Math.min(100, Math.trunc(rawLimit)));
+  const offset = decodeCursor(params?.cursor);
+  const sliced = allPrompts.slice(offset, offset + limit);
+  const nextOffset = offset + sliced.length;
+  return {
+    prompts: sliced,
+    nextCursor: nextOffset < allPrompts.length ? encodeCursor(nextOffset) : void 0
+  };
+}
+async function getPrompt(name, args = {}, db, session) {
+  const prompt = PROMPTS[name];
+  if (!prompt) {
+    throw new Error(`Prompt not found: ${name}`);
+  }
+  const inferredRepo = inferRepoFromSession(session);
+  const messages = prompt.messages.map((m) => {
+    let text = m.content.text;
+    for (const [key, value] of Object.entries(args)) {
+      text = text.replace(new RegExp(`\\{{${key}\\}}`, "g"), value);
+    }
+    text = text.replace(/{{current_repo}}/g, inferredRepo || "unknown-repo");
+    return {
+      ...m,
+      content: {
+        ...m.content,
+        text
+      }
+    };
+  });
+  return {
+    description: prompt.description,
+    messages,
+    metadata: prompt.agent ? { agent: prompt.agent } : void 0
+  };
+}
+async function completePromptArgument(name, argName, value, contextArguments, dataSources) {
+  void name;
+  void contextArguments;
+  if (argName === "task_id") {
+    const values = dataSources.tasks.map((t) => t.id);
+    return rankCompletionValues(values, value);
+  }
+  return [];
+}
+
+export {
+  MCP_PROTOCOL_VERSION,
+  CAPABILITIES,
+  logger,
+  setLogLevel,
+  getLogLevel,
+  addLogSink,
+  LOG_LEVEL_VALUES,
+  normalizeRepo,
+  SQLiteStore,
+  MemoryStoreSchema,
+  MemoryUpdateSchema,
+  MemorySearchSchema,
+  MemoryAcknowledgeSchema,
+  MemoryRecapSchema,
+  MemoryDeleteSchema,
+  MemorySummarizeSchema,
+  MemorySynthesizeSchema,
+  TaskCreateSchema,
+  TaskCreateInteractiveSchema,
+  TaskUpdateSchema,
+  TaskListSchema,
+  TaskDeleteSchema,
+  MemoryDetailSchema,
+  TaskGetSchema,
+  TOOL_DEFINITIONS,
+  encodeCursor,
+  decodeCursor,
+  listResources,
+  listResourceTemplates,
+  completeResourceArgument,
+  readResource,
+  createSessionContext,
+  updateSessionFromInitialize,
+  updateSessionRoots,
+  extractRootsFromResult,
+  getFilesystemRoots,
+  isPathWithinRoots,
+  findContainingRoot,
+  inferRepoFromSession,
+  PROMPTS,
+  listPrompts,
+  getPrompt,
+  completePromptArgument
+};