@mnemonic-ai/core 0.1.0

package/dist/cli/main.cjs

@@ -0,0 +1,1827 @@
+#!/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 __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/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/memory.ts
+var import_node_crypto = require("crypto");
+
+// 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;
+}
+var DURATION_RE = /^(\d+)\s*([wdhms])$/;
+var MS_MULTIPLIERS = {
+  w: 7 * 24 * 60 * 60 * 1e3,
+  d: 24 * 60 * 60 * 1e3,
+  h: 60 * 60 * 1e3,
+  m: 60 * 1e3,
+  s: 1e3
+};
+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]);
+}
+
+// src/core/memory.ts
+var MemoryTier = {
+  IDENTITY: "identity",
+  PROCEDURAL: "procedural",
+  STRUCTURAL: "structural",
+  EPISODIC: "episodic",
+  TRANSIENT: "transient"
+};
+var 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;
+  }
+};
+function createEdge(sourceId, targetId, relation, weight = 1) {
+  return { sourceId, targetId, relation, weight, createdAt: /* @__PURE__ */ new Date() };
+}
+
+// src/core/linker.ts
+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
+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/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/consolidation/engine.ts
+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);
+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 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/cli/index.ts
+function createClient(storeUri) {
+  if (storeUri.startsWith("sqlite")) {
+    return new Mnemonic({ store: new SQLiteStore(parseSqlitePath(storeUri)) });
+  }
+  throw new Error(
+    `CLI currently supports sqlite:// URIs. Got: ${storeUri}`
+  );
+}
+async function buildProgram() {
+  const cmdPath = "commander";
+  const commander = await import(cmdPath);
+  const { Command } = commander;
+  const program = new Command();
+  program.name("mnemonic").description("Mnemonic memory layer CLI").version("0.1.0");
+  program.command("stats").description("Show memory count by tier and token totals").option("--store <uri>", "Store URI", "sqlite:///mnemonic.db").action(async (opts) => {
+    const client = createClient(opts.store);
+    try {
+      await client.init();
+      const stats = await client.stats();
+      process.stdout.write(`Total memories: ${stats.totalMemories}
+`);
+      process.stdout.write(`Total tokens:   ${stats.totalTokens}
+`);
+      process.stdout.write(`Agent ID:       ${stats.agentId}
+`);
+      process.stdout.write("By tier:\n");
+      for (const [tier, count] of Object.entries(stats.byTier)) {
+        process.stdout.write(`  ${tier}: ${count}
+`);
+      }
+    } finally {
+      await client.store.close();
+    }
+  });
+  program.command("prune").description("Delete old or low-value memories").requiredOption("--older-than <duration>", "Duration (e.g. 30d, 24h)").option("--tier <tier>", "Only delete this tier").option("--store <uri>", "Store URI", "sqlite:///mnemonic.db").action(async (opts) => {
+    const client = createClient(opts.store);
+    try {
+      await client.init();
+      const deleted = await client.forget({
+        olderThan: opts.olderThan,
+        tier: opts.tier
+      });
+      process.stdout.write(`Deleted ${deleted} memories
+`);
+    } finally {
+      await client.store.close();
+    }
+  });
+  program.command("consolidate").description("Merge similar episodic memories into structural summaries").option("--store <uri>", "Store URI", "sqlite:///mnemonic.db").action(async (opts) => {
+    const client = createClient(opts.store);
+    try {
+      await client.init();
+      const count = await client.consolidate();
+      process.stdout.write(`Consolidated ${count} groups
+`);
+    } finally {
+      await client.store.close();
+    }
+  });
+  return program;
+}
+
+// src/cli/main.ts
+async function main() {
+  const program = await buildProgram();
+  await program.parseAsync();
+}
+main().catch((err) => {
+  const msg = err instanceof Error ? err.message : String(err);
+  process.stderr.write(`Error: ${msg}
+`);
+  process.exit(1);
+});
+//# sourceMappingURL=main.cjs.map