@vheins/local-memory-mcp 0.6.1 → 0.7.0

package/dist/{chunk-EQTLHCFK.js → chunk-3I4VJIFK.js}

@@ -82,6 +82,9 @@ function deriveLoggerName(message) {
   return "app";
 }
 function emitToStderr(level, message, context) {
+  if (process.env.MCP_SERVER === "true") {
+    return;
+  }
   const timestamp = (/* @__PURE__ */ new Date()).toISOString();
   if (message.startsWith("[MCP]")) {
     const icon = getMcpIcon(message);
@@ -169,19 +172,43 @@ function addLogSink(sink) {
 var LOG_LEVEL_VALUES = Object.keys(LEVELS);
 
 // src/mcp/storage/sqlite.ts
-import Database from "better-sqlite3";
+import initSqlJs from "sql.js";
 import path2 from "path";
 import fs2 from "fs";
 import os from "os";
 
 // src/mcp/storage/migrations.ts
 var MigrationManager = class {
-  constructor(db) {
+  constructor(db, saveDb) {
     this.db = db;
+    this.saveDb = saveDb;
   }
   db;
+  saveDb;
+  run(sql) {
+    this.db.run(sql);
+  }
+  exec(sql) {
+    this.db.exec(sql);
+  }
+  all(sql) {
+    const result = this.db.exec(sql);
+    if (result.length === 0) return [];
+    const { columns, values } = result[0];
+    return values.map((row) => {
+      const obj = {};
+      columns.forEach((col, i) => {
+        obj[col] = row[i];
+      });
+      return obj;
+    });
+  }
+  get(sql) {
+    const rows = this.all(sql);
+    return rows[0];
+  }
   migrate() {
-    this.db.exec(`
+    this.exec(`
       CREATE TABLE IF NOT EXISTS memories (
         id TEXT PRIMARY KEY,
         repo TEXT NOT NULL,
@@ -311,35 +338,6 @@ var MigrationManager = class {
 
       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" },
@@ -409,37 +407,34 @@ var MigrationManager = class {
     ];
     for (const col of columnsToAdd) {
       try {
-        const tableInfo = this.db.prepare(`PRAGMA table_info(${col.table})`).all();
+        const tableInfo = this.all(`PRAGMA table_info(${col.table})`);
         const existingTableColumns = tableInfo.map((c) => c.name);
         if (tableInfo.length > 0 && !existingTableColumns.includes(col.name)) {
-          this.db.exec(col.definition);
+          this.exec(col.definition);
         }
-      } catch (e) {
-        logger.error(
-          `Migration step failed for ${col.table}.${col.name}: ${e instanceof Error ? e.message : String(e)}`
-        );
+      } catch {
       }
     }
     this.ensureMemoryTypeConstraint();
     this.ensureTaskStatusConstraintRemoved();
     this.ensureMemoryStatusConstraintRemoved();
-    this.db.exec(`
+    this.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)}`);
+      this.run("UPDATE tasks SET task_code = substr(id, 1, 8) WHERE task_code IS NULL");
+    } catch {
     }
+    if (this.saveDb) this.saveDb();
   }
   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")) {
+    const tableSql = this.get("SELECT sql FROM sqlite_master WHERE type = 'table' AND name = 'memories'");
+    if (!tableSql?.sql || !String(tableSql.sql).includes("CHECK (type IN")) {
       return;
     }
-    this.db.exec(`
+    this.exec(`
       BEGIN TRANSACTION;
 
       CREATE TABLE memories__migrated (
@@ -486,11 +481,11 @@ var MigrationManager = class {
     `);
   }
   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'")) {
+    const tableSql = this.get("SELECT sql FROM sqlite_master WHERE type = 'table' AND name = 'tasks'");
+    if (!tableSql?.sql || !String(tableSql.sql).includes("CHECK (status IN") && !String(tableSql.sql).includes("DEFAULT 'pending'")) {
       return;
     }
-    this.db.exec(`
+    this.exec(`
       BEGIN TRANSACTION;
 
       CREATE TABLE tasks__migrated (
@@ -535,11 +530,20 @@ var MigrationManager = class {
     `);
   }
   ensureMemoryStatusConstraintRemoved() {
-    const tableSql = this.db.prepare("SELECT sql FROM sqlite_master WHERE type = 'table' AND name = 'memories'").get();
+    const tableSql = this.get("SELECT sql FROM sqlite_master WHERE type = 'table' AND name = 'memories'");
     if (tableSql?.sql?.includes("status TEXT NOT NULL DEFAULT 'active' CHECK")) {
       this.ensureMemoryTypeConstraint();
     }
   }
+  addMemoryCodeColumn() {
+    const tableInfo = this.all("PRAGMA table_info(memories)");
+    const hasCode = tableInfo.some((col) => col.name === "code");
+    if (!hasCode) {
+      this.run("ALTER TABLE memories ADD COLUMN code TEXT");
+      this.run("CREATE INDEX IF NOT EXISTS idx_memories_code ON memories(code)");
+      this.run("CREATE INDEX IF NOT EXISTS idx_memories_repo_code ON memories(repo, code)");
+    }
+  }
 };
 
 // src/mcp/utils/normalize.ts
@@ -788,13 +792,37 @@ function tokenize(text) {
 
 // src/mcp/storage/base.ts
 var BaseEntity = class {
-  constructor(db) {
+  constructor(db, saveDb) {
     this.db = db;
+    this.saveDb = saveDb;
   }
   db;
-  /**
-   * Safe JSON parsing helper to avoid crashes on corrupt data
-   */
+  saveDb;
+  run(sql, params = []) {
+    this.db.run(sql, params);
+    if (this.saveDb) this.saveDb();
+    return { changes: this.db.getRowsModified() };
+  }
+  exec(sql) {
+    this.db.exec(sql);
+    if (this.saveDb) this.saveDb();
+  }
+  all(sql, params = []) {
+    const result = this.db.exec(sql, params);
+    if (result.length === 0) return [];
+    const { columns, values } = result[0];
+    return values.map((row) => {
+      const obj = {};
+      columns.forEach((col, i) => {
+        obj[col] = row[i];
+      });
+      return obj;
+    });
+  }
+  get(sql, params = []) {
+    const rows = this.all(sql, params);
+    return rows[0];
+  }
   safeJSONParse(json, defaultValue) {
     if (!json) return defaultValue;
     try {
@@ -803,13 +831,11 @@ var BaseEntity = class {
       return defaultValue;
     }
   }
-  /**
-   * Mapping helper for MemoryEntry
-   */
   rowToMemoryEntry(row) {
     const r = row;
     return {
       id: r.id,
+      code: r.code || void 0,
       type: r.type,
       title: r.title || "Untitled",
       content: r.content,
@@ -836,9 +862,6 @@ var BaseEntity = class {
       metadata: this.safeJSONParse(r.metadata, {})
     };
   }
-  /**
-   * Mapping helper for Task
-   */
   rowToTask(row) {
     const r = row;
     return {
@@ -866,9 +889,6 @@ var BaseEntity = class {
       comments_count: r.comments_count || 0
     };
   }
-  /**
-   * Vector math utilities (simple bag-of-words implementation)
-   */
   computeVector(text) {
     const tokens = tokenize(text);
     const vector = {};
@@ -897,34 +917,35 @@ var BaseEntity = class {
 // 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
+    this.run(
+      `INSERT INTO memories (
+				id, code, 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, ?, ?, ?, ?, ?, ?, ?, ?, ?, ?)`,
+      [
+        entry.id,
+        entry.code || null,
+        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) {
@@ -964,23 +985,24 @@ var MemoryEntity = class extends BaseEntity {
     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);
+    this.run(`UPDATE memories SET ${fields.join(", ")} WHERE id = ?`, values);
   }
   delete(id) {
-    this.db.prepare("DELETE FROM memories WHERE id = ?").run(id);
+    this.run("DELETE FROM memories WHERE id = ?", [id]);
   }
   getById(id) {
-    const row = this.db.prepare("SELECT * FROM memories WHERE id = ?").get(id);
+    const row = this.get("SELECT * FROM memories WHERE id = ?", [id]);
+    return row ? this.rowToMemoryEntry(row) : null;
+  }
+  getByCode(code) {
+    const row = this.get("SELECT * FROM memories WHERE code = ?", [code]);
     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);
+    const row = this.get(
+      `SELECT *, CASE WHEN hit_count > 0 THEN CAST(recall_count AS REAL) / hit_count ELSE 0 END AS recall_rate FROM memories WHERE id = ?`,
+      [id]
+    );
     if (!row) return null;
     return {
       ...this.rowToMemoryEntry(row),
@@ -999,7 +1021,7 @@ var MemoryEntity = class extends BaseEntity {
       sql += " AND status = ?";
       params.push(options.status);
     }
-    const rows = this.db.prepare(sql).all(...params);
+    const rows = this.all(sql, params);
     return rows.map((row) => this.rowToMemoryEntry(row));
   }
   getStats(repo) {
@@ -1010,7 +1032,7 @@ var MemoryEntity = class extends BaseEntity {
       params.push(repo);
     }
     sql += " GROUP BY type";
-    const rows = this.db.prepare(sql).all(...params);
+    const rows = this.all(sql, params);
     const byType = {};
     let total = 0;
     rows.forEach((row) => {
@@ -1021,32 +1043,6 @@ var MemoryEntity = class extends BaseEntity {
   }
   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) {
@@ -1055,21 +1051,19 @@ var MemoryEntity = class extends BaseEntity {
     }
     sql += " ORDER BY importance DESC, created_at DESC LIMIT ?";
     params.push(limit);
-    const rows = this.db.prepare(sql).all(...params);
+    const rows = this.all(sql, 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(
+    let count = 0;
+    for (const entry of entries) {
+      this.run(
+        `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, ?, ?, ?, ?, ?, ?, ?, ?, ?, ?)`,
+        [
           entry.id,
           entry.scope.repo,
           entry.type,
@@ -1090,12 +1084,11 @@ var MemoryEntity = class extends BaseEntity {
           entry.role || "unknown",
           entry.model || "unknown",
           entry.completed_at || null
-        );
-        count++;
-      }
-      return count;
-    });
-    return insertMany(entries);
+        ]
+      );
+      count++;
+    }
+    return count;
   }
   bulkUpdateMemories(ids, updates) {
     if (ids.length === 0) return 0;
@@ -1119,35 +1112,28 @@ var MemoryEntity = class extends BaseEntity {
     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);
+    let count = 0;
+    const chunkSize = 500;
+    for (let i = 0; i < ids.length; i += chunkSize) {
+      const chunk = ids.slice(i, i + chunkSize);
+      const result = this.run(
+        `UPDATE memories SET ${fields.join(", ")} WHERE id IN (${chunk.map(() => "?").join(",")})`,
+        [...values, ...chunk]
+      );
+      count += result.changes;
+    }
+    return count;
   }
   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);
+    let count = 0;
+    const chunkSize = 500;
+    for (let i = 0; i < ids.length; i += chunkSize) {
+      const chunk = ids.slice(i, i + chunkSize);
+      const result = this.run(`DELETE FROM memories WHERE id IN (${chunk.map(() => "?").join(",")})`, chunk);
+      count += result.changes;
+    }
+    return count;
   }
   getRecentMemories(repo, limit, offset = 0, includeArchived = false, excludeTypes = []) {
     let query = "SELECT * FROM memories WHERE repo = ?";
@@ -1161,7 +1147,7 @@ var MemoryEntity = class extends BaseEntity {
     }
     query += " ORDER BY created_at DESC LIMIT ? OFFSET ?";
     params.push(limit, offset);
-    const rows = this.db.prepare(query).all(...params);
+    const rows = this.all(query, params);
     return rows.map((row) => this.rowToMemoryEntry(row));
   }
   getTotalCount(repo, includeArchived = false, excludeTypes = []) {
@@ -1172,25 +1158,27 @@ var MemoryEntity = class extends BaseEntity {
       sql += ` AND type NOT IN (${excludeTypes.map(() => "?").join(",")})`;
       params.push(...excludeTypes);
     }
-    const row = this.db.prepare(sql).get(...params);
-    return row.count;
+    const row = this.get(sql, params);
+    return row?.count ?? 0;
   }
   incrementHitCount(id) {
-    this.db.prepare("UPDATE memories SET hit_count = hit_count + 1, last_used_at = ? WHERE id = ?").run((/* @__PURE__ */ new Date()).toISOString(), id);
+    this.run("UPDATE memories SET hit_count = hit_count + 1, last_used_at = ? WHERE id = ?", [
+      (/* @__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);
+    for (const id of ids) {
+      this.run("UPDATE memories SET hit_count = hit_count + 1, last_used_at = ? WHERE id = ?", [now, id]);
+    }
   }
   incrementRecallCount(id) {
-    this.db.prepare("UPDATE memories SET recall_count = recall_count + 1, last_used_at = ? WHERE id = ?").run((/* @__PURE__ */ new Date()).toISOString(), id);
+    this.run("UPDATE memories SET recall_count = recall_count + 1, last_used_at = ? WHERE id = ?", [
+      (/* @__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`;
@@ -1201,41 +1189,38 @@ var MemoryEntity = class extends BaseEntity {
     }
     sql += " LIMIT ?";
     params.push(limit);
-    return this.db.prepare(sql).all(...params);
+    return this.all(sql, 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());
+    this.run(
+      `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`,
+      [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);
+    const row = this.get(
+      "SELECT summary, updated_at FROM memory_summary WHERE repo = ?",
+      [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);
+    const rows = this.all(
+      `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`,
+      [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());
+    this.run(
+      `INSERT INTO memory_summary (repo, summary, updated_at) VALUES (?, ?, ?)
+			ON CONFLICT(repo) DO UPDATE SET summary = excluded.summary, updated_at = excluded.updated_at`,
+      [repo, summary, (/* @__PURE__ */ new Date()).toISOString()]
+    );
   }
   listMemoriesForDashboard(options) {
     const {
@@ -1282,9 +1267,10 @@ ORDER BY created_at DESC
       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 totalRow = this.get(countSql, params);
+    const total = totalRow?.count ?? 0;
     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 rows = this.all(dataSql, [...params, limit, offset]);
     const items = rows.map((row) => ({
       ...this.rowToMemoryEntry(row),
       recall_rate: row.recall_rate || 0
@@ -1304,10 +1290,10 @@ ORDER BY created_at DESC
     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);
+    const candidates = this.all(sql, [...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());
+      const recent = this.all(recentSql, [...params, now.toISOString()]);
       for (const r of recent) {
         if (!candidates.find((c) => c.id === r.id)) candidates.push(r);
       }
@@ -1338,25 +1324,21 @@ ORDER BY created_at DESC
   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);
+    const result = this.run(
+      `UPDATE memories SET status = 'archived', updated_at = ? WHERE expires_at IS NOT NULL AND expires_at <= ? AND status = 'active'`,
+      [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());
+    const result = this.run(
+      `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)
+			)`,
+      [(/* @__PURE__ */ new Date()).toISOString()]
+    );
     return result.changes;
   }
 };
@@ -1364,34 +1346,34 @@ ORDER BY created_at DESC
 // 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
+    this.run(
+      `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 (?, ?, ?, ?, ?, ?, ?, ?, ?, ?, ?, ?, ?, ?, ?, ?, ?, ?, ?, ?, ?)`,
+      [
+        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) {
@@ -1413,43 +1395,34 @@ var TaskEntity = class extends BaseEntity {
     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);
+    this.run(`UPDATE tasks SET ${fields.join(", ")} WHERE id = ?`, 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);
+    this.run("DELETE FROM task_comments WHERE task_id = ?", [id]);
+    this.run("DELETE FROM tasks WHERE id = ?", [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);
+    const row = this.get(
+      `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 = ?`,
+      [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);
+    const row = this.get(
+      `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 = ?`,
+      [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 = ?
-    `;
+			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 = ?";
@@ -1461,16 +1434,16 @@ var TaskEntity = class extends BaseEntity {
       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`;
+			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);
@@ -1479,40 +1452,40 @@ var TaskEntity = class extends BaseEntity {
         params.push(offset);
       }
     }
-    const rows = this.db.prepare(query).all(...params);
+    const rows = this.all(query, 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);
+			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.all(query, [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(",")})
-    `;
+			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 ?)";
@@ -1520,16 +1493,16 @@ var TaskEntity = class extends BaseEntity {
       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`;
+			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);
@@ -1538,7 +1511,7 @@ var TaskEntity = class extends BaseEntity {
         params.push(offset);
       }
     }
-    const rows = this.db.prepare(query).all(...params);
+    const rows = this.all(query, params);
     return rows.map((r) => this.rowToTask(r));
   }
   isTaskCodeDuplicate(repo, task_code, excludeId) {
@@ -1548,20 +1521,18 @@ var TaskEntity = class extends BaseEntity {
       query += " AND id != ?";
       params.push(excludeId);
     }
-    const row = this.db.prepare(query).get(...params);
-    return row.count > 0;
+    const row = this.get(query, params);
+    return (row?.count ?? 0) > 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(
+    let count = 0;
+    for (const task of tasks) {
+      this.run(
+        `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 (?, ?, ?, ?, ?, ?, ?, ?, ?, ?, ?, ?, ?, ?, ?, ?, ?, ?, ?, ?, ?)`,
+        [
           task.id,
           task.repo,
           task.task_code,
@@ -1583,31 +1554,29 @@ var TaskEntity = class extends BaseEntity {
           task.depends_on || null,
           task.est_tokens || 0,
           task.in_progress_at || null
-        );
-        count++;
-      }
-      return count;
-    });
-    return insertMany(tasks);
+        ]
+      );
+      count++;
+    }
+    return count;
   }
   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
+    this.run(
+      `INSERT INTO task_comments (
+				id, task_id, repo, comment, agent, role, model, previous_status, next_status, created_at
+			) VALUES (?, ?, ?, ?, ?, ?, ?, ?, ?, ?)`,
+      [
+        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) {
@@ -1622,35 +1591,29 @@ var TaskEntity = class extends BaseEntity {
     });
     if (fields.length === 0) return;
     values.push(id);
-    const stmt = this.db.prepare(`UPDATE task_comments SET ${fields.join(", ")} WHERE id = ?`);
-    stmt.run(...values);
+    this.run(`UPDATE task_comments SET ${fields.join(", ")} WHERE id = ?`, values);
   }
   deleteTaskComment(id) {
-    this.db.prepare("DELETE FROM task_comments WHERE id = ?").run(id);
+    this.run("DELETE FROM task_comments WHERE id = ?", [id]);
   }
   getTaskCommentById(id) {
-    return this.db.prepare("SELECT * FROM task_comments WHERE id = ?").get(id);
+    return this.get("SELECT * FROM task_comments WHERE id = ?", [id]) ?? null;
   }
   getTaskCommentsByTaskId(taskId) {
-    return this.db.prepare(
-      `
-      SELECT * FROM task_comments
-      WHERE task_id = ?
-      ORDER BY created_at DESC, id DESC
-    `
-    ).all(taskId);
+    return this.all(`SELECT * FROM task_comments WHERE task_id = ? ORDER BY created_at DESC, id DESC`, [
+      taskId
+    ]);
   }
   getAllTaskCommentsByRepo(repo) {
-    return this.db.prepare(
-      `
-      SELECT * FROM task_comments
-      WHERE repo = ?
-      ORDER BY created_at DESC, id DESC
-    `
-    ).all(repo);
+    return this.all(`SELECT * FROM task_comments WHERE repo = ? ORDER BY created_at DESC, id DESC`, [
+      repo
+    ]);
   }
   getTaskStats(repo) {
-    const rows = this.db.prepare("SELECT status, COUNT(*) as count FROM tasks WHERE repo = ? GROUP BY status").all(repo);
+    const rows = this.all(
+      "SELECT status, COUNT(*) as count FROM tasks WHERE repo = ? GROUP BY status",
+      [repo]
+    );
     const stats = { total: 0, backlog: 0, todo: 0, inProgress: 0, completed: 0, blocked: 0, canceled: 0 };
     rows.forEach((r) => {
       const count = r.count;
@@ -1670,35 +1633,30 @@ var TaskEntity = class extends BaseEntity {
     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);
+    const stats = this.get(
+      `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}`,
+      [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);
+    const added = this.get(`SELECT COUNT(*) as count FROM tasks WHERE repo = ? ${addedDateFilter}`, [
+      repo
+    ]);
     return {
       completed: stats?.completed_count || 0,
       tokens: stats?.total_tokens || 0,
@@ -1723,33 +1681,31 @@ var TaskEntity = class extends BaseEntity {
       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);
+			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.all(query, [
+      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;
@@ -1764,39 +1720,38 @@ var ActionEntity = class extends BaseEntity {
       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()
-    });
+    this.run(
+      `INSERT INTO action_log (repo, action, query, response, memory_id, task_id, result_count, created_at)
+			VALUES (?, ?, ?, ?, ?, ?, ?, ?)`,
+      [
+        repo || "",
+        action || "unknown",
+        query || null,
+        finalResponse ? typeof finalResponse === "string" ? finalResponse : JSON.stringify(finalResponse) : null,
+        finalMemoryId || null,
+        finalTaskId || null,
+        finalResultCount ?? 0,
+        (/* @__PURE__ */ new Date()).toISOString()
+      ]
+    );
   }
   getLastActionId() {
-    const row = this.db.prepare("SELECT MAX(id) as id FROM action_log").get();
+    const row = this.get("SELECT MAX(id) as id FROM action_log");
     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);
+    return this.all(
+      `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`,
+      [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
-    `;
+			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 = ?";
@@ -1804,69 +1759,81 @@ var ActionEntity = class extends BaseEntity {
     }
     query += " ORDER BY a.created_at DESC, a.id DESC LIMIT ? OFFSET ?";
     params.push(limit, offset);
-    return this.db.prepare(query).all(...params);
+    return this.all(query, 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);
+    return this.all(
+      `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`,
+      [repo]
+    );
   }
   getActionDistribution(repo) {
-    return this.db.prepare(
-      `
-      SELECT action, count(*) as count 
-      FROM action_log 
-      WHERE repo = ?
-      GROUP BY action
-    `
-    ).all(repo);
+    return this.all(
+      `SELECT action, count(*) as count 
+			FROM action_log 
+			WHERE repo = ?
+			GROUP BY action`,
+      [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);
+    return this.get(
+      `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 = ?`,
+      [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();
+    const rows = this.all("SELECT DISTINCT repo FROM memories UNION SELECT DISTINCT repo FROM tasks");
     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;
+      const memoryCountRow = this.get("SELECT COUNT(*) as count FROM memories WHERE repo = ?", [
+        repo
+      ]);
+      const taskCountRow = this.get("SELECT COUNT(*) as count FROM tasks WHERE repo = ?", [repo]);
+      const lastActivityRow = this.get(
+        `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 = ?)`,
+        [repo, repo, repo]
+      );
       return {
         repo,
-        memoryCount,
-        taskCount,
-        lastActivity
+        memoryCount: memoryCountRow?.count ?? 0,
+        taskCount: taskCountRow?.count ?? 0,
+        lastActivity: lastActivityRow?.last ?? null
       };
     });
   }
   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));
+    const memoryStats = this.all(
+      "SELECT type, COUNT(*) as count FROM memories WHERE repo = ? GROUP BY type",
+      [repo]
+    );
+    const taskStats = this.all(
+      "SELECT status, COUNT(*) as count FROM tasks WHERE repo = ? GROUP BY status",
+      [repo]
+    );
+    const recentMemoriesRows = this.all(
+      "SELECT * FROM memories WHERE repo = ? ORDER BY created_at DESC LIMIT 5",
+      [repo]
+    );
+    const recentMemories = recentMemoriesRows.map((r) => this.rowToMemoryEntry(r));
+    const activeTasksRows = this.all(
+      "SELECT * FROM tasks WHERE repo = ? AND status IN ('in_progress', 'pending', 'backlog') ORDER BY priority DESC, created_at ASC LIMIT 5",
+      [repo]
+    );
+    const activeTasks = activeTasksRows.map((r) => this.rowToTask(r));
     return {
       memoryStats,
       taskStats,
@@ -1875,23 +1842,27 @@ var SystemEntity = class extends BaseEntity {
     };
   }
   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 totalMemoriesRow = this.get("SELECT COUNT(*) as count FROM memories");
+    const totalTasksRow = this.get("SELECT COUNT(*) as count FROM tasks");
     const totalRepos = this.listRepos().length;
     return {
-      totalMemories,
-      totalTasks,
+      totalMemories: totalMemoriesRow?.count ?? 0,
+      totalTasks: totalTasksRow?.count ?? 0,
       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);
+    const memoryCountRow = this.get("SELECT COUNT(*) as count FROM memories WHERE repo = ?", [repo]);
+    const taskCountRow = this.get("SELECT COUNT(*) as count FROM tasks WHERE repo = ?", [repo]);
+    const languagesRows = this.all(
+      "SELECT DISTINCT language FROM memories WHERE repo = ? AND language IS NOT NULL",
+      [repo]
+    );
+    const languages = languagesRows.map((r) => r.language);
     return {
       repo,
-      memoryCount,
-      taskCount,
+      memoryCount: memoryCountRow?.count ?? 0,
+      taskCount: taskCountRow?.count ?? 0,
       languages
     };
   }
@@ -1900,16 +1871,18 @@ var SystemEntity = class extends BaseEntity {
 // 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);
+    const row = this.get(
+      "SELECT summary, updated_at FROM memory_summary WHERE repo = ?",
+      [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());
+    this.run(
+      `INSERT INTO memory_summary (repo, summary, updated_at) VALUES (?, ?, ?)
+			ON CONFLICT(repo) DO UPDATE SET summary = excluded.summary, updated_at = excluded.updated_at`,
+      [repo, summary, (/* @__PURE__ */ new Date()).toISOString()]
+    );
   }
 };
 
@@ -1926,44 +1899,104 @@ function resolveDbPath() {
   return standardPath;
 }
 var DB_PATH = resolveDbPath();
-var SQLiteStore = class {
+var dbPathInstance = "";
+var sqlJsReady = null;
+var sqlJsModule = null;
+async function getSqlJs() {
+  if (!sqlJsModule) {
+    sqlJsModule = await initSqlJs();
+  }
+  await sqlJsReady;
+  return sqlJsModule;
+}
+function createSaveFunction(db, dbPath) {
+  return () => {
+    if (dbPath && dbPath !== ":memory:") {
+      const data = db.export();
+      const buffer = Buffer.from(data);
+      fs2.writeFileSync(dbPath, buffer);
+    }
+  };
+}
+function warmUpSqlJs() {
+  if (!sqlJsReady) {
+    sqlJsReady = (async () => {
+      sqlJsModule = await initSqlJs();
+    })();
+  }
+  return sqlJsReady;
+}
+var SQLiteStore = class _SQLiteStore {
   db;
   memories;
   tasks;
   actions;
   system;
   summaries;
+  _ready;
   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);
+    dbPathInstance = finalPath;
+    warmUpSqlJs();
+    this.db = {};
+    this.memories = {};
+    this.tasks = {};
+    this.actions = {};
+    this.system = {};
+    this.summaries = {};
+    this._ready = this._init(finalPath);
+  }
+  async _init(finalPath) {
+    const SQL = await getSqlJs();
+    let db;
+    if (finalPath === ":memory:") {
+      db = new SQL.Database();
+    } else {
+      const dbDir = path2.dirname(finalPath);
+      if (!fs2.existsSync(dbDir)) {
+        fs2.mkdirSync(dbDir, { recursive: true });
+      }
+      if (fs2.existsSync(finalPath)) {
+        const fileBuffer = fs2.readFileSync(finalPath);
+        db = new SQL.Database(fileBuffer);
+      } else {
+        db = new SQL.Database();
+      }
+    }
+    const saveDb = createSaveFunction(db, finalPath);
+    db.run("PRAGMA journal_mode = WAL");
+    db.run("PRAGMA synchronous = NORMAL");
+    db.run("PRAGMA busy_timeout = 5000");
+    const migrator = new MigrationManager(db, saveDb);
     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);
-    process.stderr.write(`${(/* @__PURE__ */ new Date()).toISOString()} [INFO     ] SQLiteStore initialized at ${finalPath}
-`);
+    migrator.addMemoryCodeColumn();
+    Object.assign(this, {
+      db,
+      memories: new MemoryEntity(db, saveDb),
+      tasks: new TaskEntity(db, saveDb),
+      actions: new ActionEntity(db, saveDb),
+      system: new SystemEntity(db, saveDb),
+      summaries: new SummaryEntity(db, saveDb)
+    });
+    if (finalPath !== ":memory:") {
+      saveDb();
+    }
+  }
+  async ready() {
+    await this._ready;
+  }
+  static async create(dbPath) {
+    const store = new _SQLiteStore(dbPath);
+    await store.ready();
+    return store;
   }
-  /**
-   * Returns the current database file path.
-   */
   getDbPath() {
-    return this.db.name;
+    return dbPathInstance;
   }
-  /**
-   * Closes the database connection.
-   */
   close() {
-    this.db.close();
+    if (this.db && this.db.close) {
+      this.db.close();
+    }
   }
 };
 
@@ -2087,8 +2120,9 @@ var MemoryTypeSchema = z.enum([
   "task_archive"
 ]);
 var MemoryStoreSchema = z.object({
+  code: z.string().max(20).optional(),
   type: MemoryTypeSchema,
-  title: z.string().min(3).max(100),
+  title: z.string().min(3).max(255),
   content: z.string().min(10),
   importance: z.number().min(1).max(5),
   agent: z.string().min(1),
@@ -2104,7 +2138,7 @@ var MemoryStoreSchema = z.object({
 var MemoryUpdateSchema = z.object({
   id: z.string().uuid(),
   type: MemoryTypeSchema.optional(),
-  title: z.string().min(3).max(100).optional(),
+  title: z.string().min(3).max(255).optional(),
   content: z.string().min(10).optional(),
   importance: z.number().min(1).max(5).optional(),
   agent: z.string().optional(),
@@ -2131,7 +2165,8 @@ var MemorySearchSchema = z.object({
   current_file_path: z.string().optional(),
   include_archived: z.boolean().default(false),
   current_tags: z.array(z.string()).optional(),
-  scope: MemoryScopeSchema.partial().optional()
+  scope: MemoryScopeSchema.partial().optional(),
+  structured: z.boolean().default(false)
 });
 var MemoryAcknowledgeSchema = z.object({
   memory_id: z.string().uuid(),
@@ -2141,7 +2176,8 @@ var MemoryAcknowledgeSchema = z.object({
 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)
+  offset: z.number().min(0).default(0),
+  structured: z.boolean().default(false)
 });
 var MemoryDeleteSchema = z.object({
   repo: z.string().min(1).transform(normalizeRepo).optional(),
@@ -2201,10 +2237,13 @@ var TaskCreateSchema = z.object({
   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" });
+}).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()
 });
@@ -2240,14 +2279,16 @@ var TaskListSchema = z.object({
   phase: z.string().optional(),
   query: z.string().optional(),
   limit: z.number().min(1).max(100).default(15),
-  offset: z.number().min(0).default(0)
+  offset: z.number().min(0).default(0),
+  structured: z.boolean().default(false)
 });
 var TaskSearchSchema = z.object({
   repo: z.string().min(1).transform(normalizeRepo),
   query: z.string().min(1),
   status: z.string().optional(),
   limit: z.number().min(1).max(100).default(10),
-  offset: z.number().min(0).default(0)
+  offset: z.number().min(0).default(0),
+  structured: z.boolean().default(false)
 });
 var TaskDeleteSchema = z.object({
   repo: z.string().min(1).transform(normalizeRepo),
@@ -2257,12 +2298,16 @@ var TaskDeleteSchema = z.object({
   message: "Either 'id' or 'ids' must be provided for deletion"
 });
 var MemoryDetailSchema = z.object({
-  id: z.string().uuid()
+  id: z.string().uuid().optional(),
+  code: z.string().max(20).optional()
+}).refine((data) => data.id !== void 0 || data.code !== void 0, {
+  message: "Either id or code must be provided"
 });
 var TaskGetSchema = z.object({
   repo: z.string().min(1).transform(normalizeRepo),
   id: z.string().uuid().optional(),
-  task_code: z.string().optional()
+  task_code: z.string().optional(),
+  structured: z.boolean().default(false)
 }).refine((data) => data.id !== void 0 || data.task_code !== void 0, {
   message: "Either id or task_code must be provided"
 });
@@ -2376,7 +2421,12 @@ var TOOL_DEFINITIONS = [
       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)" }
+        task_code: { type: "string", description: "Task code (e.g. TASK-001) (optional if id is provided)" },
+        structured: {
+          type: "boolean",
+          default: false,
+          description: "If true, returns structured JSON without the text content details."
+        }
       },
       required: ["repo"]
     }
@@ -2470,6 +2520,7 @@ var TOOL_DEFINITIONS = [
       properties: {
         success: { type: "boolean" },
         id: { type: "string" },
+        code: { type: "string" },
         repo: { type: "string" },
         type: { type: "string" },
         title: { type: "string" },
@@ -2612,6 +2663,11 @@ var TOOL_DEFINITIONS = [
             folder: { type: "string" },
             language: { type: "string" }
           }
+        },
+        structured: {
+          type: "boolean",
+          default: false,
+          description: "If true, returns structured JSON without the text content summary."
         }
       },
       required: ["query", "repo"]
@@ -2738,6 +2794,11 @@ var TOOL_DEFINITIONS = [
           minimum: 0,
           default: 0,
           description: "Number of memories to skip for pagination (optional, default 0)"
+        },
+        structured: {
+          type: "boolean",
+          default: false,
+          description: "If true, returns structured JSON without the text content summary."
         }
       },
       required: ["repo"]
@@ -2796,7 +2857,12 @@ var TOOL_DEFINITIONS = [
         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)" },
+        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",
@@ -2845,8 +2911,8 @@ var TOOL_DEFINITIONS = [
       properties: {
         success: { type: "boolean" },
         id: { type: "string" },
-        repo: { type: "string" },
         task_code: { type: "string" },
+        repo: { type: "string" },
         phase: { type: "string" },
         title: { type: "string" },
         status: { type: "string" },
@@ -2899,7 +2965,10 @@ var TOOL_DEFINITIONS = [
           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)." }
+        force: {
+          type: "boolean",
+          description: "If true, bypasses status transition validation (e.g. pending -> completed)."
+        }
       },
       required: ["repo"]
     },
@@ -2993,6 +3062,11 @@ var TOOL_DEFINITIONS = [
           minimum: 0,
           default: 0,
           description: "Offset for pagination"
+        },
+        structured: {
+          type: "boolean",
+          default: false,
+          description: "If true, returns structured JSON without the text content summary."
         }
       },
       required: ["repo"]
@@ -3471,7 +3545,29 @@ 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 findPromptDir() {
+  const candidates = [
+    // Production: /dist/prompts (sibling of dist/mcp/)
+    ["../../prompts", "../../prompts"],
+    // Dev: /src/mcp/prompts/definitions (next to loader.ts)
+    ["./definitions", "./definitions"]
+  ].map(([prod, dev]) => {
+    const prodPath = path4.resolve(__dirname2, prod);
+    if (fs3.existsSync(prodPath) && fs3.readdirSync(prodPath).some((f) => f.endsWith(".md"))) {
+      return prodPath;
+    }
+    const devPath = path4.resolve(__dirname2, dev);
+    if (fs3.existsSync(devPath) && fs3.readdirSync(devPath).some((f) => f.endsWith(".md"))) {
+      return devPath;
+    }
+    return null;
+  }).filter(Boolean);
+  if (candidates[0]) {
+    return candidates[0];
+  }
+  return path4.resolve(__dirname2, "./definitions");
+}
+var PROMPT_DIR = findPromptDir();
 function listPromptFiles() {
   if (!fs3.existsSync(PROMPT_DIR)) return [];
   return fs3.readdirSync(PROMPT_DIR).filter((file) => file.endsWith(".md")).map((file) => file.replace(/\.md$/, "")).sort();