@prom.codes/memory-mcp 0.3.1 → 0.4.0

package/dist/bin.js

@@ -506,6 +506,377 @@ var PrometheusEmbeddingProvider = class {
   }
 };
 
+// ../rerank-voyage/dist/index.js
+var DEFAULT_MODEL = "rerank-2.5";
+var DEFAULT_BASE_URL = "https://api.voyageai.com/v1";
+var DEFAULT_BATCH3 = 100;
+var DEFAULT_RETRIES3 = 6;
+var DEFAULT_BACKOFF3 = 2e3;
+var DEFAULT_RETRY_MAX2 = 6e4;
+function parseRetryAfterMs2(value, now = Date.now()) {
+  if (value === null)
+    return null;
+  const trimmed = value.trim();
+  if (trimmed === "")
+    return null;
+  if (/^[0-9]+(\.[0-9]+)?$/.test(trimmed)) {
+    const secs = Number(trimmed);
+    if (!Number.isFinite(secs) || secs < 0)
+      return null;
+    return Math.round(secs * 1e3);
+  }
+  if (!/[A-Za-z]/.test(trimmed))
+    return null;
+  const ts = Date.parse(trimmed);
+  if (!Number.isFinite(ts))
+    return null;
+  const delta = ts - now;
+  return delta > 0 ? delta : 0;
+}
+function sleep3(ms, signal) {
+  return new Promise((resolve2, reject) => {
+    if (signal?.aborted === true) {
+      reject(new Error("aborted"));
+      return;
+    }
+    const timer = setTimeout(() => {
+      signal?.removeEventListener("abort", onAbort);
+      resolve2();
+    }, ms);
+    const onAbort = () => {
+      clearTimeout(timer);
+      reject(new Error("aborted"));
+    };
+    signal?.addEventListener("abort", onAbort, { once: true });
+  });
+}
+function nonRetryable3(message) {
+  const err = new Error(message);
+  err.nonRetryable = true;
+  return err;
+}
+var VoyageRerankProvider = class {
+  name;
+  model;
+  region;
+  #baseUrl;
+  #apiKey;
+  #batchSize;
+  #maxRetries;
+  #retryBaseMs;
+  #retryMaxMs;
+  #fetch;
+  constructor(opts) {
+    if (typeof opts.apiKey !== "string" || opts.apiKey === "") {
+      throw new Error("VoyageRerankProvider: apiKey is required");
+    }
+    if (opts.batchSize !== void 0 && (!Number.isInteger(opts.batchSize) || opts.batchSize <= 0 || opts.batchSize > 1e3)) {
+      throw new Error(`VoyageRerankProvider: batchSize must be an integer in 1..1000, got ${opts.batchSize}`);
+    }
+    this.model = opts.model ?? DEFAULT_MODEL;
+    this.name = opts.name ?? `voyage:${this.model}`;
+    this.region = opts.region ?? "us";
+    this.#baseUrl = (opts.baseUrl ?? DEFAULT_BASE_URL).replace(/\/+$/, "");
+    this.#apiKey = opts.apiKey;
+    this.#batchSize = opts.batchSize ?? DEFAULT_BATCH3;
+    this.#maxRetries = opts.maxRetries ?? DEFAULT_RETRIES3;
+    this.#retryBaseMs = opts.retryBaseMs ?? DEFAULT_BACKOFF3;
+    this.#retryMaxMs = opts.retryMaxMs ?? DEFAULT_RETRY_MAX2;
+    this.#fetch = opts.fetch ?? fetch;
+  }
+  async rerank(query, candidates, opts) {
+    if (candidates.length === 0)
+      return [];
+    const all = new Array(candidates.length);
+    let cursor = 0;
+    for (let start = 0; start < candidates.length; start += this.#batchSize) {
+      const slice = candidates.slice(start, start + this.#batchSize);
+      const scored = await this.#rerankBatch(query, slice, opts?.signal);
+      for (const hit of scored) {
+        const globalIndex = start + hit.localIndex;
+        const cand = candidates[globalIndex];
+        all[cursor++] = { id: cand.id, index: globalIndex, score: hit.score };
+      }
+    }
+    all.sort((a, b) => b.score - a.score);
+    if (opts?.topK !== void 0 && opts.topK >= 0 && opts.topK < all.length) {
+      return all.slice(0, opts.topK);
+    }
+    return all;
+  }
+  async #rerankBatch(query, batch, signal) {
+    const body = {
+      query,
+      documents: batch.map((c) => c.text),
+      model: this.model,
+      return_documents: false,
+      truncation: true
+    };
+    const init = {
+      method: "POST",
+      headers: {
+        "content-type": "application/json",
+        authorization: `Bearer ${this.#apiKey}`
+      },
+      body: JSON.stringify(body)
+    };
+    if (signal !== void 0)
+      init.signal = signal;
+    let attempt = 0;
+    let lastError = null;
+    while (attempt <= this.#maxRetries) {
+      try {
+        const res = await this.#fetch(`${this.#baseUrl}/rerank`, init);
+        if (res.status === 429 || res.status >= 500 && res.status < 600) {
+          lastError = new Error(`${this.name}: HTTP ${res.status}`);
+          attempt += 1;
+          if (attempt > this.#maxRetries)
+            break;
+          const backoff = this.#computeBackoff(attempt, res.headers.get("retry-after"));
+          await sleep3(backoff, signal);
+          continue;
+        }
+        if (!res.ok) {
+          const text = await res.text().catch(() => "");
+          throw nonRetryable3(`${this.name}: HTTP ${res.status} ${res.statusText}${text === "" ? "" : ` \u2014 ${text}`}`);
+        }
+        const payload = await res.json();
+        return this.#decode(payload, batch.length);
+      } catch (err) {
+        if (err?.name === "AbortError")
+          throw err;
+        if (err?.nonRetryable === true)
+          throw err;
+        if (attempt >= this.#maxRetries)
+          throw err;
+        lastError = err;
+        attempt += 1;
+        await sleep3(this.#computeBackoff(attempt, null), signal);
+      }
+    }
+    throw lastError instanceof Error ? lastError : new Error(`${this.name}: exhausted ${this.#maxRetries} retries`);
+  }
+  #computeBackoff(attempt, retryAfterHeader) {
+    const exp = this.#retryBaseMs * 2 ** Math.max(0, attempt - 1);
+    const advised = parseRetryAfterMs2(retryAfterHeader);
+    const lower = advised === null ? exp : Math.max(exp, advised);
+    return Math.min(lower, this.#retryMaxMs);
+  }
+  #decode(payload, expected) {
+    if (!Array.isArray(payload.data) || payload.data.length !== expected) {
+      throw nonRetryable3(`${this.name}: expected ${expected} rerank rows, got ${payload.data?.length ?? 0}`);
+    }
+    return payload.data.map((row) => {
+      if (!Number.isInteger(row.index) || row.index < 0 || row.index >= expected) {
+        throw nonRetryable3(`${this.name}: invalid index ${row.index} in rerank response`);
+      }
+      if (typeof row.relevance_score !== "number" || !Number.isFinite(row.relevance_score)) {
+        throw nonRetryable3(`${this.name}: invalid relevance_score ${row.relevance_score} at index ${row.index}`);
+      }
+      return { localIndex: row.index, score: row.relevance_score };
+    });
+  }
+};
+
+// ../rerank-openai-compat/dist/index.js
+var DEFAULT_MODEL2 = "bge-reranker-base";
+var DEFAULT_BATCH4 = 100;
+var DEFAULT_RETRIES4 = 6;
+var DEFAULT_BACKOFF4 = 2e3;
+var DEFAULT_RETRY_MAX3 = 6e4;
+var DEFAULT_TIMEOUT = 18e4;
+function parseRetryAfterMs3(value, now = Date.now()) {
+  if (value === null)
+    return null;
+  const trimmed = value.trim();
+  if (trimmed === "")
+    return null;
+  if (/^[0-9]+(\.[0-9]+)?$/.test(trimmed)) {
+    const secs = Number(trimmed);
+    if (!Number.isFinite(secs) || secs < 0)
+      return null;
+    return Math.round(secs * 1e3);
+  }
+  if (!/[A-Za-z]/.test(trimmed))
+    return null;
+  const ts = Date.parse(trimmed);
+  if (!Number.isFinite(ts))
+    return null;
+  const delta = ts - now;
+  return delta > 0 ? delta : 0;
+}
+function sleep4(ms, signal) {
+  return new Promise((resolve2, reject) => {
+    if (signal?.aborted === true) {
+      reject(new Error("aborted"));
+      return;
+    }
+    const timer = setTimeout(() => {
+      signal?.removeEventListener("abort", onAbort);
+      resolve2();
+    }, ms);
+    const onAbort = () => {
+      clearTimeout(timer);
+      reject(new Error("aborted"));
+    };
+    signal?.addEventListener("abort", onAbort, { once: true });
+  });
+}
+function nonRetryable4(message) {
+  const err = new Error(message);
+  err.nonRetryable = true;
+  return err;
+}
+var OpenAICompatRerankProvider = class {
+  name;
+  model;
+  region;
+  #baseUrl;
+  #apiKey;
+  #batchSize;
+  #maxRetries;
+  #retryBaseMs;
+  #retryMaxMs;
+  #timeoutMs;
+  #fetch;
+  constructor(opts) {
+    if (typeof opts.baseUrl !== "string" || opts.baseUrl === "") {
+      throw new Error("OpenAICompatRerankProvider: baseUrl is required");
+    }
+    if (opts.batchSize !== void 0 && (!Number.isInteger(opts.batchSize) || opts.batchSize <= 0 || opts.batchSize > 1e3)) {
+      throw new Error(`OpenAICompatRerankProvider: batchSize must be an integer in 1..1000, got ${opts.batchSize}`);
+    }
+    if (opts.timeoutMs !== void 0 && (!Number.isInteger(opts.timeoutMs) || opts.timeoutMs < 0)) {
+      throw new Error(`OpenAICompatRerankProvider: timeoutMs must be a non-negative integer (0 disables), got ${opts.timeoutMs}`);
+    }
+    this.model = opts.model ?? DEFAULT_MODEL2;
+    this.name = opts.name ?? `openai-compat:${this.model}`;
+    this.region = opts.region ?? "self-hosted";
+    this.#baseUrl = opts.baseUrl.replace(/\/+$/, "");
+    this.#apiKey = opts.apiKey === void 0 || opts.apiKey === "" ? void 0 : opts.apiKey;
+    this.#batchSize = opts.batchSize ?? DEFAULT_BATCH4;
+    this.#maxRetries = opts.maxRetries ?? DEFAULT_RETRIES4;
+    this.#retryBaseMs = opts.retryBaseMs ?? DEFAULT_BACKOFF4;
+    this.#retryMaxMs = opts.retryMaxMs ?? DEFAULT_RETRY_MAX3;
+    this.#timeoutMs = opts.timeoutMs ?? DEFAULT_TIMEOUT;
+    this.#fetch = opts.fetch ?? fetch;
+  }
+  async rerank(query, candidates, opts) {
+    if (candidates.length === 0)
+      return [];
+    const all = new Array(candidates.length);
+    let cursor = 0;
+    for (let start = 0; start < candidates.length; start += this.#batchSize) {
+      const slice = candidates.slice(start, start + this.#batchSize);
+      const scored = await this.#rerankBatch(query, slice, opts?.signal);
+      for (const hit of scored) {
+        const globalIndex = start + hit.localIndex;
+        const cand = candidates[globalIndex];
+        all[cursor++] = { id: cand.id, index: globalIndex, score: hit.score };
+      }
+    }
+    all.sort((a, b) => b.score - a.score);
+    if (opts?.topK !== void 0 && opts.topK >= 0 && opts.topK < all.length) {
+      return all.slice(0, opts.topK);
+    }
+    return all;
+  }
+  async #rerankBatch(query, batch, signal) {
+    const body = {
+      query,
+      documents: batch.map((c) => c.text),
+      model: this.model,
+      return_documents: false
+    };
+    const headers = { "content-type": "application/json" };
+    if (this.#apiKey !== void 0)
+      headers.authorization = `Bearer ${this.#apiKey}`;
+    const payloadJson = JSON.stringify(body);
+    let attempt = 0;
+    let lastError = null;
+    while (attempt <= this.#maxRetries) {
+      const controller = new AbortController();
+      let timedOut = false;
+      let timer;
+      if (this.#timeoutMs > 0) {
+        timer = setTimeout(() => {
+          timedOut = true;
+          controller.abort();
+        }, this.#timeoutMs);
+      }
+      const onParentAbort = () => controller.abort();
+      if (signal !== void 0) {
+        if (signal.aborted)
+          controller.abort();
+        else
+          signal.addEventListener("abort", onParentAbort, { once: true });
+      }
+      const init = {
+        method: "POST",
+        headers,
+        body: payloadJson,
+        signal: controller.signal
+      };
+      try {
+        const res = await this.#fetch(`${this.#baseUrl}/rerank`, init);
+        if (res.status === 429 || res.status >= 500 && res.status < 600) {
+          lastError = new Error(`${this.name}: HTTP ${res.status}`);
+          attempt += 1;
+          if (attempt > this.#maxRetries)
+            break;
+          const backoff = this.#computeBackoff(attempt, res.headers.get("retry-after"));
+          await sleep4(backoff, signal);
+          continue;
+        }
+        if (!res.ok) {
+          const text = await res.text().catch(() => "");
+          throw nonRetryable4(`${this.name}: HTTP ${res.status} ${res.statusText}${text === "" ? "" : ` \u2014 ${text}`}`);
+        }
+        const payload = await res.json();
+        return this.#decode(payload, batch.length);
+      } catch (err) {
+        const isAbort = err?.name === "AbortError";
+        if (isAbort && !timedOut)
+          throw err;
+        if (!isAbort && err?.nonRetryable === true)
+          throw err;
+        const normalized = timedOut ? new Error(`${this.name}: request timed out after ${this.#timeoutMs}ms`) : err;
+        if (attempt >= this.#maxRetries)
+          throw normalized;
+        lastError = normalized;
+        attempt += 1;
+        await sleep4(this.#computeBackoff(attempt, null), signal);
+      } finally {
+        if (timer !== void 0)
+          clearTimeout(timer);
+        if (signal !== void 0)
+          signal.removeEventListener("abort", onParentAbort);
+      }
+    }
+    throw lastError instanceof Error ? lastError : new Error(`${this.name}: exhausted ${this.#maxRetries} retries`);
+  }
+  #computeBackoff(attempt, retryAfterHeader) {
+    const exp = this.#retryBaseMs * 2 ** Math.max(0, attempt - 1);
+    const advised = parseRetryAfterMs3(retryAfterHeader);
+    const lower = advised === null ? exp : Math.max(exp, advised);
+    return Math.min(lower, this.#retryMaxMs);
+  }
+  #decode(payload, expected) {
+    if (!Array.isArray(payload.results) || payload.results.length !== expected) {
+      throw nonRetryable4(`${this.name}: expected ${expected} rerank rows, got ${payload.results?.length ?? 0}`);
+    }
+    return payload.results.map((row) => {
+      if (!Number.isInteger(row.index) || row.index < 0 || row.index >= expected) {
+        throw nonRetryable4(`${this.name}: invalid index ${row.index} in rerank response`);
+      }
+      if (typeof row.relevance_score !== "number" || !Number.isFinite(row.relevance_score)) {
+        throw nonRetryable4(`${this.name}: invalid relevance_score ${row.relevance_score} at index ${row.index}`);
+      }
+      return { localIndex: row.index, score: row.relevance_score };
+    });
+  }
+};
+
 // dist/api-key.js
 var KEY_PATTERN = /^prom_(live|test)_[A-Za-z0-9]{10,}$/;
 var API_KEY_ENV = "PROMETHEUS_API_KEY";
@@ -520,6 +891,114 @@ function requireApiKey(env) {
   return key;
 }
 
+// dist/extraction.js
+var SYSTEM_PROMPT = 'You extract durable, atomic facts from a coding agent\'s session notes for long-term project memory. Output ONLY a JSON array of objects {"key":..., "value":...}. Each fact must be ONE self-contained statement that will be useful in a FUTURE session: a decision, a convention, a preference, a stable configuration, or a learned fact about the project. `key` is a short kebab-case slug; `value` is the full fact in one sentence. DROP transient step-by-step narration, anything true only for this one session, and anything obvious. Never invent facts not supported by the notes. If there is nothing durable, output []. Output at most 12 facts.';
+function parseExtraction(raw, maxFacts = 12, maxValueChars = 2e3) {
+  const match = raw.match(/\[[\s\S]*\]/);
+  if (!match)
+    return [];
+  let parsed;
+  try {
+    parsed = JSON.parse(match[0]);
+  } catch {
+    return [];
+  }
+  if (!Array.isArray(parsed))
+    return [];
+  const out = [];
+  const seen = /* @__PURE__ */ new Set();
+  for (const item of parsed) {
+    if (out.length >= maxFacts)
+      break;
+    if (typeof item !== "object" || item === null)
+      continue;
+    const rec = item;
+    const rawKey = typeof rec.key === "string" ? rec.key : "";
+    const value = typeof rec.value === "string" ? rec.value.trim() : "";
+    if (value === "")
+      continue;
+    const key = slugify(rawKey) || slugify(value).slice(0, 48);
+    if (key === "" || seen.has(key))
+      continue;
+    seen.add(key);
+    const fact = { key, value: value.slice(0, maxValueChars) };
+    out.push(typeof rec.confidence === "number" && rec.confidence >= 0 && rec.confidence <= 1 ? { ...fact, confidence: rec.confidence } : fact);
+  }
+  return out;
+}
+function slugify(s) {
+  return s.toLowerCase().replace(/[^a-z0-9]+/g, "-").replace(/^-+|-+$/g, "").slice(0, 64);
+}
+var OpenAICompatExtractor = class {
+  name;
+  model;
+  #url;
+  #apiKey;
+  #maxRetries;
+  #retryBaseMs;
+  #temperature;
+  #fetch;
+  constructor(opts) {
+    this.name = opts.name;
+    this.model = opts.model;
+    this.#url = `${opts.baseUrl.replace(/\/+$/, "")}/chat/completions`;
+    this.#apiKey = opts.apiKey;
+    this.#maxRetries = opts.maxRetries ?? 3;
+    this.#retryBaseMs = opts.retryBaseMs ?? 500;
+    this.#temperature = opts.temperature ?? 0;
+    this.#fetch = opts.fetchImpl ?? fetch;
+  }
+  async extract(text, opts) {
+    const trimmed = text.trim();
+    if (trimmed === "")
+      return [];
+    const body = JSON.stringify({
+      model: this.model,
+      temperature: this.#temperature,
+      messages: [
+        { role: "system", content: SYSTEM_PROMPT },
+        { role: "user", content: `Session notes:
+
+${trimmed}` }
+      ]
+    });
+    const headers = { "content-type": "application/json" };
+    if (this.#apiKey !== void 0 && this.#apiKey !== "") {
+      headers.authorization = `Bearer ${this.#apiKey}`;
+    }
+    let lastErr;
+    for (let attempt = 0; attempt <= this.#maxRetries; attempt++) {
+      try {
+        const res = await this.#fetch(this.#url, {
+          method: "POST",
+          headers,
+          body,
+          ...opts?.signal ? { signal: opts.signal } : {}
+        });
+        if (res.status === 429 || res.status >= 500) {
+          lastErr = new Error(`extractor HTTP ${res.status}`);
+        } else if (!res.ok) {
+          return [];
+        } else {
+          const json = await res.json();
+          const content = json.choices?.[0]?.message?.content ?? "";
+          return parseExtraction(content);
+        }
+      } catch (err) {
+        lastErr = err;
+      }
+      if (attempt < this.#maxRetries) {
+        await delay(this.#retryBaseMs * 2 ** attempt);
+      }
+    }
+    void lastErr;
+    return [];
+  }
+};
+function delay(ms) {
+  return new Promise((r) => setTimeout(r, ms));
+}
+
 // dist/sqlite.js
 import { randomUUID } from "node:crypto";
 import { mkdirSync } from "node:fs";
@@ -747,6 +1226,7 @@ function rowToRecord(row) {
 var SqliteMemoryBackend = class {
   db;
   embedder;
+  reranker;
   /** Record ids whose vector is missing/stale, awaiting a batched embed. */
   pendingEmbed = /* @__PURE__ */ new Set();
   closed = false;
@@ -761,6 +1241,7 @@ var SqliteMemoryBackend = class {
     this.db.exec(VEC_SCHEMA);
     this.db.exec(`INSERT INTO agent_memory_fts (agent_memory_fts) VALUES ('rebuild')`);
     this.embedder = opts.embedder;
+    this.reranker = opts.reranker;
     if (this.embedder !== void 0)
       this.queueUnembedded();
   }
@@ -871,15 +1352,44 @@ var SqliteMemoryBackend = class {
         vecHits = [];
       }
     }
-    if (vecHits.length === 0)
-      return ftsHits.slice(0, finalLimit);
-    if (ftsHits.length === 0)
-      return vecHits.slice(0, finalLimit);
-    const fused = reciprocalRankFusion([
-      { id: "fts", items: ftsHits.map((h) => ({ key: h.record.id, payload: h })) },
-      { id: "vec", items: vecHits.map((h) => ({ key: h.record.id, payload: h })) }
-    ], { limit: finalLimit });
-    return fused.map((f) => f.payload);
+    let pool;
+    if (vecHits.length === 0) {
+      pool = ftsHits;
+    } else if (ftsHits.length === 0) {
+      pool = vecHits;
+    } else {
+      pool = reciprocalRankFusion([
+        { id: "fts", items: ftsHits.map((h) => ({ key: h.record.id, payload: h })) },
+        { id: "vec", items: vecHits.map((h) => ({ key: h.record.id, payload: h })) }
+      ], { limit: poolLimit }).map((f) => f.payload);
+    }
+    const reranked = input.rerank === false ? pool : await this.rerankPool(input.query, pool, finalLimit);
+    return reranked.slice(0, finalLimit);
+  }
+  /**
+   * Reorder a first-stage pool with the cross-encoder reranker, scoring each
+   * candidate's `key + value` jointly against the query. Returns the pool
+   * unchanged when no reranker is configured, the pool is trivial, or the
+   * provider errors.
+   */
+  async rerankPool(query, pool, topK) {
+    if (this.reranker === void 0 || pool.length <= 1)
+      return pool;
+    try {
+      const candidates = pool.map((h) => ({
+        id: h.record.id,
+        text: `${h.record.key}
+${h.record.value}`
+      }));
+      const hits = await this.reranker.rerank(query, candidates, { topK });
+      if (hits.length === 0)
+        return pool;
+      const byId = new Map(pool.map((h) => [h.record.id, h]));
+      const reordered = hits.map((h) => byId.get(h.id)).filter((h) => h !== void 0);
+      return reordered.length > 0 ? reordered : pool;
+    } catch {
+      return pool;
+    }
   }
   /** FTS5 BM25 keyword channel → ranked hits (best first). */
   ftsSearch(input, limit) {
@@ -1149,6 +1659,99 @@ function discoverMemoryEmbedder(env) {
   }
   return { id: "none", embedder: void 0 };
 }
+function discoverMemoryReranker(env) {
+  const forced = (env.PROMETHEUS_MEMORY_RERANK_PROVIDER ?? "none").toLowerCase();
+  if (forced === "" || forced === "none")
+    return { id: "none", provider: null };
+  if (forced === "voyage") {
+    const apiKey = env.VOYAGE_API_KEY;
+    if (apiKey === void 0 || apiKey === "") {
+      throw new Error('PROMETHEUS_MEMORY_RERANK_PROVIDER="voyage" requires VOYAGE_API_KEY.');
+    }
+    const provider = new VoyageRerankProvider({
+      name: "voyage-rerank",
+      apiKey,
+      model: env.VOYAGE_RERANK_MODEL ?? "rerank-2.5",
+      region: "us",
+      baseUrl: env.VOYAGE_BASE_URL ?? "https://api.voyageai.com/v1",
+      maxRetries: intEnv(env, "VOYAGE_RERANK_MAX_RETRIES", 6),
+      retryBaseMs: intEnv(env, "VOYAGE_RERANK_RETRY_BASE_MS", 2e3),
+      batchSize: intEnv(env, "VOYAGE_RERANK_BATCH", 100)
+    });
+    return { id: "voyage", provider };
+  }
+  if (forced === "bge" || forced === "generic") {
+    const baseUrl = env.PROMETHEUS_MEMORY_RERANK_ENDPOINT;
+    if (baseUrl === void 0 || baseUrl === "") {
+      throw new Error(`PROMETHEUS_MEMORY_RERANK_PROVIDER="${forced}" requires PROMETHEUS_MEMORY_RERANK_ENDPOINT.`);
+    }
+    const model = env.PROMETHEUS_MEMORY_RERANK_MODEL ?? "bge-reranker-base";
+    const provider = new OpenAICompatRerankProvider({
+      name: env.PROMETHEUS_MEMORY_RERANK_NAME ?? `bge-rerank:${model}`,
+      model,
+      region: "self-hosted",
+      baseUrl,
+      maxRetries: intEnv(env, "PROMETHEUS_MEMORY_RERANK_MAX_RETRIES", 6),
+      retryBaseMs: intEnv(env, "PROMETHEUS_MEMORY_RERANK_RETRY_BASE_MS", 2e3),
+      batchSize: intEnv(env, "PROMETHEUS_MEMORY_RERANK_BATCH", 100),
+      timeoutMs: intEnv(env, "PROMETHEUS_MEMORY_RERANK_TIMEOUT_MS", 18e4),
+      ...env.PROMETHEUS_MEMORY_RERANK_API_KEY ? { apiKey: env.PROMETHEUS_MEMORY_RERANK_API_KEY } : {}
+    });
+    return { id: "bge", provider };
+  }
+  throw new Error(`unknown PROMETHEUS_MEMORY_RERANK_PROVIDER="${forced}" (expected "none", "voyage", or "bge")`);
+}
+function discoverMemoryExtractor(env) {
+  const forced = (env.PROMETHEUS_MEMORY_EXTRACT_PROVIDER ?? "none").toLowerCase();
+  if (forced === "" || forced === "none")
+    return { id: "none", provider: null };
+  if (forced === "mistral") {
+    const apiKey = env.MISTRAL_API_KEY;
+    if (apiKey === void 0 || apiKey === "") {
+      throw new Error('PROMETHEUS_MEMORY_EXTRACT_PROVIDER="mistral" requires MISTRAL_API_KEY.');
+    }
+    return {
+      id: "mistral",
+      provider: new OpenAICompatExtractor({
+        name: "mistral-extract",
+        model: env.PROMETHEUS_MEMORY_EXTRACT_MODEL ?? "mistral-small-latest",
+        baseUrl: env.MISTRAL_BASE_URL ?? "https://api.mistral.ai/v1",
+        apiKey
+      })
+    };
+  }
+  if (forced === "openai") {
+    const apiKey = env.OPENAI_API_KEY;
+    if (apiKey === void 0 || apiKey === "") {
+      throw new Error('PROMETHEUS_MEMORY_EXTRACT_PROVIDER="openai" requires OPENAI_API_KEY.');
+    }
+    return {
+      id: "openai",
+      provider: new OpenAICompatExtractor({
+        name: "openai-extract",
+        model: env.PROMETHEUS_MEMORY_EXTRACT_MODEL ?? "gpt-4o-mini",
+        baseUrl: env.OPENAI_BASE_URL ?? "https://api.openai.com/v1",
+        apiKey
+      })
+    };
+  }
+  if (forced === "generic" || forced === "openai-compat") {
+    const baseUrl = env.PROMETHEUS_MEMORY_EXTRACT_ENDPOINT;
+    if (baseUrl === void 0 || baseUrl === "") {
+      throw new Error(`PROMETHEUS_MEMORY_EXTRACT_PROVIDER="${forced}" requires PROMETHEUS_MEMORY_EXTRACT_ENDPOINT.`);
+    }
+    return {
+      id: "generic",
+      provider: new OpenAICompatExtractor({
+        name: env.PROMETHEUS_MEMORY_EXTRACT_NAME ?? "generic-extract",
+        model: env.PROMETHEUS_MEMORY_EXTRACT_MODEL ?? "default",
+        baseUrl,
+        ...env.PROMETHEUS_MEMORY_EXTRACT_API_KEY ? { apiKey: env.PROMETHEUS_MEMORY_EXTRACT_API_KEY } : {}
+      })
+    };
+  }
+  throw new Error(`unknown PROMETHEUS_MEMORY_EXTRACT_PROVIDER="${forced}" (expected "none", "mistral", "openai", or "generic")`);
+}
 function composeFromEnv(opts) {
   const env = opts.env;
   const override = (opts.workspaceRootOverride ?? "").trim();
@@ -1160,7 +1763,12 @@ function composeFromEnv(opts) {
   const rawDbPath = env.PROMETHEUS_MEMORY_DB_PATH;
   const dbPath = rawDbPath !== void 0 && rawDbPath !== "" ? rawDbPath : defaultMemoryDbPath();
   const { id: embedderId, embedder } = discoverMemoryEmbedder(env);
-  const backend = new SqliteMemoryBackend(dbPath, embedder !== void 0 ? { embedder } : {});
+  const { id: rerankerId, provider: reranker } = discoverMemoryReranker(env);
+  const { id: extractorId, provider: extractor } = discoverMemoryExtractor(env);
+  const backend = new SqliteMemoryBackend(dbPath, {
+    ...embedder !== void 0 ? { embedder } : {},
+    ...reranker !== null ? { reranker } : {}
+  });
   return {
     backend,
     workspaceRoot,
@@ -1169,6 +1777,10 @@ function composeFromEnv(opts) {
     dbPath,
     embeddingsEnabled: embedder !== void 0,
     embedderId,
+    reranker,
+    rerankerId,
+    extractor,
+    extractorId,
     close: () => backend.close()
   };
 }
@@ -1598,7 +2210,7 @@ var setupInput = {
   runtimes: z.array(runtimeEnum).min(1).optional()
 };
 function registerTools(server, deps) {
-  const { backend, workspaceRoot, projectId, projectName, dbPath } = deps;
+  const { backend, workspaceRoot, projectId, projectName, dbPath, extractor } = deps;
   server.registerTool("read", {
     title: "Recall agent memory",
     description: "Read agent memory for this project along the scope chain (project \u2192 workspace \u2192 tenant \u2192 system; narrowest scope wins). Syncs `.prometheus/memories/*.md` first, then returns the resolved records plus a prompt-ready `woven` markdown block (token-capped). Call this at the START of a session or task to recall what earlier sessions learned.",
@@ -1662,6 +2274,41 @@ ${p.value}`)
     assertValueSize(texts);
     assertNoSecrets(texts);
     const scope = args.scope ?? "project";
+    let facts = args.facts ?? [];
+    let extractedCount = 0;
+    if (extractor) {
+      const prose = [args.plan ?? "", args.outcome ?? ""].join("\n").trim();
+      if (prose !== "") {
+        try {
+          const mined = await extractor.extract(prose);
+          const have = new Set(facts.map((f) => f.key));
+          const fresh = mined.filter((f) => {
+            if (have.has(f.key))
+              return false;
+            try {
+              assertNoSecrets(`${f.key}
+${f.value}`);
+            } catch {
+              return false;
+            }
+            have.add(f.key);
+            return true;
+          });
+          if (fresh.length > 0) {
+            facts = [
+              ...facts,
+              ...fresh.map((f) => ({
+                key: f.key,
+                value: f.value,
+                ...f.confidence !== void 0 ? { confidence: f.confidence } : {}
+              }))
+            ];
+            extractedCount = fresh.length;
+          }
+        } catch {
+        }
+      }
+    }
     const written = await backend.consolidate({
       projectId,
       scope,
@@ -1669,10 +2316,10 @@ ${p.value}`)
       sessionId: args.sessionId,
       plan: args.plan,
       outcome: args.outcome,
-      facts: args.facts,
+      facts,
       procedures: args.procedures
     });
-    return textResult({ written: written.map(recordToJson) });
+    return textResult({ written: written.map(recordToJson), extracted: extractedCount });
   });
   server.registerTool("search", {
     title: "Search agent memory",
@@ -1787,7 +2434,7 @@ async function main() {
       env,
       ...override !== void 0 && override !== "" ? { workspaceRootOverride: override } : {}
     });
-    process.stderr.write(`prometheus-memory-mcp: workspace=${composed.workspaceRoot} (via ${via}) project=${composed.projectName} (${composed.projectId}) db=${composed.dbPath} embed=${composed.embedderId}${composed.embeddingsEnabled ? "" : " (keyword-only)"}
+    process.stderr.write(`prometheus-memory-mcp: workspace=${composed.workspaceRoot} (via ${via}) project=${composed.projectName} (${composed.projectId}) db=${composed.dbPath} embed=${composed.embedderId}${composed.embeddingsEnabled ? "" : " (keyword-only)"} rerank=${composed.rerankerId} extract=${composed.extractorId}
 `);
     registerTools(server, composed);
   };

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@prom.codes/memory-mcp",
-  "version": "0.3.1",
+  "version": "0.4.0",
   "description": "prom.codes Memory — persistent, local-first agent memory as an MCP server.",
   "type": "module",
   "bin": {