remem-mcp 0.7.0 → 0.7.3

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

@@ -82,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",
@@ -185,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 = 9;
+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)
 );
@@ -193,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;
@@ -332,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);
   }
   /**
@@ -591,16 +799,68 @@ var SQLiteBackend = class {
     }
     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,
@@ -614,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(
@@ -627,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);
@@ -767,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
     );
@@ -783,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) }));
@@ -793,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];
@@ -800,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) {
@@ -926,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(",");
@@ -967,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;
@@ -1504,6 +1928,359 @@ var SQLiteBackend = class {
     }
     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 {
@@ -1562,4 +2339,4 @@ export {
   local_exports,
   init_local
 };
-//# sourceMappingURL=chunk-OYUNKUZK.js.map
+//# sourceMappingURL=chunk-4WCDAEPP.js.map