remem-mcp 0.6.8 → 0.7.3

package/dist/{chunk-X4ECGLYH.js → chunk-4WCDAEPP.js}

@@ -1,13 +1,12 @@
 import {
   generateId,
-  init_engine,
   init_ulid
-} from "./chunk-FA324IBN.js";
+} from "./chunk-XJGDYQ34.js";
 import {
   __esm,
   __export,
   init_esm_shims
-} from "./chunk-XK4Y53J2.js";
+} from "./chunk-ONQHLUGM.js";
 
 // src/embedding/local.ts
 var local_exports = {};
@@ -50,91 +49,11 @@ var init_local = __esm({
   }
 });
 
-// src/sdk.ts
-init_esm_shims();
-init_local();
-import { createHash as createHash3 } from "crypto";
-import { homedir } from "os";
-import { join as join3 } from "path";
-
-// src/security/redactor.ts
-init_esm_shims();
-var SECRET_PATTERNS = [
-  // OpenAI API key
-  /sk-[a-zA-Z0-9]{20,}/g,
-  // Anthropic API key
-  /sk-ant-[a-zA-Z0-9-]+/g,
-  // GitHub personal access token
-  /ghp_[a-zA-Z0-9]{36}/g,
-  // GitHub OAuth token
-  /gho_[a-zA-Z0-9]{36}/g,
-  // GitHub fine-grained token
-  /github_pat_[a-zA-Z0-9_]{82}/g,
-  // Slack token
-  /xox[baprs]-[a-zA-Z0-9-]+/g,
-  // AWS access key ID
-  /AKIA[0-9A-Z]{16}/g,
-  // AWS secret access key (40 chars, base64-ish)
-  /(?<![A-Za-z0-9+/])[A-Za-z0-9+/]{40}(?![A-Za-z0-9+/])/g,
-  // PEM private key block
-  /-----BEGIN [A-Z ]*PRIVATE KEY-----[\s\S]*?-----END [A-Z ]*PRIVATE KEY-----/g,
-  // Google API key
-  /AIza[0-9A-Za-z\-_]{35}/g,
-  // Generic bearer token (require 20+ char token to avoid redacting "Bearer with JWT")
-  /Bearer\s+[a-zA-Z0-9\-._~+/]{20,}=*/g
-];
-var MIN_LENGTH = 40;
-var ENTROPY_THRESHOLD = 4.5;
-function shannonEntropy(str) {
-  const freq = /* @__PURE__ */ new Map();
-  for (const ch of str) {
-    freq.set(ch, (freq.get(ch) ?? 0) + 1);
-  }
-  let entropy = 0;
-  const len = str.length;
-  for (const count of freq.values()) {
-    const p = count / len;
-    entropy -= p * Math.log2(p);
-  }
-  return entropy;
-}
-function findHighEntropyStrings(text) {
-  const results = [];
-  const regex = /[a-zA-Z0-9+/=]{40,}/g;
-  let match;
-  match = regex.exec(text);
-  while (match !== null) {
-    const str = match[0];
-    if (str.length >= MIN_LENGTH) {
-      const entropy = shannonEntropy(str);
-      if (entropy >= ENTROPY_THRESHOLD) {
-        results.push(str);
-      }
-    }
-    match = regex.exec(text);
-  }
-  return results;
-}
-function redact(text) {
-  let result = text;
-  let redacted = false;
-  for (const pattern of SECRET_PATTERNS) {
-    const before = result;
-    result = result.replace(pattern, "[REDACTED]");
-    if (result !== before) redacted = true;
-  }
-  const highEntropy = findHighEntropyStrings(result);
-  for (const str of highEntropy) {
-    result = result.replace(str, "[REDACTED]");
-    redacted = true;
-  }
-  return { text: result, redacted };
-}
-
 // src/storage/sqlite.ts
 init_esm_shims();
 import { createHash } from "crypto";
-import { copyFileSync, existsSync, mkdirSync, readFileSync } from "fs";
+import { copyFileSync, existsSync, mkdirSync, readFileSync, readdirSync, writeFileSync } from "fs";
+import { homedir } from "os";
 import { dirname, join } from "path";
 import { fileURLToPath } from "url";
 import Database from "better-sqlite3";
@@ -163,6 +82,42 @@ function rrfMerge(bm25Results, vecResults, limit) {
 
 // src/storage/sqlite.ts
 init_ulid();
+
+// src/utils/write-queue.ts
+init_esm_shims();
+var WriteQueue = class {
+  queue = Promise.resolve();
+  pendingCount = 0;
+  /**
+   * Enqueue a write task. All tasks are serialized — the next task
+   * only starts after the previous one completes (success or failure).
+   */
+  async enqueue(task) {
+    this.pendingCount++;
+    const result = this.queue.then(async () => {
+      try {
+        return await task();
+      } finally {
+        this.pendingCount--;
+      }
+    });
+    this.queue = result.catch(() => {
+    });
+    return result;
+  }
+  /** Number of tasks currently waiting/running. */
+  get pending() {
+    return this.pendingCount;
+  }
+  /** Wait for all pending tasks to complete. */
+  async drain() {
+    while (this.pendingCount > 0) {
+      await this.queue;
+    }
+  }
+};
+
+// src/storage/sqlite.ts
 var __dirname2 = dirname(fileURLToPath(import.meta.url));
 var FTS_STOPWORDS_SET = /* @__PURE__ */ new Set([
   "the",
@@ -266,7 +221,7 @@ function stripQueryProperNouns(query) {
   if (noProperNouns.length > 0) return noProperNouns.join(" ");
   return filtered.length > 0 ? filtered.join(" ") : tokens.join(" ");
 }
-var CURRENT_SCHEMA_VERSION = 8;
+var CURRENT_SCHEMA_VERSION = 13;
 var EVERGREEN_TAGS = new Set(
   (process.env.REMEM_EVERGREEN_TAGS ?? "evergreen,never-forget").split(",").map((t) => t.trim().toLowerCase()).filter(Boolean)
 );
@@ -274,8 +229,145 @@ function isEvergreen(tags) {
   if (!tags || tags.length === 0) return false;
   return tags.some((t) => EVERGREEN_TAGS.has(t.toLowerCase()));
 }
+function autoAssignTier(type, tags) {
+  if (tags) {
+    const lower = tags.map((t) => t.toLowerCase());
+    if (lower.includes("rule") || lower.includes("canonical")) return "rule";
+    if (lower.includes("decision")) return "decision";
+    if (lower.includes("test") || lower.includes("test-fixture")) return "test";
+  }
+  if (type === "decision") return "decision";
+  if (type === "pattern") return "rule";
+  return "episodic";
+}
+var AUTHORITY_POSITIVE_TAGS = /* @__PURE__ */ new Set([
+  "canonical",
+  "active",
+  "source-of-truth",
+  "pinned"
+]);
+var AUTHORITY_NEGATIVE_TAGS = /* @__PURE__ */ new Set([
+  "superseded",
+  "historical",
+  "test-fixture",
+  "do-not-answer-from"
+]);
+function authorityMultiplier(tier, tags) {
+  let multiplier = 1;
+  if (tier === "rule") multiplier += 0.2;
+  else if (tier === "decision") multiplier += 0.15;
+  else if (tier === "test") multiplier -= 0.1;
+  if (tags) {
+    for (const tag of tags) {
+      const lower = tag.toLowerCase();
+      if (AUTHORITY_POSITIVE_TAGS.has(lower)) multiplier += 0.1;
+      if (AUTHORITY_NEGATIVE_TAGS.has(lower)) multiplier -= 0.15;
+    }
+  }
+  return Math.max(0.5, Math.min(1.5, multiplier));
+}
+var ENTITY_STOPWORDS = /* @__PURE__ */ new Set([
+  "the",
+  "this",
+  "that",
+  "with",
+  "from",
+  "have",
+  "been",
+  "will",
+  "would",
+  "could",
+  "should",
+  "there",
+  "their",
+  "about",
+  "which",
+  "when",
+  "what",
+  "they",
+  "them",
+  "then",
+  "than",
+  "into",
+  "after",
+  "before",
+  "between",
+  "during",
+  "through",
+  "above",
+  "below",
+  "under",
+  "over",
+  "again",
+  "because",
+  "while",
+  "where",
+  "these",
+  "those",
+  "being",
+  "having",
+  "using",
+  "based",
+  "other",
+  "some",
+  "such",
+  "more",
+  "most",
+  "only",
+  "very",
+  "also",
+  "just",
+  "like",
+  "even",
+  "still",
+  "back",
+  "make",
+  "made",
+  "used",
+  "uses",
+  "using",
+  "want",
+  "need",
+  "know",
+  "think",
+  "thing",
+  "things",
+  "stuff",
+  "code",
+  "file",
+  "files",
+  "line",
+  "lines",
+  "here",
+  "there",
+  "where",
+  "when",
+  "what",
+  "which",
+  "whose"
+]);
+function extractEntities(text) {
+  const capsMatches = text.match(/\b[A-Z][a-zA-Z]{2,}\b/g) ?? [];
+  const techMatches = text.match(/\b[a-z]+[-_][a-z]+\b/gi) ?? [];
+  const acroMatches = text.match(/\b[A-Z]{2,}\b/g) ?? [];
+  const words = text.match(/\b[a-z]{5,}\b/gi) ?? [];
+  const candidates = [...capsMatches, ...techMatches, ...acroMatches, ...words];
+  const seen = /* @__PURE__ */ new Set();
+  const entities = [];
+  for (const candidate of candidates) {
+    const lower = candidate.toLowerCase();
+    if (ENTITY_STOPWORDS.has(lower)) continue;
+    if (seen.has(lower)) continue;
+    seen.add(lower);
+    entities.push(lower);
+    if (entities.length >= 10) break;
+  }
+  return entities;
+}
 var SQLiteBackend = class {
   db;
+  /** v11: Single-writer queue — serializes all write operations to prevent "database is locked". */
+  writeQueue = new WriteQueue();
   /** Get the underlying database instance (for CodeGraph/Wiki operations). */
   getDatabase() {
     return this.db;
@@ -292,7 +384,7 @@ var SQLiteBackend = class {
       this.db = new Database(dbPath, { readonly: true });
     }
     try {
-      this.db.pragma("busy_timeout = 5000");
+      this.db.pragma("busy_timeout = 10000");
     } catch {
     }
     if (!readonly) {
@@ -413,6 +505,41 @@ var SQLiteBackend = class {
         this.writeSchemaVersion(9);
       })();
     }
+    if (currentVersion < 10) {
+      migrationsRan = true;
+      this.backupDatabase(dbPath, 9);
+      this.db.transaction(() => {
+        this.runSchema();
+        this.migrateV9ToV10();
+        this.writeSchemaVersion(10);
+      })();
+    }
+    if (currentVersion < 11) {
+      migrationsRan = true;
+      this.backupDatabase(dbPath, 10);
+      this.db.transaction(() => {
+        this.runSchema();
+        this.writeSchemaVersion(11);
+      })();
+    }
+    if (currentVersion < 12) {
+      migrationsRan = true;
+      this.backupDatabase(dbPath, 11);
+      this.db.transaction(() => {
+        this.runSchema();
+        this.migrateV11ToV12();
+        this.writeSchemaVersion(12);
+      })();
+    }
+    if (currentVersion < 13) {
+      migrationsRan = true;
+      this.backupDatabase(dbPath, 12);
+      this.db.transaction(() => {
+        this.runSchema();
+        this.migrateV12ToV13();
+        this.writeSchemaVersion(13);
+      })();
+    }
     this.rebuildFtsIfNeeded(migrationsRan);
   }
   /**
@@ -647,33 +774,93 @@ var SQLiteBackend = class {
     try {
       this.db.exec("ALTER TABLE symbols ADD COLUMN module_path TEXT");
       addedAny = true;
-    } catch {
+    } catch (err) {
+      if (!String(err).includes("duplicate column"))
+        console.error(`[remem-mcp] migrateV8ToV9: ${err}`);
     }
     try {
       this.db.exec("ALTER TABLE calls ADD COLUMN confidence REAL");
       addedAny = true;
-    } catch {
+    } catch (err) {
+      if (!String(err).includes("duplicate column"))
+        console.error(`[remem-mcp] migrateV8ToV9: ${err}`);
     }
     try {
       this.db.exec("ALTER TABLE calls ADD COLUMN call_type TEXT NOT NULL DEFAULT 'direct'");
       addedAny = true;
-    } catch {
+    } catch (err) {
+      if (!String(err).includes("duplicate column"))
+        console.error(`[remem-mcp] migrateV8ToV9: ${err}`);
     }
     if (addedAny) {
-      console.error("[remem-mcp] Added CodeGraph call resolution columns (module_path, confidence, call_type)");
+      console.error(
+        "[remem-mcp] Added CodeGraph call resolution columns (module_path, confidence, call_type)"
+      );
     }
     console.error("[remem-mcp] Migrated schema v8 \u2192 v9 (CodeGraph call resolution)");
   }
+  /** Migrate schema v9 → v10: add tier + salience columns to captures, create entities table, backfill tiers. */
+  migrateV9ToV10() {
+    let addedAny = false;
+    try {
+      this.db.exec("ALTER TABLE captures ADD COLUMN tier TEXT NOT NULL DEFAULT 'episodic'");
+      addedAny = true;
+    } catch {
+    }
+    try {
+      this.db.exec("ALTER TABLE captures ADD COLUMN salience REAL NOT NULL DEFAULT 1.0");
+      addedAny = true;
+    } catch {
+    }
+    if (addedAny) {
+      console.error("[remem-mcp] Added tier + salience columns to captures");
+    }
+    this.db.exec("UPDATE captures SET tier = 'decision' WHERE type = 'decision' AND tier = 'episodic'");
+    this.db.exec("UPDATE captures SET tier = 'rule' WHERE type = 'pattern' AND tier = 'episodic'");
+    this.db.exec("UPDATE captures SET tier = 'test' WHERE type = 'error' AND tags LIKE '%test%' AND tier = 'episodic'");
+    console.error("[remem-mcp] Migrated schema v9 \u2192 v10 (authority tiers + salience + entities table)");
+  }
+  /**
+   * v11 → v12: Add expires_at + feedback_salience columns to captures.
+   * Create capture_feedback + audit_log tables (via runSchema).
+   * No data migration needed — new columns have defaults.
+   */
+  migrateV11ToV12() {
+    const cols = this.db.prepare("PRAGMA table_info(captures)").all();
+    const colNames = new Set(cols.map((c) => c.name));
+    if (!colNames.has("expires_at")) {
+      this.db.exec("ALTER TABLE captures ADD COLUMN expires_at INTEGER");
+    }
+    if (!colNames.has("feedback_salience")) {
+      this.db.exec("ALTER TABLE captures ADD COLUMN feedback_salience REAL NOT NULL DEFAULT 1.0");
+    }
+    console.error("[remem-mcp] Migrated schema v11 \u2192 v12 (feedback + mutation log + TTL)");
+  }
+  /**
+   * v12 → v13: Add weight column to memory_links for Hebbian co-retrieval strengthening.
+   */
+  migrateV12ToV13() {
+    const cols = this.db.prepare("PRAGMA table_info(memory_links)").all();
+    const colNames = new Set(cols.map((c) => c.name));
+    if (!colNames.has("weight")) {
+      this.db.exec("ALTER TABLE memory_links ADD COLUMN weight REAL NOT NULL DEFAULT 1.0");
+    }
+    console.error("[remem-mcp] Migrated schema v12 \u2192 v13 (Hebbian link weights)");
+  }
   async put(entry) {
+    this.putInternal(entry);
+  }
+  putInternal(entry) {
     const contentHash = entry.contentHash ?? createHash("sha256").update(entry.content).digest("hex");
+    const tier = autoAssignTier(entry.type, entry.tags);
     const putTx = this.db.transaction(() => {
       const dup = this.db.prepare(
         "SELECT 1 FROM captures WHERE content_hash = ? AND session_key = ? AND agent_id = ? AND deleted_at IS NULL LIMIT 1"
       ).get(contentHash, entry.sessionKey, entry.agentId);
       if (dup) return false;
       this.db.prepare(
-        `INSERT INTO captures (id, session_key, agent_id, type, content, content_hash, tags, created_at, metadata, team_id, user_id, task_id, trust_state)
-           VALUES (?, ?, ?, ?, ?, ?, ?, ?, ?, ?, ?, ?, ?)`
+        `INSERT INTO captures (id, session_key, agent_id, type, content, content_hash, tags, created_at, metadata, team_id, user_id, task_id, trust_state, tier)
+           VALUES (?, ?, ?, ?, ?, ?, ?, ?, ?, ?, ?, ?, ?, ?)`
       ).run(
         entry.id,
         entry.sessionKey,
@@ -687,7 +874,8 @@ var SQLiteBackend = class {
         entry.teamId ?? null,
         entry.userId ?? null,
         entry.taskId ?? null,
-        entry.trustState ?? "candidate"
+        entry.trustState ?? "candidate",
+        tier
       );
       if (entry.messages && entry.messages.length > 0) {
         const msgStmt = this.db.prepare(
@@ -700,7 +888,18 @@ var SQLiteBackend = class {
       }
       return true;
     });
-    putTx();
+    const inserted = putTx();
+    if (inserted) {
+      try {
+        const entities = extractEntities(entry.content);
+        if (entities.length > 0) {
+          this.putEntitiesInternal(entry.id, entities);
+        }
+        this.autoLinkCapture(entry.id, entry.tags, entities, entry.sessionKey);
+      } catch {
+      }
+      this.recordAuditInternal("put", entry.id, { type: entry.type, tags: entry.tags }, entry.agentId);
+    }
   }
   async putVector(id, embedding) {
     const buffer = new Float32Array(embedding);
@@ -832,7 +1031,7 @@ var SQLiteBackend = class {
   }
   async listAll(limit = 50, offset = 0) {
     const rows = this.db.prepare(
-      "SELECT * FROM captures WHERE deleted_at IS NULL AND trust_state != 'rejected' AND superseded_by IS NULL ORDER BY created_at DESC LIMIT ? OFFSET ?"
+      "SELECT * FROM captures WHERE deleted_at IS NULL AND trust_state != 'rejected' AND superseded_by IS NULL AND id IS NOT NULL ORDER BY created_at DESC LIMIT ? OFFSET ?"
     ).all(limit, offset);
     return rows.map(rowToEntry);
   }
@@ -840,7 +1039,8 @@ var SQLiteBackend = class {
     this.db.prepare("DELETE FROM atoms WHERE capture_id = ?").run(captureId);
   }
   async search(query, queryEmbedding, opts) {
-    const { mode, limit, offset, sessionKey, filters } = opts;
+    const { mode, limit, offset, sessionKey, filters, explain } = opts;
+    const explainMap = /* @__PURE__ */ new Map();
     const temporalIntent = /\b(currently|current|now|latest|new|present|today|active)\b/i.test(
       query
     );
@@ -856,8 +1056,48 @@ var SQLiteBackend = class {
     if (mode === "hybrid" || mode === "keyword") {
       bm25Results = this.bm25Search(query, bm25CandidateLimit, sessionKey, filters);
     }
+    let entityResults = [];
+    let queryEntities = [];
+    if (mode === "hybrid" || mode === "keyword") {
+      try {
+        queryEntities = extractEntities(query);
+        if (queryEntities.length > 0) {
+          entityResults = this.searchByEntities(
+            queryEntities,
+            limit * 2,
+            sessionKey,
+            filters ? { teamId: filters.teamId, userId: filters.userId, taskId: filters.taskId, type: filters.type } : void 0
+          );
+        }
+      } catch {
+      }
+    }
+    if (explain) {
+      bm25Results.forEach((r, i) => {
+        explainMap.set(r.id, { ...explainMap.get(r.id) ?? {}, bm25_rank: i + 1, bm25_score: r.score });
+      });
+      vecResults.forEach((r, i) => {
+        explainMap.set(r.id, { ...explainMap.get(r.id) ?? {}, vector_rank: i + 1, vector_score: r.score });
+      });
+      entityResults.forEach((r, i) => {
+        explainMap.set(r.id, { ...explainMap.get(r.id) ?? {}, entity_rank: i + 1, entity_matches: queryEntities });
+      });
+    }
     if (mode === "keyword") {
-      return this.fetchEntries(bm25Results, limit, offset, temporalIntent);
+      const allResults = [...bm25Results, ...entityResults];
+      if (entityResults.length > 0) {
+        const scores = /* @__PURE__ */ new Map();
+        const sortedBm25 = [...bm25Results].sort((a, b) => a.score - b.score);
+        sortedBm25.forEach((r, i) => {
+          scores.set(r.id, (scores.get(r.id) ?? 0) + 1 / (40 + i + 1));
+        });
+        entityResults.forEach((r, i) => {
+          scores.set(r.id, (scores.get(r.id) ?? 0) + r.score);
+        });
+        const merged = [...scores.entries()].map(([id, score]) => ({ id, score })).sort((a, b) => b.score - a.score).slice(0, limit + offset);
+        return this.fetchEntriesById(merged.slice(offset, offset + limit), temporalIntent, false, explain ? explainMap : void 0);
+      }
+      return this.fetchEntriesById((allResults.length > 0 ? allResults : bm25Results).slice(offset, offset + limit), temporalIntent, false, explain ? explainMap : void 0);
     }
     if (mode === "vector") {
       const similarityResults = vecResults.map((r) => ({ id: r.id, score: 1 / (1 + r.score) }));
@@ -866,6 +1106,14 @@ var SQLiteBackend = class {
     if (isScale) {
       const rrfPoolSize = Math.min(Math.max((limit + offset) * 20, 100), 500);
       const fused2 = rrfMerge(bm25Results, vecResults, rrfPoolSize);
+      if (entityResults.length > 0) {
+        const entityIds = new Set(entityResults.map((e) => e.id));
+        for (const e of entityResults) {
+          if (!fused2.some((f) => f.id === e.id)) {
+            fused2.push(e);
+          }
+        }
+      }
       const fusedIds = new Set(fused2.map((f) => f.id));
       const extraVec = vecResults.filter((v) => !fusedIds.has(v.id)).map((v) => ({ id: v.id, score: 0 }));
       const paged2 = [...fused2, ...extraVec];
@@ -873,8 +1121,101 @@ var SQLiteBackend = class {
       return scored.slice(0, limit);
     }
     const fused = rrfMerge(bm25Results, vecResults, limit + offset);
+    if (entityResults.length > 0) {
+      for (const e of entityResults) {
+        if (!fused.some((f) => f.id === e.id)) {
+          fused.push(e);
+        }
+      }
+      fused.sort((a, b) => b.score - a.score);
+    }
+    const topIds = fused.slice(0, Math.min(limit, 20)).map((f) => f.id);
+    if (topIds.length > 0) {
+      const expanded = this.expandByLinks(topIds, limit * 2);
+      const fusedIds = new Set(fused.map((f) => f.id));
+      for (const exp of expanded) {
+        if (!fusedIds.has(exp.id)) {
+          fused.push(exp);
+          if (explain) {
+            const sourceId = topIds.find(
+              (id) => this.getLinksFrom(id).some((l) => l.to_id === exp.id) || this.getLinksTo(id).some((l) => l.from_id === exp.id)
+            );
+            explainMap.set(exp.id, {
+              ...explainMap.get(exp.id) ?? {},
+              link_provenance: sourceId ? `expanded from ${sourceId}` : "link-neighbor"
+            });
+          }
+        }
+      }
+      fused.sort((a, b) => b.score - a.score);
+    }
     const paged = fused.slice(offset, offset + limit);
-    return this.fetchEntriesById(paged, temporalIntent);
+    const results = await this.fetchEntriesById(paged, temporalIntent, false, explain ? explainMap : void 0);
+    if (results.length === 0 && mode === "hybrid") {
+      const rawResults = this.rawFallbackSearch(query, limit, sessionKey, filters);
+      if (rawResults.length > 0) {
+        if (explain) {
+          rawResults.forEach((r) => {
+            explainMap.set(r.id, { ...explainMap.get(r.id) ?? {}, raw_fallback: true });
+          });
+        }
+        return this.fetchEntriesById(rawResults.slice(0, limit), temporalIntent, false, explain ? explainMap : void 0);
+      }
+    }
+    if (results.length >= 2) {
+      try {
+        this.strengthenLinksOnCoRetrieval(results.map((r) => r.entry.id));
+      } catch {
+      }
+    }
+    return results;
+  }
+  /**
+   * v11: Raw observation fallback search.
+   * Searches FTS5 without trust_state filter — includes stale and rejected.
+   * Still excludes soft-deleted and superseded (those are intentionally removed).
+   */
+  rawFallbackSearch(query, limit, sessionKey, filters) {
+    const ftsQuery = this.escapeFtsQuery(query);
+    if (!ftsQuery) return [];
+    const conditions = ["c.deleted_at IS NULL", "c.superseded_by IS NULL"];
+    const params = [];
+    if (sessionKey) {
+      conditions.push("c.session_key = ?");
+      params.push(sessionKey);
+    }
+    if (filters?.teamId) {
+      conditions.push("c.team_id = ?");
+      params.push(filters.teamId);
+    }
+    if (filters?.userId) {
+      conditions.push("c.user_id = ?");
+      params.push(filters.userId);
+    }
+    if (filters?.taskId) {
+      conditions.push("c.task_id = ?");
+      params.push(filters.taskId);
+    }
+    if (filters?.type) {
+      conditions.push("c.type = ?");
+      params.push(filters.type);
+    }
+    try {
+      const rows = this.db.prepare(
+        `SELECT fts.id as id, bm25(captures_fts) as score
+           FROM captures_fts fts
+           JOIN captures c ON c.id = fts.id
+           WHERE captures_fts MATCH ? AND ${conditions.join(" AND ")}
+           ORDER BY score ASC
+           LIMIT ?`
+      ).all(ftsQuery, ...params, limit);
+      return rows.map((r, i) => ({
+        id: r.id,
+        score: 1 / (40 + i + 1)
+      }));
+    } catch {
+      return [];
+    }
   }
   /** Run a BM25 search via FTS5. */
   bm25Search(query, limit, sessionKey, filters) {
@@ -999,7 +1340,7 @@ var SQLiteBackend = class {
     return this.fetchEntriesById(paged, temporalIntent);
   }
   /** Fetch capture entries by ID, preserving the order of the input list. Applies memory decay and trust-state ranking. */
-  async fetchEntriesById(results, temporalIntent = false, scaleBoost = false) {
+  async fetchEntriesById(results, temporalIntent = false, scaleBoost = false, explainMap) {
     if (results.length === 0) return [];
     const ids = results.map((r) => r.id);
     const placeholders = ids.map(() => "?").join(",");
@@ -1040,7 +1381,17 @@ var SQLiteBackend = class {
       const lastAccessed = row.last_accessed_at;
       const accessBoost = accessCount > 0 && lastAccessed ? 0.3 + 1.2 * (1 / (1 + (now - lastAccessed) / (7 * 24 * 60 * 60 * 1e3))) : 1;
       const accessScored = biasedScore >= 0 ? biasedScore * accessBoost : biasedScore / accessBoost;
-      return { entry: rowToEntry(row), score: accessScored };
+      const tier = row.tier ?? "episodic";
+      const authBoost = authorityMultiplier(tier, tags);
+      const authScored = accessScored >= 0 ? accessScored * authBoost : accessScored / authBoost;
+      const feedbackSalience = row.feedback_salience ?? 1;
+      const feedbackScored = feedbackSalience !== 1 ? authScored >= 0 ? authScored * feedbackSalience : authScored / feedbackSalience : authScored;
+      const scoreDetails = explainMap ? {
+        ...explainMap.get(row.id) ?? {},
+        authority_multiplier: authBoost,
+        feedback_salience: feedbackSalience
+      } : void 0;
+      return { entry: rowToEntry(row), score: feedbackScored, scoreDetails };
     }).filter((r) => r !== null).filter((r) => !temporalIntent || r.entry.trustState !== "stale").sort((a, b) => {
       if (temporalIntent) {
         const timeDiff = b.entry.createdAt - a.entry.createdAt;
@@ -1454,9 +1805,9 @@ var SQLiteBackend = class {
   // ─── Skills ─────────────────────────────────────────────────
   async putSkill(entry) {
     this.db.prepare(
-      `INSERT INTO skills (id, team_id, agent_id, name, description, content, version, created_at, updated_at)
-         VALUES (?, ?, ?, ?, ?, ?, ?, ?, ?)
-         ON CONFLICT(id) DO UPDATE SET name = excluded.name, description = excluded.description, content = excluded.content, version = excluded.version, updated_at = excluded.updated_at`
+      `INSERT INTO skills (id, team_id, agent_id, name, description, content, version, created_at, updated_at, trigger_conditions, steps, validation_rules, source_capture_ids, archived)
+         VALUES (?, ?, ?, ?, ?, ?, ?, ?, ?, ?, ?, ?, ?, ?)
+         ON CONFLICT(id) DO UPDATE SET name = excluded.name, description = excluded.description, content = excluded.content, version = excluded.version, updated_at = excluded.updated_at, trigger_conditions = excluded.trigger_conditions, steps = excluded.steps, validation_rules = excluded.validation_rules, source_capture_ids = excluded.source_capture_ids, archived = excluded.archived`
     ).run(
       entry.id,
       entry.teamId,
@@ -1466,7 +1817,12 @@ var SQLiteBackend = class {
       entry.content ?? null,
       entry.version,
       entry.createdAt,
-      entry.updatedAt
+      entry.updatedAt,
+      entry.triggerConditions ? JSON.stringify(entry.triggerConditions) : null,
+      entry.steps ? JSON.stringify(entry.steps) : null,
+      entry.validationRules ? JSON.stringify(entry.validationRules) : null,
+      entry.sourceCaptureIds ? JSON.stringify(entry.sourceCaptureIds) : null,
+      entry.archived ? 1 : 0
     );
   }
   async getSkill(id) {
@@ -1497,6 +1853,434 @@ var SQLiteBackend = class {
   close() {
     this.db.close();
   }
+  // ─── Canvas + Refs (v9: symbolic short-term memory) ───────────────────
+  // These methods implement the StorageBackend interface for F1 (Mermaid canvas).
+  async appendCanvasNode(sessionKey, node, edges, teamId) {
+    const now = Date.now();
+    let canvasRow = this.db.prepare("SELECT id FROM canvases WHERE session_key = ? ORDER BY updated_at DESC LIMIT 1").get(sessionKey);
+    if (!canvasRow) {
+      const canvasId = `01${now.toString(36).toUpperCase()}${Math.random().toString(36).slice(2, 10).toUpperCase()}`;
+      this.db.prepare(
+        "INSERT INTO canvases (id, session_key, mermaid_text, node_count, created_at, updated_at, team_id) VALUES (?, ?, NULL, 0, ?, ?, ?)"
+      ).run(canvasId, sessionKey, now, now, teamId ?? null);
+      canvasRow = { id: canvasId };
+    }
+    const maxSeq = this.db.prepare("SELECT MAX(seq) as max_seq FROM canvas_nodes WHERE canvas_id = ?").get(canvasRow.id);
+    const seq = (maxSeq.max_seq ?? 0) + 1;
+    this.db.prepare(
+      "INSERT INTO canvas_nodes (id, canvas_id, node_id, label, seq, created_at) VALUES (?, ?, ?, ?, ?, ?)"
+    ).run(`01${now.toString(36).toUpperCase()}${Math.random().toString(36).slice(2, 10).toUpperCase()}`, canvasRow.id, node.id, node.label, seq, now);
+    for (const edge of edges) {
+      this.db.prepare(
+        "INSERT INTO canvas_edges (id, canvas_id, from_node_id, to_node_id, label, created_at) VALUES (?, ?, ?, ?, ?, ?)"
+      ).run(`01${now.toString(36).toUpperCase()}${Math.random().toString(36).slice(2, 10).toUpperCase()}`, canvasRow.id, edge.from, edge.to, edge.label ?? null, now);
+    }
+    this.db.prepare("UPDATE canvases SET node_count = node_count + 1, updated_at = ? WHERE id = ?").run(now, canvasRow.id);
+    const allNodes = this.db.prepare("SELECT node_id, label FROM canvas_nodes WHERE canvas_id = ? ORDER BY seq ASC").all(canvasRow.id);
+    const allEdges = this.db.prepare("SELECT from_node_id, to_node_id, label FROM canvas_edges WHERE canvas_id = ?").all(canvasRow.id);
+    const mermaidLines = ["graph LR"];
+    for (const n of allNodes) {
+      mermaidLines.push(`  ${n.node_id}["${n.label.replace(/"/g, "'")}"]`);
+    }
+    for (const e of allEdges) {
+      if (e.label) {
+        mermaidLines.push(`  ${e.from_node_id} -->|${e.label.replace(/"/g, "'")}| ${e.to_node_id}`);
+      } else {
+        mermaidLines.push(`  ${e.from_node_id} --> ${e.to_node_id}`);
+      }
+    }
+    this.db.prepare("UPDATE canvases SET mermaid_text = ? WHERE id = ?").run(mermaidLines.join("\n"), canvasRow.id);
+  }
+  async getLatestCanvasNode(sessionKey) {
+    const row = this.db.prepare(
+      `SELECT cn.node_id as id, cn.label, cn.node_id as captureId
+         FROM canvas_nodes cn
+         JOIN canvases c ON cn.canvas_id = c.id
+         WHERE c.session_key = ?
+         ORDER BY cn.seq DESC LIMIT 1`
+    ).get(sessionKey);
+    return row ?? null;
+  }
+  async getCanvasMermaidText(sessionKey) {
+    const row = this.db.prepare("SELECT mermaid_text FROM canvases WHERE session_key = ? ORDER BY updated_at DESC LIMIT 1").get(sessionKey);
+    return row?.mermaid_text ?? null;
+  }
+  async writeRef(sessionKey, nodeId, content) {
+    const refsDir = join(homedir(), ".local", "share", "remem-mcp", "refs", sessionKey);
+    try {
+      mkdirSync(refsDir, { recursive: true });
+      writeFileSync(join(refsDir, `${nodeId}.md`), content, "utf-8");
+    } catch (err) {
+      console.error(`[remem-mcp] writeRef failed: ${err}`);
+    }
+  }
+  async readRef(nodeId) {
+    const refsBase = join(homedir(), ".local", "share", "remem-mcp", "refs");
+    try {
+      const sessions = readdirSync(refsBase);
+      for (const session of sessions) {
+        const refPath = join(refsBase, session, `${nodeId}.md`);
+        if (existsSync(refPath)) {
+          return readFileSync(refPath, "utf-8");
+        }
+      }
+    } catch {
+    }
+    return null;
+  }
+  // ─── v10: Decay/forget sweep ──────────────────────────────────
+  /**
+   * Run a forget sweep: compute salience for all non-deleted, non-evergreen captures,
+   * then soft-delete (set deleted_at) those below the threshold.
+   *
+   * Salience formula (adapted from ai-memory):
+   *   salience = exp(-lambda * age_days) + sigma * log(1 + access_count) * exp(-mu * days_since_access)
+   *
+   * - lambda: age decay rate (default 0.01, ~70 day half-life)
+   * - sigma: access frequency weight (default 0.3)
+   * - mu: access recency decay (default 0.02, ~35 day half-life)
+   *
+   * Evergreen tags and tier=rule/decision captures are exempt (salience stays 1.0).
+   * Verified captures get a floor of 0.3.
+   */
+  async forgetSweep(opts = {}) {
+    const dryRun = opts.dryRun ?? false;
+    const threshold = opts.threshold ?? 0.05;
+    const maxAgeDays = opts.maxAgeDays ?? 365;
+    const maxAgeMs = maxAgeDays * 24 * 60 * 60 * 1e3;
+    const lambda = 0.01;
+    const sigma = 0.3;
+    const mu = 0.02;
+    const now = Date.now();
+    const rows = this.db.prepare(
+      `SELECT id, type, tags, created_at, access_count, last_accessed_at, trust_state, tier, expires_at, feedback_salience
+         FROM captures
+         WHERE deleted_at IS NULL AND (created_at < ? OR (expires_at IS NOT NULL AND expires_at < ?))`
+    ).all(now - maxAgeMs, now);
+    let swept = 0;
+    let remaining = 0;
+    const toDelete = [];
+    for (const row of rows) {
+      if (row.expires_at !== null && row.expires_at < now) {
+        toDelete.push(row.id);
+        swept++;
+        continue;
+      }
+      const tags = row.tags ? JSON.parse(row.tags) : [];
+      const evergreen = isEvergreen(tags);
+      if (evergreen || row.tier === "rule" || row.tier === "decision") {
+        remaining++;
+        continue;
+      }
+      const ageDays = (now - row.created_at) / (24 * 60 * 60 * 1e3);
+      const daysSinceAccess = row.last_accessed_at ? (now - row.last_accessed_at) / (24 * 60 * 60 * 1e3) : ageDays;
+      const ageTerm = Math.exp(-lambda * ageDays);
+      const accessTerm = sigma * Math.log(1 + (row.access_count ?? 0)) * Math.exp(-mu * daysSinceAccess);
+      let salience = ageTerm + accessTerm;
+      if (row.trust_state === "verified") {
+        salience = Math.max(salience, 0.3);
+      }
+      salience *= row.feedback_salience ?? 1;
+      if (salience < threshold) {
+        toDelete.push(row.id);
+        swept++;
+      } else {
+        remaining++;
+      }
+    }
+    if (!dryRun && toDelete.length > 0) {
+      const deleteStmt = this.db.prepare(
+        "UPDATE captures SET deleted_at = ? WHERE id = ? AND deleted_at IS NULL"
+      );
+      const tx = this.db.transaction(() => {
+        for (const id of toDelete) {
+          deleteStmt.run(now, id);
+          this.recordAuditInternal("forget", id, { reason: "salience_below_threshold_or_ttl_expired" });
+        }
+      });
+      tx();
+    }
+    return { swept, remaining, checked: rows.length };
+  }
+  // ─── v10: Entity-assisted recall ──────────────────────────────
+  /** Store extracted entities for a capture (replaces existing). */
+  putEntities(captureId, entities) {
+    this.putEntitiesInternal(captureId, entities);
+  }
+  /** Internal entity storage — called from within putInternal. */
+  putEntitiesInternal(captureId, entities) {
+    if (entities.length === 0) return;
+    const tx = this.db.transaction(() => {
+      this.db.prepare("DELETE FROM entities WHERE capture_id = ?").run(captureId);
+      const stmt = this.db.prepare(
+        "INSERT INTO entities (capture_id, entity, created_at) VALUES (?, ?, ?)"
+      );
+      const now = Date.now();
+      for (const entity of entities.slice(0, 10)) {
+        stmt.run(captureId, entity.toLowerCase(), now);
+      }
+    });
+    tx();
+  }
+  /** Get entities for a capture. */
+  getEntities(captureId) {
+    const rows = this.db.prepare("SELECT entity FROM entities WHERE capture_id = ? ORDER BY id").all(captureId);
+    return rows.map((r) => r.entity);
+  }
+  /**
+   * Search captures by entity match (lexical).
+   * Returns capture IDs ranked by number of matching entities (RRF-style).
+   */
+  searchByEntities(entities, limit, sessionKey, filters) {
+    if (entities.length === 0) return [];
+    const normalized = entities.map((e) => e.toLowerCase());
+    const placeholders = normalized.map(() => "?").join(",");
+    const params = [...normalized];
+    const conditions = [
+      "c.deleted_at IS NULL",
+      "c.trust_state != 'rejected'",
+      "c.superseded_by IS NULL"
+    ];
+    if (sessionKey) {
+      conditions.push("c.session_key = ?");
+      params.push(sessionKey);
+    }
+    if (filters?.teamId) {
+      conditions.push("c.team_id = ?");
+      params.push(filters.teamId);
+    }
+    if (filters?.userId) {
+      conditions.push("c.user_id = ?");
+      params.push(filters.userId);
+    }
+    if (filters?.taskId) {
+      conditions.push("c.task_id = ?");
+      params.push(filters.taskId);
+    }
+    if (filters?.type) {
+      conditions.push("c.type = ?");
+      params.push(filters.type);
+    }
+    const rows = this.db.prepare(
+      `SELECT e.capture_id as id, COUNT(*) as match_count
+         FROM entities e
+         JOIN captures c ON c.id = e.capture_id
+         WHERE e.entity IN (${placeholders})
+           AND ${conditions.join(" AND ")}
+         GROUP BY e.capture_id
+         ORDER BY match_count DESC
+         LIMIT ?`
+    ).all(...params, limit);
+    return rows.map((r, i) => ({
+      id: r.id,
+      score: 1 / (40 + i + 1)
+      // same k as RRF
+    }));
+  }
+  // ─── v11: Memory-to-memory links ──────────────────────────────
+  /** Link two captures. Auto-links use auto=1. */
+  linkCaptures(fromId, toId, linkType, auto = false) {
+    if (fromId === toId) return;
+    try {
+      this.db.prepare(
+        `INSERT OR IGNORE INTO memory_links (from_id, to_id, link_type, auto, created_at)
+           VALUES (?, ?, ?, ?, ?)`
+      ).run(fromId, toId, linkType, auto ? 1 : 0, Date.now());
+      this.recordAuditInternal("link", fromId, { toId, linkType, auto });
+    } catch {
+    }
+  }
+  /** Get links from a capture (outbound). */
+  getLinksFrom(captureId) {
+    return this.db.prepare("SELECT to_id, link_type, auto FROM memory_links WHERE from_id = ?").all(captureId);
+  }
+  /** Get links to a capture (inbound). */
+  getLinksTo(captureId) {
+    return this.db.prepare("SELECT from_id, link_type, auto FROM memory_links WHERE to_id = ?").all(captureId);
+  }
+  /**
+   * Expand capture IDs via link-neighbor traversal (1-hop).
+   * Returns linked capture IDs with decayed score (0.5x of original).
+   * Only includes non-deleted, non-rejected captures.
+   */
+  expandByLinks(ids, limit) {
+    if (ids.length === 0) return [];
+    const placeholders = ids.map(() => "?").join(",");
+    const rows = this.db.prepare(
+      `SELECT linked_id as id, MAX(weight) as weight FROM (
+          SELECT to_id as linked_id, weight FROM memory_links WHERE from_id IN (${placeholders})
+          UNION
+          SELECT from_id as linked_id, weight FROM memory_links WHERE to_id IN (${placeholders})
+        )
+        WHERE linked_id NOT IN (${placeholders})
+        GROUP BY linked_id
+        ORDER BY weight DESC
+        LIMIT ?`
+    ).all(...ids, ...ids, ...ids, limit);
+    if (rows.length === 0) return [];
+    const validPlaceholders = rows.map(() => "?").join(",");
+    const validRows = this.db.prepare(
+      `SELECT id FROM captures WHERE id IN (${validPlaceholders})
+         AND deleted_at IS NULL AND trust_state != 'rejected' AND superseded_by IS NULL`
+    ).all(...rows.map((r) => r.id));
+    const validIds = new Set(validRows.map((r) => r.id));
+    return rows.filter((r) => validIds.has(r.id)).map((r, i) => ({
+      id: r.id,
+      score: 0.5 * (r.weight ?? 1) / (40 + i + 1)
+      // decayed RRF × weight
+    }));
+  }
+  /**
+   * v13: Hebbian co-retrieval strengthening.
+   * When captures co-occur in search results, strengthen links between them.
+   * Creates links if they don't exist, increments weight if they do.
+   */
+  strengthenLinksOnCoRetrieval(ids) {
+    if (ids.length < 2) return;
+    const now = Date.now();
+    const linkType = "co-retrieval";
+    const insertStmt = this.db.prepare(
+      `INSERT OR IGNORE INTO memory_links (from_id, to_id, link_type, auto, weight, created_at)
+       VALUES (?, ?, ?, 1, 1.0, ?)`
+    );
+    const updateStmt = this.db.prepare(
+      `UPDATE memory_links SET weight = weight + 0.1 WHERE from_id = ? AND to_id = ? AND link_type = ?`
+    );
+    const topIds = ids.slice(0, 10);
+    for (let i = 0; i < topIds.length; i++) {
+      for (let j = i + 1; j < topIds.length; j++) {
+        const [a, b] = topIds[i] < topIds[j] ? [topIds[i], topIds[j]] : [topIds[j], topIds[i]];
+        try {
+          insertStmt.run(a, b, linkType, now);
+          updateStmt.run(a, b, linkType);
+        } catch {
+        }
+      }
+    }
+  }
+  /**
+   * Auto-link a new capture to existing captures based on shared tags and entities.
+   * Called after put() + entity extraction.
+   */
+  autoLinkCapture(captureId, tags, entities, sessionKey) {
+    const now = Date.now();
+    const linkStmt = this.db.prepare(
+      `INSERT OR IGNORE INTO memory_links (from_id, to_id, link_type, auto, created_at)
+       VALUES (?, ?, ?, 1, ?)`
+    );
+    if (tags.length > 0) {
+      const tagPlaceholders = tags.map(() => "?").join(",");
+      const tagRows = this.db.prepare(
+        `SELECT DISTINCT c.id as other_id FROM captures c
+           WHERE c.id != ? AND c.session_key = ? AND c.deleted_at IS NULL
+             AND c.tags IS NOT NULL
+             AND (c.tags LIKE ${tags.map(() => "?").join(" OR c.tags LIKE ")})`
+      ).all(
+        captureId,
+        sessionKey,
+        ...tags.map((t) => `%"${t}"%`)
+      );
+      for (const row of tagRows.slice(0, 5)) {
+        linkStmt.run(captureId, row.other_id, "shared-tag", now);
+      }
+    }
+    if (entities.length > 0) {
+      const entityPlaceholders = entities.map(() => "?").join(",");
+      const entityRows = this.db.prepare(
+        `SELECT DISTINCT e.capture_id as other_id FROM entities e
+           JOIN captures c ON c.id = e.capture_id
+           WHERE e.capture_id != ? AND c.session_key = ? AND c.deleted_at IS NULL
+             AND e.entity IN (${entityPlaceholders})`
+      ).all(captureId, sessionKey, ...entities);
+      for (const row of entityRows.slice(0, 5)) {
+        linkStmt.run(captureId, row.other_id, "shared-entity", now);
+      }
+    }
+    const proximityRows = this.db.prepare(
+      `SELECT id as other_id FROM captures
+         WHERE id != ? AND session_key = ? AND deleted_at IS NULL
+           AND ABS(created_at - ?) < 300000
+         ORDER BY ABS(created_at - ?) ASC LIMIT 3`
+    ).all(captureId, sessionKey, now, now);
+    for (const row of proximityRows) {
+      linkStmt.run(captureId, row.other_id, "session-proximity", now);
+    }
+  }
+  // ─── v12: Feedback + audit + TTL ──────────────────────────────
+  /**
+   * Record feedback signal for a capture. Adjusts feedback_salience multiplier.
+   * - helpful: +0.1 (max 2.0)
+   * - not_helpful: -0.1 (min 0.1)
+   * - stale: floor salience at 0.3
+   * - wrong: floor salience at 0.1
+   */
+  recordFeedback(captureId, signal, reason, agentId) {
+    const now = Date.now();
+    this.db.transaction(() => {
+      this.db.prepare(
+        "INSERT INTO capture_feedback (capture_id, signal, reason, agent_id, created_at) VALUES (?, ?, ?, ?, ?)"
+      ).run(captureId, signal, reason ?? null, agentId ?? null, now);
+      const row = this.db.prepare("SELECT feedback_salience FROM captures WHERE id = ?").get(captureId);
+      if (!row) return;
+      let newSalience = row.feedback_salience;
+      if (signal === "helpful") {
+        newSalience = Math.min(2, newSalience + 0.1);
+      } else if (signal === "not_helpful") {
+        newSalience = Math.max(0.1, newSalience - 0.1);
+      } else if (signal === "stale") {
+        newSalience = Math.min(newSalience, 0.3);
+      } else if (signal === "wrong") {
+        newSalience = Math.min(newSalience, 0.1);
+      }
+      this.db.prepare("UPDATE captures SET feedback_salience = ? WHERE id = ?").run(newSalience, captureId);
+      this.recordAuditInternal("feedback", captureId, { signal, reason, newSalience }, agentId);
+    })();
+  }
+  /** Get feedback signals for a capture. */
+  getFeedback(captureId) {
+    return this.db.prepare(
+      "SELECT signal, reason, created_at FROM capture_feedback WHERE capture_id = ? ORDER BY id DESC"
+    ).all(captureId);
+  }
+  /** Record a mutation log entry. Public API. */
+  recordAudit(action, captureId, details, agentId) {
+    this.recordAuditInternal(action, captureId, details, agentId);
+  }
+  /** Internal mutation log — called from within transactions. */
+  recordAuditInternal(action, captureId, details, agentId) {
+    try {
+      this.db.prepare(
+        "INSERT INTO mutation_log (action, capture_id, details, agent_id, created_at) VALUES (?, ?, ?, ?, ?)"
+      ).run(
+        action,
+        captureId,
+        details ? JSON.stringify(details) : null,
+        agentId ?? null,
+        Date.now()
+      );
+    } catch {
+    }
+  }
+  /** Query mutation log. */
+  queryAudit(opts) {
+    const conditions = [];
+    const params = [];
+    if (opts.action) {
+      conditions.push("action = ?");
+      params.push(opts.action);
+    }
+    if (opts.captureId) {
+      conditions.push("capture_id = ?");
+      params.push(opts.captureId);
+    }
+    if (opts.since) {
+      conditions.push("created_at >= ?");
+      params.push(opts.since);
+    }
+    const where = conditions.length > 0 ? `WHERE ${conditions.join(" AND ")}` : "";
+    const limit = opts.limit ?? 100;
+    return this.db.prepare(`SELECT * FROM mutation_log ${where} ORDER BY created_at DESC LIMIT ?`).all(...params, limit);
+  }
 };
 function rowToEntry(row) {
   return {
@@ -1539,733 +2323,20 @@ function skillRowToEntry(row) {
     content: row.content ?? void 0,
     version: row.version,
     createdAt: row.created_at,
-    updatedAt: row.updated_at
+    updatedAt: row.updated_at,
+    triggerConditions: row.trigger_conditions ? JSON.parse(row.trigger_conditions) : void 0,
+    steps: row.steps ? JSON.parse(row.steps) : void 0,
+    validationRules: row.validation_rules ? JSON.parse(row.validation_rules) : void 0,
+    sourceCaptureIds: row.source_capture_ids ? JSON.parse(row.source_capture_ids) : void 0,
+    archived: row.archived === 1
   };
 }
 
-// src/sdk.ts
-init_ulid();
-init_engine();
-
-// src/wiki/engine.ts
-init_esm_shims();
-init_ulid();
-import { createHash as createHash2 } from "crypto";
-import { existsSync as existsSync2, readdirSync, readFileSync as readFileSync2, statSync } from "fs";
-import { basename, extname, join as join2, relative, sep } from "path";
-function parseFrontmatter(content) {
-  if (!content.startsWith("---")) {
-    return { frontmatter: null, body: content };
-  }
-  const end = content.indexOf("\n---", 3);
-  if (end === -1) {
-    return { frontmatter: null, body: content };
-  }
-  const frontmatter = content.slice(3, end).trim();
-  const body = content.slice(end + 4).replace(/^\n/, "");
-  return { frontmatter, body };
-}
-function extractTags(frontmatter) {
-  if (!frontmatter) return null;
-  const match = frontmatter.match(/^tags:\s*(.+)$/m);
-  if (!match) return null;
-  return match[1].replace(/[[\]]/g, "").trim();
-}
-function extractTitle(frontmatter, body, fileName) {
-  if (frontmatter) {
-    const titleMatch = frontmatter.match(/^title:\s*(.+)$/m);
-    if (titleMatch) return titleMatch[1].replace(/["']/g, "").trim();
-  }
-  const h1Match = body.match(/^#\s+(.+)$/m);
-  if (h1Match) return h1Match[1].trim();
-  return basename(fileName, extname(fileName));
-}
-function extractWikilinks(content) {
-  const links = [];
-  const lines = content.split("\n");
-  const regex = /\[\[([^\]|]+)(?:\|([^\]]+))?\]\]/g;
-  for (let i = 0; i < lines.length; i++) {
-    let match;
-    regex.lastIndex = 0;
-    match = regex.exec(lines[i]);
-    while (match !== null) {
-      links.push({
-        target: match[1].trim(),
-        text: (match[2] ?? match[1]).trim(),
-        line: i + 1
-      });
-      match = regex.exec(lines[i]);
-    }
-  }
-  return links;
-}
-function extractMarkdownLinks(content) {
-  const links = [];
-  const lines = content.split("\n");
-  const regex = /(?<!!)\[([^\]]+)\]\(([^)]+)\)/g;
-  for (let i = 0; i < lines.length; i++) {
-    let match;
-    regex.lastIndex = 0;
-    match = regex.exec(lines[i]);
-    while (match !== null) {
-      const target = match[2].trim();
-      if (!target.startsWith("http") && !target.startsWith("mailto:")) {
-        links.push({
-          target: target.replace(/\.md$/i, ""),
-          text: match[1].trim(),
-          line: i + 1
-        });
-      }
-      match = regex.exec(lines[i]);
-    }
-  }
-  return links;
-}
-function parseMarkdownFile(filePath, repoPath) {
-  const ext = extname(filePath).toLowerCase();
-  if (ext !== ".md" && ext !== ".markdown") return null;
-  let source;
-  try {
-    source = readFileSync2(filePath, "utf-8");
-  } catch {
-    return null;
-  }
-  const relPath = relative(repoPath, filePath).split(sep).join("/");
-  const { frontmatter, body } = parseFrontmatter(source);
-  const title = extractTitle(frontmatter, body, filePath);
-  const tags = extractTags(frontmatter);
-  const contentHash = createHash2("sha256").update(source).digest("hex");
-  const page = {
-    id: generateId(),
-    title,
-    content: body,
-    sourceFile: relPath,
-    section: null,
-    tags,
-    frontmatter,
-    contentHash
-  };
-  const wikilinks = extractWikilinks(body).map((l) => ({ ...l, type: "wikilink" }));
-  const mdlinks = extractMarkdownLinks(body).map((l) => ({ ...l, type: "markdown" }));
-  const links = [...wikilinks, ...mdlinks];
-  return { page, links };
-}
-function ingestFile(db, filePath, repoPath, teamId) {
-  const ext = extname(filePath).toLowerCase();
-  if (ext !== ".md" && ext !== ".markdown") {
-    return { file: filePath, pages: 0, links: 0, skipped: true, reason: "not markdown" };
-  }
-  const parsed = parseMarkdownFile(filePath, repoPath);
-  if (!parsed) {
-    return { file: filePath, pages: 0, links: 0, skipped: true, reason: "parse failed" };
-  }
-  const relPath = relative(repoPath, filePath).split(sep).join("/");
-  const now = Date.now();
-  const existing = db.prepare("SELECT id FROM wiki_pages WHERE source_file = ? AND team_id IS ?").get(relPath, teamId);
-  let pageId = parsed.page.id;
-  if (existing) {
-    pageId = existing.id;
-    db.prepare(
-      "UPDATE wiki_pages SET title = ?, content = ?, tags = ?, frontmatter = ?, content_hash = ?, updated_at = ? WHERE id = ?"
-    ).run(
-      parsed.page.title,
-      parsed.page.content,
-      parsed.page.tags,
-      parsed.page.frontmatter,
-      parsed.page.contentHash,
-      now,
-      pageId
-    );
-    db.prepare("DELETE FROM wiki_links WHERE from_page_id = ?").run(pageId);
-  } else {
-    db.prepare(
-      `INSERT INTO wiki_pages (id, title, content, source_file, section, tags, frontmatter, content_hash, team_id, created_at, updated_at)
-       VALUES (?, ?, ?, ?, ?, ?, ?, ?, ?, ?, ?)`
-    ).run(
-      parsed.page.id,
-      parsed.page.title,
-      parsed.page.content,
-      parsed.page.sourceFile,
-      parsed.page.section,
-      parsed.page.tags,
-      parsed.page.frontmatter,
-      parsed.page.contentHash,
-      teamId,
-      now,
-      now
-    );
-  }
-  const linkStmt = db.prepare(
-    "INSERT INTO wiki_links (from_page_id, to_page_id, to_title, link_text, link_type, line) VALUES (?, ?, ?, ?, ?, ?)"
-  );
-  for (const link of parsed.links) {
-    const target = db.prepare("SELECT id FROM wiki_pages WHERE title = ? AND team_id IS ? LIMIT 1").get(link.target, teamId);
-    linkStmt.run(pageId, target?.id ?? null, link.target, link.text, link.type, link.line);
-  }
-  return {
-    file: relPath,
-    pages: 1,
-    links: parsed.links.length,
-    skipped: false
-  };
-}
-function ingestDirectory(db, dirPath, repoPath, teamId, maxFiles = 200) {
-  const results = [];
-  const files = [];
-  const walk = (dir) => {
-    if (files.length >= maxFiles) return;
-    let entries;
-    try {
-      entries = readdirSync(dir);
-    } catch {
-      return;
-    }
-    for (const entry of entries) {
-      if (files.length >= maxFiles) return;
-      const fullPath = join2(dir, entry);
-      let stat;
-      try {
-        stat = statSync(fullPath);
-      } catch {
-        continue;
-      }
-      if (stat.isDirectory()) {
-        if (entry.startsWith(".") || entry === "node_modules" || entry === "vendor") continue;
-        walk(fullPath);
-      } else if (stat.isFile()) {
-        const ext = extname(fullPath).toLowerCase();
-        if (ext === ".md" || ext === ".markdown") {
-          files.push(fullPath);
-        }
-      }
-    }
-  };
-  walk(dirPath);
-  for (const file of files) {
-    const result = ingestFile(db, file, repoPath, teamId);
-    results.push(result);
-  }
-  const unresolved = db.prepare("SELECT id, to_title FROM wiki_links WHERE to_page_id IS NULL").all();
-  if (unresolved.length > 0) {
-    const updateStmt = db.prepare("UPDATE wiki_links SET to_page_id = ? WHERE id = ?");
-    for (const u of unresolved) {
-      const target = db.prepare("SELECT id FROM wiki_pages WHERE title = ? AND team_id IS ? LIMIT 1").get(u.to_title, teamId);
-      if (target) {
-        updateStmt.run(target.id, u.id);
-      }
-    }
-  }
-  return results;
-}
-function searchWiki(db, query, opts = {}) {
-  const limit = opts.limit ?? 10;
-  let sql = `
-    SELECT w.id, w.title, w.source_file, snippet(wiki_fts, 1, '<b>', '</b>', '...', 20) as snippet
-    FROM wiki_fts f
-    JOIN wiki_pages w ON w.id = f.id
-    WHERE wiki_fts MATCH ?
-  `;
-  const params = [query];
-  if (opts.teamId !== void 0) {
-    sql += " AND w.team_id IS ?";
-    params.push(opts.teamId);
-  }
-  sql += " LIMIT ?";
-  params.push(limit);
-  const rows = db.prepare(sql).all(...params);
-  return rows.map((r) => ({
-    id: r.id,
-    title: r.title,
-    sourceFile: r.source_file,
-    snippet: r.snippet
-  }));
-}
-function getWikiPage(db, pageId) {
-  const row = db.prepare("SELECT * FROM wiki_pages WHERE id = ?").get(pageId);
-  if (!row) return null;
-  const page = {
-    id: row.id,
-    title: row.title,
-    content: row.content,
-    sourceFile: row.source_file,
-    section: row.section,
-    tags: row.tags,
-    frontmatter: row.frontmatter,
-    contentHash: row.content_hash
-  };
-  const linkRows = db.prepare("SELECT * FROM wiki_links WHERE from_page_id = ? ORDER BY line").all(pageId);
-  const links = linkRows.map((r) => ({
-    fromPageId: r.from_page_id,
-    toPageId: r.to_page_id,
-    toTitle: r.to_title,
-    linkText: r.link_text,
-    linkType: r.link_type,
-    line: r.line
-  }));
-  const backlinkRows = db.prepare("SELECT * FROM wiki_links WHERE to_page_id = ? ORDER BY line").all(pageId);
-  const backlinks = backlinkRows.map((r) => ({
-    fromPageId: r.from_page_id,
-    toPageId: r.to_page_id,
-    toTitle: r.to_title,
-    linkText: r.link_text,
-    linkType: r.link_type,
-    line: r.line
-  }));
-  return { page, links, backlinks };
-}
-function findOutdatedPages(db, repoPath, opts = {}) {
-  const pages = db.prepare("SELECT id, title, source_file, content_hash FROM wiki_pages WHERE team_id IS ?").all(opts.teamId ?? null);
-  const outdated = [];
-  for (const page of pages) {
-    const fullPath = join2(repoPath, page.source_file);
-    if (!existsSync2(fullPath)) {
-      outdated.push({
-        id: page.id,
-        title: page.title,
-        sourceFile: page.source_file,
-        reason: "file deleted"
-      });
-      continue;
-    }
-    try {
-      const content = readFileSync2(fullPath, "utf-8");
-      const hash = createHash2("sha256").update(content).digest("hex");
-      if (hash !== page.content_hash) {
-        outdated.push({
-          id: page.id,
-          title: page.title,
-          sourceFile: page.source_file,
-          reason: "content changed"
-        });
-      }
-    } catch {
-      outdated.push({
-        id: page.id,
-        title: page.title,
-        sourceFile: page.source_file,
-        reason: "read error"
-      });
-    }
-  }
-  return outdated;
-}
-
-// src/sdk.ts
-function classifyGlobalContent(content, type) {
-  if (type !== "learning" && type !== "decision" && type !== "task") return false;
-  const projectSignals = [
-    /\b\/[a-z]/i,
-    /\b\w+\/\w+\.\w{1,5}\b/,
-    /line\s*\d+/i,
-    /\b\d{4,}\b/,
-    /\bcommit\s+[0-9a-f]{7,}/i,
-    /\bsrc\//,
-    /\bdist\//,
-    /\btests?\//
-  ];
-  for (const sig of projectSignals) {
-    if (sig.test(content)) return false;
-  }
-  const lower = content.toLowerCase();
-  const globalSignals = [
-    /\balways\s+/i,
-    /\bnever\s+/i,
-    /\brule\b/i,
-    /\bconvention\b/i,
-    /\bpattern\b/i,
-    /\bprefer\b/i,
-    /\bavoid\b/i,
-    /\bshould\b/i,
-    /\bbest\s+practice\b/i
-  ];
-  let score = 0;
-  for (const sig of globalSignals) {
-    if (sig.test(lower)) score++;
-  }
-  if (content.length < 300 && score >= 1) return true;
-  if (content.length < 150 && type === "learning") return true;
-  return false;
-}
-var Memory = class {
-  storage;
-  embedder;
-  sessionKey;
-  globalKey;
-  redactSecrets;
-  constructor(opts) {
-    const dbPath = opts?.dbPath ?? join3(homedir(), ".local", "share", "remem-mcp", "memory.db");
-    this.storage = new SQLiteBackend(dbPath);
-    this.embedder = new LocalEmbedder();
-    this.sessionKey = opts?.sessionKey ?? process.env.REMEM_SESSION_KEY ?? createHash3("sha256").update(process.cwd()).digest("hex").slice(0, 16);
-    this.globalKey = opts?.globalSessionKey ?? process.env.REMEM_GLOBAL_SESSION_KEY ?? null;
-    this.redactSecrets = opts?.redactSecrets ?? true;
-  }
-  /** Capture a memory entry. Returns the ID, or null if duplicate. */
-  async capture(content, type, tags = [], opts) {
-    const { text: redactedContent } = this.redactSecrets ? redact(content) : { text: content };
-    let sessionKey = opts?.sessionKey ?? this.sessionKey;
-    if (opts?.autoGlobal && !opts?.sessionKey && this.globalKey && this.globalKey !== sessionKey) {
-      if (classifyGlobalContent(content, type)) {
-        sessionKey = this.globalKey;
-      }
-    }
-    const contentHash = createHash3("sha256").update(redactedContent).digest("hex");
-    const existing = await this.storage.findByContentHash(contentHash, sessionKey);
-    if (existing.length > 0) return null;
-    const id = generateId();
-    const entry = {
-      id,
-      sessionKey,
-      agentId: "sdk",
-      type,
-      content: redactedContent,
-      tags,
-      createdAt: Date.now()
-    };
-    await this.storage.put(entry);
-    try {
-      const embedding = await this.embedder.embed(redactedContent);
-      await this.storage.putVector(id, embedding);
-    } catch {
-    }
-    return id;
-  }
-  /** Recall relevant memory. Searches project + global (if configured). */
-  async recall(query, opts) {
-    const limit = Math.min(opts?.limit ?? 10, 50);
-    const mode = opts?.mode ?? "hybrid";
-    const sessionKey = opts?.sessionKey ?? this.sessionKey;
-    let queryEmbedding = null;
-    if (mode === "hybrid" || mode === "vector") {
-      const stripped = stripQueryProperNouns(query);
-      queryEmbedding = await this.embedder.embed(stripped || query);
-    }
-    if (this.globalKey && !opts?.sessionKey && this.globalKey !== sessionKey) {
-      const reservedGlobal = Math.min(3, limit);
-      const projectLimit = limit - reservedGlobal;
-      const projectResults = await this.storage.search(query, queryEmbedding, {
-        sessionKey,
-        limit: projectLimit,
-        offset: 0,
-        mode
-      });
-      let globalResults = [];
-      try {
-        globalResults = await this.storage.search(query, queryEmbedding, {
-          sessionKey: this.globalKey,
-          limit: reservedGlobal,
-          offset: 0,
-          mode
-        });
-      } catch {
-      }
-      const seen = new Set(projectResults.map((r) => r.entry.id));
-      return [...projectResults, ...globalResults.filter((r) => !seen.has(r.entry.id))].slice(
-        0,
-        limit
-      );
-    }
-    return this.storage.search(query, queryEmbedding, {
-      sessionKey,
-      limit,
-      offset: 0,
-      mode
-    });
-  }
-  /** Search with filters. Searches project + global (if configured). */
-  async search(query, opts) {
-    const limit = Math.min(opts?.limit ?? 20, 100);
-    const mode = opts?.mode ?? "hybrid";
-    const sessionKey = opts?.sessionKey ?? this.sessionKey;
-    let queryEmbedding = null;
-    if (mode === "hybrid" || mode === "vector") {
-      const stripped = stripQueryProperNouns(query);
-      queryEmbedding = await this.embedder.embed(stripped || query);
-    }
-    if (this.globalKey && !opts?.sessionKey && this.globalKey !== sessionKey) {
-      const reservedGlobal = Math.min(3, limit);
-      const projectLimit = limit - reservedGlobal;
-      const projectResults = await this.storage.search(query, queryEmbedding, {
-        sessionKey,
-        limit: projectLimit,
-        offset: 0,
-        mode,
-        filters: opts?.filters
-      });
-      let globalResults = [];
-      try {
-        globalResults = await this.storage.search(query, queryEmbedding, {
-          sessionKey: this.globalKey,
-          limit: reservedGlobal,
-          offset: 0,
-          mode,
-          filters: opts?.filters
-        });
-      } catch {
-      }
-      const seen = new Set(projectResults.map((r) => r.entry.id));
-      return [...projectResults, ...globalResults.filter((r) => !seen.has(r.entry.id))].slice(
-        0,
-        limit
-      );
-    }
-    return this.storage.search(query, queryEmbedding, {
-      sessionKey,
-      limit,
-      offset: 0,
-      mode,
-      filters: opts?.filters
-    });
-  }
-  /** Compute the embedding vector for a piece of text using the configured embedder. */
-  async embed(text) {
-    return this.embedder.embed(text);
-  }
-  /** Delete a capture by ID. */
-  async forget(id) {
-    return this.storage.delete(id);
-  }
-  /** Update an existing capture's content, tags, type, or trust state. */
-  async update(id, opts) {
-    const existing = await this.storage.get(id);
-    if (!existing) return false;
-    const newContent = opts.content ?? existing.content;
-    const newTags = opts.tags ?? existing.tags;
-    const newType = opts.type ?? existing.type;
-    const newTrust = opts.verified ? "verified" : existing.trustState ?? "candidate";
-    const contentHash = createHash3("sha256").update(newContent).digest("hex");
-    const db = this.storage.getDatabase();
-    db.prepare(
-      "UPDATE captures SET content = ?, tags = ?, type = ?, trust_state = ?, content_hash = ? WHERE id = ?"
-    ).run(newContent, JSON.stringify(newTags), newType, newTrust, contentHash, id);
-    const rowid = db.prepare("SELECT rowid FROM captures WHERE id = ?").get(id)?.rowid;
-    if (rowid) {
-      db.prepare(
-        "INSERT INTO captures_fts(captures_fts, rowid, content, tags, type) VALUES('delete', ?, '', '', '')"
-      ).run(rowid);
-      db.prepare(
-        "INSERT INTO captures_fts (rowid, id, content, tags, type) VALUES (?, ?, ?, ?, ?)"
-      ).run(rowid, id, newContent, JSON.stringify(newTags), newType);
-    }
-    if (opts.content && opts.content !== existing.content) {
-      try {
-        const embedding = await this.embedder.embed(newContent);
-        await this.storage.putVector(id, embedding);
-      } catch {
-      }
-    }
-    return true;
-  }
-  /** Find and optionally merge duplicate captures by content similarity (Jaccard). */
-  async consolidate(opts) {
-    const threshold = opts.threshold ?? 0.75;
-    const confirm = opts.confirm ?? false;
-    const sessionKey = opts.sessionKey ?? this.sessionKey;
-    const db = this.storage.getDatabase();
-    let sql = "SELECT id, content, type, tags, created_at FROM captures WHERE deleted_at IS NULL";
-    const params = [];
-    if (sessionKey !== "all") {
-      sql += " AND session_key = ?";
-      params.push(sessionKey);
-    }
-    sql += " ORDER BY created_at DESC";
-    const rows = db.prepare(sql).all(...params);
-    if (rows.length < 2) return { groups: [], merged: 0 };
-    const groups = [];
-    const seen = /* @__PURE__ */ new Set();
-    for (let i = 0; i < rows.length; i++) {
-      if (seen.has(rows[i].id)) continue;
-      const words1 = new Set(rows[i].content.toLowerCase().split(/\s+/));
-      const group = [rows[i].id];
-      for (let j = i + 1; j < rows.length; j++) {
-        if (seen.has(rows[j].id)) continue;
-        const words2 = new Set(rows[j].content.toLowerCase().split(/\s+/));
-        const intersection = [...words1].filter((w) => words2.has(w)).length;
-        const union = (/* @__PURE__ */ new Set([...words1, ...words2])).size;
-        const sim = union > 0 ? intersection / union : 0;
-        if (sim >= threshold) {
-          group.push(rows[j].id);
-          seen.add(rows[j].id);
-        }
-      }
-      if (group.length > 1) {
-        seen.add(rows[i].id);
-        groups.push({
-          ids: group,
-          similarity: threshold,
-          preview: rows[i].content.slice(0, 80).replace(/\n/g, " ")
-        });
-      }
-    }
-    if (!confirm || groups.length === 0) {
-      return { groups, merged: 0 };
-    }
-    let merged = 0;
-    const softDelete = db.prepare("UPDATE captures SET deleted_at = ? WHERE id = ?");
-    const deleteVec = db.prepare("DELETE FROM captures_vec WHERE id = ?");
-    const deleteAtoms = db.prepare("DELETE FROM atoms WHERE capture_id = ?");
-    const mergeTx = db.transaction(() => {
-      for (const g of groups) {
-        const groupRows = g.ids.map((id) => rows.find((r) => r.id === id)).filter(Boolean).sort((a, b) => a.created_at - b.created_at);
-        const dups = groupRows.slice(1);
-        for (const dup of dups) {
-          softDelete.run(Date.now(), dup.id);
-          deleteVec.run(dup.id);
-          deleteAtoms.run(dup.id);
-          merged++;
-        }
-      }
-    });
-    mergeTx();
-    return { groups, merged };
-  }
-  /** Create a handoff packet for the next agent session. */
-  async handoff(opts) {
-    const lines = [];
-    lines.push(`# Handoff: ${opts.task}`);
-    lines.push(`Status: ${opts.status}`);
-    lines.push(`Date: ${(/* @__PURE__ */ new Date()).toISOString()}`);
-    lines.push("");
-    lines.push("## Progress");
-    lines.push(opts.progress);
-    lines.push("");
-    if (opts.decisions && opts.decisions.length > 0) {
-      lines.push("## Decisions");
-      for (const d of opts.decisions) lines.push(`- ${d}`);
-      lines.push("");
-    }
-    if (opts.files && opts.files.length > 0) {
-      lines.push("## Files");
-      for (const f of opts.files) lines.push(`- ${f}`);
-      lines.push("");
-    }
-    if (opts.nextSteps && opts.nextSteps.length > 0) {
-      lines.push("## Next steps");
-      opts.nextSteps.forEach((s, i) => {
-        lines.push(`${i + 1}. ${s}`);
-      });
-      lines.push("");
-    }
-    const content = lines.join("\n");
-    const dedupPayload = JSON.stringify({
-      task: opts.task,
-      status: opts.status,
-      progress: opts.progress,
-      decisions: opts.decisions ?? [],
-      files: opts.files ?? [],
-      nextSteps: opts.nextSteps ?? []
-    });
-    const contentHash = createHash3("sha256").update(dedupPayload).digest("hex");
-    const existing = await this.storage.findByContentHash(contentHash, this.sessionKey);
-    if (existing.length > 0) return null;
-    const id = generateId();
-    const entry = {
-      id,
-      sessionKey: this.sessionKey,
-      agentId: "sdk",
-      type: "task",
-      content,
-      tags: ["handoff", `status:${opts.status}`],
-      createdAt: Date.now(),
-      metadata: {
-        handoff: true,
-        task: opts.task,
-        status: opts.status,
-        progress: opts.progress,
-        decisions: opts.decisions ?? [],
-        files: opts.files ?? [],
-        nextSteps: opts.nextSteps ?? []
-      },
-      contentHash
-    };
-    await this.storage.put(entry);
-    try {
-      const embedding = await this.embedder.embed(content);
-      await this.storage.putVector(id, embedding);
-    } catch {
-    }
-    return id;
-  }
-  /** Record an Architecture Decision Record (ADR). */
-  async adr(opts) {
-    const lines = [];
-    lines.push(`# ADR: ${opts.title}`);
-    lines.push(`Date: ${(/* @__PURE__ */ new Date()).toISOString()}`);
-    lines.push("");
-    lines.push("## Context");
-    lines.push(opts.context);
-    lines.push("");
-    lines.push("## Decision");
-    lines.push(opts.decision);
-    lines.push("");
-    const alternatives = Array.isArray(opts.alternatives) ? opts.alternatives : typeof opts.alternatives === "string" && opts.alternatives ? [opts.alternatives] : [];
-    if (alternatives.length > 0) {
-      lines.push("## Alternatives considered");
-      for (const alt of alternatives) lines.push(`- ${alt}`);
-      lines.push("");
-    }
-    if (opts.consequences) {
-      lines.push("## Consequences");
-      lines.push(opts.consequences);
-      lines.push("");
-    }
-    const content = lines.join("\n");
-    const dedupPayload = JSON.stringify({
-      title: opts.title,
-      context: opts.context,
-      decision: opts.decision,
-      alternatives,
-      consequences: opts.consequences ?? ""
-    });
-    const contentHash = createHash3("sha256").update(dedupPayload).digest("hex");
-    const existing = await this.storage.findByContentHash(contentHash, this.sessionKey);
-    if (existing.length > 0) return null;
-    const id = generateId();
-    const entry = {
-      id,
-      sessionKey: this.sessionKey,
-      agentId: "sdk",
-      type: "decision",
-      content,
-      tags: ["adr", ...opts.tags ?? []],
-      createdAt: Date.now(),
-      metadata: {
-        adr: true,
-        title: opts.title,
-        context: opts.context,
-        decision: opts.decision,
-        alternatives,
-        consequences: opts.consequences ?? ""
-      },
-      contentHash
-    };
-    await this.storage.put(entry);
-    try {
-      const embedding = await this.embedder.embed(content);
-      await this.storage.putVector(id, embedding);
-    } catch {
-    }
-    return id;
-  }
-  /** Close the database connection. */
-  close() {
-    this.storage.close();
-  }
-};
-
 export {
   stripQueryProperNouns,
   SQLiteBackend,
   LocalEmbedder,
   local_exports,
-  init_local,
-  redact,
-  ingestFile,
-  ingestDirectory,
-  searchWiki,
-  getWikiPage,
-  findOutdatedPages,
-  classifyGlobalContent,
-  Memory
+  init_local
 };
-//# sourceMappingURL=chunk-X4ECGLYH.js.map
+//# sourceMappingURL=chunk-4WCDAEPP.js.map