neuromcp 0.1.0

package/dist/index.js

@@ -0,0 +1,2024 @@
+#!/usr/bin/env node
+
+// src/index.ts
+import { StdioServerTransport } from "@modelcontextprotocol/sdk/server/stdio.js";
+
+// src/config.ts
+import { resolve } from "path";
+import { homedir } from "os";
+function env(key, fallback) {
+  return process.env[key] ?? fallback;
+}
+function envNum(key, fallback) {
+  const raw = process.env[key];
+  if (raw === void 0) return fallback;
+  const n = Number(raw);
+  return Number.isFinite(n) ? n : fallback;
+}
+function envBool(key, fallback) {
+  const raw = process.env[key];
+  if (raw === void 0) return fallback;
+  return raw === "true" || raw === "1";
+}
+function loadConfig() {
+  const defaultDbPath = resolve(homedir(), ".neuromcp", "memory.db");
+  return {
+    dbPath: env("NEUROMCP_DB_PATH", defaultDbPath),
+    maxDbSizeMb: envNum("NEUROMCP_MAX_DB_SIZE_MB", 500),
+    embeddingProvider: env("NEUROMCP_EMBEDDING_PROVIDER", "auto"),
+    embeddingModel: env("NEUROMCP_EMBEDDING_MODEL", "auto"),
+    ollamaHost: env("OLLAMA_HOST", "http://localhost:11434"),
+    embeddingUrl: process.env["NEUROMCP_EMBEDDING_URL"] ?? null,
+    defaultNamespace: env("NEUROMCP_DEFAULT_NAMESPACE", "default"),
+    tombstoneTtlDays: envNum("NEUROMCP_TOMBSTONE_TTL_DAYS", 30),
+    autoConsolidate: envBool("NEUROMCP_AUTO_CONSOLIDATE", false),
+    consolidateIntervalHours: envNum("NEUROMCP_CONSOLIDATE_INTERVAL_HOURS", 24),
+    decayLambda: envNum("NEUROMCP_DECAY_LAMBDA", 0.01),
+    dedupThreshold: envNum("NEUROMCP_DEDUP_THRESHOLD", 0.92),
+    minImportance: envNum("NEUROMCP_MIN_IMPORTANCE", 0.05),
+    autoCommitSimilarity: envNum("NEUROMCP_AUTO_COMMIT_SIMILARITY", 0.95),
+    sweepIntervalHours: envNum("NEUROMCP_SWEEP_INTERVAL_HOURS", 6),
+    claudeCodeIntegration: env("NEUROMCP_CLAUDE_CODE_INTEGRATION", "auto"),
+    logLevel: env("NEUROMCP_LOG_LEVEL", "info"),
+    logFormat: env("NEUROMCP_LOG_FORMAT", "text")
+  };
+}
+
+// src/observability/logger.ts
+var LEVELS = { debug: 0, info: 1, warn: 2, error: 3 };
+function formatText(entry) {
+  const parts = [
+    entry.timestamp,
+    entry.level.toUpperCase().padEnd(5),
+    `[${entry.component}]`,
+    entry.message
+  ];
+  if (entry.operation_id !== void 0) {
+    parts.push(`op=${entry.operation_id}`);
+  }
+  if (entry.duration_ms !== void 0) {
+    parts.push(`${entry.duration_ms}ms`);
+  }
+  const skip = /* @__PURE__ */ new Set(["timestamp", "level", "component", "message", "operation_id", "duration_ms"]);
+  for (const [k, v] of Object.entries(entry)) {
+    if (!skip.has(k)) {
+      parts.push(`${k}=${JSON.stringify(v)}`);
+    }
+  }
+  return parts.join(" ");
+}
+function formatJson(entry) {
+  return JSON.stringify(entry);
+}
+function createLogger(options) {
+  const threshold = LEVELS[options.level];
+  const format = options.format === "json" ? formatJson : formatText;
+  function log(level, component, message, metadata, operationId) {
+    if (LEVELS[level] < threshold) return;
+    const entry = {
+      timestamp: (/* @__PURE__ */ new Date()).toISOString(),
+      level,
+      component,
+      message,
+      ...operationId !== void 0 ? { operation_id: operationId } : {},
+      ...metadata ?? {}
+    };
+    process.stderr.write(format(entry) + "\n");
+  }
+  return {
+    debug: (component, message, metadata, operationId) => log("debug", component, message, metadata, operationId),
+    info: (component, message, metadata, operationId) => log("info", component, message, metadata, operationId),
+    warn: (component, message, metadata, operationId) => log("warn", component, message, metadata, operationId),
+    error: (component, message, metadata, operationId) => log("error", component, message, metadata, operationId)
+  };
+}
+
+// src/observability/metrics.ts
+import { randomBytes } from "crypto";
+function percentile(sorted, p) {
+  if (sorted.length === 0) return 0;
+  const idx = Math.ceil(p / 100 * sorted.length) - 1;
+  return sorted[Math.max(0, idx)];
+}
+function createMetrics() {
+  const counters = /* @__PURE__ */ new Map();
+  const histograms = /* @__PURE__ */ new Map();
+  const gauges = /* @__PURE__ */ new Map();
+  return {
+    increment(name, by = 1) {
+      counters.set(name, (counters.get(name) ?? 0) + by);
+    },
+    record(name, value) {
+      const existing = histograms.get(name);
+      if (existing !== void 0) {
+        existing.push(value);
+      } else {
+        histograms.set(name, [value]);
+      }
+    },
+    gauge(name, value) {
+      gauges.set(name, value);
+    },
+    snapshot() {
+      const histogramSnapshot = {};
+      for (const [name, values] of histograms) {
+        const sorted = [...values].sort((a, b) => a - b);
+        histogramSnapshot[name] = {
+          p50: percentile(sorted, 50),
+          p95: percentile(sorted, 95),
+          p99: percentile(sorted, 99),
+          count: sorted.length
+        };
+      }
+      return {
+        counters: Object.fromEntries(counters),
+        histograms: histogramSnapshot,
+        gauges: Object.fromEntries(gauges)
+      };
+    },
+    newOperationId() {
+      return randomBytes(16).toString("hex");
+    }
+  };
+}
+
+// src/storage/database.ts
+import { mkdirSync } from "fs";
+import { dirname } from "path";
+import Database from "better-sqlite3";
+var _db = null;
+var PRAGMAS = [
+  "PRAGMA journal_mode = WAL;",
+  "PRAGMA synchronous = NORMAL;",
+  "PRAGMA foreign_keys = ON;",
+  "PRAGMA busy_timeout = 5000;",
+  "PRAGMA cache_size = -64000;",
+  "PRAGMA auto_vacuum = INCREMENTAL;"
+];
+function openDatabase(path) {
+  mkdirSync(dirname(path), { recursive: true });
+  const db = new Database(path);
+  for (const pragma of PRAGMAS) {
+    db.pragma(pragma.replace(/^PRAGMA\s+/, "").replace(";", ""));
+  }
+  _db = db;
+  return db;
+}
+
+// src/storage/migrations.ts
+import { copyFileSync } from "fs";
+
+// src/storage/schema.ts
+var SCHEMA_VERSION = 1;
+var CREATE_TABLES = `
+  CREATE TABLE IF NOT EXISTS memories (
+    id TEXT PRIMARY KEY,
+    content_hash TEXT NOT NULL,
+    content TEXT NOT NULL,
+    summary TEXT,
+    embedding_model TEXT NOT NULL DEFAULT '',
+    embedding_dim INTEGER NOT NULL DEFAULT 0,
+    namespace TEXT NOT NULL DEFAULT 'default',
+    project_id TEXT,
+    agent_id TEXT,
+    source TEXT NOT NULL DEFAULT 'user',
+    source_trust TEXT NOT NULL DEFAULT 'medium',
+    visibility TEXT NOT NULL DEFAULT 'namespace',
+    schema_version INTEGER NOT NULL DEFAULT 1,
+    category TEXT NOT NULL DEFAULT 'general',
+    tags TEXT NOT NULL DEFAULT '[]',
+    importance REAL NOT NULL DEFAULT 0.5,
+    access_count INTEGER NOT NULL DEFAULT 0,
+    created_at TEXT NOT NULL DEFAULT (strftime('%Y-%m-%dT%H:%M:%fZ', 'now')),
+    updated_at TEXT NOT NULL DEFAULT (strftime('%Y-%m-%dT%H:%M:%fZ', 'now')),
+    last_accessed_at TEXT,
+    expires_at TEXT,
+    is_deleted INTEGER NOT NULL DEFAULT 0,
+    tombstoned_at TEXT,
+    supersedes_id TEXT,
+    superseded_by_id TEXT,
+    metadata TEXT NOT NULL DEFAULT '{}'
+  );
+
+  CREATE TABLE IF NOT EXISTS consolidation_log (
+    id TEXT PRIMARY KEY,
+    operation_id TEXT NOT NULL,
+    action TEXT NOT NULL,
+    source_ids TEXT NOT NULL DEFAULT '[]',
+    result_id TEXT,
+    plan_snapshot TEXT,
+    reason TEXT,
+    namespace TEXT,
+    created_at TEXT NOT NULL DEFAULT (strftime('%Y-%m-%dT%H:%M:%fZ', 'now'))
+  );
+
+  CREATE TABLE IF NOT EXISTS operations (
+    id TEXT PRIMARY KEY,
+    type TEXT NOT NULL,
+    status TEXT NOT NULL DEFAULT 'running',
+    namespace TEXT,
+    started_at TEXT NOT NULL DEFAULT (strftime('%Y-%m-%dT%H:%M:%fZ', 'now')),
+    completed_at TEXT,
+    items_total INTEGER,
+    items_processed INTEGER NOT NULL DEFAULT 0,
+    error TEXT,
+    metadata TEXT NOT NULL DEFAULT '{}'
+  );
+
+  CREATE TABLE IF NOT EXISTS schema_version (
+    version INTEGER PRIMARY KEY,
+    applied_at TEXT NOT NULL DEFAULT (strftime('%Y-%m-%dT%H:%M:%fZ', 'now')),
+    description TEXT
+  );
+`;
+var CREATE_INDEXES = `
+  CREATE INDEX IF NOT EXISTS idx_memories_namespace ON memories(namespace);
+  CREATE INDEX IF NOT EXISTS idx_memories_content_hash ON memories(content_hash);
+  CREATE INDEX IF NOT EXISTS idx_memories_category ON memories(category);
+  CREATE INDEX IF NOT EXISTS idx_memories_importance ON memories(importance);
+  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_is_deleted ON memories(is_deleted);
+  CREATE INDEX IF NOT EXISTS idx_memories_expires_at ON memories(expires_at);
+  CREATE INDEX IF NOT EXISTS idx_memories_project_id ON memories(project_id);
+  CREATE INDEX IF NOT EXISTS idx_memories_agent_id ON memories(agent_id);
+  CREATE INDEX IF NOT EXISTS idx_memories_source ON memories(source);
+  CREATE INDEX IF NOT EXISTS idx_memories_namespace_deleted ON memories(namespace, is_deleted);
+  CREATE INDEX IF NOT EXISTS idx_consolidation_log_operation_id ON consolidation_log(operation_id);
+  CREATE INDEX IF NOT EXISTS idx_consolidation_log_namespace ON consolidation_log(namespace);
+  CREATE INDEX IF NOT EXISTS idx_operations_type ON operations(type);
+  CREATE INDEX IF NOT EXISTS idx_operations_status ON operations(status);
+  CREATE INDEX IF NOT EXISTS idx_operations_namespace ON operations(namespace);
+`;
+function ftsTableExists(db) {
+  const row = db.prepare(
+    "SELECT name FROM sqlite_master WHERE type='table' AND name='memories_fts'"
+  ).get();
+  return row !== void 0;
+}
+function applySchema(db) {
+  db.exec(CREATE_TABLES);
+  db.exec(CREATE_INDEXES);
+  if (!ftsTableExists(db)) {
+    db.exec(`
+      CREATE VIRTUAL TABLE memories_fts USING fts5(
+        content,
+        summary,
+        tags,
+        category,
+        content='memories',
+        content_rowid='rowid'
+      );
+    `);
+  }
+}
+
+// src/storage/migrations.ts
+function getCurrentVersion(db) {
+  const row = db.prepare(
+    "SELECT name FROM sqlite_master WHERE type='table' AND name='schema_version'"
+  ).get();
+  if (row === void 0) {
+    return 0;
+  }
+  const versionRow = db.prepare(
+    "SELECT MAX(version) AS version FROM schema_version"
+  ).get();
+  return versionRow?.version ?? 0;
+}
+function recordVersion(db, version, description) {
+  db.prepare(
+    "INSERT OR REPLACE INTO schema_version (version, applied_at, description) VALUES (?, strftime('%Y-%m-%dT%H:%M:%fZ', 'now'), ?)"
+  ).run(version, description);
+}
+function runMigrations(db, dbPath, logger) {
+  const currentVersion = getCurrentVersion(db);
+  if (currentVersion >= SCHEMA_VERSION) {
+    logger.debug("migrations", "Schema is up to date", {
+      currentVersion,
+      targetVersion: SCHEMA_VERSION
+    });
+    return;
+  }
+  if (currentVersion > 0) {
+    const backupPath = `${dbPath}.backup-v${currentVersion}`;
+    logger.info("migrations", "Backing up database before migration", {
+      from: currentVersion,
+      to: SCHEMA_VERSION,
+      backupPath
+    });
+    copyFileSync(dbPath, backupPath);
+  }
+  logger.info("migrations", "Applying schema migration", {
+    from: currentVersion,
+    to: SCHEMA_VERSION
+  });
+  applySchema(db);
+  recordVersion(db, SCHEMA_VERSION, `Migration from v${currentVersion} to v${SCHEMA_VERSION}`);
+  logger.info("migrations", "Schema migration complete", {
+    version: SCHEMA_VERSION
+  });
+}
+
+// src/vectors/sqlite-vec.ts
+import * as sqliteVec from "sqlite-vec";
+var SqliteVecStore = class {
+  name = "sqlite-vec";
+  dimensions;
+  db = null;
+  constructor(dimensions) {
+    this.dimensions = dimensions;
+  }
+  initialize(db) {
+    sqliteVec.load(db);
+    db.exec(`
+      CREATE VIRTUAL TABLE IF NOT EXISTS memories_vec
+      USING vec0(
+        id TEXT PRIMARY KEY,
+        embedding float[${this.dimensions}]
+      );
+    `);
+    this.db = db;
+  }
+  upsert(id, embedding) {
+    const db = this.getDb();
+    const buf = Buffer.from(embedding.buffer, embedding.byteOffset, embedding.byteLength);
+    db.prepare("DELETE FROM memories_vec WHERE id = ?").run(id);
+    db.prepare("INSERT INTO memories_vec (id, embedding) VALUES (?, ?)").run(id, buf);
+  }
+  upsertBatch(entries) {
+    const db = this.getDb();
+    const deleteStmt = db.prepare("DELETE FROM memories_vec WHERE id = ?");
+    const insertStmt = db.prepare("INSERT INTO memories_vec (id, embedding) VALUES (?, ?)");
+    const runBatch = db.transaction(() => {
+      for (const entry of entries) {
+        const buf = Buffer.from(
+          entry.embedding.buffer,
+          entry.embedding.byteOffset,
+          entry.embedding.byteLength
+        );
+        deleteStmt.run(entry.id);
+        insertStmt.run(entry.id, buf);
+      }
+    });
+    runBatch();
+  }
+  search(query, k) {
+    const db = this.getDb();
+    const buf = Buffer.from(query.buffer, query.byteOffset, query.byteLength);
+    const rows = db.prepare(
+      "SELECT id, distance FROM memories_vec WHERE embedding MATCH ? ORDER BY distance LIMIT ?"
+    ).all(buf, k);
+    return rows.map((row) => ({
+      id: row.id,
+      distance: row.distance
+    }));
+  }
+  remove(id) {
+    const db = this.getDb();
+    db.prepare("DELETE FROM memories_vec WHERE id = ?").run(id);
+  }
+  clear() {
+    const db = this.getDb();
+    db.prepare("DELETE FROM memories_vec").run();
+  }
+  count() {
+    const db = this.getDb();
+    const row = db.prepare("SELECT COUNT(*) as cnt FROM memories_vec").get();
+    return row.cnt;
+  }
+  getDb() {
+    if (this.db === null) {
+      throw new Error("SqliteVecStore not initialized. Call initialize() first.");
+    }
+    return this.db;
+  }
+};
+
+// src/embeddings/onnx.ts
+import { resolve as resolve2, dirname as dirname2 } from "path";
+import { existsSync } from "fs";
+import { fileURLToPath } from "url";
+var ort = null;
+async function loadOrt() {
+  if (ort !== null) return ort;
+  const mod = await import("onnxruntime-node");
+  ort = { InferenceSession: mod.InferenceSession, Tensor: mod.Tensor };
+  return ort;
+}
+var MODEL_FILENAME = "bge-small-en-v1.5.onnx";
+function resolveModelPath() {
+  const thisDir = dirname2(fileURLToPath(import.meta.url));
+  const candidates = [
+    // From dist/ (bundled) → ../models/ (package root)
+    resolve2(thisDir, "..", "models", MODEL_FILENAME),
+    // From src/embeddings/ (dev) → ../../models/
+    resolve2(thisDir, "..", "..", "models", MODEL_FILENAME),
+    // Relative to cwd
+    resolve2(process.cwd(), "models", MODEL_FILENAME),
+    // Common install location: node_modules/neuromcp/models/
+    resolve2(thisDir, "models", MODEL_FILENAME)
+  ];
+  const unique = [...new Set(candidates)];
+  for (const candidate of unique) {
+    if (existsSync(candidate)) return candidate;
+  }
+  return null;
+}
+function simpleTokenize(text, maxLength) {
+  const VOCAB_SIZE = 30522;
+  const CLS_ID = 101n;
+  const SEP_ID = 102n;
+  const PAD_ID = 0n;
+  const words = text.toLowerCase().trim().split(/\s+/).filter((w) => w.length > 0);
+  const wordIds = words.slice(0, maxLength - 2).map((word) => {
+    let hash = 0;
+    for (let i = 0; i < word.length; i++) {
+      hash = (hash << 5) - hash + word.charCodeAt(i) | 0;
+    }
+    const id = (hash % (VOCAB_SIZE - 2) + (VOCAB_SIZE - 2)) % (VOCAB_SIZE - 2) + 1;
+    return BigInt(id);
+  });
+  const tokenCount = wordIds.length + 2;
+  const inputIds = new BigInt64Array(maxLength);
+  const attentionMask = new BigInt64Array(maxLength);
+  const tokenTypeIds = new BigInt64Array(maxLength);
+  inputIds[0] = CLS_ID;
+  attentionMask[0] = 1n;
+  for (let i = 0; i < wordIds.length; i++) {
+    inputIds[i + 1] = wordIds[i];
+    attentionMask[i + 1] = 1n;
+  }
+  inputIds[wordIds.length + 1] = SEP_ID;
+  attentionMask[wordIds.length + 1] = 1n;
+  for (let i = tokenCount; i < maxLength; i++) {
+    inputIds[i] = PAD_ID;
+    attentionMask[i] = 0n;
+    tokenTypeIds[i] = 0n;
+  }
+  return { inputIds, attentionMask, tokenTypeIds };
+}
+function meanPool(lastHiddenState, attentionMask, seqLen, hiddenSize) {
+  const result = new Float32Array(hiddenSize);
+  let tokenCount = 0;
+  for (let t = 0; t < seqLen; t++) {
+    if (attentionMask[t] === 0n) continue;
+    tokenCount++;
+    const offset = t * hiddenSize;
+    for (let h = 0; h < hiddenSize; h++) {
+      result[h] += lastHiddenState[offset + h];
+    }
+  }
+  if (tokenCount > 0) {
+    for (let h = 0; h < hiddenSize; h++) {
+      result[h] /= tokenCount;
+    }
+  }
+  return result;
+}
+function l2Normalize(vec) {
+  let sumSq = 0;
+  for (let i = 0; i < vec.length; i++) {
+    sumSq += vec[i] * vec[i];
+  }
+  const norm = Math.sqrt(sumSq);
+  if (norm > 0) {
+    for (let i = 0; i < vec.length; i++) {
+      vec[i] /= norm;
+    }
+  }
+  return vec;
+}
+var OnnxEmbeddingProvider = class {
+  name = "bge-small-en-v1.5";
+  dimensions = 384;
+  maxTokens = 512;
+  session = null;
+  modelPath;
+  constructor(modelPath) {
+    this.modelPath = modelPath ?? resolveModelPath();
+  }
+  async isAvailable() {
+    try {
+      await this.ensureSession();
+      return true;
+    } catch {
+      return false;
+    }
+  }
+  async embed(text) {
+    const session = await this.ensureSession();
+    const { inputIds, attentionMask, tokenTypeIds } = simpleTokenize(text, this.maxTokens);
+    const { Tensor } = await loadOrt();
+    const feeds = {
+      input_ids: new Tensor("int64", inputIds, [1, this.maxTokens]),
+      attention_mask: new Tensor("int64", attentionMask, [1, this.maxTokens]),
+      token_type_ids: new Tensor("int64", tokenTypeIds, [1, this.maxTokens])
+    };
+    const output = await session.run(feeds);
+    const outputTensor = output["last_hidden_state"] ?? Object.values(output)[0];
+    if (outputTensor === void 0) {
+      throw new Error("ONNX model returned no output tensors");
+    }
+    const hiddenState = outputTensor.data;
+    const pooled = meanPool(hiddenState, attentionMask, this.maxTokens, this.dimensions);
+    return l2Normalize(pooled);
+  }
+  async embedBatch(texts) {
+    const results = [];
+    for (const text of texts) {
+      results.push(await this.embed(text));
+    }
+    return results;
+  }
+  async ensureSession() {
+    if (this.session !== null) return this.session;
+    if (this.modelPath === null) {
+      throw new Error(
+        `ONNX model not found. Run: npx tsx scripts/download-model.ts
+Expected location: models/${MODEL_FILENAME}`
+      );
+    }
+    const { InferenceSession: IS } = await loadOrt();
+    this.session = await IS.create(this.modelPath, {
+      executionProviders: ["cpu"]
+    });
+    return this.session;
+  }
+};
+
+// src/embeddings/factory.ts
+async function createEmbeddingProvider(config, logger) {
+  const requestedProvider = config.embeddingProvider;
+  if (requestedProvider === "auto" || requestedProvider === "onnx") {
+    const provider = new OnnxEmbeddingProvider();
+    const available = await provider.isAvailable();
+    if (available) {
+      logger.info("embeddings", `Loaded ONNX provider: ${provider.name}`, {
+        dimensions: provider.dimensions
+      });
+      return provider;
+    }
+    if (requestedProvider === "onnx") {
+      throw new Error(
+        "ONNX embedding provider requested but unavailable. Run: npx tsx scripts/download-model.ts"
+      );
+    }
+  }
+  throw new Error(
+    `No embedding provider available (requested: ${requestedProvider}). Currently only ONNX is supported. Run: npx tsx scripts/download-model.ts`
+  );
+}
+
+// src/server.ts
+import { z as z2 } from "zod";
+import { McpServer } from "@modelcontextprotocol/sdk/server/mcp.js";
+
+// src/tools/store.ts
+import { createHash } from "crypto";
+
+// src/governance/trust.ts
+var TRUST_RANKS = {
+  unverified: 0,
+  low: 1,
+  medium: 2,
+  high: 3
+};
+function isHigherTrust(a, b) {
+  return TRUST_RANKS[a] > TRUST_RANKS[b];
+}
+function defaultTrustForSource(source) {
+  switch (source) {
+    case "user":
+      return "high";
+    case "consolidation":
+    case "auto":
+    case "claude-code":
+      return "medium";
+    case "error":
+      return "low";
+  }
+}
+function meetsMinTrust(memoryTrust, minTrust) {
+  return TRUST_RANKS[memoryTrust] >= TRUST_RANKS[minTrust];
+}
+
+// src/tools/store.ts
+function generateId() {
+  return createHash("sha256").update(Date.now() + "-" + Math.random()).digest("hex").slice(0, 32);
+}
+function contentHash(content) {
+  return createHash("sha256").update(content).digest("hex");
+}
+function mergeTags(existing, incoming) {
+  const existingTags = JSON.parse(existing);
+  const merged = [.../* @__PURE__ */ new Set([...existingTags, ...incoming])];
+  return JSON.stringify(merged);
+}
+async function storeMemory(input, deps) {
+  const { db, vecStore, embedder, logger, metrics, config } = deps;
+  const start = Date.now();
+  const namespace = input.namespace ?? config.defaultNamespace;
+  const source = input.source ?? "user";
+  const sourceTrust = input.source_trust ?? defaultTrustForSource(source);
+  const category = input.category ?? "general";
+  const tags = input.tags ?? [];
+  const importance = input.importance ?? 0.5;
+  const metadata = input.metadata ?? {};
+  const tagsJson = JSON.stringify([...tags]);
+  const metadataJson = JSON.stringify(metadata);
+  const hash = contentHash(input.content);
+  const exactMatch = db.prepare(
+    "SELECT id, importance, tags FROM memories WHERE content_hash = ? AND namespace = ? AND is_deleted = 0 LIMIT 1"
+  ).get(hash, namespace);
+  if (exactMatch !== void 0) {
+    const newImportance = Math.max(exactMatch.importance, importance);
+    const mergedTags = mergeTags(exactMatch.tags, [...tags]);
+    db.prepare(
+      "UPDATE memories SET importance = ?, tags = ?, access_count = access_count + 1, last_accessed_at = strftime('%Y-%m-%dT%H:%M:%fZ', 'now'), updated_at = strftime('%Y-%m-%dT%H:%M:%fZ', 'now') WHERE id = ?"
+    ).run(newImportance, mergedTags, exactMatch.id);
+    logger.info("store", "exact dedup match", { id: exactMatch.id, namespace });
+    metrics.increment("store.dedup_exact");
+    metrics.record("store.duration_ms", Date.now() - start);
+    return { id: exactMatch.id, matched: true, similarity: 1 };
+  }
+  const embedding = await embedder.embed(input.content);
+  const neighbors = vecStore.search(embedding, 5);
+  for (const neighbor of neighbors) {
+    const similarity = 1 - neighbor.distance;
+    if (similarity > config.dedupThreshold) {
+      const existing = db.prepare(
+        "SELECT id, importance, tags FROM memories WHERE id = ? AND namespace = ? AND is_deleted = 0 LIMIT 1"
+      ).get(neighbor.id, namespace);
+      if (existing !== void 0) {
+        const newImportance = Math.max(existing.importance, importance);
+        const mergedTags = mergeTags(existing.tags, [...tags]);
+        db.prepare(
+          "UPDATE memories SET importance = ?, tags = ?, access_count = access_count + 1, last_accessed_at = strftime('%Y-%m-%dT%H:%M:%fZ', 'now'), updated_at = strftime('%Y-%m-%dT%H:%M:%fZ', 'now') WHERE id = ?"
+        ).run(newImportance, mergedTags, existing.id);
+        logger.info("store", "semantic dedup match", {
+          id: existing.id,
+          similarity,
+          namespace
+        });
+        metrics.increment("store.dedup_semantic");
+        metrics.record("store.duration_ms", Date.now() - start);
+        return { id: existing.id, matched: true, similarity };
+      }
+    }
+  }
+  const id = generateId();
+  const now = (/* @__PURE__ */ new Date()).toISOString();
+  db.prepare(
+    `INSERT INTO memories (
+      id, content_hash, content, summary, embedding_model, embedding_dim,
+      namespace, project_id, agent_id, source, source_trust, visibility,
+      schema_version, category, tags, importance, access_count,
+      created_at, updated_at, last_accessed_at, expires_at,
+      is_deleted, tombstoned_at, supersedes_id, superseded_by_id, metadata
+    ) VALUES (
+      ?, ?, ?, NULL, ?, ?, ?, ?, ?, ?, ?, 'namespace', 1, ?, ?, ?, 0,
+      ?, ?, NULL, ?, 0, NULL, NULL, NULL, ?
+    )`
+  ).run(
+    id,
+    hash,
+    input.content,
+    embedder.name,
+    embedder.dimensions,
+    namespace,
+    input.project_id ?? null,
+    input.agent_id ?? null,
+    source,
+    sourceTrust,
+    category,
+    tagsJson,
+    importance,
+    now,
+    now,
+    input.expires_at ?? null,
+    metadataJson
+  );
+  vecStore.upsert(id, embedding);
+  const row = db.prepare("SELECT rowid FROM memories WHERE id = ?").get(id);
+  db.prepare(
+    "INSERT INTO memories_fts (rowid, content, summary, tags, category) VALUES (?, ?, NULL, ?, ?)"
+  ).run(row.rowid, input.content, tagsJson, category);
+  logger.info("store", "new memory stored", { id, namespace, category });
+  metrics.increment("store.new");
+  metrics.record("store.duration_ms", Date.now() - start);
+  return { id, matched: false };
+}
+
+// src/governance/namespace.ts
+function namespaceFilter(namespace, defaultNs) {
+  const ns = namespace ?? defaultNs;
+  if (ns === "*") return { clause: "1=1", params: [] };
+  return { clause: "namespace = ?", params: [ns] };
+}
+
+// src/tools/search.ts
+var RRF_K = 60;
+function sanitizeFtsQuery(query) {
+  return '"' + query.replace(/"/g, '""') + '"';
+}
+async function searchMemory(input, deps) {
+  const { db, vecStore, embedder, logger, metrics, config } = deps;
+  const start = Date.now();
+  const limit = input.limit ?? 10;
+  const hybrid = input.hybrid !== false;
+  const namespace = input.namespace ?? config.defaultNamespace;
+  const minTrust = input.min_trust ?? "low";
+  const embedding = await embedder.embed(input.query);
+  const vecResults = vecStore.search(embedding, limit * 3);
+  const vecRanks = /* @__PURE__ */ new Map();
+  vecResults.forEach((r, i) => {
+    vecRanks.set(r.id, i + 1);
+  });
+  const ftsRanks = /* @__PURE__ */ new Map();
+  if (hybrid) {
+    try {
+      const ftsQuery = sanitizeFtsQuery(input.query);
+      const ftsRows = db.prepare(
+        `SELECT m.id FROM memories_fts f
+           JOIN memories m ON m.rowid = f.rowid
+           WHERE memories_fts MATCH ? AND m.is_deleted = 0
+           ORDER BY rank LIMIT ?`
+      ).all(ftsQuery, limit * 3);
+      ftsRows.forEach((row, i) => {
+        ftsRanks.set(row.id, i + 1);
+      });
+    } catch {
+      logger.warn("search", "FTS5 query failed, falling back to vector-only", {
+        query: input.query
+      });
+    }
+  }
+  const allIds = /* @__PURE__ */ new Set([...vecRanks.keys(), ...ftsRanks.keys()]);
+  const scored = [];
+  for (const id of allIds) {
+    const vecRank = vecRanks.get(id);
+    const ftsRank = ftsRanks.get(id);
+    let score = 0;
+    if (vecRank !== void 0) {
+      score += 1 / (RRF_K + vecRank);
+    }
+    if (ftsRank !== void 0) {
+      score += 1 / (RRF_K + ftsRank);
+    }
+    scored.push({ id, score });
+  }
+  scored.sort((a, b) => b.score - a.score);
+  const nsFilter = namespaceFilter(input.namespace, config.defaultNamespace);
+  const results = [];
+  for (const candidate of scored) {
+    if (results.length >= limit) break;
+    const memory = db.prepare("SELECT * FROM memories WHERE id = ?").get(candidate.id);
+    if (memory === void 0) continue;
+    if (memory.is_deleted === 1) continue;
+    if (nsFilter.params.length > 0 && memory.namespace !== nsFilter.params[0]) {
+      continue;
+    }
+    if (!meetsMinTrust(memory.source_trust, minTrust)) {
+      continue;
+    }
+    if (input.category !== void 0 && memory.category !== input.category) {
+      continue;
+    }
+    if (input.tags !== void 0 && input.tags.length > 0) {
+      const memTags = JSON.parse(memory.tags);
+      const hasAll = input.tags.every((t) => memTags.includes(t));
+      if (!hasAll) continue;
+    }
+    if (input.min_importance !== void 0 && memory.importance < input.min_importance) {
+      continue;
+    }
+    if (input.after !== void 0 && memory.created_at < input.after) {
+      continue;
+    }
+    if (input.before !== void 0 && memory.created_at > input.before) {
+      continue;
+    }
+    results.push({ ...memory, similarity_score: candidate.score });
+  }
+  if (results.length > 0) {
+    const bumpStmt = db.prepare(
+      "UPDATE memories SET access_count = access_count + 1, last_accessed_at = strftime('%Y-%m-%dT%H:%M:%fZ', 'now') WHERE id = ?"
+    );
+    const bumpAll = db.transaction(() => {
+      for (const r of results) {
+        bumpStmt.run(r.id);
+      }
+    });
+    bumpAll();
+  }
+  logger.info("search", "search complete", {
+    query: input.query,
+    results: results.length,
+    hybrid,
+    namespace
+  });
+  metrics.increment("search.queries");
+  metrics.record("search.results", results.length);
+  metrics.record("search.duration_ms", Date.now() - start);
+  return results;
+}
+
+// src/tools/recall.ts
+function recallMemory(input, db, config, logger, metrics) {
+  const start = Date.now();
+  const limit = input.limit ?? 20;
+  const namespace = input.namespace ?? config.defaultNamespace;
+  const conditions = ["is_deleted = 0"];
+  const params = [];
+  if (namespace !== "*") {
+    conditions.push("namespace = ?");
+    params.push(namespace);
+  }
+  if (input.id !== void 0) {
+    conditions.push("id = ?");
+    params.push(input.id);
+  }
+  if (input.category !== void 0) {
+    conditions.push("category = ?");
+    params.push(input.category);
+  }
+  const sql = `SELECT * FROM memories WHERE ${conditions.join(" AND ")} ORDER BY created_at DESC LIMIT ?`;
+  params.push(limit);
+  const rows = db.prepare(sql).all(...params);
+  const filtered = input.tags !== void 0 && input.tags.length > 0 ? rows.filter((row) => {
+    const memTags = JSON.parse(row.tags);
+    return input.tags.every((t) => memTags.includes(t));
+  }) : rows;
+  if (filtered.length > 0) {
+    const bumpStmt = db.prepare(
+      "UPDATE memories SET access_count = access_count + 1, last_accessed_at = strftime('%Y-%m-%dT%H:%M:%fZ', 'now') WHERE id = ?"
+    );
+    const bumpAll = db.transaction(() => {
+      for (const row of filtered) {
+        bumpStmt.run(row.id);
+      }
+    });
+    bumpAll();
+  }
+  logger.info("recall", "recall complete", {
+    results: filtered.length,
+    namespace
+  });
+  metrics.increment("recall.queries");
+  metrics.record("recall.results", filtered.length);
+  metrics.record("recall.duration_ms", Date.now() - start);
+  return filtered;
+}
+
+// src/tools/forget.ts
+import { randomBytes as randomBytes2 } from "crypto";
+
+// src/governance/tombstone.ts
+function tombstone(db, id) {
+  db.prepare(
+    "UPDATE memories SET is_deleted = 1, tombstoned_at = strftime('%Y-%m-%dT%H:%M:%SZ', 'now') WHERE id = ?"
+  ).run(id);
+}
+function tombstoneWithLineage(db, tombstoneId, supersededById) {
+  db.prepare(
+    `UPDATE memories
+       SET is_deleted = 1,
+           tombstoned_at = strftime('%Y-%m-%dT%H:%M:%SZ', 'now'),
+           superseded_by_id = ?
+     WHERE id = ?`
+  ).run(supersededById, tombstoneId);
+}
+
+// src/tools/forget.ts
+function forgetMemory(input, db, vecStore, config, logger, metrics) {
+  const start = Date.now();
+  const dryRun = input.dry_run ?? false;
+  const hasFilter = input.id !== void 0 || input.namespace !== void 0 || input.tags !== void 0 && input.tags.length > 0 || input.older_than_days !== void 0 || input.below_importance !== void 0;
+  if (!hasFilter) {
+    throw new Error(
+      "forgetMemory requires at least one filter (id, namespace, tags, older_than_days, or below_importance)"
+    );
+  }
+  const conditions = ["is_deleted = 0"];
+  const params = [];
+  if (input.id !== void 0) {
+    conditions.push("id = ?");
+    params.push(input.id);
+  }
+  if (input.namespace !== void 0) {
+    conditions.push("namespace = ?");
+    params.push(input.namespace);
+  }
+  if (input.older_than_days !== void 0) {
+    const cutoff = new Date(
+      Date.now() - input.older_than_days * 864e5
+    ).toISOString();
+    conditions.push("created_at < ?");
+    params.push(cutoff);
+  }
+  if (input.below_importance !== void 0) {
+    conditions.push("importance < ?");
+    params.push(input.below_importance);
+  }
+  const sql = `SELECT id, tags FROM memories WHERE ${conditions.join(" AND ")}`;
+  const rows = db.prepare(sql).all(...params);
+  const matched = input.tags !== void 0 && input.tags.length > 0 ? rows.filter((row) => {
+    const memTags = JSON.parse(row.tags);
+    return input.tags.every((t) => memTags.includes(t));
+  }) : rows;
+  const ids = matched.map((r) => r.id);
+  if (!dryRun && ids.length > 0) {
+    const operationId = randomBytes2(16).toString("hex");
+    const runDelete = db.transaction(() => {
+      for (const id of ids) {
+        tombstone(db, id);
+        vecStore.remove(id);
+        const logId = randomBytes2(16).toString("hex");
+        db.prepare(
+          `INSERT INTO consolidation_log (id, operation_id, action, source_ids, result_id, reason, namespace)
+           VALUES (?, ?, 'tombstone', ?, NULL, 'forget', ?)`
+        ).run(logId, operationId, JSON.stringify([id]), input.namespace ?? null);
+      }
+    });
+    runDelete();
+    logger.info("forget", "memories deleted", {
+      count: ids.length,
+      operationId
+    });
+    metrics.increment("forget.deleted", ids.length);
+  }
+  metrics.record("forget.duration_ms", Date.now() - start);
+  return { count: ids.length, ids, dry_run: dryRun };
+}
+
+// src/consolidation/planner.ts
+import { randomBytes as randomBytes3 } from "crypto";
+
+// src/consolidation/dedup.ts
+function findDuplicates(db, vecStore, namespace, threshold) {
+  const isAll = namespace === "*";
+  const nsClause = isAll ? "1=1" : "namespace = ?";
+  const nsParams = isAll ? [] : [namespace];
+  const rows = db.prepare(
+    `SELECT id, content, tags, importance, source_trust FROM memories WHERE is_deleted = 0 AND ${nsClause}`
+  ).all(...nsParams);
+  const alreadyMerged = /* @__PURE__ */ new Set();
+  const merges = [];
+  for (const row of rows) {
+    if (alreadyMerged.has(row.id)) continue;
+    const vecRow = db.prepare("SELECT embedding FROM memories_vec WHERE id = ?").get(row.id);
+    if (vecRow === void 0) continue;
+    const embedding = new Float32Array(
+      vecRow.embedding.buffer,
+      vecRow.embedding.byteOffset,
+      vecRow.embedding.byteLength / 4
+    );
+    const neighbors = vecStore.search(embedding, 10);
+    for (const neighbor of neighbors) {
+      if (neighbor.id === row.id) continue;
+      if (alreadyMerged.has(neighbor.id)) continue;
+      const similarity = 1 - neighbor.distance;
+      if (similarity <= threshold) continue;
+      const neighborRow = db.prepare(
+        "SELECT id, content, tags, importance, source_trust FROM memories WHERE id = ? AND is_deleted = 0"
+      ).get(neighbor.id);
+      if (neighborRow === void 0) continue;
+      if (!isAll) {
+        const nsCheck = db.prepare("SELECT namespace FROM memories WHERE id = ?").get(neighbor.id);
+        if (nsCheck === void 0 || nsCheck.namespace !== namespace) continue;
+      }
+      const { keepId, tombstoneId, keepRow: winner, loseRow: loser } = pickWinner(
+        row,
+        neighborRow
+      );
+      const keepTags = JSON.parse(winner.tags);
+      const loseTags = JSON.parse(loser.tags);
+      const mergedTags = [.../* @__PURE__ */ new Set([...keepTags, ...loseTags])];
+      const mergedImportance = Math.max(winner.importance, loser.importance);
+      merges.push({
+        keep_id: keepId,
+        tombstone_id: tombstoneId,
+        similarity,
+        merged_tags: mergedTags,
+        merged_importance: mergedImportance,
+        reason: `cosine similarity ${similarity.toFixed(3)} exceeds threshold ${threshold}`
+      });
+      alreadyMerged.add(tombstoneId);
+    }
+  }
+  return merges;
+}
+function pickWinner(a, b) {
+  if (isHigherTrust(a.source_trust, b.source_trust)) {
+    return { keepId: a.id, tombstoneId: b.id, keepRow: a, loseRow: b };
+  }
+  if (isHigherTrust(b.source_trust, a.source_trust)) {
+    return { keepId: b.id, tombstoneId: a.id, keepRow: b, loseRow: a };
+  }
+  if (a.content.length >= b.content.length) {
+    return { keepId: a.id, tombstoneId: b.id, keepRow: a, loseRow: b };
+  }
+  return { keepId: b.id, tombstoneId: a.id, keepRow: b, loseRow: a };
+}
+
+// src/consolidation/decay.ts
+function computeDecay(db, namespace, lambda, minImportance) {
+  const isAll = namespace === "*";
+  const nsClause = isAll ? "1=1" : "namespace = ?";
+  const nsParams = isAll ? [] : [namespace];
+  const rows = db.prepare(
+    `SELECT id, importance, access_count, created_at, last_accessed_at, source, source_trust
+       FROM memories
+       WHERE is_deleted = 0 AND ${nsClause}`
+  ).all(...nsParams);
+  const now = Date.now();
+  const decays = [];
+  const prunes = [];
+  for (const row of rows) {
+    const referenceDate = row.last_accessed_at ?? row.created_at;
+    const refMs = new Date(referenceDate).getTime();
+    const daysSinceAccess = (now - refMs) / 864e5;
+    const newImportance = row.importance * Math.exp(-lambda * daysSinceAccess);
+    if (Math.abs(newImportance - row.importance) > 0.01) {
+      decays.push({
+        id: row.id,
+        current_importance: row.importance,
+        new_importance: newImportance,
+        days_since_access: daysSinceAccess
+      });
+    }
+    const ageMs = now - new Date(row.created_at).getTime();
+    const ageDays = ageMs / 864e5;
+    if (newImportance < minImportance && row.access_count < 3 && ageDays > 30 && row.source_trust !== "high" && row.source !== "user") {
+      prunes.push({
+        id: row.id,
+        importance: newImportance,
+        access_count: row.access_count,
+        age_days: ageDays,
+        reason: `decayed importance ${newImportance.toFixed(4)} below threshold ${minImportance}`
+      });
+    }
+  }
+  return { decays, prunes };
+}
+
+// src/consolidation/sweep.ts
+function findExpired(db, namespace) {
+  const isAll = namespace === "*";
+  const nsClause = isAll ? "1=1" : "namespace = ?";
+  const nsParams = isAll ? [] : [namespace];
+  const now = (/* @__PURE__ */ new Date()).toISOString();
+  const rows = db.prepare(
+    `SELECT id, expires_at FROM memories
+       WHERE is_deleted = 0
+         AND expires_at IS NOT NULL
+         AND expires_at < ?
+         AND ${nsClause}`
+  ).all(now, ...nsParams);
+  return rows.map((row) => ({
+    id: row.id,
+    expired_at: row.expires_at
+  }));
+}
+
+// src/consolidation/planner.ts
+function createConsolidationPlan(db, vecStore, namespace, options, metrics) {
+  const operationId = randomBytes3(16).toString("hex");
+  const start = Date.now();
+  const proposedMerges = findDuplicates(
+    db,
+    vecStore,
+    namespace,
+    options.similarity_threshold
+  );
+  const { decays: proposedDecays, prunes: proposedPrunes } = computeDecay(
+    db,
+    namespace,
+    options.decay_lambda,
+    options.min_importance_after_decay
+  );
+  const proposedSweeps = findExpired(db, namespace);
+  metrics.record("consolidation.plan_duration_ms", Date.now() - start);
+  return {
+    operation_id: operationId,
+    namespace,
+    created_at: (/* @__PURE__ */ new Date()).toISOString(),
+    proposed_merges: proposedMerges,
+    proposed_decays: proposedDecays,
+    proposed_prunes: proposedPrunes,
+    proposed_ttl_sweeps: proposedSweeps,
+    summary: {
+      merge_count: proposedMerges.length,
+      decay_count: proposedDecays.length,
+      prune_count: proposedPrunes.length,
+      sweep_count: proposedSweeps.length
+    }
+  };
+}
+
+// src/consolidation/executor.ts
+import { randomBytes as randomBytes4 } from "crypto";
+function executeConsolidationPlan(plan, db, vecStore, logger, metrics) {
+  const start = Date.now();
+  let merged = 0;
+  let decayed = 0;
+  let pruned = 0;
+  let swept = 0;
+  const logAction = db.prepare(
+    `INSERT INTO consolidation_log (id, operation_id, action, source_ids, result_id, reason, namespace)
+     VALUES (?, ?, ?, ?, ?, ?, ?)`
+  );
+  const updateImportance = db.prepare(
+    "UPDATE memories SET importance = ?, updated_at = strftime('%Y-%m-%dT%H:%M:%fZ', 'now') WHERE id = ?"
+  );
+  const updateWinner = db.prepare(
+    `UPDATE memories
+       SET tags = ?,
+           importance = ?,
+           supersedes_id = ?,
+           updated_at = strftime('%Y-%m-%dT%H:%M:%fZ', 'now')
+     WHERE id = ?`
+  );
+  const runAll = db.transaction(() => {
+    for (const merge of plan.proposed_merges) {
+      tombstoneWithLineage(db, merge.tombstone_id, merge.keep_id);
+      vecStore.remove(merge.tombstone_id);
+      updateWinner.run(
+        JSON.stringify([...merge.merged_tags]),
+        merge.merged_importance,
+        merge.tombstone_id,
+        merge.keep_id
+      );
+      logAction.run(
+        randomBytes4(16).toString("hex"),
+        plan.operation_id,
+        "merge",
+        JSON.stringify([merge.keep_id, merge.tombstone_id]),
+        merge.keep_id,
+        merge.reason,
+        plan.namespace
+      );
+      merged++;
+    }
+    for (const decay of plan.proposed_decays) {
+      updateImportance.run(decay.new_importance, decay.id);
+      logAction.run(
+        randomBytes4(16).toString("hex"),
+        plan.operation_id,
+        "decay",
+        JSON.stringify([decay.id]),
+        decay.id,
+        `importance ${decay.current_importance.toFixed(4)} -> ${decay.new_importance.toFixed(4)}`,
+        plan.namespace
+      );
+      decayed++;
+    }
+    for (const prune of plan.proposed_prunes) {
+      tombstone(db, prune.id);
+      vecStore.remove(prune.id);
+      logAction.run(
+        randomBytes4(16).toString("hex"),
+        plan.operation_id,
+        "prune",
+        JSON.stringify([prune.id]),
+        null,
+        prune.reason,
+        plan.namespace
+      );
+      pruned++;
+    }
+    for (const sweep of plan.proposed_ttl_sweeps) {
+      tombstone(db, sweep.id);
+      vecStore.remove(sweep.id);
+      logAction.run(
+        randomBytes4(16).toString("hex"),
+        plan.operation_id,
+        "tombstone",
+        JSON.stringify([sweep.id]),
+        null,
+        `expired at ${sweep.expired_at}`,
+        plan.namespace
+      );
+      swept++;
+    }
+  });
+  runAll();
+  logger.info("consolidation", "plan executed", {
+    operationId: plan.operation_id,
+    merged,
+    decayed,
+    pruned,
+    swept
+  });
+  metrics.increment("consolidation.merged", merged);
+  metrics.increment("consolidation.decayed", decayed);
+  metrics.increment("consolidation.pruned", pruned);
+  metrics.increment("consolidation.swept", swept);
+  metrics.record("consolidation.exec_duration_ms", Date.now() - start);
+  return {
+    operation_id: plan.operation_id,
+    merged,
+    decayed,
+    pruned,
+    swept
+  };
+}
+
+// src/tools/consolidate.ts
+function consolidate(input, db, vecStore, embedder, config, logger, metrics) {
+  const namespace = input.namespace ?? config.defaultNamespace;
+  const similarityThreshold = input.similarity_threshold ?? config.dedupThreshold;
+  const decayLambda = input.decay_lambda ?? config.decayLambda;
+  const minImportance = input.min_importance_after_decay ?? config.minImportance;
+  const plan = createConsolidationPlan(db, vecStore, namespace, {
+    similarity_threshold: similarityThreshold,
+    decay_lambda: decayLambda,
+    min_importance_after_decay: minImportance
+  }, metrics);
+  if (!input.commit) {
+    return { type: "plan", plan };
+  }
+  const result = executeConsolidationPlan(plan, db, vecStore, logger, metrics);
+  return { type: "result", result };
+}
+
+// src/tools/stats.ts
+import { statSync } from "fs";
+function memoryStats(input, db, embedder, config) {
+  const namespace = input.namespace ?? config.defaultNamespace;
+  const isAll = namespace === "*";
+  const nsClause = isAll ? "1=1" : "namespace = ?";
+  const nsParams = isAll ? [] : [namespace];
+  const totalRow = db.prepare(
+    `SELECT COUNT(*) as count FROM memories WHERE is_deleted = 0 AND ${nsClause}`
+  ).get(...nsParams);
+  const catRows = db.prepare(
+    `SELECT category, COUNT(*) as count FROM memories WHERE is_deleted = 0 AND ${nsClause} GROUP BY category`
+  ).all(...nsParams);
+  const byCategory = {};
+  for (const row of catRows) {
+    byCategory[row.category] = row.count;
+  }
+  const srcRows = db.prepare(
+    `SELECT source, COUNT(*) as count FROM memories WHERE is_deleted = 0 AND ${nsClause} GROUP BY source`
+  ).all(...nsParams);
+  const bySource = {};
+  for (const row of srcRows) {
+    bySource[row.source] = row.count;
+  }
+  const trustRows = db.prepare(
+    `SELECT source_trust, COUNT(*) as count FROM memories WHERE is_deleted = 0 AND ${nsClause} GROUP BY source_trust`
+  ).all(...nsParams);
+  const byTrust = {};
+  for (const row of trustRows) {
+    byTrust[row.source_trust] = row.count;
+  }
+  const avgRow = db.prepare(
+    `SELECT AVG(importance) as avg_imp FROM memories WHERE is_deleted = 0 AND ${nsClause}`
+  ).get(...nsParams);
+  const rangeRow = db.prepare(
+    `SELECT MIN(created_at) as oldest, MAX(created_at) as newest FROM memories WHERE is_deleted = 0 AND ${nsClause}`
+  ).get(...nsParams);
+  let dbSizeBytes = 0;
+  try {
+    dbSizeBytes = statSync(config.dbPath).size;
+  } catch {
+  }
+  const lastConsRow = db.prepare(
+    `SELECT MAX(created_at) as last_cons FROM consolidation_log`
+  ).get();
+  const tombstoneRow = db.prepare(
+    `SELECT COUNT(*) as count FROM memories WHERE is_deleted = 1`
+  ).get();
+  return {
+    total: totalRow.count,
+    by_category: byCategory,
+    by_source: bySource,
+    by_trust: byTrust,
+    avg_importance: avgRow.avg_imp ?? 0,
+    oldest: rangeRow.oldest,
+    newest: rangeRow.newest,
+    embedding_model: embedder.name,
+    db_size_bytes: dbSizeBytes,
+    last_consolidation: lastConsRow.last_cons,
+    tombstone_count: tombstoneRow.count
+  };
+}
+
+// src/tools/admin.ts
+import { createHash as createHash2, randomBytes as randomBytes5 } from "crypto";
+function exportMemories(input, db, config) {
+  const namespace = input.namespace ?? config.defaultNamespace;
+  const format = input.format ?? "jsonl";
+  const includeTombstoned = input.include_tombstoned ?? false;
+  const isAll = namespace === "*";
+  const conditions = [];
+  const params = [];
+  if (!isAll) {
+    conditions.push("namespace = ?");
+    params.push(namespace);
+  }
+  if (!includeTombstoned) {
+    conditions.push("is_deleted = 0");
+  }
+  const whereClause = conditions.length > 0 ? `WHERE ${conditions.join(" AND ")}` : "";
+  const rows = db.prepare(`SELECT * FROM memories ${whereClause} ORDER BY created_at ASC`).all(...params);
+  const stripped = rows.map((row) => {
+    const { embedding_model, embedding_dim, ...rest } = row;
+    return rest;
+  });
+  if (format === "json") {
+    return JSON.stringify(stripped, null, 2);
+  }
+  return stripped.map((r) => JSON.stringify(r)).join("\n");
+}
+function contentHash2(content) {
+  return createHash2("sha256").update(content).digest("hex");
+}
+function generateId2() {
+  return randomBytes5(16).toString("hex");
+}
+async function importMemories(input, db, vecStore, embedder, config, logger, metrics) {
+  const trust = input.trust ?? "unverified";
+  const namespace = input.namespace ?? config.defaultNamespace;
+  let records;
+  const trimmed = input.data.trim();
+  if (trimmed.startsWith("[")) {
+    records = JSON.parse(trimmed);
+  } else {
+    records = trimmed.split("\n").filter((line) => line.trim().length > 0).map((line) => JSON.parse(line));
+  }
+  let imported = 0;
+  let skipped = 0;
+  let errors = 0;
+  for (const record of records) {
+    try {
+      if (record.content === void 0 || record.content.length === 0) {
+        errors++;
+        continue;
+      }
+      const hash = contentHash2(record.content);
+      const existing = db.prepare(
+        "SELECT id FROM memories WHERE content_hash = ? AND namespace = ? AND is_deleted = 0 LIMIT 1"
+      ).get(hash, namespace);
+      if (existing !== void 0) {
+        skipped++;
+        continue;
+      }
+      const id = generateId2();
+      const now = (/* @__PURE__ */ new Date()).toISOString();
+      const tags = typeof record.tags === "string" ? record.tags : JSON.stringify(record.tags ?? []);
+      const metadata = typeof record.metadata === "string" ? record.metadata : JSON.stringify(record.metadata ?? {});
+      const category = record.category ?? "general";
+      const importance = record.importance ?? 0.5;
+      db.prepare(
+        `INSERT INTO memories (
+          id, content_hash, content, summary, embedding_model, embedding_dim,
+          namespace, project_id, agent_id, source, source_trust, visibility,
+          schema_version, category, tags, importance, access_count,
+          created_at, updated_at, last_accessed_at, expires_at,
+          is_deleted, tombstoned_at, supersedes_id, superseded_by_id, metadata
+        ) VALUES (
+          ?, ?, ?, NULL, ?, ?, ?, ?, ?, 'auto', ?, 'namespace', 1, ?, ?, ?, 0,
+          ?, ?, NULL, ?, 0, NULL, NULL, NULL, ?
+        )`
+      ).run(
+        id,
+        hash,
+        record.content,
+        embedder.name,
+        embedder.dimensions,
+        namespace,
+        record.project_id ?? null,
+        record.agent_id ?? null,
+        trust,
+        category,
+        tags,
+        importance,
+        now,
+        now,
+        record.expires_at ?? null,
+        metadata
+      );
+      const embedding = await embedder.embed(record.content);
+      vecStore.upsert(id, embedding);
+      const row = db.prepare("SELECT rowid FROM memories WHERE id = ?").get(id);
+      db.prepare(
+        "INSERT INTO memories_fts (rowid, content, summary, tags, category) VALUES (?, ?, NULL, ?, ?)"
+      ).run(row.rowid, record.content, tags, category);
+      imported++;
+    } catch (err) {
+      logger.error("import", "failed to import record", {
+        error: err instanceof Error ? err.message : String(err)
+      });
+      errors++;
+    }
+  }
+  logger.info("import", "import complete", { imported, skipped, errors });
+  metrics.increment("import.imported", imported);
+  metrics.increment("import.skipped", skipped);
+  metrics.increment("import.errors", errors);
+  return { imported, skipped, errors };
+}
+
+// src/resources/index.ts
+import { ResourceTemplate } from "@modelcontextprotocol/sdk/server/mcp.js";
+function registerResources(server, deps) {
+  const { db, embedder, config, metrics } = deps;
+  server.registerResource("global_stats", "memory://stats", {
+    description: "Global memory statistics across all namespaces",
+    mimeType: "application/json"
+  }, () => ({
+    contents: [{
+      uri: "memory://stats",
+      mimeType: "application/json",
+      text: JSON.stringify(memoryStats({ namespace: "*" }, db, embedder, config))
+    }]
+  }));
+  server.registerResource("recent_memories", "memory://recent", {
+    description: "Last 20 memories across all namespaces",
+    mimeType: "application/json"
+  }, () => {
+    const rows = db.prepare(
+      "SELECT * FROM memories WHERE is_deleted = 0 ORDER BY created_at DESC LIMIT 20"
+    ).all();
+    return {
+      contents: [{
+        uri: "memory://recent",
+        mimeType: "application/json",
+        text: JSON.stringify(rows)
+      }]
+    };
+  });
+  server.registerResource("namespaces", "memory://namespaces", {
+    description: "List all namespaces with memory counts",
+    mimeType: "application/json"
+  }, () => {
+    const rows = db.prepare(
+      "SELECT namespace, COUNT(*) as count FROM memories WHERE is_deleted = 0 GROUP BY namespace ORDER BY count DESC"
+    ).all();
+    return {
+      contents: [{
+        uri: "memory://namespaces",
+        mimeType: "application/json",
+        text: JSON.stringify(rows)
+      }]
+    };
+  });
+  server.registerResource("consolidation_log", "memory://consolidation/log", {
+    description: "Recent consolidation log entries",
+    mimeType: "application/json"
+  }, () => {
+    const rows = db.prepare(
+      "SELECT * FROM consolidation_log ORDER BY created_at DESC LIMIT 50"
+    ).all();
+    return {
+      contents: [{
+        uri: "memory://consolidation/log",
+        mimeType: "application/json",
+        text: JSON.stringify(rows)
+      }]
+    };
+  });
+  server.registerResource("operations", "memory://operations", {
+    description: "Active and recent operations",
+    mimeType: "application/json"
+  }, () => {
+    const rows = db.prepare(
+      "SELECT * FROM operations ORDER BY started_at DESC LIMIT 20"
+    ).all();
+    return {
+      contents: [{
+        uri: "memory://operations",
+        mimeType: "application/json",
+        text: JSON.stringify(rows)
+      }]
+    };
+  });
+  server.registerResource("health", "memory://health", {
+    description: "Server health check with metrics snapshot",
+    mimeType: "application/json"
+  }, () => {
+    const snapshot = metrics.snapshot();
+    const totalRow = db.prepare(
+      "SELECT COUNT(*) as count FROM memories WHERE is_deleted = 0"
+    ).get();
+    const health = {
+      status: "ok",
+      version: "0.1.0",
+      memory_count: totalRow.count,
+      embedding_model: embedder.name,
+      embedding_dimensions: embedder.dimensions,
+      metrics: snapshot
+    };
+    return {
+      contents: [{
+        uri: "memory://health",
+        mimeType: "application/json",
+        text: JSON.stringify(health)
+      }]
+    };
+  });
+  server.registerResource(
+    "namespace_stats",
+    new ResourceTemplate("memory://stats/{namespace}", { list: void 0 }),
+    {
+      description: "Statistics for a specific namespace",
+      mimeType: "application/json"
+    },
+    (uri, variables) => {
+      const namespace = String(variables.namespace);
+      const stats = memoryStats({ namespace }, db, embedder, config);
+      return {
+        contents: [{
+          uri: uri.href,
+          mimeType: "application/json",
+          text: JSON.stringify(stats)
+        }]
+      };
+    }
+  );
+  server.registerResource(
+    "namespace_recent",
+    new ResourceTemplate("memory://recent/{namespace}", { list: void 0 }),
+    {
+      description: "Last 20 memories in a specific namespace",
+      mimeType: "application/json"
+    },
+    (uri, variables) => {
+      const namespace = String(variables.namespace);
+      const rows = db.prepare(
+        "SELECT * FROM memories WHERE is_deleted = 0 AND namespace = ? ORDER BY created_at DESC LIMIT 20"
+      ).all(namespace);
+      return {
+        contents: [{
+          uri: uri.href,
+          mimeType: "application/json",
+          text: JSON.stringify(rows)
+        }]
+      };
+    }
+  );
+  server.registerResource(
+    "memory_by_id",
+    new ResourceTemplate("memory://id/{id}", { list: void 0 }),
+    {
+      description: "Retrieve a specific memory by its ID",
+      mimeType: "application/json"
+    },
+    (uri, variables) => {
+      const id = String(variables.id);
+      const row = db.prepare(
+        "SELECT * FROM memories WHERE id = ?"
+      ).get(id);
+      if (row === void 0) {
+        return { contents: [{ uri: uri.href, mimeType: "application/json", text: JSON.stringify({ error: "not_found", id }) }] };
+      }
+      return {
+        contents: [{
+          uri: uri.href,
+          mimeType: "application/json",
+          text: JSON.stringify(row)
+        }]
+      };
+    }
+  );
+  server.registerResource(
+    "memories_by_tag",
+    new ResourceTemplate("memory://tag/{tag}", { list: void 0 }),
+    {
+      description: "Memories containing a specific tag (across all namespaces)",
+      mimeType: "application/json"
+    },
+    (uri, variables) => {
+      const tag = String(variables.tag);
+      const rows = db.prepare(
+        "SELECT * FROM memories WHERE is_deleted = 0 AND tags LIKE ? ORDER BY created_at DESC LIMIT 50"
+      ).all(`%"${tag}"%`);
+      return {
+        contents: [{
+          uri: uri.href,
+          mimeType: "application/json",
+          text: JSON.stringify(rows)
+        }]
+      };
+    }
+  );
+  server.registerResource(
+    "memories_by_namespace_tag",
+    new ResourceTemplate("memory://tag/{namespace}/{tag}", { list: void 0 }),
+    {
+      description: "Memories with a specific tag in a specific namespace",
+      mimeType: "application/json"
+    },
+    (uri, variables) => {
+      const namespace = String(variables.namespace);
+      const tag = String(variables.tag);
+      const rows = db.prepare(
+        "SELECT * FROM memories WHERE is_deleted = 0 AND namespace = ? AND tags LIKE ? ORDER BY created_at DESC LIMIT 50"
+      ).all(namespace, `%"${tag}"%`);
+      return {
+        contents: [{
+          uri: uri.href,
+          mimeType: "application/json",
+          text: JSON.stringify(rows)
+        }]
+      };
+    }
+  );
+  server.registerResource(
+    "namespace_memories",
+    new ResourceTemplate("memory://namespace/{ns}", { list: void 0 }),
+    {
+      description: "All memories in a namespace (up to 100)",
+      mimeType: "application/json"
+    },
+    (uri, variables) => {
+      const ns = String(variables.ns);
+      const rows = db.prepare(
+        "SELECT * FROM memories WHERE is_deleted = 0 AND namespace = ? ORDER BY created_at DESC LIMIT 100"
+      ).all(ns);
+      return {
+        contents: [{
+          uri: uri.href,
+          mimeType: "application/json",
+          text: JSON.stringify(rows)
+        }]
+      };
+    }
+  );
+  server.registerResource(
+    "consolidation_log_by_op",
+    new ResourceTemplate("memory://consolidation/log/{operation_id}", { list: void 0 }),
+    {
+      description: "Consolidation log entries for a specific operation",
+      mimeType: "application/json"
+    },
+    (uri, variables) => {
+      const operationId = String(variables.operation_id);
+      const rows = db.prepare(
+        "SELECT * FROM consolidation_log WHERE operation_id = ? ORDER BY created_at ASC"
+      ).all(operationId);
+      return {
+        contents: [{
+          uri: uri.href,
+          mimeType: "application/json",
+          text: JSON.stringify(rows)
+        }]
+      };
+    }
+  );
+}
+
+// src/prompts/index.ts
+import { z } from "zod";
+function registerPrompts(server, deps) {
+  const { db, vecStore, embedder, config, logger, metrics } = deps;
+  server.registerPrompt("memory_context_for_task", {
+    description: "Search memories relevant to a task and format them as context for an LLM.",
+    argsSchema: {
+      task: z.string().describe("Description of the task to find relevant memories for"),
+      namespace: z.string().optional().describe("Namespace to search"),
+      limit: z.string().optional().describe("Max memories to include (default: 5)")
+    }
+  }, async (args) => {
+    const limit = args.limit !== void 0 ? parseInt(args.limit, 10) : 5;
+    const results = await searchMemory(
+      { query: args.task, namespace: args.namespace, limit },
+      { db, vecStore, embedder, logger, metrics, config }
+    );
+    if (results.length === 0) {
+      return {
+        messages: [{
+          role: "user",
+          content: {
+            type: "text",
+            text: `No relevant memories found for task: "${args.task}"`
+          }
+        }]
+      };
+    }
+    const memoryBlock = results.map((m, i) => {
+      const tags = JSON.parse(m.tags);
+      return [
+        `### Memory ${i + 1} (score: ${m.similarity_score.toFixed(4)})`,
+        `- **Category**: ${m.category}`,
+        `- **Tags**: ${tags.length > 0 ? tags.join(", ") : "none"}`,
+        `- **Importance**: ${m.importance}`,
+        `- **Created**: ${m.created_at}`,
+        "",
+        m.content
+      ].join("\n");
+    }).join("\n\n---\n\n");
+    return {
+      messages: [{
+        role: "user",
+        content: {
+          type: "text",
+          text: [
+            `# Relevant Memories for Task`,
+            "",
+            `**Task**: ${args.task}`,
+            `**Found**: ${results.length} relevant memories`,
+            "",
+            memoryBlock
+          ].join("\n")
+        }
+      }]
+    };
+  });
+  server.registerPrompt("review_memory_candidate", {
+    description: "Show a proposed memory alongside existing near-duplicates to help decide whether to store it.",
+    argsSchema: {
+      content: z.string().describe("The proposed memory content to review"),
+      namespace: z.string().optional().describe("Namespace to check for duplicates")
+    }
+  }, async (args) => {
+    const namespace = args.namespace ?? config.defaultNamespace;
+    const results = await searchMemory(
+      { query: args.content, namespace, limit: 5 },
+      { db, vecStore, embedder, logger, metrics, config }
+    );
+    const duplicateBlock = results.length === 0 ? "No similar memories found. This appears to be a new topic." : results.map((m, i) => {
+      const tags = JSON.parse(m.tags);
+      return [
+        `### Existing Memory ${i + 1} (similarity: ${m.similarity_score.toFixed(4)})`,
+        `- **ID**: ${m.id}`,
+        `- **Category**: ${m.category}`,
+        `- **Tags**: ${tags.length > 0 ? tags.join(", ") : "none"}`,
+        `- **Importance**: ${m.importance}`,
+        "",
+        m.content
+      ].join("\n");
+    }).join("\n\n---\n\n");
+    return {
+      messages: [{
+        role: "user",
+        content: {
+          type: "text",
+          text: [
+            "# Memory Candidate Review",
+            "",
+            "## Proposed Memory",
+            "",
+            args.content,
+            "",
+            `## Existing Similar Memories (namespace: ${namespace})`,
+            "",
+            duplicateBlock,
+            "",
+            "## Decision",
+            "",
+            "Should this memory be stored? Consider:",
+            "1. Is it a duplicate of an existing memory?",
+            "2. Does it add new information not captured above?",
+            "3. Would it be better to update an existing memory instead?"
+          ].join("\n")
+        }
+      }]
+    };
+  });
+  server.registerPrompt("consolidation_dry_run", {
+    description: "Preview proposed consolidation actions (merges, decays, prunes, sweeps) without applying them.",
+    argsSchema: {
+      namespace: z.string().optional().describe("Namespace to consolidate (default: config default)")
+    }
+  }, (args) => {
+    const output = consolidate(
+      { namespace: args.namespace, commit: false },
+      db,
+      vecStore,
+      embedder,
+      config,
+      logger,
+      metrics
+    );
+    if (output.type !== "plan") {
+      return {
+        messages: [{
+          role: "user",
+          content: { type: "text", text: "Unexpected: consolidation returned a result instead of a plan." }
+        }]
+      };
+    }
+    const { plan } = output;
+    const sections = [
+      "# Consolidation Dry Run",
+      "",
+      `**Namespace**: ${plan.namespace}`,
+      `**Operation ID**: ${plan.operation_id}`,
+      "",
+      "## Summary",
+      "",
+      `- Proposed merges: ${plan.summary.merge_count}`,
+      `- Proposed decays: ${plan.summary.decay_count}`,
+      `- Proposed prunes: ${plan.summary.prune_count}`,
+      `- Proposed TTL sweeps: ${plan.summary.sweep_count}`
+    ];
+    if (plan.proposed_merges.length > 0) {
+      sections.push("", "## Proposed Merges", "");
+      for (const merge of plan.proposed_merges) {
+        sections.push(
+          `- **Keep** \`${merge.keep_id}\` / **Tombstone** \`${merge.tombstone_id}\``,
+          `  Similarity: ${merge.similarity.toFixed(4)} | Reason: ${merge.reason}`
+        );
+      }
+    }
+    if (plan.proposed_decays.length > 0) {
+      sections.push("", "## Proposed Decays", "");
+      for (const decay of plan.proposed_decays) {
+        sections.push(
+          `- \`${decay.id}\`: ${decay.current_importance.toFixed(3)} -> ${decay.new_importance.toFixed(3)} (${decay.days_since_access} days since access)`
+        );
+      }
+    }
+    if (plan.proposed_prunes.length > 0) {
+      sections.push("", "## Proposed Prunes", "");
+      for (const prune of plan.proposed_prunes) {
+        sections.push(
+          `- \`${prune.id}\`: importance=${prune.importance.toFixed(3)}, accesses=${prune.access_count}, age=${prune.age_days}d | ${prune.reason}`
+        );
+      }
+    }
+    if (plan.proposed_ttl_sweeps.length > 0) {
+      sections.push("", "## Proposed TTL Sweeps", "");
+      for (const sweep of plan.proposed_ttl_sweeps) {
+        sections.push(`- \`${sweep.id}\`: expired at ${sweep.expired_at}`);
+      }
+    }
+    return {
+      messages: [{
+        role: "user",
+        content: { type: "text", text: sections.join("\n") }
+      }]
+    };
+  });
+}
+
+// src/server.ts
+function textResult(data) {
+  return { content: [{ type: "text", text: JSON.stringify(data) }] };
+}
+function createServer(deps) {
+  const { db, vecStore, embedder, config, logger, metrics } = deps;
+  const server = new McpServer(
+    { name: "neuromcp", version: "0.1.0" },
+    {
+      capabilities: {
+        resources: {},
+        tools: {},
+        prompts: {}
+      }
+    }
+  );
+  server.registerTool("store_memory", {
+    description: "Store a new memory with semantic deduplication. Returns the memory ID and whether it matched an existing memory.",
+    inputSchema: {
+      content: z2.string().describe("The memory content to store"),
+      namespace: z2.string().optional().describe("Namespace to store in (default: config default)"),
+      category: z2.string().optional().describe('Category label (e.g. "code", "conversation", "fact")'),
+      tags: z2.array(z2.string()).optional().describe("Tags for filtering"),
+      importance: z2.number().min(0).max(1).optional().describe("Importance score 0-1 (default: 0.5)"),
+      source: z2.enum(["user", "auto", "consolidation", "claude-code", "error"]).optional().describe("Source of the memory"),
+      source_trust: z2.enum(["high", "medium", "low", "unverified"]).optional().describe("Trust level"),
+      project_id: z2.string().optional().describe("Project identifier"),
+      agent_id: z2.string().optional().describe("Agent identifier"),
+      metadata: z2.record(z2.unknown()).optional().describe("Arbitrary metadata"),
+      expires_at: z2.string().optional().describe("ISO 8601 expiration timestamp")
+    }
+  }, async (args) => {
+    const result = await storeMemory(args, { db, vecStore, embedder, logger, metrics, config });
+    return textResult(result);
+  });
+  server.registerTool("search_memory", {
+    description: "Search memories using hybrid vector + full-text search with RRF ranking.",
+    inputSchema: {
+      query: z2.string().describe("Search query text"),
+      namespace: z2.string().optional().describe("Namespace to search (default: config default)"),
+      limit: z2.number().int().min(1).max(100).optional().describe("Max results (default: 10)"),
+      category: z2.string().optional().describe("Filter by category"),
+      tags: z2.array(z2.string()).optional().describe("Filter: all tags must be present"),
+      min_importance: z2.number().min(0).max(1).optional().describe("Minimum importance threshold"),
+      min_trust: z2.enum(["high", "medium", "low", "unverified"]).optional().describe("Minimum trust level"),
+      after: z2.string().optional().describe("Only memories created after this ISO timestamp"),
+      before: z2.string().optional().describe("Only memories created before this ISO timestamp"),
+      hybrid: z2.boolean().optional().describe("Use hybrid search (default: true)")
+    }
+  }, async (args) => {
+    const results = await searchMemory(args, { db, vecStore, embedder, logger, metrics, config });
+    return textResult(results);
+  });
+  server.registerTool("recall_memory", {
+    description: "Recall memories by ID, namespace, category, or tags without semantic search.",
+    inputSchema: {
+      id: z2.string().optional().describe("Specific memory ID to recall"),
+      namespace: z2.string().optional().describe("Namespace filter"),
+      category: z2.string().optional().describe("Category filter"),
+      tags: z2.array(z2.string()).optional().describe("Tags filter: all must match"),
+      limit: z2.number().int().min(1).max(100).optional().describe("Max results (default: 20)")
+    }
+  }, (args) => {
+    const results = recallMemory(args, db, config, logger, metrics);
+    return textResult(results);
+  });
+  server.registerTool("forget_memory", {
+    description: "Tombstone (soft-delete) memories matching the given filters. At least one filter is required.",
+    inputSchema: {
+      id: z2.string().optional().describe("Specific memory ID to forget"),
+      namespace: z2.string().optional().describe("Namespace filter"),
+      tags: z2.array(z2.string()).optional().describe("Tags filter"),
+      older_than_days: z2.number().int().min(1).optional().describe("Delete memories older than N days"),
+      below_importance: z2.number().min(0).max(1).optional().describe("Delete memories below this importance"),
+      dry_run: z2.boolean().optional().describe("Preview what would be deleted without actually deleting")
+    }
+  }, (args) => {
+    const result = forgetMemory(args, db, vecStore, config, logger, metrics);
+    return textResult(result);
+  });
+  server.registerTool("consolidate", {
+    description: "Run consolidation: merge near-duplicates, decay stale memories, prune low-value, sweep expired. Set commit=true to apply.",
+    inputSchema: {
+      namespace: z2.string().optional().describe("Namespace to consolidate (default: config default)"),
+      similarity_threshold: z2.number().min(0).max(1).optional().describe("Similarity threshold for merging"),
+      decay_lambda: z2.number().optional().describe("Decay rate parameter"),
+      min_importance_after_decay: z2.number().min(0).max(1).optional().describe("Prune threshold after decay"),
+      commit: z2.boolean().describe("If false, returns a dry-run plan. If true, executes the plan.")
+    }
+  }, (args) => {
+    const output = consolidate(args, db, vecStore, embedder, config, logger, metrics);
+    return textResult(output);
+  });
+  server.registerTool("memory_stats", {
+    description: "Get statistics about stored memories: counts, categories, trust levels, importance, and database size.",
+    inputSchema: {
+      namespace: z2.string().optional().describe('Namespace to get stats for (default: config default, "*" for all)')
+    }
+  }, (args) => {
+    const stats = memoryStats(args, db, embedder, config);
+    return textResult(stats);
+  });
+  server.registerTool("export_memories", {
+    description: "Export memories as JSONL or JSON for backup or migration.",
+    inputSchema: {
+      namespace: z2.string().optional().describe('Namespace to export (default: config default, "*" for all)'),
+      format: z2.enum(["jsonl", "json"]).optional().describe("Export format (default: jsonl)"),
+      include_tombstoned: z2.boolean().optional().describe("Include soft-deleted memories")
+    }
+  }, (args) => {
+    const data = exportMemories(args, db, config);
+    return textResult({ data });
+  });
+  server.registerTool("import_memories", {
+    description: "Import memories from JSONL or JSON data. Deduplicates by content hash.",
+    inputSchema: {
+      data: z2.string().describe("JSONL or JSON array string of memory records"),
+      namespace: z2.string().optional().describe("Override namespace for all imported memories"),
+      trust: z2.enum(["high", "medium", "low", "unverified"]).optional().describe("Trust level for imported memories (default: unverified)")
+    }
+  }, async (args) => {
+    const result = await importMemories(args, db, vecStore, embedder, config, logger, metrics);
+    return textResult(result);
+  });
+  registerResources(server, deps);
+  registerPrompts(server, deps);
+  logger.info("server", "MCP server created", {
+    tools: 8,
+    resources: 13,
+    prompts: 3
+  });
+  return server;
+}
+
+// src/index.ts
+async function main() {
+  const config = loadConfig();
+  const logger = createLogger({ level: config.logLevel, format: config.logFormat });
+  const metrics = createMetrics();
+  logger.info("startup", "Loading neuromcp", {
+    dbPath: config.dbPath,
+    embeddingProvider: config.embeddingProvider,
+    defaultNamespace: config.defaultNamespace
+  });
+  const db = openDatabase(config.dbPath);
+  runMigrations(db, config.dbPath, logger);
+  const embedder = await createEmbeddingProvider(config, logger);
+  const vecStore = new SqliteVecStore(embedder.dimensions);
+  vecStore.initialize(db);
+  const server = createServer({ db, vecStore, embedder, config, logger, metrics });
+  const transport = new StdioServerTransport();
+  await server.connect(transport);
+  logger.info("startup", "neuromcp MCP server running on stdio");
+}
+main().catch((error) => {
+  const message = error instanceof Error ? error.message : String(error);
+  const stack = error instanceof Error ? error.stack : void 0;
+  process.stderr.write(`Fatal error: ${message}
+`);
+  if (stack !== void 0) {
+    process.stderr.write(`${stack}
+`);
+  }
+  process.exit(1);
+});
+//# sourceMappingURL=index.js.map