@mnemonic-ai/core 0.1.0

package/dist/mcp/main.cjs

@@ -0,0 +1,2775 @@
+#!/usr/bin/env node
+"use strict";
+var __create = Object.create;
+var __defProp = Object.defineProperty;
+var __getOwnPropDesc = Object.getOwnPropertyDescriptor;
+var __getOwnPropNames = Object.getOwnPropertyNames;
+var __getProtoOf = Object.getPrototypeOf;
+var __hasOwnProp = Object.prototype.hasOwnProperty;
+var __esm = (fn, res) => function __init() {
+  return fn && (res = (0, fn[__getOwnPropNames(fn)[0]])(fn = 0)), res;
+};
+var __export = (target, all) => {
+  for (var name in all)
+    __defProp(target, name, { get: all[name], enumerable: true });
+};
+var __copyProps = (to, from, except, desc) => {
+  if (from && typeof from === "object" || typeof from === "function") {
+    for (let key of __getOwnPropNames(from))
+      if (!__hasOwnProp.call(to, key) && key !== except)
+        __defProp(to, key, { get: () => from[key], enumerable: !(desc = __getOwnPropDesc(from, key)) || desc.enumerable });
+  }
+  return to;
+};
+var __toESM = (mod, isNodeMode, target) => (target = mod != null ? __create(__getProtoOf(mod)) : {}, __copyProps(
+  // If the importer is in node compatibility mode or this is not an ESM
+  // file that has been converted to a CommonJS file using a Babel-
+  // compatible transform (i.e. "__esModule" has not been set), then set
+  // "default" to the CommonJS "module.exports" for node compatibility.
+  isNodeMode || !mod || !mod.__esModule ? __defProp(target, "default", { value: mod, enumerable: true }) : target,
+  mod
+));
+
+// src/core/utils.ts
+function cosineSimilarityVector(query, embeddings) {
+  const dim = query.length;
+  const n = embeddings.length;
+  const result = new Float64Array(n);
+  for (let ei = 0; ei < n; ei++) {
+    if (embeddings[ei].length !== dim) {
+      throw new Error(
+        `Embedding dimension mismatch: ${embeddings[ei].length} vs query ${dim}`
+      );
+    }
+  }
+  let normQ = 0;
+  for (let i = 0; i < dim; i++) normQ += query[i] * query[i];
+  normQ = Math.sqrt(normQ);
+  if (normQ === 0) return result;
+  const qNormed = new Float64Array(dim);
+  for (let i = 0; i < dim; i++) qNormed[i] = query[i] / normQ;
+  for (let ei = 0; ei < n; ei++) {
+    const emb = embeddings[ei];
+    let dot = 0;
+    let normE = 0;
+    for (let i = 0; i < dim; i++) {
+      dot += qNormed[i] * emb[i];
+      normE += emb[i] * emb[i];
+    }
+    normE = Math.sqrt(normE);
+    result[ei] = normE === 0 ? 0 : dot / normE;
+  }
+  return result;
+}
+function cosineSimilarityMatrix(embeddings) {
+  const n = embeddings.length;
+  if (n === 0) return new Float64Array(0);
+  const dim = embeddings[0].length;
+  for (let i = 1; i < n; i++) {
+    if (embeddings[i].length !== dim) {
+      throw new Error(
+        `Embedding dimension mismatch at index ${i}: ${embeddings[i].length} vs ${dim}`
+      );
+    }
+  }
+  const result = new Float64Array(n * n);
+  const normed = [];
+  const isZeroNorm = [];
+  for (let i = 0; i < n; i++) {
+    const emb = embeddings[i];
+    let norm = 0;
+    for (let d = 0; d < dim; d++) norm += emb[d] * emb[d];
+    norm = Math.sqrt(norm);
+    const row = new Float64Array(dim);
+    if (norm > 0) {
+      for (let d = 0; d < dim; d++) row[d] = emb[d] / norm;
+      isZeroNorm.push(false);
+    } else {
+      isZeroNorm.push(true);
+    }
+    normed.push(row);
+  }
+  for (let i = 0; i < n; i++) {
+    result[i * n + i] = isZeroNorm[i] ? 0 : 1;
+    for (let j = i + 1; j < n; j++) {
+      let dot = 0;
+      for (let d = 0; d < dim; d++) dot += normed[i][d] * normed[j][d];
+      result[i * n + j] = dot;
+      result[j * n + i] = dot;
+    }
+  }
+  return result;
+}
+function parseDuration(s) {
+  const match = s.trim().toLowerCase().match(DURATION_RE);
+  if (!match) {
+    throw new Error(
+      `Cannot parse duration: '${s}'. Use e.g. 2w, 30d, 24h, 60m, 120s.`
+    );
+  }
+  const n = parseInt(match[1], 10);
+  const unit = match[2];
+  return n * MS_MULTIPLIERS[unit];
+}
+function estimateTokens(text, charsPerToken = 4) {
+  return Math.max(1, Math.floor(text.length / charsPerToken));
+}
+function parseSqlitePath(uri) {
+  if (!uri.includes("///")) {
+    throw new Error(
+      `Invalid SQLite URI: '${uri}'. Expected format: sqlite:///path/to/db`
+    );
+  }
+  return uri.split("///")[1] || "mnemonic.db";
+}
+function bruteForceSimilarPairs(memories, threshold, maxCandidates) {
+  const cap = Math.max(0, maxCandidates);
+  const withEmb = memories.filter((m) => m.embedding != null).slice(0, cap);
+  if (withEmb.length < 2) return [];
+  const simMatrix = cosineSimilarityMatrix(withEmb.map((m) => m.embedding));
+  const n = withEmb.length;
+  const pairs = [];
+  for (let i = 0; i < n; i++) {
+    for (let j = i + 1; j < n; j++) {
+      const sim = simMatrix[i * n + j];
+      if (sim >= threshold) {
+        pairs.push({ idA: withEmb[i].id, idB: withEmb[j].id, similarity: sim });
+      }
+    }
+  }
+  return pairs;
+}
+function bruteForceCosineSearch(memories, embedding, limit) {
+  if (limit <= 0) return [];
+  const withEmb = memories.filter((m) => m.embedding != null);
+  if (withEmb.length === 0) return [];
+  const embList = withEmb.map((m) => m.embedding);
+  const sims = cosineSimilarityVector(embedding, embList);
+  const indices = Array.from({ length: withEmb.length }, (_, i) => i);
+  indices.sort((a, b) => sims[b] - sims[a]);
+  return indices.slice(0, limit).map((i) => withEmb[i]);
+}
+var DURATION_RE, MS_MULTIPLIERS;
+var init_utils = __esm({
+  "src/core/utils.ts"() {
+    "use strict";
+    DURATION_RE = /^(\d+)\s*([wdhms])$/;
+    MS_MULTIPLIERS = {
+      w: 7 * 24 * 60 * 60 * 1e3,
+      d: 24 * 60 * 60 * 1e3,
+      h: 60 * 60 * 1e3,
+      m: 60 * 1e3,
+      s: 1e3
+    };
+  }
+});
+
+// src/core/memory.ts
+function createEdge(sourceId, targetId, relation, weight = 1) {
+  return { sourceId, targetId, relation, weight, createdAt: /* @__PURE__ */ new Date() };
+}
+var import_node_crypto, MemoryTier, Memory;
+var init_memory = __esm({
+  "src/core/memory.ts"() {
+    "use strict";
+    import_node_crypto = require("crypto");
+    init_utils();
+    MemoryTier = {
+      IDENTITY: "identity",
+      PROCEDURAL: "procedural",
+      STRUCTURAL: "structural",
+      EPISODIC: "episodic",
+      TRANSIENT: "transient"
+    };
+    Memory = class {
+      content;
+      id;
+      tier;
+      source;
+      actor;
+      sessionId;
+      createdAt;
+      lastAccessedAt;
+      accessCount;
+      importance;
+      supersededBy;
+      contradictedBy;
+      embedding;
+      metadata;
+      linkedIds;
+      agentId;
+      shared;
+      _charsPerToken;
+      constructor(init) {
+        const now = /* @__PURE__ */ new Date();
+        this.content = init.content;
+        this.id = init.id ?? (0, import_node_crypto.randomUUID)().replace(/-/g, "");
+        this.tier = init.tier ?? MemoryTier.EPISODIC;
+        this.source = init.source ?? "unknown";
+        this.actor = init.actor ?? "system";
+        this.sessionId = init.sessionId ?? null;
+        this.createdAt = init.createdAt ?? now;
+        this.lastAccessedAt = init.lastAccessedAt ?? now;
+        this.accessCount = init.accessCount ?? 0;
+        this.importance = init.importance ?? 1;
+        this.supersededBy = init.supersededBy ?? null;
+        this.contradictedBy = init.contradictedBy ?? null;
+        this.embedding = init.embedding ?? null;
+        this.metadata = init.metadata ?? {};
+        this.linkedIds = init.linkedIds ?? [];
+        this.agentId = init.agentId ?? "default";
+        this.shared = init.shared ?? false;
+        this._charsPerToken = init.charsPerToken ?? 4;
+      }
+      /** The tier as a plain string, regardless of whether it was set as an enum. */
+      get tierName() {
+        return this.tier;
+      }
+      /** Rough token count using configurable chars-per-token ratio. */
+      get tokenEstimate() {
+        return estimateTokens(this.content, this._charsPerToken);
+      }
+      /** Record an access. */
+      touch() {
+        this.lastAccessedAt = /* @__PURE__ */ new Date();
+        this.accessCount += 1;
+      }
+    };
+  }
+});
+
+// src/embeddings/openai.ts
+var openai_exports = {};
+__export(openai_exports, {
+  OpenAIEmbedder: () => OpenAIEmbedder
+});
+var MODEL_DIMENSIONS, OpenAIEmbedder;
+var init_openai = __esm({
+  "src/embeddings/openai.ts"() {
+    "use strict";
+    MODEL_DIMENSIONS = {
+      "text-embedding-3-small": 1536,
+      "text-embedding-3-large": 3072,
+      "text-embedding-ada-002": 1536
+    };
+    OpenAIEmbedder = class {
+      _model;
+      _apiKey;
+      _client = null;
+      constructor(options) {
+        this._model = options?.model ?? "text-embedding-3-small";
+        this._apiKey = options?.apiKey;
+      }
+      get dimension() {
+        return MODEL_DIMENSIONS[this._model] ?? 1536;
+      }
+      async getClient() {
+        if (!this._client) {
+          const mod = await Function('return import("openai")')();
+          this._client = new mod.default({ apiKey: this._apiKey });
+        }
+        return this._client;
+      }
+      async embed(text) {
+        const client = await this.getClient();
+        const response = await client.embeddings.create({
+          model: this._model,
+          input: text
+        });
+        return response.data[0].embedding;
+      }
+      async embedBatch(texts) {
+        const client = await this.getClient();
+        const response = await client.embeddings.create({
+          model: this._model,
+          input: texts
+        });
+        return response.data.sort((a, b) => a.index - b.index).map((d) => d.embedding);
+      }
+    };
+  }
+});
+
+// src/embeddings/local.ts
+var local_exports = {};
+__export(local_exports, {
+  LocalEmbedder: () => LocalEmbedder
+});
+var MODEL_DIMENSIONS2, DEFAULT_MODEL, DEFAULT_DIMENSION, LocalEmbedder;
+var init_local = __esm({
+  "src/embeddings/local.ts"() {
+    "use strict";
+    MODEL_DIMENSIONS2 = {
+      "Xenova/all-MiniLM-L6-v2": 384,
+      "Xenova/all-MiniLM-L12-v2": 384,
+      "Xenova/all-mpnet-base-v2": 768
+    };
+    DEFAULT_MODEL = "Xenova/all-MiniLM-L6-v2";
+    DEFAULT_DIMENSION = 384;
+    LocalEmbedder = class {
+      _modelName;
+      _pipeline = null;
+      _dimension;
+      constructor(options) {
+        this._modelName = options?.model ?? DEFAULT_MODEL;
+        this._dimension = MODEL_DIMENSIONS2[this._modelName] ?? DEFAULT_DIMENSION;
+      }
+      get dimension() {
+        return this._dimension;
+      }
+      async _getPipeline() {
+        if (this._pipeline) return this._pipeline;
+        let pipeline;
+        try {
+          const mod = await import("@huggingface/transformers");
+          pipeline = mod.pipeline ?? mod.default?.pipeline;
+        } catch {
+          throw new Error(
+            "LocalEmbedder requires '@huggingface/transformers'. Install it with: npm install @huggingface/transformers"
+          );
+        }
+        this._pipeline = await pipeline("feature-extraction", this._modelName, {
+          quantized: true
+        });
+        return this._pipeline;
+      }
+      async embed(text) {
+        const pipe = await this._getPipeline();
+        const output = await pipe(text, { pooling: "mean", normalize: true });
+        return Array.from(output.data).slice(0, this._dimension);
+      }
+      async embedBatch(texts) {
+        const results = [];
+        for (const text of texts) {
+          results.push(await this.embed(text));
+        }
+        return results;
+      }
+    };
+  }
+});
+
+// src/stores/postgres.ts
+var postgres_exports = {};
+__export(postgres_exports, {
+  PostgresStore: () => PostgresStore
+});
+async function loadPg() {
+  if (_pgModule) return _pgModule;
+  try {
+    _pgModule = await import("pg");
+    return _pgModule;
+  } catch {
+    throw new Error(
+      "PostgresStore requires the 'pg' package. Install it with: npm install pg pgvector"
+    );
+  }
+}
+async function loadPgvectorRegister() {
+  if (_registerPgvector) return _registerPgvector;
+  try {
+    const mod = await import("pgvector/pg");
+    _registerPgvector = mod.registerTypes ?? mod.default?.registerTypes ?? mod.registerType ?? mod.default?.registerType;
+    return _registerPgvector;
+  } catch {
+    throw new Error(
+      "PostgresStore requires the 'pgvector' package. Install it with: npm install pgvector"
+    );
+  }
+}
+function rowToMemory2(row) {
+  const embedding = row["embedding"];
+  let parsedEmbedding = null;
+  if (embedding != null) {
+    if (Array.isArray(embedding)) {
+      parsedEmbedding = embedding;
+    } else if (typeof embedding === "string") {
+      parsedEmbedding = JSON.parse(embedding);
+    }
+  }
+  const m = new Memory({
+    id: row["id"],
+    content: row["content"],
+    tier: row["tier"],
+    source: row["source"],
+    actor: row["actor"],
+    sessionId: row["session_id"],
+    createdAt: new Date(row["created_at"]),
+    lastAccessedAt: new Date(row["last_accessed"]),
+    accessCount: row["access_count"],
+    importance: row["importance"],
+    supersededBy: row["superseded_by"],
+    embedding: parsedEmbedding,
+    metadata: typeof row["metadata"] === "string" ? JSON.parse(row["metadata"]) : row["metadata"] ?? {},
+    linkedIds: typeof row["linked_ids"] === "string" ? JSON.parse(row["linked_ids"]) : row["linked_ids"] ?? [],
+    agentId: row["agent_id"] ?? "default",
+    shared: row["shared"] === true || row["shared"] === "t"
+  });
+  m.contradictedBy = row["contradicted_by"];
+  return m;
+}
+var _pgModule, _registerPgvector, PostgresStore;
+var init_postgres = __esm({
+  "src/stores/postgres.ts"() {
+    "use strict";
+    init_memory();
+    init_utils();
+    _pgModule = null;
+    _registerPgvector = null;
+    PostgresStore = class {
+      _dsn;
+      _embeddingDim;
+      _poolMin;
+      _poolMax;
+      _pool = null;
+      _pgvectorRegistered = false;
+      constructor(options) {
+        this._dsn = options.dsn;
+        this._embeddingDim = options.embeddingDim ?? 1536;
+        this._poolMin = options.poolMin ?? 2;
+        this._poolMax = options.poolMax ?? 10;
+      }
+      async _getPool() {
+        if (this._pool) return this._pool;
+        const pg = await loadPg();
+        this._pool = new pg.Pool({
+          connectionString: this._dsn,
+          min: this._poolMin,
+          max: this._poolMax
+        });
+        return this._pool;
+      }
+      async _query(sql, params = []) {
+        const pool = await this._getPool();
+        const client = await pool.connect();
+        try {
+          return await client.query(sql, params);
+        } finally {
+          client.release();
+        }
+      }
+      /** Register pgvector on the pool's connect event so every connection gets it. */
+      async _setupPgvectorOnPool() {
+        if (this._pgvectorRegistered) return;
+        const pool = await this._getPool();
+        const register = await loadPgvectorRegister();
+        pool.on("connect", (client2) => {
+          register(client2).catch((err) => {
+            process.stderr.write(`pgvector registration failed: ${err.message}
+`);
+          });
+        });
+        const client = await pool.connect();
+        try {
+          await register(client);
+        } finally {
+          client.release();
+        }
+        this._pgvectorRegistered = true;
+      }
+      async initialize() {
+        await this._query("CREATE EXTENSION IF NOT EXISTS vector");
+        await this._setupPgvectorOnPool();
+        await this._query(`
+      CREATE TABLE IF NOT EXISTS memories (
+        id             TEXT PRIMARY KEY,
+        content        TEXT NOT NULL,
+        tier           TEXT NOT NULL,
+        source         TEXT NOT NULL DEFAULT 'unknown',
+        actor          TEXT NOT NULL DEFAULT 'system',
+        session_id     TEXT,
+        created_at     TIMESTAMPTZ NOT NULL,
+        last_accessed  TIMESTAMPTZ NOT NULL,
+        access_count   INTEGER NOT NULL DEFAULT 0,
+        importance     DOUBLE PRECISION NOT NULL DEFAULT 1.0,
+        superseded_by  TEXT,
+        contradicted_by TEXT,
+        embedding      vector(${this._embeddingDim}),
+        metadata       JSONB NOT NULL DEFAULT '{}',
+        linked_ids     JSONB NOT NULL DEFAULT '[]',
+        agent_id       TEXT NOT NULL DEFAULT 'default',
+        shared         BOOLEAN NOT NULL DEFAULT FALSE
+      )
+    `);
+        await this._query(`
+      CREATE TABLE IF NOT EXISTS edges (
+        source_id  TEXT NOT NULL REFERENCES memories(id) ON DELETE CASCADE,
+        target_id  TEXT NOT NULL REFERENCES memories(id) ON DELETE CASCADE,
+        relation   TEXT NOT NULL,
+        weight     DOUBLE PRECISION NOT NULL DEFAULT 1.0,
+        created_at TIMESTAMPTZ NOT NULL,
+        PRIMARY KEY (source_id, target_id, relation)
+      )
+    `);
+        await this._query(`
+      CREATE TABLE IF NOT EXISTS meta (
+        key   TEXT PRIMARY KEY,
+        value TEXT NOT NULL
+      )
+    `);
+        await this._migrateColumns();
+        await this._query(
+          "CREATE INDEX IF NOT EXISTS idx_memories_agent_id ON memories (agent_id)"
+        );
+        await this._query(
+          "CREATE INDEX IF NOT EXISTS idx_memories_tier ON memories (tier)"
+        );
+        await this._query(
+          "CREATE INDEX IF NOT EXISTS idx_memories_created_at ON memories (created_at)"
+        );
+        await this._query(
+          "CREATE INDEX IF NOT EXISTS idx_edges_source ON edges (source_id)"
+        );
+        await this._query(
+          "CREATE INDEX IF NOT EXISTS idx_edges_target ON edges (target_id)"
+        );
+        await this._query(
+          "CREATE INDEX IF NOT EXISTS idx_memories_shared ON memories (shared) WHERE shared = TRUE"
+        );
+        try {
+          await this._query(`
+        CREATE INDEX IF NOT EXISTS idx_memories_embedding_hnsw
+        ON memories USING hnsw (embedding vector_cosine_ops)
+        WITH (m = 16, ef_construction = 64)
+      `);
+        } catch {
+        }
+      }
+      async _migrateColumns() {
+        await this._query(
+          "ALTER TABLE memories ADD COLUMN IF NOT EXISTS agent_id TEXT NOT NULL DEFAULT 'default'"
+        );
+        await this._query(
+          "ALTER TABLE memories ADD COLUMN IF NOT EXISTS shared BOOLEAN NOT NULL DEFAULT FALSE"
+        );
+        await this._query(
+          "ALTER TABLE memories ADD COLUMN IF NOT EXISTS contradicted_by TEXT"
+        );
+        await this._query(
+          "UPDATE memories SET contradicted_by = metadata->>'contradicted_by' WHERE contradicted_by IS NULL AND metadata->>'contradicted_by' IS NOT NULL"
+        );
+        for (const col of ["source_id", "target_id"]) {
+          const name = `edges_${col}_fkey`;
+          try {
+            await this._query(
+              `ALTER TABLE edges ADD CONSTRAINT ${name} FOREIGN KEY (${col}) REFERENCES memories(id) ON DELETE CASCADE`
+            );
+          } catch (err) {
+            const code = err.code;
+            if (code !== "42710") throw err;
+          }
+        }
+      }
+      async close() {
+        if (this._pool) {
+          await this._pool.end();
+          this._pool = null;
+          this._pgvectorRegistered = false;
+        }
+      }
+      async save(memory) {
+        await this._query(
+          `INSERT INTO memories
+       (id, content, tier, source, actor, session_id, created_at,
+        last_accessed, access_count, importance, superseded_by,
+        contradicted_by, embedding, metadata, linked_ids, agent_id, shared)
+       VALUES ($1, $2, $3, $4, $5, $6, $7, $8, $9, $10, $11, $12, $13::vector, $14, $15, $16, $17)
+       ON CONFLICT (id) DO UPDATE SET
+        content = EXCLUDED.content,
+        tier = EXCLUDED.tier,
+        source = EXCLUDED.source,
+        actor = EXCLUDED.actor,
+        session_id = EXCLUDED.session_id,
+        last_accessed = EXCLUDED.last_accessed,
+        access_count = EXCLUDED.access_count,
+        importance = EXCLUDED.importance,
+        superseded_by = EXCLUDED.superseded_by,
+        contradicted_by = EXCLUDED.contradicted_by,
+        embedding = EXCLUDED.embedding,
+        metadata = EXCLUDED.metadata,
+        linked_ids = EXCLUDED.linked_ids,
+        agent_id = EXCLUDED.agent_id,
+        shared = EXCLUDED.shared`,
+          [
+            memory.id,
+            memory.content,
+            memory.tierName,
+            memory.source,
+            memory.actor,
+            memory.sessionId,
+            memory.createdAt.toISOString(),
+            memory.lastAccessedAt.toISOString(),
+            memory.accessCount,
+            memory.importance,
+            memory.supersededBy,
+            memory.contradictedBy ?? null,
+            memory.embedding ? `[${memory.embedding.join(",")}]` : null,
+            JSON.stringify(memory.metadata),
+            JSON.stringify(memory.linkedIds),
+            memory.agentId,
+            memory.shared
+          ]
+        );
+      }
+      async get(memoryId) {
+        const result = await this._query(
+          "SELECT * FROM memories WHERE id = $1",
+          [memoryId]
+        );
+        if (result.rows.length === 0) return null;
+        return rowToMemory2(result.rows[0]);
+      }
+      async listAll(options) {
+        const clauses = [];
+        const params = [];
+        let paramIdx = 1;
+        if (options?.agentId) {
+          if (options.includeShared === false) {
+            clauses.push(`agent_id = $${paramIdx}`);
+            params.push(options.agentId);
+            paramIdx++;
+          } else {
+            clauses.push(`(agent_id = $${paramIdx} OR shared = TRUE)`);
+            params.push(options.agentId);
+            paramIdx++;
+          }
+        }
+        if (options?.tier != null) {
+          clauses.push(`tier = $${paramIdx}`);
+          params.push(options.tier);
+          paramIdx++;
+        }
+        const where = clauses.length > 0 ? ` WHERE ${clauses.join(" AND ")}` : "";
+        let limitClause = "";
+        if (options?.limit != null) {
+          limitClause = ` LIMIT $${paramIdx}`;
+          params.push(options.limit);
+          paramIdx++;
+        }
+        const result = await this._query(
+          `SELECT * FROM memories${where}${limitClause}`,
+          params
+        );
+        return result.rows.map(rowToMemory2);
+      }
+      async delete(memoryId) {
+        await this._query("DELETE FROM memories WHERE id = $1", [memoryId]);
+      }
+      async deleteOlderThan(ageMs, tier, options) {
+        const cutoff = new Date(Date.now() - ageMs).toISOString();
+        const conditions = ["created_at < $1"];
+        const params = [cutoff];
+        let paramIdx = 2;
+        if (tier != null) {
+          conditions.push(`tier = $${paramIdx}`);
+          params.push(tier);
+          paramIdx++;
+        }
+        if (options?.agentId) {
+          conditions.push(`agent_id = $${paramIdx}`);
+          params.push(options.agentId);
+          paramIdx++;
+        }
+        const where = conditions.join(" AND ");
+        const result = await this._query(
+          `DELETE FROM memories WHERE ${where}`,
+          params
+        );
+        return result.rowCount ?? 0;
+      }
+      async saveEdge(edge) {
+        await this._query(
+          `INSERT INTO edges (source_id, target_id, relation, weight, created_at)
+       VALUES ($1, $2, $3, $4, $5)
+       ON CONFLICT (source_id, target_id, relation) DO UPDATE SET
+        weight = EXCLUDED.weight,
+        created_at = EXCLUDED.created_at`,
+          [
+            edge.sourceId,
+            edge.targetId,
+            edge.relation,
+            edge.weight,
+            edge.createdAt.toISOString()
+          ]
+        );
+      }
+      async getEdges(memoryId) {
+        const result = await this._query(
+          "SELECT * FROM edges WHERE source_id = $1 OR target_id = $1",
+          [memoryId]
+        );
+        return result.rows.map(
+          (r) => ({
+            sourceId: r["source_id"],
+            targetId: r["target_id"],
+            relation: r["relation"],
+            weight: r["weight"],
+            createdAt: new Date(r["created_at"])
+          })
+        );
+      }
+      async searchByEmbedding(embedding, limit = 50, options) {
+        try {
+          const embeddingStr = `[${embedding.join(",")}]`;
+          if (options?.agentId) {
+            const result2 = await this._query(
+              `SELECT * FROM memories
+           WHERE (agent_id = $1 OR shared = TRUE) AND embedding IS NOT NULL
+           ORDER BY embedding <=> $2::vector
+           LIMIT $3`,
+              [options.agentId, embeddingStr, limit]
+            );
+            return result2.rows.map(rowToMemory2);
+          }
+          const result = await this._query(
+            `SELECT * FROM memories
+         WHERE embedding IS NOT NULL
+         ORDER BY embedding <=> $1::vector
+         LIMIT $2`,
+            [embeddingStr, limit]
+          );
+          return result.rows.map(rowToMemory2);
+        } catch (err) {
+          const msg = err instanceof Error ? err.message : String(err);
+          if (msg.includes("operator") || msg.includes("vector") || msg.includes("does not exist")) {
+            const all = await this.listAll(options);
+            return bruteForceCosineSearch(all, embedding, limit);
+          }
+          throw err;
+        }
+      }
+      async findSimilarPairs(options) {
+        const threshold = options?.threshold ?? 0.7;
+        const maxCandidates = options?.maxCandidates ?? 1e3;
+        const maxNeighbors = options?.maxNeighborsPerCandidate ?? 50;
+        const distanceThreshold = 1 - threshold;
+        const conditions = ["embedding IS NOT NULL"];
+        const params = [];
+        let paramIdx = 1;
+        if (options?.agentId) {
+          conditions.push(`agent_id = $${paramIdx}`);
+          params.push(options.agentId);
+          paramIdx++;
+        }
+        if (options?.tier != null) {
+          conditions.push(`tier = $${paramIdx}`);
+          params.push(options.tier);
+          paramIdx++;
+        }
+        params.push(maxCandidates);
+        const limitIdx = paramIdx++;
+        params.push(distanceThreshold);
+        const distIdx = paramIdx++;
+        params.push(threshold);
+        const simIdx = paramIdx++;
+        params.push(maxNeighbors);
+        const neighborLimitIdx = paramIdx++;
+        const where = conditions.join(" AND ");
+        const sql = `
+      WITH candidates AS (
+          SELECT id, embedding
+          FROM memories
+          WHERE ${where}
+          LIMIT $${limitIdx}
+      )
+      SELECT c1.id AS id_a, c2_sub.id AS id_b, c2_sub.sim AS similarity
+      FROM candidates c1
+      CROSS JOIN LATERAL (
+          SELECT c2.id, 1.0 - (c1.embedding <=> c2.embedding) AS sim
+          FROM candidates c2
+          WHERE c2.id > c1.id
+            AND c1.embedding <=> c2.embedding <= $${distIdx}
+          ORDER BY c1.embedding <=> c2.embedding
+          LIMIT $${neighborLimitIdx}
+      ) c2_sub
+      WHERE c2_sub.sim >= $${simIdx}
+    `;
+        try {
+          const result = await this._query(sql, params);
+          return result.rows.map(
+            (r) => ({
+              idA: r["id_a"],
+              idB: r["id_b"],
+              similarity: r["similarity"]
+            })
+          );
+        } catch (err) {
+          const msg = err instanceof Error ? err.message : String(err);
+          if (msg.includes("operator") || msg.includes("vector") || msg.includes("does not exist")) {
+            const all = await this.listAll({
+              agentId: options?.agentId,
+              includeShared: false,
+              tier: options?.tier,
+              limit: maxCandidates
+            });
+            return bruteForceSimilarPairs(all, threshold, maxCandidates);
+          }
+          throw err;
+        }
+      }
+      async getMeta(key) {
+        const result = await this._query(
+          "SELECT value FROM meta WHERE key = $1",
+          [key]
+        );
+        return result.rows.length > 0 ? result.rows[0].value : null;
+      }
+      async setMeta(key, value) {
+        await this._query(
+          `INSERT INTO meta (key, value) VALUES ($1, $2)
+       ON CONFLICT (key) DO UPDATE SET value = EXCLUDED.value`,
+          [key, value]
+        );
+      }
+    };
+  }
+});
+
+// src/client.ts
+var import_node_crypto2 = require("crypto");
+
+// src/core/config.ts
+function createDefaultScorerConfig() {
+  return {
+    weightRecency: 0.4,
+    weightFrequency: 0.25,
+    weightLinks: 0.2,
+    weightBase: 0.15,
+    frequencyLogCap: 5,
+    linkSaturation: 5,
+    supersessionPenalty: 0.1,
+    contradictionPenalty: 0.5,
+    consolidationPenalty: 0.5,
+    tierBaseScores: {
+      identity: 1,
+      procedural: 0.9,
+      structural: 0.8,
+      episodic: 0.5,
+      transient: 0.2
+    }
+  };
+}
+function createDefaultClassifierConfig() {
+  return {
+    extraPatterns: {},
+    episodicMinWords: 10,
+    customClassifier: null
+  };
+}
+function createDefaultLinkerConfig() {
+  return {
+    similarityThreshold: 0.65,
+    maxLinks: 10,
+    keywordPenalty: 0.8,
+    contradictionThreshold: 0.7,
+    elaborationThreshold: 0.85,
+    supersessionThreshold: 0.8,
+    negationWords: /* @__PURE__ */ new Set([
+      "not",
+      "never",
+      "don't",
+      "doesn't",
+      "isn't",
+      "aren't",
+      "won't",
+      "no"
+    ]),
+    customRelationFn: null
+  };
+}
+function createDefaultAssemblerConfig() {
+  return {
+    defaultMaxTokens: 3e3,
+    diversityStrength: 0.3,
+    sortOrder: "chronological",
+    minRelevance: 0.25
+  };
+}
+function createDefaultConsolidationConfig() {
+  return {
+    minClusterSize: 3,
+    similarityThreshold: 0.7,
+    maxContentLength: 2e3,
+    prefix: "[Consolidated]",
+    sourceName: "consolidation",
+    actorName: "system",
+    maxCandidates: 1e3,
+    maxNeighborsPerCandidate: 50
+  };
+}
+function createDefaultPromotionConfig() {
+  return {
+    transientToEpisodicAccesses: 2,
+    episodicToStructuralAccesses: 5,
+    structuralToIdentityAccesses: 15,
+    proceduralToIdentityAccesses: 25,
+    demotionImportanceThreshold: 0.1
+  };
+}
+var SalienceSignal = class {
+  name;
+  patterns;
+  boost;
+  _compiled;
+  constructor(name, patterns, boost) {
+    this.name = name;
+    this.patterns = patterns;
+    this.boost = boost;
+    this._compiled = patterns.map((p) => new RegExp(p, "i"));
+  }
+  scan(text) {
+    return this._compiled.some((re) => re.test(text));
+  }
+};
+var BUILTIN_SALIENCE_SIGNALS = [
+  new SalienceSignal("error", [
+    "\\b(?:error|exception|traceback|stack\\s*trace|segfault|panic|crash)\\b",
+    "\\b(?:failed|failure|broken|bug|regression)\\b",
+    "\\b(?:404|500|502|503|ECONNREFUSED|OOM|timeout)\\b"
+  ], 0.15),
+  new SalienceSignal("urgency", [
+    "\\b(?:urgent|critical|blocker|p0|p1|sev[- ]?[01]|outage|incident)\\b",
+    "\\b(?:ASAP|immediately|right now|emergency)\\b",
+    "\\b(?:production is down|prod is down|site is down)\\b"
+  ], 0.25),
+  new SalienceSignal("correction", [
+    "\\b(?:actually|correction|i was wrong|that's wrong|that's not right)\\b",
+    "\\b(?:let me correct|i meant|i misspoke|sorry,? i meant)\\b",
+    "\\b(?:no,? (?:it's|it is|that's|that is)|wait,? (?:no|actually))\\b"
+  ], 0.2),
+  new SalienceSignal("decision", [
+    "\\b(?:we've decided|final decision|going with|approved|sign[- ]?off)\\b",
+    "\\b(?:agreement|consensus|resolved to|committed to)\\b",
+    "\\b(?:from now on|henceforth|going forward)\\b"
+  ], 0.15),
+  new SalienceSignal("frustration", [
+    "\\b(?:i(?:'ve| have) told you|already said|keep telling you)\\b",
+    "\\b(?:again\\?|how many times|stop (?:doing|suggesting))\\b",
+    "\\b(?:this is (?:wrong|bad|terrible|awful)|doesn't work)\\b"
+  ], 0.2)
+];
+function createDefaultSalienceConfig() {
+  return {
+    enabled: true,
+    maxBoost: 0.4,
+    signals: [...BUILTIN_SALIENCE_SIGNALS]
+  };
+}
+var BUILTIN_TIERS = [
+  { name: "identity", defaultHalfLifeDays: 3650, description: "Name, role, company, tech stack \u2014 near-permanent" },
+  { name: "procedural", defaultHalfLifeDays: 365, description: "Learned workflows, multi-step procedures, how-to knowledge" },
+  { name: "structural", defaultHalfLifeDays: 180, description: "Architecture decisions, preferences, constraints" },
+  { name: "episodic", defaultHalfLifeDays: 30, description: "Specific conversations, tasks completed" },
+  { name: "transient", defaultHalfLifeDays: 7, description: "One-off questions, small talk" }
+];
+var MnemonicConfig = class {
+  scorer;
+  classifier;
+  linker;
+  assembler;
+  consolidation;
+  promotion;
+  salience;
+  charsPerToken;
+  defaultTier;
+  embeddingSearchLimit;
+  _tiers;
+  constructor(overrides) {
+    this.scorer = { ...createDefaultScorerConfig(), ...overrides?.scorer };
+    this.classifier = { ...createDefaultClassifierConfig(), ...overrides?.classifier };
+    this.linker = { ...createDefaultLinkerConfig(), ...overrides?.linker };
+    this.assembler = { ...createDefaultAssemblerConfig(), ...overrides?.assembler };
+    this.consolidation = { ...createDefaultConsolidationConfig(), ...overrides?.consolidation };
+    this.promotion = { ...createDefaultPromotionConfig(), ...overrides?.promotion };
+    this.salience = { ...createDefaultSalienceConfig(), ...overrides?.salience };
+    this.charsPerToken = overrides?.charsPerToken ?? 4;
+    this.defaultTier = overrides?.defaultTier ?? "episodic";
+    this.embeddingSearchLimit = overrides?.embeddingSearchLimit ?? 100;
+    if (this.consolidation.maxCandidates < 1) {
+      throw new Error(`maxCandidates must be >= 1, got ${this.consolidation.maxCandidates}`);
+    }
+    if (this.consolidation.maxNeighborsPerCandidate < 1) {
+      throw new Error(
+        `maxNeighborsPerCandidate must be >= 1, got ${this.consolidation.maxNeighborsPerCandidate}`
+      );
+    }
+    this._tiers = /* @__PURE__ */ new Map();
+    for (const td of BUILTIN_TIERS) {
+      this._tiers.set(td.name, td);
+    }
+  }
+  registerTier(tier) {
+    this._tiers.set(tier.name, tier);
+    if (!(tier.name in this.scorer.tierBaseScores)) {
+      this.scorer.tierBaseScores[tier.name] = 0.5;
+    }
+  }
+  getTier(name) {
+    const td = this._tiers.get(name);
+    if (!td) throw new Error(`Unknown tier: '${name}'`);
+    return td;
+  }
+  tierNames() {
+    return [...this._tiers.keys()];
+  }
+  halfLifeDays(tierName) {
+    return this.getTier(tierName).defaultHalfLifeDays;
+  }
+};
+
+// src/core/classifier.ts
+var IDENTITY_PATTERNS = [
+  /\bmy name is\b/i,
+  /\bi(?:'m| am) (?:a |an )?(?:software|data|ml|backend|frontend|devops|platform)\b/i,
+  /\bi work (?:at|for)\b/i,
+  /\bmy (?:role|title|position) is\b/i,
+  /\bour (?:tech |technology )?stack (?:is|includes)\b/i,
+  /\bi (?:use|prefer|always use)\b.+(?:language|framework|editor|ide|os)\b/i
+];
+var PROCEDURAL_PATTERNS = [
+  /\b(?:step\s+\d|first|then|next|finally|afterwards)\b.*\b(?:step|run|execute|do|click|open|type|enter)\b/i,
+  /\bto\s+(?:do|deploy|set up|configure|install|build|run|create|fix)\b.+\b(?:first|then|after|before|finally)\b/i,
+  /\bworkflow\b.*\b(?:is|goes|looks like|involves)\b/i,
+  /\bprocedure\b.*\b(?:is|for|to)\b/i,
+  /\bwhen(?:ever)?\b.+\b(?:always|you should|we|i) (?:run|do|execute|call|use)\b/i,
+  /\brecipe\b.*\bfor\b/i,
+  /\brunbook\b/i
+];
+var STRUCTURAL_PATTERNS = [
+  /\bwe (?:decided|chose|agreed) to\b/i,
+  /\barchitectur(?:e|al)\b/i,
+  /\bconstraint\b/i,
+  /\brequirement\b/i,
+  /\bprefer(?:s|ence)?\b.+(?:over|instead|rather)\b/i,
+  /\balways\b.+\b(?:use|deploy|run)\b/i,
+  /\bnever\b.+\b(?:use|deploy|run)\b/i,
+  /\bstandard(?:s|ise|ize)?\b/i,
+  /\bconvention\b/i
+];
+var TRANSIENT_PATTERNS = [
+  /\b(?:hey|hi|hello|thanks|thank you|cheers|bye|goodbye)\b/i,
+  /\bwhat(?:'s| is) the (?:time|date|weather)\b/i,
+  /\bjust (?:a )?quick\b/i,
+  /\bnever ?mind\b/i
+];
+var COMPILED_DEFAULTS = [
+  ["identity", IDENTITY_PATTERNS],
+  ["procedural", PROCEDURAL_PATTERNS],
+  ["structural", STRUCTURAL_PATTERNS],
+  ["transient", TRANSIENT_PATTERNS]
+];
+function buildTierPatterns(cfg) {
+  if (Object.keys(cfg.extraPatterns).length === 0) {
+    return COMPILED_DEFAULTS;
+  }
+  return COMPILED_DEFAULTS.map(([name, compiled]) => {
+    const extra = (cfg.extraPatterns[name] ?? []).map((p) => new RegExp(p, "i"));
+    return [name, [...compiled, ...extra]];
+  });
+}
+function classify(content, options) {
+  const config = options?.config ?? new MnemonicConfig();
+  const cfg = config.classifier;
+  const actor = options?.actor ?? "";
+  if (cfg.customClassifier) {
+    return cfg.customClassifier(content, options?.source ?? "", actor);
+  }
+  for (const [tierName, patterns] of buildTierPatterns(cfg)) {
+    for (const pat of patterns) {
+      if (pat.test(content)) {
+        return tierName;
+      }
+    }
+  }
+  if (actor === "user" && content.split(/\s+/).length > cfg.episodicMinWords) {
+    return "episodic";
+  }
+  return config.defaultTier;
+}
+
+// src/core/scorer.ts
+function recencyFactor(memory, halfLifeDays) {
+  const now = Date.now();
+  const elapsedDays = Math.max(0, (now - memory.lastAccessedAt.getTime()) / 864e5);
+  return Math.pow(0.5, elapsedDays / halfLifeDays);
+}
+function frequencyFactor(memory, logCap) {
+  if (logCap <= 0) return 1;
+  return Math.min(1, Math.log2(1 + memory.accessCount) / logCap);
+}
+function linkFactor(memory, saturation) {
+  return Math.min(1, memory.linkedIds.length / saturation);
+}
+function score(memory, config) {
+  const cfg = config ?? new MnemonicConfig();
+  const sc = cfg.scorer;
+  const tierName = memory.tierName;
+  let halfLife;
+  try {
+    halfLife = cfg.halfLifeDays(tierName);
+  } catch {
+    halfLife = 30;
+  }
+  const base = sc.tierBaseScores[tierName] ?? 0.5;
+  const composite = sc.weightRecency * recencyFactor(memory, halfLife) + sc.weightFrequency * frequencyFactor(memory, sc.frequencyLogCap) + sc.weightLinks * linkFactor(memory, sc.linkSaturation) + sc.weightBase * base;
+  const boost = memory.metadata["boost"] ?? 0;
+  let result = Math.max(0, composite + boost);
+  if (memory.supersededBy != null) {
+    result *= Math.min(1, Math.max(0, sc.supersessionPenalty));
+  }
+  if (memory.supersededBy == null && memory.contradictedBy != null) {
+    result *= Math.min(1, Math.max(0, sc.contradictionPenalty));
+  }
+  if (memory.metadata["consolidated_into"] != null) {
+    result *= Math.min(1, Math.max(0, sc.consolidationPenalty));
+  }
+  return result;
+}
+
+// src/core/linker.ts
+init_memory();
+init_utils();
+var NUMBER_RE = /\b\d+(?:[.,]\d+)*/g;
+var CORRECTION_RE = /\b(?:correction|actually|i was wrong|that was wrong|that's wrong|that's not right)\b|\b(?:that isn't right|that isn't correct)\b|\b(?:let me correct|i meant|i misspoke|sorry,? i meant)\b|\b(?:no,? (?:it's|it is|that's|that is)|wait,? (?:no|actually))\b|\b(?:disregard|ignore what i said|scratch that|on second thought)\b/i;
+function keywordOverlap(a, b) {
+  const sa = new Set(a.toLowerCase().split(/\s+/));
+  const sb = new Set(b.toLowerCase().split(/\s+/));
+  if (sa.size === 0 || sb.size === 0) return 0;
+  let intersection = 0;
+  for (const word of sa) {
+    if (sb.has(word)) intersection++;
+  }
+  const union = (/* @__PURE__ */ new Set([...sa, ...sb])).size;
+  return intersection / union;
+}
+function extractNumbers(text) {
+  return new Set(text.match(NUMBER_RE) ?? []);
+}
+function hasNumberDisagreement(a, b) {
+  const aNums = extractNumbers(a);
+  const bNums = extractNumbers(b);
+  if (aNums.size === 0 || bNums.size === 0) return false;
+  if (aNums.size !== bNums.size) return true;
+  for (const n of aNums) {
+    if (!bNums.has(n)) return true;
+  }
+  return false;
+}
+function hasCorrectionSignal(text) {
+  return CORRECTION_RE.test(text);
+}
+function inferRelation(a, b, similarity, cfg) {
+  if (cfg.customRelationFn) {
+    return cfg.customRelationFn(a, b, similarity);
+  }
+  const aWords = new Set(a.content.toLowerCase().split(/\s+/));
+  const bWords = new Set(b.content.toLowerCase().split(/\s+/));
+  const hasNegation = [...aWords].some((w) => cfg.negationWords.has(w)) !== [...bWords].some((w) => cfg.negationWords.has(w));
+  const hasNumbers = hasNumberDisagreement(a.content, b.content);
+  const hasCorrection = hasCorrectionSignal(a.content) || hasCorrectionSignal(b.content);
+  const hasContradiction = (hasNegation || hasNumbers || hasCorrection) && similarity > cfg.contradictionThreshold;
+  if (hasContradiction && a.createdAt > b.createdAt) {
+    if (hasNumbers || hasCorrection || similarity > cfg.supersessionThreshold) {
+      return "supersedes";
+    }
+  }
+  if (hasContradiction) return "contradicts";
+  if (similarity > cfg.elaborationThreshold) return "elaborates";
+  return "related_to";
+}
+function findLinks(newMemory, existing, options) {
+  const cfg = (options?.config ?? new MnemonicConfig()).linker;
+  const threshold = options?.similarityThreshold ?? cfg.similarityThreshold;
+  const limit = options?.maxLinks ?? cfg.maxLinks;
+  const others = existing.filter((m) => m.id !== newMemory.id);
+  if (others.length === 0) return [];
+  const scored = [];
+  if (newMemory.embedding) {
+    const withEmb = others.filter((m) => m.embedding != null);
+    const withoutEmb = others.filter((m) => m.embedding == null);
+    if (withEmb.length > 0) {
+      const embList = withEmb.map((m) => m.embedding);
+      const sims = cosineSimilarityVector(newMemory.embedding, embList);
+      for (let i = 0; i < withEmb.length; i++) {
+        if (sims[i] >= threshold) {
+          scored.push([sims[i], withEmb[i]]);
+        }
+      }
+    }
+    for (const mem of withoutEmb) {
+      const sim = keywordOverlap(newMemory.content, mem.content) * cfg.keywordPenalty;
+      if (sim >= threshold) scored.push([sim, mem]);
+    }
+  } else {
+    for (const mem of others) {
+      const sim = keywordOverlap(newMemory.content, mem.content) * cfg.keywordPenalty;
+      if (sim >= threshold) scored.push([sim, mem]);
+    }
+  }
+  scored.sort((a, b) => b[0] - a[0]);
+  return scored.slice(0, limit).map(([sim, mem]) => {
+    const relation = inferRelation(newMemory, mem, sim, cfg);
+    return createEdge(newMemory.id, mem.id, relation, sim);
+  });
+}
+
+// src/core/assembler.ts
+init_utils();
+function getSortFn(sortOrder) {
+  if (typeof sortOrder === "function") return sortOrder;
+  if (sortOrder === "importance") return (a, b) => b.importance - a.importance;
+  if (sortOrder === "relevance") return () => 0;
+  return (a, b) => a.createdAt.getTime() - b.createdAt.getTime();
+}
+function assemble(_query, candidates, options) {
+  const config = options?.config ?? new MnemonicConfig();
+  const cfg = config.assembler;
+  const budget = options?.maxTokens ?? cfg.defaultMaxTokens;
+  const divStrength = options?.diversityStrength ?? cfg.diversityStrength;
+  const relevanceFloor = options?.minRelevance ?? cfg.minRelevance;
+  const qEmbed = options?.queryEmbedding ?? null;
+  let n = candidates.length;
+  if (n === 0) return [];
+  let importances = new Float64Array(n);
+  for (let i = 0; i < n; i++) {
+    importances[i] = score(candidates[i], config);
+  }
+  let embIndices = [];
+  for (let i = 0; i < n; i++) {
+    if (candidates[i].embedding) embIndices.push(i);
+  }
+  let relevances = new Float64Array(n);
+  for (let i = 0; i < n; i++) {
+    relevances[i] = keywordOverlap(_query, candidates[i].content);
+  }
+  if (qEmbed && embIndices.length > 0) {
+    const embList = embIndices.map((i) => candidates[i].embedding);
+    const sims = cosineSimilarityVector(qEmbed, embList);
+    for (let pos = 0; pos < embIndices.length; pos++) {
+      const idx = embIndices[pos];
+      relevances[idx] = Math.max(Math.max(0, sims[pos]), relevances[idx]);
+    }
+  }
+  if (relevanceFloor > 0) {
+    const keep = [];
+    for (let i = 0; i < n; i++) {
+      if (relevances[i] >= relevanceFloor) keep.push(i);
+    }
+    if (keep.length < n) {
+      const oldToNew = /* @__PURE__ */ new Map();
+      keep.forEach((old, idx) => oldToNew.set(old, idx));
+      candidates = keep.map((i) => candidates[i]);
+      importances = Float64Array.from(keep.map((i) => importances[i]));
+      relevances = Float64Array.from(keep.map((i) => relevances[i]));
+      embIndices = embIndices.filter((i) => oldToNew.has(i)).map((i) => oldToNew.get(i));
+      n = candidates.length;
+    }
+  }
+  let simMatrix = null;
+  const idxToPos = /* @__PURE__ */ new Map();
+  if (embIndices.length > 0 && divStrength > 0) {
+    const embList = embIndices.map((i) => candidates[i].embedding);
+    simMatrix = cosineSimilarityMatrix(embList);
+    for (let pos = 0; pos < embIndices.length; pos++) {
+      idxToPos.set(embIndices[pos], pos);
+    }
+  }
+  const nEmb = embIndices.length;
+  const remaining = Array.from({ length: n }, (_, i) => i);
+  const selectedEmbPositions = [];
+  const selectedIndices = [];
+  let budgetLeft = budget;
+  while (remaining.length > 0 && budgetLeft > 0) {
+    let bestRi = -1;
+    let bestValue = -1;
+    for (let ri = 0; ri < remaining.length; ri++) {
+      const ci = remaining[ri];
+      if (candidates[ci].tokenEstimate > budgetLeft) continue;
+      let value = relevances[ci] * importances[ci];
+      if (selectedEmbPositions.length > 0 && simMatrix && idxToPos.has(ci)) {
+        const pos = idxToPos.get(ci);
+        let maxSim = 0;
+        for (const sp of selectedEmbPositions) {
+          const s = simMatrix[pos * nEmb + sp];
+          if (s > maxSim) maxSim = s;
+        }
+        value *= Math.min(1, Math.max(0, 1 - divStrength * maxSim));
+      }
+      if (value > bestValue) {
+        bestValue = value;
+        bestRi = ri;
+      }
+    }
+    if (bestRi < 0) break;
+    const chosenIdx = remaining.splice(bestRi, 1)[0];
+    candidates[chosenIdx].touch();
+    selectedIndices.push(chosenIdx);
+    if (idxToPos.has(chosenIdx)) {
+      selectedEmbPositions.push(idxToPos.get(chosenIdx));
+    }
+    budgetLeft -= candidates[chosenIdx].tokenEstimate;
+  }
+  const selected = selectedIndices.map((i) => candidates[i]);
+  selected.sort(getSortFn(cfg.sortOrder));
+  return selected;
+}
+function detectConflicts(memories, config) {
+  const cfg = config ?? new MnemonicConfig();
+  const negWords = cfg.linker.negationWords;
+  const conflicts = [];
+  const seenPairs = /* @__PURE__ */ new Set();
+  const n = memories.length;
+  const pairKey = (a, b) => `${Math.min(a, b)},${Math.max(a, b)}`;
+  const idToIdx = /* @__PURE__ */ new Map();
+  for (let i = 0; i < n; i++) idToIdx.set(memories[i].id, i);
+  for (let i = 0; i < n; i++) {
+    const mem = memories[i];
+    if (mem.contradictedBy && idToIdx.has(mem.contradictedBy)) {
+      const j = idToIdx.get(mem.contradictedBy);
+      const key = pairKey(i, j);
+      if (!seenPairs.has(key)) {
+        seenPairs.add(key);
+        conflicts.push([Math.min(i, j), Math.max(i, j), "contradicted by newer memory"]);
+      }
+    }
+  }
+  for (let i = 0; i < n; i++) {
+    for (let j = i + 1; j < n; j++) {
+      const key = pairKey(i, j);
+      if (seenPairs.has(key)) continue;
+      const a = memories[i], b = memories[j];
+      const kwSim = keywordOverlap(a.content, b.content);
+      let embSim = 0;
+      if (a.embedding && b.embedding) {
+        const sims = cosineSimilarityVector(a.embedding, [b.embedding]);
+        embSim = sims[0];
+      }
+      const maxSim = Math.max(kwSim, embSim);
+      if (maxSim < 0.6) continue;
+      if (hasNumberDisagreement(a.content, b.content)) {
+        conflicts.push([i, j, "numbers differ on similar topic"]);
+        seenPairs.add(key);
+      } else if (hasCorrectionSignal(a.content) || hasCorrectionSignal(b.content)) {
+        conflicts.push([i, j, "correction language detected"]);
+        seenPairs.add(key);
+      } else if (maxSim > 0.8) {
+        const aWords = new Set(a.content.toLowerCase().split(/\s+/));
+        const bWords = new Set(b.content.toLowerCase().split(/\s+/));
+        const aNeg = [...aWords].some((w) => negWords.has(w));
+        const bNeg = [...bWords].some((w) => negWords.has(w));
+        if (aNeg !== bNeg) {
+          conflicts.push([i, j, "contradictory statements"]);
+          seenPairs.add(key);
+        }
+      }
+    }
+  }
+  return conflicts;
+}
+function formatContext(memories, header = "Relevant context:", conflicts) {
+  if (memories.length === 0) return "";
+  const lines = [header, ""];
+  for (const mem of memories) {
+    lines.push(`- [${mem.tierName}] ${mem.content}`);
+  }
+  if (conflicts && conflicts.length > 0) {
+    lines.push("");
+    for (const [idxA, idxB, reason] of conflicts) {
+      lines.push(`[!] Potential conflict between items ${idxA + 1} and ${idxB + 1}: ${reason}`);
+    }
+  }
+  return lines.join("\n");
+}
+
+// src/client.ts
+init_memory();
+
+// src/core/promotion.ts
+var TIER_TRANSITIONS = {
+  transient: { promoteTo: "episodic", demoteTo: null, promoteThresholdKey: "transientToEpisodicAccesses" },
+  episodic: { promoteTo: "structural", demoteTo: "transient", promoteThresholdKey: "episodicToStructuralAccesses" },
+  structural: { promoteTo: "identity", demoteTo: "episodic", promoteThresholdKey: "structuralToIdentityAccesses" },
+  procedural: { promoteTo: "identity", demoteTo: "structural", promoteThresholdKey: "proceduralToIdentityAccesses" },
+  identity: { promoteTo: null, demoteTo: "structural", promoteThresholdKey: null }
+};
+function checkPromotions(memories, config) {
+  const cfg = (config ?? new MnemonicConfig()).promotion;
+  const results = [];
+  for (const mem of memories) {
+    const transition = TIER_TRANSITIONS[mem.tierName];
+    if (!transition?.promoteTo || !transition.promoteThresholdKey) continue;
+    const threshold = cfg[transition.promoteThresholdKey];
+    if (mem.accessCount >= threshold) {
+      results.push({
+        memoryId: mem.id,
+        oldTier: mem.tierName,
+        newTier: transition.promoteTo,
+        reason: `access_count (${mem.accessCount}) >= ${threshold}`
+      });
+    }
+  }
+  return results;
+}
+function checkDemotions(memories, config) {
+  const fullCfg = config ?? new MnemonicConfig();
+  const cfg = fullCfg.promotion;
+  const results = [];
+  for (const mem of memories) {
+    if (mem.supersededBy != null) continue;
+    const transition = TIER_TRANSITIONS[mem.tierName];
+    if (!transition?.demoteTo) continue;
+    const importance = score(mem, fullCfg);
+    if (importance < cfg.demotionImportanceThreshold) {
+      results.push({
+        memoryId: mem.id,
+        oldTier: mem.tierName,
+        newTier: transition.demoteTo,
+        reason: `importance (${importance.toFixed(4)}) < ${cfg.demotionImportanceThreshold}`
+      });
+    }
+  }
+  return results;
+}
+function applyTierChange(memory, newTier) {
+  const oldTier = memory.tierName;
+  const history = memory.metadata["previous_tiers"] ?? [];
+  history.push(oldTier);
+  memory.metadata["previous_tiers"] = history;
+  memory.tier = newTier;
+}
+
+// src/core/salience.ts
+function detectSalience(content, config) {
+  const cfg = config ?? createDefaultSalienceConfig();
+  if (!cfg.enabled) {
+    return { boost: 0, signals: [] };
+  }
+  let totalBoost = 0;
+  const fired = [];
+  for (const signal of cfg.signals) {
+    if (signal.scan(content)) {
+      totalBoost += signal.boost;
+      fired.push(signal.name);
+    }
+  }
+  return {
+    boost: Math.min(totalBoost, cfg.maxBoost),
+    signals: fired
+  };
+}
+
+// src/client.ts
+init_utils();
+
+// src/consolidation/engine.ts
+init_memory();
+init_utils();
+var TRANSIENT_ERRORS = /* @__PURE__ */ new Set([
+  "RateLimitError",
+  "APITimeoutError",
+  "APIConnectionTimeoutError",
+  // OpenAI Node SDK timeout subclass
+  "APIConnectionError",
+  "InternalServerError"
+]);
+function findConsolidationCandidates(memories, config, pairs) {
+  const cfg = (config ?? new MnemonicConfig()).consolidation;
+  const episodic = memories.filter(
+    (m) => m.tierName === "episodic" && m.embedding != null
+  );
+  if (episodic.length < cfg.minClusterSize) return [];
+  if (pairs != null) {
+    return clusterFromPairs(episodic, pairs, cfg.minClusterSize);
+  }
+  return clusterFromMatrix(episodic, cfg.similarityThreshold, cfg.minClusterSize);
+}
+function unionFindClusters(items, edges, minClusterSize) {
+  const n = items.length;
+  const parent = Array.from({ length: n }, (_, i) => i);
+  function find(x) {
+    while (parent[x] !== x) {
+      parent[x] = parent[parent[x]];
+      x = parent[x];
+    }
+    return x;
+  }
+  for (const [a, b] of edges) {
+    const ra = find(a);
+    const rb = find(b);
+    if (ra !== rb) parent[ra] = rb;
+  }
+  const clusters = /* @__PURE__ */ new Map();
+  for (let i = 0; i < n; i++) {
+    const root = find(i);
+    if (!clusters.has(root)) clusters.set(root, []);
+    clusters.get(root).push(items[i]);
+  }
+  return [...clusters.values()].filter((c) => c.length >= minClusterSize);
+}
+function clusterFromPairs(episodic, pairs, minClusterSize) {
+  const idToIdx = /* @__PURE__ */ new Map();
+  for (let i = 0; i < episodic.length; i++) {
+    idToIdx.set(episodic[i].id, i);
+  }
+  const edges = [];
+  for (const p of pairs) {
+    const ia = idToIdx.get(p.idA);
+    const ib = idToIdx.get(p.idB);
+    if (ia != null && ib != null) {
+      edges.push([ia, ib]);
+    }
+  }
+  return unionFindClusters(episodic, edges, minClusterSize);
+}
+function clusterFromMatrix(episodic, similarityThreshold, minClusterSize) {
+  const n = episodic.length;
+  const simMatrix = cosineSimilarityMatrix(episodic.map((m) => m.embedding));
+  const edges = [];
+  for (let i = 0; i < n; i++) {
+    for (let j = i + 1; j < n; j++) {
+      if (simMatrix[i * n + j] >= similarityThreshold) {
+        edges.push([i, j]);
+      }
+    }
+  }
+  return unionFindClusters(episodic, edges, minClusterSize);
+}
+function defaultJoin(cluster, maxLength) {
+  const sorted = [...cluster].sort(
+    (a, b) => b.createdAt.getTime() - a.createdAt.getTime()
+  );
+  const unique = [];
+  for (const mem of sorted) {
+    if (unique.some((prev) => keywordOverlap(mem.content, prev) > 0.8)) continue;
+    unique.push(mem.content);
+  }
+  const header = `(${cluster.length} memories, ${unique.length} unique)`;
+  let combined = header + "\n" + unique.join("\n");
+  if (combined.length > maxLength) {
+    combined = combined.slice(0, maxLength - 3) + "...";
+  }
+  return combined;
+}
+async function mergeCluster(cluster, config) {
+  const cfg = (config ?? new MnemonicConfig()).consolidation;
+  let combined;
+  if (cfg.summarizer != null) {
+    try {
+      combined = (await cfg.summarizer(cluster.map((m) => m.content))).trim();
+      if (!combined) {
+        throw new Error("Summarizer returned empty content");
+      }
+    } catch (err) {
+      const errName = err instanceof Error ? err.constructor.name : "";
+      if (TRANSIENT_ERRORS.has(errName)) {
+        throw err;
+      }
+      console.warn(`Summarizer failed permanently with ${errName}; falling back to default join`);
+      combined = defaultJoin(cluster, cfg.maxContentLength);
+    }
+    if (combined.length > cfg.maxContentLength) {
+      combined = combined.slice(0, cfg.maxContentLength - 3) + "...";
+    }
+  } else {
+    combined = defaultJoin(cluster, cfg.maxContentLength);
+  }
+  const summary = new Memory({
+    content: `${cfg.prefix} ${combined}`,
+    tier: "structural",
+    source: cfg.sourceName,
+    actor: cfg.actorName,
+    metadata: {
+      consolidated_from: cluster.map((m) => m.id),
+      original_count: cluster.length
+    }
+  });
+  summary.importance = Math.max(...cluster.map((m) => m.importance));
+  const linkedSet = new Set(cluster.flatMap((m) => m.linkedIds));
+  summary.linkedIds = [...linkedSet];
+  return summary;
+}
+
+// src/stores/sync-adapter.ts
+function syncToAsync(store) {
+  return {
+    async initialize() {
+      store.initialize();
+    },
+    async close() {
+      store.close();
+    },
+    async save(memory) {
+      store.save(memory);
+    },
+    async get(memoryId) {
+      return store.get(memoryId);
+    },
+    async listAll(options) {
+      return store.listAll(options);
+    },
+    async delete(memoryId) {
+      store.delete(memoryId);
+    },
+    async deleteOlderThan(ageMs, tier, options) {
+      return store.deleteOlderThan(ageMs, tier, options);
+    },
+    async saveEdge(edge) {
+      store.saveEdge(edge);
+    },
+    async getEdges(memoryId) {
+      return store.getEdges(memoryId);
+    },
+    async searchByEmbedding(embedding, limit, options) {
+      return store.searchByEmbedding(embedding, limit, options);
+    },
+    async findSimilarPairs(options) {
+      return store.findSimilarPairs(options);
+    },
+    async getMeta(key) {
+      return store.getMeta(key);
+    },
+    async setMeta(key, value) {
+      store.setMeta(key, value);
+    }
+  };
+}
+
+// src/stores/sqlite.ts
+var import_better_sqlite3 = __toESM(require("better-sqlite3"), 1);
+init_memory();
+init_utils();
+var SCHEMA = `
+CREATE TABLE IF NOT EXISTS memories (
+    id             TEXT PRIMARY KEY,
+    content        TEXT NOT NULL,
+    tier           TEXT NOT NULL,
+    source         TEXT NOT NULL DEFAULT 'unknown',
+    actor          TEXT NOT NULL DEFAULT 'system',
+    session_id     TEXT,
+    created_at     TEXT NOT NULL,
+    last_accessed  TEXT NOT NULL,
+    access_count   INTEGER NOT NULL DEFAULT 0,
+    importance     REAL NOT NULL DEFAULT 1.0,
+    superseded_by  TEXT,
+    contradicted_by TEXT,
+    embedding      TEXT,
+    metadata       TEXT NOT NULL DEFAULT '{}',
+    linked_ids     TEXT NOT NULL DEFAULT '[]',
+    agent_id       TEXT NOT NULL DEFAULT 'default',
+    shared         INTEGER NOT NULL DEFAULT 0
+);
+
+CREATE TABLE IF NOT EXISTS edges (
+    source_id  TEXT NOT NULL,
+    target_id  TEXT NOT NULL,
+    relation   TEXT NOT NULL,
+    weight     REAL NOT NULL DEFAULT 1.0,
+    created_at TEXT NOT NULL,
+    PRIMARY KEY (source_id, target_id, relation)
+);
+
+CREATE TABLE IF NOT EXISTS meta (
+    key   TEXT PRIMARY KEY,
+    value TEXT NOT NULL
+);
+
+CREATE INDEX IF NOT EXISTS idx_memories_agent_id ON memories (agent_id);
+`;
+var SQLiteStore = class {
+  _db;
+  constructor(path = "mnemonic.db") {
+    this._db = new import_better_sqlite3.default(path);
+    this._db.pragma("journal_mode = WAL");
+  }
+  initialize() {
+    this._db.exec(SCHEMA);
+    this._migrate();
+  }
+  close() {
+    this._db.close();
+  }
+  /** Add missing columns/tables for stores created before multi-agent support. */
+  _migrate() {
+    const cols = this._db.prepare("PRAGMA table_info(memories)").all();
+    const colNames = new Set(cols.map((c) => c.name));
+    if (!colNames.has("agent_id")) {
+      this._db.exec(
+        "ALTER TABLE memories ADD COLUMN agent_id TEXT NOT NULL DEFAULT 'default'"
+      );
+      this._db.exec(
+        "CREATE INDEX IF NOT EXISTS idx_memories_agent_id ON memories (agent_id)"
+      );
+    }
+    if (!colNames.has("shared")) {
+      this._db.exec(
+        "ALTER TABLE memories ADD COLUMN shared INTEGER NOT NULL DEFAULT 0"
+      );
+    }
+    if (!colNames.has("contradicted_by")) {
+      this._db.exec(
+        "ALTER TABLE memories ADD COLUMN contradicted_by TEXT"
+      );
+      this._db.exec(
+        "UPDATE memories SET contradicted_by = json_extract(metadata, '$.contradicted_by') WHERE contradicted_by IS NULL AND json_extract(metadata, '$.contradicted_by') IS NOT NULL"
+      );
+    }
+    this._db.exec(
+      "CREATE TABLE IF NOT EXISTS meta (key TEXT PRIMARY KEY, value TEXT NOT NULL)"
+    );
+  }
+  save(memory) {
+    this._db.prepare(
+      `INSERT OR REPLACE INTO memories
+         (id, content, tier, source, actor, session_id, created_at,
+          last_accessed, access_count, importance, superseded_by,
+          contradicted_by, embedding, metadata, linked_ids, agent_id, shared)
+         VALUES (?, ?, ?, ?, ?, ?, ?, ?, ?, ?, ?, ?, ?, ?, ?, ?, ?)`
+    ).run(
+      memory.id,
+      memory.content,
+      memory.tierName,
+      memory.source,
+      memory.actor,
+      memory.sessionId,
+      memory.createdAt.toISOString(),
+      memory.lastAccessedAt.toISOString(),
+      memory.accessCount,
+      memory.importance,
+      memory.supersededBy,
+      memory.contradictedBy ?? null,
+      memory.embedding ? JSON.stringify(memory.embedding) : null,
+      JSON.stringify(memory.metadata),
+      JSON.stringify(memory.linkedIds),
+      memory.agentId,
+      memory.shared ? 1 : 0
+    );
+  }
+  get(memoryId) {
+    const row = this._db.prepare("SELECT * FROM memories WHERE id = ?").get(memoryId);
+    if (!row) return null;
+    return rowToMemory(row);
+  }
+  listAll(options) {
+    const clauses = [];
+    const params = [];
+    if (options?.agentId) {
+      if (options.includeShared === false) {
+        clauses.push("agent_id = ?");
+        params.push(options.agentId);
+      } else {
+        clauses.push("(agent_id = ? OR shared = 1)");
+        params.push(options.agentId);
+      }
+    }
+    if (options?.tier != null) {
+      clauses.push("tier = ?");
+      params.push(options.tier);
+    }
+    const where = clauses.length > 0 ? ` WHERE ${clauses.join(" AND ")}` : "";
+    let limitClause = "";
+    if (options?.limit != null) {
+      limitClause = " LIMIT ?";
+      params.push(options.limit);
+    }
+    const rows = this._db.prepare(`SELECT * FROM memories${where}${limitClause}`).all(...params);
+    return rows.map(rowToMemory);
+  }
+  delete(memoryId) {
+    this._db.transaction(() => {
+      this._db.prepare("DELETE FROM memories WHERE id = ?").run(memoryId);
+      this._db.prepare("DELETE FROM edges WHERE source_id = ? OR target_id = ?").run(memoryId, memoryId);
+    })();
+  }
+  deleteOlderThan(ageMs, tier, options) {
+    const cutoff = new Date(Date.now() - ageMs).toISOString();
+    const conditions = ["created_at < ?"];
+    const params = [cutoff];
+    if (tier != null) {
+      conditions.push("tier = ?");
+      params.push(tier);
+    }
+    if (options?.agentId) {
+      conditions.push("agent_id = ?");
+      params.push(options.agentId);
+    }
+    const where = conditions.join(" AND ");
+    const ids = this._db.prepare(`SELECT id FROM memories WHERE ${where}`).all(...params);
+    if (ids.length === 0) return 0;
+    const idList = ids.map((r) => r.id);
+    const placeholders = idList.map(() => "?").join(",");
+    const txn = this._db.transaction(() => {
+      this._db.prepare(
+        `DELETE FROM edges WHERE source_id IN (${placeholders}) OR target_id IN (${placeholders})`
+      ).run(...idList, ...idList);
+      const result = this._db.prepare(`DELETE FROM memories WHERE ${where}`).run(...params);
+      return result.changes;
+    });
+    return txn();
+  }
+  saveEdge(edge) {
+    this._db.prepare(
+      `INSERT OR REPLACE INTO edges (source_id, target_id, relation, weight, created_at)
+         VALUES (?, ?, ?, ?, ?)`
+    ).run(
+      edge.sourceId,
+      edge.targetId,
+      edge.relation,
+      edge.weight,
+      edge.createdAt.toISOString()
+    );
+  }
+  getEdges(memoryId) {
+    const rows = this._db.prepare("SELECT * FROM edges WHERE source_id = ? OR target_id = ?").all(memoryId, memoryId);
+    return rows.map((r) => ({
+      sourceId: r["source_id"],
+      targetId: r["target_id"],
+      relation: r["relation"],
+      weight: r["weight"],
+      createdAt: new Date(r["created_at"])
+    }));
+  }
+  searchByEmbedding(embedding, limit = 50, options) {
+    const all = this.listAll(options);
+    return bruteForceCosineSearch(all, embedding, limit);
+  }
+  findSimilarPairs(options) {
+    const maxCandidates = options?.maxCandidates ?? 1e3;
+    const memories = this.listAll({
+      agentId: options?.agentId,
+      includeShared: false,
+      tier: options?.tier
+    });
+    return bruteForceSimilarPairs(
+      memories,
+      options?.threshold ?? 0.7,
+      maxCandidates
+    );
+  }
+  getMeta(key) {
+    const row = this._db.prepare("SELECT value FROM meta WHERE key = ?").get(key);
+    return row?.value ?? null;
+  }
+  setMeta(key, value) {
+    this._db.prepare("INSERT OR REPLACE INTO meta (key, value) VALUES (?, ?)").run(key, value);
+  }
+};
+function rowToMemory(row) {
+  const embRaw = row["embedding"];
+  const m = new Memory({
+    id: row["id"],
+    content: row["content"],
+    tier: row["tier"],
+    source: row["source"],
+    actor: row["actor"],
+    sessionId: row["session_id"],
+    createdAt: new Date(row["created_at"]),
+    lastAccessedAt: new Date(row["last_accessed"]),
+    accessCount: row["access_count"],
+    importance: row["importance"],
+    supersededBy: row["superseded_by"],
+    embedding: embRaw ? JSON.parse(embRaw) : null,
+    metadata: JSON.parse(row["metadata"]),
+    linkedIds: JSON.parse(row["linked_ids"]),
+    agentId: row["agent_id"] ?? "default",
+    shared: row["shared"] === 1 || row["shared"] === true
+  });
+  m.contradictedBy = row["contradicted_by"];
+  return m;
+}
+
+// src/client.ts
+var _storeRegistry = /* @__PURE__ */ new Map();
+function _registeredStores() {
+  return _storeRegistry.entries();
+}
+function sanitizeUri(uri) {
+  try {
+    const url = new URL(uri);
+    if (url.username || url.password) {
+      url.username = "***";
+      url.password = "";
+    }
+    return url.toString();
+  } catch {
+    return uri.includes("://") ? uri.split("://")[0] + "://***" : uri;
+  }
+}
+function parseStoreUri(uri, embeddingDim) {
+  if (uri.startsWith("sqlite:")) {
+    return new SQLiteStore(parseSqlitePath(uri));
+  }
+  if (uri.startsWith("postgres://") || uri.startsWith("postgresql://")) {
+    throw new Error(
+      "PostgresStore cannot be resolved from URI synchronously. Import PostgresStore directly and pass it as the store option."
+    );
+  }
+  for (const [scheme, factory] of _storeRegistry) {
+    if (uri.startsWith(`${scheme}://`) || uri.startsWith(`${scheme}+`)) {
+      const result = factory(uri, embeddingDim);
+      if (result instanceof Promise) {
+        throw new Error(
+          `Store factory for '${scheme}' returned a Promise. Async store factories must be resolved before passing to Mnemonic.`
+        );
+      }
+      return result;
+    }
+  }
+  throw new Error(`Unsupported store URI: '${sanitizeUri(uri)}'`);
+}
+var Mnemonic = class _Mnemonic {
+  _config;
+  _store;
+  _embedder;
+  _autoClassify;
+  _agentId;
+  _resolvedAgentId = null;
+  _initPromise = null;
+  constructor(options) {
+    this._config = options?.config ?? new MnemonicConfig();
+    this._embedder = options?.embedder ?? null;
+    this._autoClassify = options?.autoClassify ?? true;
+    this._agentId = options?.agentId ?? null;
+    const storeOpt = options?.store ?? "sqlite:///mnemonic.db";
+    if (typeof storeOpt === "string") {
+      const raw = parseStoreUri(storeOpt, this._embedder?.dimension);
+      this._store = _wrapIfSync(raw);
+    } else {
+      this._store = _wrapIfSync(storeOpt);
+    }
+  }
+  get config() {
+    return this._config;
+  }
+  /** The underlying async store. */
+  get store() {
+    return this._store;
+  }
+  /** The embedder (if configured). */
+  get embedder() {
+    return this._embedder;
+  }
+  /** The resolved agent ID (available after init()). */
+  get agentId() {
+    if (!this._resolvedAgentId) {
+      throw new Error("Client not initialized. Call init() first.");
+    }
+    return this._resolvedAgentId;
+  }
+  /**
+   * Initialize the store and resolve agent identity. Must be called before use.
+   * Pass `{ skipStoreInit: true }` when reusing an already-initialized store
+   * (e.g. creating per-agent clients that share a single backend).
+   */
+  async init(options) {
+    if (this._resolvedAgentId) return;
+    if (this._initPromise) {
+      await this._initPromise;
+      return;
+    }
+    this._initPromise = (async () => {
+      if (!options?.skipStoreInit) {
+        await this._store.initialize();
+      }
+      await this._resolveAgentId();
+    })();
+    try {
+      await this._initPromise;
+    } finally {
+      this._initPromise = null;
+    }
+  }
+  async _resolveAgentId() {
+    if (this._agentId) {
+      this._resolvedAgentId = this._agentId;
+      return;
+    }
+    const persisted = await this._store.getMeta("agent_id");
+    if (persisted) {
+      this._resolvedAgentId = persisted;
+      return;
+    }
+    const generated = (0, import_node_crypto2.randomUUID)().replace(/-/g, "");
+    await this._store.setMeta("agent_id", generated);
+    this._resolvedAgentId = generated;
+  }
+  _ensureInitialized() {
+    if (!this._resolvedAgentId) {
+      throw new Error("Client not initialized. Call init() first.");
+    }
+  }
+  /** Return only memories owned by this agent (excludes shared from others). */
+  async _ownMemories() {
+    return this._store.listAll({
+      agentId: this._resolvedAgentId,
+      includeShared: false
+    });
+  }
+  static _contentHash(content) {
+    return (0, import_node_crypto2.createHash)("sha256").update(content).digest("hex");
+  }
+  /**
+   * Store a memory with automatic classification and linking.
+   * If identical content already exists for this agent, returns the existing memory.
+   */
+  async add(content, options) {
+    this._ensureInitialized();
+    const contentHash = _Mnemonic._contentHash(content);
+    const knownMemories = await this._store.listAll({ agentId: this._resolvedAgentId });
+    for (const mem of knownMemories) {
+      if (mem.agentId === this._resolvedAgentId && _Mnemonic._contentHash(mem.content) === contentHash) {
+        return mem;
+      }
+    }
+    const source = options?.source ?? "unknown";
+    const actor = options?.actor ?? "system";
+    let resolvedTier;
+    if (options?.tier != null) {
+      resolvedTier = options.tier;
+    } else if (this._autoClassify) {
+      resolvedTier = classify(content, {
+        source,
+        actor,
+        config: this._config
+      });
+    } else {
+      resolvedTier = this._config.defaultTier;
+    }
+    const memory = new Memory({
+      content,
+      tier: resolvedTier,
+      source,
+      actor,
+      sessionId: options?.sessionId ?? null,
+      metadata: options?.metadata ?? {},
+      agentId: this._resolvedAgentId,
+      shared: options?.shared ?? false,
+      charsPerToken: this._config.charsPerToken
+    });
+    if (this._embedder) {
+      memory.embedding = await this._embedder.embed(content);
+    }
+    const salience = detectSalience(content, this._config.salience);
+    if (salience.boost > 0) {
+      memory.metadata["salience_signals"] = salience.signals;
+      memory.metadata["boost"] = (memory.metadata["boost"] ?? 0) + salience.boost;
+    }
+    memory.importance = score(memory, this._config);
+    const existing = await this._store.listAll({
+      agentId: this._resolvedAgentId
+    });
+    const edges = findLinks(memory, existing, { config: this._config });
+    await this._store.save(memory);
+    for (const edge of edges) {
+      memory.linkedIds.push(edge.targetId);
+      await this._store.saveEdge(edge);
+      const linked = await this._store.get(edge.targetId);
+      if (linked) {
+        if (linked.agentId === this._resolvedAgentId) {
+          if (!linked.linkedIds.includes(memory.id)) {
+            linked.linkedIds.push(memory.id);
+          }
+          if (edge.relation === "supersedes" && linked.supersededBy == null) {
+            linked.supersededBy = memory.id;
+          } else if (edge.relation === "contradicts" && linked.contradictedBy == null) {
+            linked.contradictedBy = memory.id;
+          }
+          await this._store.save(linked);
+        }
+      }
+    }
+    await this._store.save(memory);
+    return memory;
+  }
+  async _assemble(query, options) {
+    let queryEmbedding = null;
+    const limit = this._config.embeddingSearchLimit;
+    let candidates;
+    if (this._embedder) {
+      queryEmbedding = await this._embedder.embed(query);
+      candidates = await this._store.searchByEmbedding(
+        queryEmbedding,
+        limit,
+        { agentId: this._resolvedAgentId }
+      );
+    } else {
+      candidates = await this._store.listAll({
+        agentId: this._resolvedAgentId
+      });
+    }
+    if (options?.excludeSuperseded) {
+      candidates = candidates.filter((m) => m.supersededBy == null);
+    }
+    const selected = assemble(query, candidates, {
+      queryEmbedding,
+      maxTokens: options?.maxTokens,
+      minRelevance: options?.minRelevance,
+      config: this._config
+    });
+    await Promise.all(selected.map((mem) => this._store.save(mem)));
+    return selected;
+  }
+  /** Retrieve optimised context for a given query within a token budget. */
+  async recall(query, options) {
+    this._ensureInitialized();
+    const selected = await this._assemble(query, {
+      ...options,
+      excludeSuperseded: true
+    });
+    const conflicts = detectConflicts(selected, this._config);
+    return formatContext(selected, options?.header, conflicts);
+  }
+  /** Like recall but returns the raw Memory objects. */
+  async recallMemories(query, options) {
+    this._ensureInitialized();
+    return this._assemble(query, options);
+  }
+  /** Delete memories matching the given criteria. Returns count deleted. */
+  async forget(options) {
+    this._ensureInitialized();
+    if (!options?.olderThan && !options?.tier && options?.belowImportance == null) {
+      throw new Error(
+        "forget() requires at least one filter (olderThan, tier, or belowImportance)"
+      );
+    }
+    const tier = options?.tier;
+    if (options?.belowImportance == null) {
+      const olderThan = options?.olderThan?.trim();
+      if (olderThan === "") {
+        throw new Error("olderThan must be a valid duration string (e.g. '30d'), not empty");
+      }
+      const ageMs = olderThan ? parseDuration(olderThan) : 0;
+      return this._store.deleteOlderThan(ageMs, tier, {
+        agentId: this._resolvedAgentId
+      });
+    }
+    let candidates = await this._store.listAll({
+      agentId: this._resolvedAgentId,
+      includeShared: false,
+      tier: tier ?? void 0
+    });
+    if (options?.olderThan != null) {
+      const ageMs = parseDuration(options.olderThan);
+      const cutoff = Date.now() - ageMs;
+      candidates = candidates.filter((m) => m.createdAt.getTime() < cutoff);
+    }
+    let deleted = 0;
+    for (const mem of candidates) {
+      const currentImportance = score(mem, this._config);
+      if (currentImportance < options.belowImportance) {
+        await this._store.delete(mem.id);
+        deleted++;
+      }
+    }
+    return deleted;
+  }
+  /**
+   * Merge similar episodic memories into higher-tier summaries.
+   *
+   * Originals are kept alive but deprioritised via a scoring penalty
+   * and `consolidated_into` metadata. A `consolidates` edge links
+   * the summary to each original for graph traversal.
+   */
+  async consolidate() {
+    this._ensureInitialized();
+    const ownEpisodic = await this._store.listAll({
+      agentId: this._resolvedAgentId,
+      includeShared: false,
+      tier: MemoryTier.EPISODIC
+    });
+    const eligible = [];
+    for (const m of ownEpisodic) {
+      const summaryId = m.metadata["consolidated_into"];
+      if (summaryId == null || await this._store.get(summaryId) == null) {
+        eligible.push(m);
+      }
+    }
+    const privateMemories = eligible.filter((m) => !m.shared);
+    const sharedMemories = eligible.filter((m) => m.shared);
+    const cfg = this._config.consolidation;
+    const eligibleIds = new Set(eligible.map((m) => m.id));
+    const allPairs = await this._store.findSimilarPairs({
+      threshold: cfg.similarityThreshold,
+      agentId: this._resolvedAgentId,
+      tier: MemoryTier.EPISODIC,
+      maxCandidates: cfg.maxCandidates,
+      maxNeighborsPerCandidate: cfg.maxNeighborsPerCandidate
+    });
+    const eligiblePairs = allPairs.filter(
+      (p) => eligibleIds.has(p.idA) && eligibleIds.has(p.idB)
+    );
+    const privateIds = new Set(privateMemories.map((m) => m.id));
+    const sharedIds = new Set(sharedMemories.map((m) => m.id));
+    const privatePairs = eligiblePairs.filter(
+      (p) => privateIds.has(p.idA) && privateIds.has(p.idB)
+    );
+    const sharedPairs = eligiblePairs.filter(
+      (p) => sharedIds.has(p.idA) && sharedIds.has(p.idB)
+    );
+    let totalClusters = 0;
+    for (const [memories, pairs, isShared] of [
+      [privateMemories, privatePairs, false],
+      [sharedMemories, sharedPairs, true]
+    ]) {
+      const clusters = findConsolidationCandidates(memories, this._config, pairs);
+      const CONCURRENCY = 8;
+      const prepared = [];
+      const processBatch = async (batch) => {
+        const results = await Promise.all(
+          batch.map(async (cluster) => {
+            const summary = await mergeCluster(cluster, this._config);
+            summary.agentId = this._resolvedAgentId;
+            summary.shared = isShared;
+            for (const mem of cluster) {
+              if (!summary.linkedIds.includes(mem.id)) {
+                summary.linkedIds.push(mem.id);
+              }
+            }
+            if (this._embedder) {
+              summary.embedding = await this._embedder.embed(summary.content);
+            }
+            summary.importance = score(summary, this._config);
+            return { cluster, summary };
+          })
+        );
+        prepared.push(...results);
+      };
+      for (let i = 0; i < clusters.length; i += CONCURRENCY) {
+        await processBatch(clusters.slice(i, i + CONCURRENCY));
+      }
+      for (const { cluster, summary } of prepared) {
+        await this._store.save(summary);
+        for (const mem of cluster) {
+          const edge = createEdge(summary.id, mem.id, "consolidates");
+          await this._store.saveEdge(edge);
+          mem.metadata["consolidated_into"] = summary.id;
+          mem.linkedIds.push(summary.id);
+          mem.importance = score(mem, this._config);
+          await this._store.save(mem);
+        }
+      }
+      totalClusters += clusters.length;
+    }
+    return totalClusters;
+  }
+  /** Run the tier promotion/demotion pipeline on own memories. */
+  async promote() {
+    this._ensureInitialized();
+    const ownMemories = await this._ownMemories();
+    let changes = await this._applyTierResults(
+      checkPromotions(ownMemories, this._config)
+    );
+    const refreshed = await this._ownMemories();
+    changes += await this._applyTierResults(
+      checkDemotions(refreshed, this._config)
+    );
+    return changes;
+  }
+  /** Re-run the linker across all memories to retroactively set edges. */
+  async relink() {
+    this._ensureInitialized();
+    const ownMemories = await this._ownMemories();
+    const visible = await this._store.listAll({ agentId: this._resolvedAgentId });
+    const ownById = new Map(ownMemories.map((m) => [m.id, m]));
+    const existingRelations = /* @__PURE__ */ new Map();
+    for (const mem of ownMemories) {
+      const edges = await this._store.getEdges(mem.id);
+      for (const e of edges) existingRelations.set(`${e.sourceId}:${e.targetId}`, e.relation);
+    }
+    let newEdges = 0;
+    for (const mem of ownMemories) {
+      const edges = findLinks(mem, visible, { config: this._config });
+      for (const edge of edges) {
+        const key = `${edge.sourceId}:${edge.targetId}`;
+        const existingRel = existingRelations.get(key);
+        if (existingRel == null) {
+          await this._store.saveEdge(edge);
+          existingRelations.set(key, edge.relation);
+          newEdges++;
+        } else if (existingRel !== edge.relation) {
+          await this._store.saveEdge(edge);
+          existingRelations.set(key, edge.relation);
+        }
+        if (edge.targetId !== mem.id && !mem.linkedIds.includes(edge.targetId)) {
+          mem.linkedIds.push(edge.targetId);
+        }
+        const linked = ownById.get(edge.targetId);
+        if (linked) {
+          if (!linked.linkedIds.includes(mem.id)) linked.linkedIds.push(mem.id);
+          if (edge.relation === "supersedes" && linked.supersededBy == null) {
+            linked.supersededBy = mem.id;
+          } else if (edge.relation === "contradicts" && linked.contradictedBy == null) {
+            linked.contradictedBy = mem.id;
+          }
+        }
+      }
+    }
+    await Promise.all(ownMemories.map((m) => this._store.save(m)));
+    return newEdges;
+  }
+  /** Return aggregate statistics about own memories. */
+  async stats() {
+    this._ensureInitialized();
+    const memories = await this._ownMemories();
+    const byTier = {};
+    let totalTokens = 0;
+    for (const m of memories) {
+      byTier[m.tierName] = (byTier[m.tierName] ?? 0) + 1;
+      totalTokens += m.tokenEstimate;
+    }
+    return {
+      totalMemories: memories.length,
+      totalTokens,
+      byTier,
+      agentId: this._resolvedAgentId
+    };
+  }
+  /** Make a memory visible to all agents. */
+  async share(memoryId) {
+    this._ensureInitialized();
+    const memory = await this._store.get(memoryId);
+    if (!memory) {
+      throw new Error(`Memory not found: ${memoryId}`);
+    }
+    if (memory.agentId !== this._resolvedAgentId) {
+      throw new Error("Cannot share another agent's memory");
+    }
+    memory.shared = true;
+    await this._store.save(memory);
+    return memory;
+  }
+  /** Make a memory private (only visible to owner). */
+  async unshare(memoryId) {
+    this._ensureInitialized();
+    const memory = await this._store.get(memoryId);
+    if (!memory) {
+      throw new Error(`Memory not found: ${memoryId}`);
+    }
+    if (memory.agentId !== this._resolvedAgentId) {
+      throw new Error("Cannot unshare another agent's memory");
+    }
+    memory.shared = false;
+    await this._store.save(memory);
+    return memory;
+  }
+  async _applyTierResults(results) {
+    let applied = 0;
+    for (const result of results) {
+      const mem = await this._store.get(result.memoryId);
+      if (!mem) continue;
+      applyTierChange(mem, result.newTier);
+      mem.importance = score(mem, this._config);
+      await this._store.save(mem);
+      applied++;
+    }
+    return applied;
+  }
+};
+function _wrapIfSync(store) {
+  if (store instanceof SQLiteStore) {
+    return syncToAsync(store);
+  }
+  return store;
+}
+
+// src/embeddings/factory.ts
+async function buildEmbedder(provider) {
+  const resolved = (provider ?? process.env["MNEMONIC_EMBEDDER"] ?? "none").trim().toLowerCase();
+  if (resolved === "none" || resolved === "") return null;
+  if (resolved === "openai") {
+    const { OpenAIEmbedder: OpenAIEmbedder2 } = await Promise.resolve().then(() => (init_openai(), openai_exports));
+    return new OpenAIEmbedder2({
+      model: process.env["MNEMONIC_OPENAI_MODEL"],
+      apiKey: process.env["MNEMONIC_OPENAI_API_KEY"]
+    });
+  }
+  if (resolved === "local") {
+    const { LocalEmbedder: LocalEmbedder2 } = await Promise.resolve().then(() => (init_local(), local_exports));
+    return new LocalEmbedder2();
+  }
+  throw new Error(
+    `Unknown embedder provider: '${resolved}'. Valid options: none, openai, local`
+  );
+}
+
+// src/mcp/server.ts
+init_utils();
+var MAX_AGENT_CACHE = 256;
+var AGENT_ID_RE = /^[a-zA-Z0-9_-]{1,128}$/;
+function validateAgentId(agentId) {
+  const trimmed = agentId.trim();
+  if (!AGENT_ID_RE.test(trimmed)) {
+    throw new Error(
+      "Invalid agent_id: must be 1-128 alphanumeric/underscore/hyphen characters"
+    );
+  }
+  return trimmed;
+}
+function serializeMemory(memory, callerAgentId) {
+  return {
+    id: memory.id,
+    content: memory.content,
+    tier: memory.tierName,
+    source: memory.source,
+    actor: memory.actor,
+    session_id: memory.sessionId,
+    created_at: memory.createdAt.toISOString(),
+    last_accessed_at: memory.lastAccessedAt.toISOString(),
+    access_count: memory.accessCount,
+    importance: Math.round(memory.importance * 1e4) / 1e4,
+    superseded_by: memory.supersededBy,
+    contradicted_by: memory.contradictedBy,
+    has_embedding: memory.embedding != null,
+    metadata: memory.metadata,
+    linked_ids: memory.linkedIds,
+    token_estimate: memory.tokenEstimate,
+    owned_by_caller: callerAgentId != null ? memory.agentId === callerAgentId : false,
+    shared: memory.shared
+  };
+}
+async function buildFromUri(uri) {
+  const embedder = await buildEmbedder();
+  const dim = embedder?.dimension ?? 1536;
+  if (uri.startsWith("sqlite:")) {
+    return { store: new SQLiteStore(parseSqlitePath(uri)), embedder };
+  }
+  if (uri.startsWith("postgres://") || uri.startsWith("postgresql://")) {
+    const { PostgresStore: PostgresStore2 } = await Promise.resolve().then(() => (init_postgres(), postgres_exports));
+    return { store: new PostgresStore2({ dsn: uri, embeddingDim: dim }), embedder };
+  }
+  for (const [scheme, factory] of _registeredStores()) {
+    if (uri.startsWith(`${scheme}://`) || uri.startsWith(`${scheme}+`)) {
+      const result = factory(uri, dim);
+      const store = result instanceof Promise ? await result : result;
+      return { store, embedder };
+    }
+  }
+  throw new Error(
+    `Unsupported store URI: '${uri}'. Use sqlite:///path, postgres[ql]://..., or register a custom store.`
+  );
+}
+async function createServer(options) {
+  let mcpSdk;
+  try {
+    const mcpPath = "@modelcontextprotocol/sdk/server/mcp.js";
+    mcpSdk = await import(mcpPath);
+  } catch {
+    throw new Error(
+      "MCP server requires '@modelcontextprotocol/sdk'. Install it with: npm install @modelcontextprotocol/sdk"
+    );
+  }
+  const { McpServer } = mcpSdk;
+  let z;
+  try {
+    const zodPath = "zod";
+    const zod = await import(zodPath);
+    z = zod.z ?? zod.default?.z;
+  } catch {
+    throw new Error(
+      "MCP server requires 'zod'. Install it with: npm install zod"
+    );
+  }
+  let baseClient;
+  if (options?.mnemonic) {
+    baseClient = options.mnemonic;
+    try {
+      baseClient.agentId;
+    } catch {
+      await baseClient.init();
+    }
+  } else {
+    const storeUri = process.env["MNEMONIC_STORE_URI"] ?? "sqlite:///mnemonic.db";
+    const agentId = process.env["MNEMONIC_AGENT_ID"] || void 0;
+    const { store, embedder } = await buildFromUri(storeUri);
+    baseClient = new Mnemonic({ store, embedder, agentId });
+    await baseClient.init();
+  }
+  const agentCache = /* @__PURE__ */ new Map();
+  async function getAgent(agentId) {
+    if (!agentId) return baseClient;
+    agentId = validateAgentId(agentId);
+    const cached = agentCache.get(agentId);
+    if (cached) {
+      agentCache.delete(agentId);
+      agentCache.set(agentId, cached);
+      return cached;
+    }
+    if (agentCache.size >= MAX_AGENT_CACHE) {
+      const lru = agentCache.keys().next().value;
+      agentCache.delete(lru);
+    }
+    const agent = new Mnemonic({
+      store: baseClient.store,
+      embedder: baseClient.embedder,
+      config: baseClient.config,
+      agentId
+    });
+    await agent.init({ skipStoreInit: true });
+    agentCache.set(agentId, agent);
+    return agent;
+  }
+  function jsonResponse(data) {
+    return {
+      content: [{ type: "text", text: JSON.stringify(data, null, 2) }]
+    };
+  }
+  function errorResponse(err) {
+    const message = err instanceof Error ? err.message : String(err);
+    let hint = "";
+    if (message.includes("not found")) hint = " Use memory_search to find valid IDs.";
+    else if (message.includes("not the owner") || message.includes("permission")) hint = " Only the owning agent can modify this memory.";
+    else if (message.includes("at least one filter")) hint = " Provide older_than, tier, or below_importance.";
+    return {
+      content: [
+        {
+          type: "text",
+          text: JSON.stringify({ error: message + hint }, null, 2)
+        }
+      ],
+      isError: true
+    };
+  }
+  const server = new McpServer({
+    name: "mnemonic",
+    version: "0.1.0"
+  });
+  server.tool(
+    "memory_store",
+    {
+      description: "Save information to long-term memory. Call proactively when the user shares preferences, identity facts, decisions, corrections, or notable events \u2014 also when they correct prior knowledge or express a strong preference. Auto-classifies into tiers, scores importance, links to related memories, and detects supersession.",
+      annotations: { readOnlyHint: false, idempotentHint: false }
+    },
+    {
+      content: z.string().describe("Clear standalone statement to remember, e.g. 'User prefers Kubernetes over ECS' or 'Project uses Next.js 14 with App Router'"),
+      source: z.string().default("conversation").describe("Where this came from. Use lowercase_snake values. Common: 'conversation', 'observation', 'document', 'tool_output', 'system'. Custom sources welcome: 'slack', 'email', 'jira', 'meeting_notes', etc."),
+      actor: z.string().default("user").describe("Who produced this. Common: 'user', 'assistant', 'system'. Can also be a specific name or agent ID."),
+      tier: z.enum(["identity", "procedural", "structural", "episodic", "transient"]).optional().describe("Override auto-classification. Usually omit \u2014 the classifier handles it."),
+      session_id: z.string().optional().describe("Group memories by conversation or task"),
+      metadata: z.record(z.unknown()).optional().describe("Key-value pairs, e.g. {project: 'api', priority: 'high'}"),
+      agent_id: z.string().optional().describe("Target agent's memory space. Omit for default."),
+      shared: z.boolean().optional().describe("Make visible to all agents. Default: false.")
+    },
+    async (params) => {
+      try {
+        const agent = await getAgent(params.agent_id);
+        const memory = await agent.add(params.content, {
+          source: params.source,
+          actor: params.actor,
+          tier: params.tier,
+          sessionId: params.session_id,
+          metadata: params.metadata,
+          shared: params.shared
+        });
+        return jsonResponse(serializeMemory(memory, agent.agentId));
+      } catch (err) {
+        return errorResponse(err);
+      }
+    }
+  );
+  server.tool(
+    "memory_recall",
+    {
+      description: "Retrieve relevant memories as formatted text, ranked by relevance and importance within a token budget. Call at the start of every conversation to load context. Also call when the topic shifts or when you need to verify what you already know. Returns a ready-to-use text block. Prefer over memory_search unless you need structured data or memory IDs.",
+      annotations: { readOnlyHint: true, idempotentHint: true }
+    },
+    {
+      query: z.string().describe("What you need to know, e.g. 'deployment preferences' or 'user's tech stack'"),
+      max_tokens: z.number().int().min(100).max(16e3).optional().describe("Token budget for returned context. Default: 2000."),
+      min_relevance: z.number().min(0).max(1).optional().describe("Minimum relevance score (0.0-1.0) for a memory to be included. Filters out low-relevance noise."),
+      header: z.string().optional().describe("Header prepended to context, e.g. '## Relevant Memory'"),
+      agent_id: z.string().optional().describe("Target agent's memory space. Omit for default.")
+    },
+    async (params) => {
+      try {
+        const agent = await getAgent(params.agent_id);
+        const context = await agent.recall(params.query, {
+          maxTokens: params.max_tokens,
+          minRelevance: params.min_relevance,
+          header: params.header
+        });
+        return { content: [{ type: "text", text: context }] };
+      } catch (err) {
+        return errorResponse(err);
+      }
+    }
+  );
+  server.tool(
+    "memory_search",
+    {
+      description: "Search memories and return structured JSON with full metadata (id, tier, importance, timestamps, linked_ids). Use instead of memory_recall when you need memory IDs for share/unshare/forget, or need to inspect importance scores and graph links.",
+      annotations: { readOnlyHint: true, idempotentHint: true }
+    },
+    {
+      query: z.string().describe("What to search for, e.g. 'infrastructure decisions' or 'recent debugging sessions'"),
+      max_tokens: z.number().int().min(100).max(16e3).optional().describe("Token budget for candidate selection. Default: 2000."),
+      min_relevance: z.number().min(0).max(1).optional().describe("Minimum relevance score (0.0-1.0) for a memory to be included. Filters out low-relevance noise."),
+      agent_id: z.string().optional().describe("Target agent's memory space. Omit for default.")
+    },
+    async (params) => {
+      try {
+        const agent = await getAgent(params.agent_id);
+        const memories = await agent.recallMemories(params.query, {
+          maxTokens: params.max_tokens,
+          minRelevance: params.min_relevance
+        });
+        return jsonResponse(memories.map((m) => serializeMemory(m, agent.agentId)));
+      } catch (err) {
+        return errorResponse(err);
+      }
+    }
+  );
+  server.tool(
+    "memory_forget",
+    {
+      description: "Delete memories matching filters. Memories naturally fade via decay \u2014 only explicitly delete when content is wrong, sensitive, or the user requests removal. At least one filter is required.",
+      annotations: { destructiveHint: true, idempotentHint: false }
+    },
+    {
+      older_than: z.string().optional().describe("Delete older than duration: '30d', '24h', '2w', '90m', '120s'"),
+      tier: z.enum(["identity", "procedural", "structural", "episodic", "transient"]).optional().describe("Only delete memories in this tier"),
+      below_importance: z.number().min(0).max(1).optional().describe("Delete below this importance score (0.0\u20131.0)"),
+      agent_id: z.string().optional().describe("Target agent's memory space. Omit for default.")
+    },
+    async (params) => {
+      try {
+        const agent = await getAgent(params.agent_id);
+        const deleted = await agent.forget({
+          olderThan: params.older_than,
+          tier: params.tier,
+          belowImportance: params.below_importance
+        });
+        return jsonResponse({ deleted });
+      } catch (err) {
+        return errorResponse(err);
+      }
+    }
+  );
+  server.tool(
+    "memory_consolidate",
+    {
+      description: "Merge similar episodic memories into structural summaries. Originals are kept but deprioritised \u2014 they fade naturally via decay while the summary takes over in recall. Run after storing 10+ memories in a session, or when memory_stats shows many episodic memories.",
+      annotations: { readOnlyHint: false, destructiveHint: false, idempotentHint: false }
+    },
+    { agent_id: z.string().optional().describe("Target agent. Omit for default.") },
+    async (params) => {
+      try {
+        const agent = await getAgent(params.agent_id);
+        return jsonResponse({ consolidated_groups: await agent.consolidate() });
+      } catch (err) {
+        return errorResponse(err);
+      }
+    }
+  );
+  server.tool(
+    "memory_promote",
+    {
+      description: "Promote frequently accessed memories to higher tiers and demote inactive ones. Tiers affect recall ranking and decay rate. Run at the end of sessions to update tier rankings based on access patterns.",
+      annotations: { readOnlyHint: false, idempotentHint: false }
+    },
+    { agent_id: z.string().optional().describe("Target agent. Omit for default.") },
+    async (params) => {
+      try {
+        const agent = await getAgent(params.agent_id);
+        return jsonResponse({ tier_changes: await agent.promote() });
+      } catch (err) {
+        return errorResponse(err);
+      }
+    }
+  );
+  server.tool(
+    "memory_relink",
+    {
+      description: "Re-run the linker across all memories to retroactively detect supersession and contradiction edges. Use after upgrading or when existing memories lack relationship metadata.",
+      annotations: { readOnlyHint: false, idempotentHint: true }
+    },
+    { agent_id: z.string().optional().describe("Target agent. Omit for default.") },
+    async (params) => {
+      try {
+        const agent = await getAgent(params.agent_id);
+        return jsonResponse({ new_edges: await agent.relink() });
+      } catch (err) {
+        return errorResponse(err);
+      }
+    }
+  );
+  server.tool(
+    "memory_stats",
+    {
+      description: "Get memory health: total count, tier breakdown, token usage. Call when the user asks 'what do you remember?' or to decide if consolidation or pruning is needed.",
+      annotations: { readOnlyHint: true, idempotentHint: true }
+    },
+    { agent_id: z.string().optional().describe("Target agent. Omit for default.") },
+    async (params) => {
+      try {
+        const agent = await getAgent(params.agent_id);
+        return jsonResponse(await agent.stats());
+      } catch (err) {
+        return errorResponse(err);
+      }
+    }
+  );
+  server.tool(
+    "memory_share",
+    {
+      description: "Make a memory visible to all agents. Only the owning agent can share. Use memory_search first to get the memory ID.",
+      annotations: { readOnlyHint: false, idempotentHint: true }
+    },
+    {
+      memory_id: z.string().describe("Memory ID from memory_search results"),
+      agent_id: z.string().optional().describe("Owning agent. Omit for default.")
+    },
+    async (params) => {
+      try {
+        const agent = await getAgent(params.agent_id);
+        const memory = await agent.share(params.memory_id);
+        return jsonResponse(serializeMemory(memory, agent.agentId));
+      } catch (err) {
+        return errorResponse(err);
+      }
+    }
+  );
+  server.tool(
+    "memory_unshare",
+    {
+      description: "Make a shared memory private again. Only the owning agent can unshare. Use memory_search first to get the memory ID.",
+      annotations: { readOnlyHint: false, idempotentHint: true }
+    },
+    {
+      memory_id: z.string().describe("Memory ID from memory_search results"),
+      agent_id: z.string().optional().describe("Owning agent. Omit for default.")
+    },
+    async (params) => {
+      try {
+        const agent = await getAgent(params.agent_id);
+        const memory = await agent.unshare(params.memory_id);
+        return jsonResponse(serializeMemory(memory, agent.agentId));
+      } catch (err) {
+        return errorResponse(err);
+      }
+    }
+  );
+  return { server, baseClient, agentCache };
+}
+
+// src/mcp/main.ts
+async function main() {
+  const { server, baseClient } = await createServer();
+  const transportPath = "@modelcontextprotocol/sdk/server/stdio.js";
+  const mcpTransport = await import(transportPath);
+  const { StdioServerTransport } = mcpTransport;
+  const transport = new StdioServerTransport();
+  for (const sig of ["SIGINT", "SIGTERM"]) {
+    process.on(sig, async () => {
+      await baseClient.store.close().catch(() => {
+      });
+      process.exit(0);
+    });
+  }
+  await server.connect(transport);
+}
+main().catch((err) => {
+  const msg = err instanceof Error ? err.message : String(err);
+  process.stderr.write(`Fatal: ${msg}
+`);
+  process.exit(1);
+});
+//# sourceMappingURL=main.cjs.map