memorix 1.7.2 → 1.7.3

package/dist/cli/index.js

@@ -3232,7 +3232,7 @@ ${import_picocolors.default.gray(m3)}  ${s4}
 
 // src/cli/version.ts
 function getCliVersion() {
-  return true ? "1.7.2" : pkg.version;
+  return true ? "1.7.3" : pkg.version;
 }
 var init_version = __esm({
   "src/cli/version.ts"() {
@@ -20748,6 +20748,7 @@ function loadYamlConfig(projectRoot) {
     llm: { ...userConfig.llm, ...projectConfig.llm },
     agent: { ...userConfig.agent, ...projectConfig.agent },
     embedding: { ...userConfig.embedding, ...projectConfig.embedding },
+    rerank: { ...userConfig.rerank, ...projectConfig.rerank },
     git: { ...userConfig.git, ...projectConfig.git },
     codegraph: { ...userConfig.codegraph, ...projectConfig.codegraph },
     behavior: { ...userConfig.behavior, ...projectConfig.behavior },
@@ -21024,6 +21025,7 @@ function mergeTomlConfig(base, override) {
       llm: { ...base.memory?.llm, ...override.memory?.llm }
     },
     embedding: { ...base.embedding, ...override.embedding },
+    rerank: { ...base.rerank, ...override.rerank },
     hooks: { ...base.hooks, ...override.hooks },
     git: { ...base.git, ...override.git },
     codegraph: { ...base.codegraph, ...override.codegraph },
@@ -21575,6 +21577,7 @@ __export(resolved_config_exports, {
   getResolvedConfigForCwd: () => getResolvedConfigForCwd,
   getResolvedEmbeddingLane: () => getResolvedEmbeddingLane,
   getResolvedMemoryLane: () => getResolvedMemoryLane,
+  getResolvedRerankLane: () => getResolvedRerankLane,
   resetResolvedConfigCache: () => resetResolvedConfigCache
 });
 import { homedir as homedir5 } from "os";
@@ -21607,6 +21610,16 @@ function getResolvedConfig(options = {}) {
     legacy.llm?.baseUrl
   );
   const openRouterMemoryLlmApiKey = isOpenRouterMemoryLane(memoryLlmProvider, memoryLlmBaseUrl) ? process.env.OPENROUTER_API_KEY : void 0;
+  const memoryLlmApiKey = first(
+    process.env.MEMORIX_LLM_API_KEY,
+    process.env.MEMORIX_API_KEY,
+    toml.memory?.llm?.api_key,
+    yaml.llm?.apiKey,
+    legacy.llm?.apiKey,
+    process.env.OPENAI_API_KEY,
+    process.env.ANTHROPIC_API_KEY,
+    openRouterMemoryLlmApiKey
+  );
   const resolved = {
     agent: {
       provider: first(
@@ -21647,16 +21660,7 @@ function getResolvedConfig(options = {}) {
         provider: memoryLlmProvider,
         model: memoryLlmModel,
         baseUrl: memoryLlmBaseUrl,
-        apiKey: first(
-          process.env.MEMORIX_LLM_API_KEY,
-          process.env.MEMORIX_API_KEY,
-          toml.memory?.llm?.api_key,
-          yaml.llm?.apiKey,
-          legacy.llm?.apiKey,
-          process.env.OPENAI_API_KEY,
-          process.env.ANTHROPIC_API_KEY,
-          openRouterMemoryLlmApiKey
-        )
+        apiKey: memoryLlmApiKey
       }
     },
     embedding: {
@@ -21666,6 +21670,12 @@ function getResolvedConfig(options = {}) {
       apiKey: first(process.env.MEMORIX_EMBEDDING_API_KEY, toml.embedding?.api_key, yaml.embedding?.apiKey, legacy.embeddingApi?.apiKey, openRouterEmbeddingApiKey),
       dimensions: firstNumber(parseNumber(process.env.MEMORIX_EMBEDDING_DIMENSIONS), toml.embedding?.dimensions, yaml.embedding?.dimensions, legacy.embeddingApi?.dimensions)
     },
+    rerank: resolveRerankLane({
+      toml,
+      yaml,
+      memoryLlmApiKey,
+      memoryLlmBaseUrl
+    }),
     git: {
       autoHook: firstBool(toml.git?.auto_hook, yaml.git?.autoHook),
       ingestOnCommit: firstBool(toml.git?.ingest_on_commit, yaml.git?.ingestOnCommit),
@@ -21735,6 +21745,9 @@ function getResolvedMemoryLane(options = {}) {
 function getResolvedEmbeddingLane(options = {}) {
   return getResolvedConfig(options).embedding;
 }
+function getResolvedRerankLane(options = {}) {
+  return getResolvedConfig(options).rerank;
+}
 function resetResolvedConfigCache() {
 }
 function first(...values) {
@@ -21777,6 +21790,10 @@ function getEnvSourceNames() {
     "MEMORIX_EMBEDDING_BASE_URL",
     "MEMORIX_EMBEDDING_MODEL",
     "MEMORIX_EMBEDDING_DIMENSIONS",
+    "MEMORIX_RERANK_PROVIDER",
+    "MEMORIX_RERANK_MODEL",
+    "MEMORIX_RERANK_BASE_URL",
+    "MEMORIX_RERANK_API_KEY",
     "MEMORIX_CODEGRAPH_EXTERNAL_CONTEXT",
     "MEMORIX_CODEGRAPH_EXTERNAL_COMMAND",
     "MEMORIX_CODEGRAPH_EXTERNAL_TIMEOUT_MS",
@@ -21800,6 +21817,63 @@ function normalizeExternalContext(value) {
   if (normalized === "auto" || normalized === "off") return normalized;
   return void 0;
 }
+function normalizeRerankProvider(value) {
+  const normalized = value?.trim().toLowerCase();
+  if (normalized === "http") return "http";
+  return "off";
+}
+function resolveRerankLane(args) {
+  const provider2 = normalizeRerankProvider(first(
+    process.env.MEMORIX_RERANK_PROVIDER,
+    args.toml.rerank?.provider,
+    args.yaml.rerank?.provider,
+    "off"
+  ));
+  const model = first(
+    process.env.MEMORIX_RERANK_MODEL,
+    args.toml.rerank?.model,
+    args.yaml.rerank?.model
+  );
+  const explicitBaseUrl = first(
+    process.env.MEMORIX_RERANK_BASE_URL,
+    args.toml.rerank?.base_url,
+    args.yaml.rerank?.baseUrl
+  );
+  const baseUrl = provider2 === "http" ? first(explicitBaseUrl, args.memoryLlmBaseUrl) : explicitBaseUrl;
+  const dedicatedApiKey = first(
+    process.env.MEMORIX_RERANK_API_KEY,
+    args.toml.rerank?.api_key,
+    args.yaml.rerank?.apiKey
+  );
+  const sameEndpoint = provider2 === "http" && sameTrustedEndpoint(baseUrl, args.memoryLlmBaseUrl);
+  const inheritedApiKey = sameEndpoint ? args.memoryLlmApiKey : void 0;
+  const apiKey = first(dedicatedApiKey, inheritedApiKey);
+  const canSendRequest = provider2 === "http" && Boolean(baseUrl) && (Boolean(apiKey) || !args.memoryLlmApiKey || sameEndpoint);
+  return { provider: provider2, model, baseUrl, apiKey, canSendRequest };
+}
+function sameTrustedEndpoint(left, right) {
+  const a4 = normalizeTrustedEndpoint(left);
+  const b4 = normalizeTrustedEndpoint(right);
+  return Boolean(a4 && b4 && a4 === b4);
+}
+function normalizeTrustedEndpoint(value) {
+  const trimmed = value?.trim();
+  if (!trimmed) return void 0;
+  try {
+    const url2 = new URL(trimmed);
+    const protocol = url2.protocol.toLowerCase();
+    const hostname2 = url2.hostname.toLowerCase();
+    const port = url2.port;
+    let pathname = url2.pathname.replace(/\/+$/, "");
+    if (pathname.toLowerCase().endsWith("/rerank")) {
+      pathname = pathname.slice(0, -"/rerank".length).replace(/\/+$/, "");
+    }
+    return `${protocol}//${hostname2}${port ? `:${port}` : ""}${pathname}`;
+  } catch {
+    const fallback = trimmed.replace(/\/+$/, "").replace(/\/rerank$/i, "").replace(/\/+$/, "");
+    return fallback.toLowerCase() || void 0;
+  }
+}
 var init_resolved_config = __esm({
   "src/config/resolved-config.ts"() {
     "use strict";
@@ -24035,9 +24109,27 @@ __export(provider_exports2, {
   getLLMConfig: () => getLLMConfig,
   initLLM: () => initLLM,
   isLLMEnabled: () => isLLMEnabled,
+  normalizeOpenAICompatibleBaseUrl: () => normalizeOpenAICompatibleBaseUrl,
   parseLLMTimeoutMs: () => parseLLMTimeoutMs,
   setLLMConfig: () => setLLMConfig
 });
+function normalizeOpenAICompatibleBaseUrl(baseUrl) {
+  const base = baseUrl.trim().replace(/\/+$/, "");
+  if (!base) return base;
+  let pathname = "";
+  try {
+    pathname = new URL(base).pathname.replace(/\/+$/, "");
+  } catch {
+    pathname = base.split(/[?#]/, 1)[0].replace(/\/+$/, "");
+  }
+  const lastSegment = pathname.split("/").filter(Boolean).at(-1);
+  if (lastSegment && OPENAI_API_VERSION_SEGMENT.test(lastSegment)) {
+    return base;
+  }
+  const queryOrHash = base.match(/[?#].*$/)?.[0] ?? "";
+  const pathWithoutQuery = base.slice(0, base.length - queryOrHash.length).replace(/\/+$/, "");
+  return `${pathWithoutQuery}/v1${queryOrHash}`;
+}
 function parseLLMTimeoutMs(raw) {
   if (raw === void 0 || raw.trim() === "") return LLM_TIMEOUT_DEFAULT_MS;
   const parsed = Number(raw);
@@ -24141,8 +24233,7 @@ async function callLLM(systemPrompt, userMessage, signal) {
 }
 async function callOpenAICompatible(systemPrompt, userMessage, signal) {
   const config2 = currentConfig;
-  let base = config2.baseUrl.replace(/\/+$/, "");
-  if (!base.endsWith("/v1")) base += "/v1";
+  const base = normalizeOpenAICompatibleBaseUrl(config2.baseUrl);
   const url2 = `${base}/chat/completions`;
   const fetchSignal = signal ? AbortSignal.any([signal, AbortSignal.timeout(LLM_CALL_TIMEOUT_MS)]) : AbortSignal.timeout(LLM_CALL_TIMEOUT_MS);
   const response = await fetch(url2, {
@@ -24221,8 +24312,7 @@ async function callLLMWithTools(messages, tools, signal) {
 }
 async function callOpenAIWithTools(messages, tools, signal) {
   const config2 = currentConfig;
-  let base = config2.baseUrl.replace(/\/+$/, "");
-  if (!base.endsWith("/v1")) base += "/v1";
+  const base = normalizeOpenAICompatibleBaseUrl(config2.baseUrl);
   const url2 = `${base}/chat/completions`;
   const openaiMessages = messages.map((msg) => {
     if (msg.role === "tool") {
@@ -24372,8 +24462,7 @@ async function callAnthropicWithTools(messages, tools, signal) {
 }
 async function* callOpenAIWithToolsStream(messages, tools) {
   const config2 = currentConfig;
-  let base = config2.baseUrl.replace(/\/+$/, "");
-  if (!base.endsWith("/v1")) base += "/v1";
+  const base = normalizeOpenAICompatibleBaseUrl(config2.baseUrl);
   const url2 = `${base}/chat/completions`;
   const openaiMessages = messages.map((msg) => {
     if (msg.role === "tool") {
@@ -24621,7 +24710,7 @@ async function* callAnthropicWithToolsStream(messages, tools) {
     }
   };
 }
-var LLM_TIMEOUT_DEFAULT_MS, LLM_TIMEOUT_MIN_MS, LLM_TIMEOUT_MAX_MS, MAX_LLM_RESPONSE_BYTES, LLM_CALL_TIMEOUT_MS, PROVIDER_DEFAULTS, currentConfig;
+var LLM_TIMEOUT_DEFAULT_MS, LLM_TIMEOUT_MIN_MS, LLM_TIMEOUT_MAX_MS, MAX_LLM_RESPONSE_BYTES, OPENAI_API_VERSION_SEGMENT, LLM_CALL_TIMEOUT_MS, PROVIDER_DEFAULTS, currentConfig;
 var init_provider2 = __esm({
   "src/llm/provider.ts"() {
     "use strict";
@@ -24631,6 +24720,7 @@ var init_provider2 = __esm({
     LLM_TIMEOUT_MIN_MS = 1e3;
     LLM_TIMEOUT_MAX_MS = 3e5;
     MAX_LLM_RESPONSE_BYTES = 2 * 1024 * 1024;
+    OPENAI_API_VERSION_SEGMENT = /^v\d+(?:[a-z][a-z0-9-]*)?$/i;
     LLM_CALL_TIMEOUT_MS = parseLLMTimeoutMs(process.env.MEMORIX_LLM_TIMEOUT_MS);
     PROVIDER_DEFAULTS = {
       openai: { baseUrl: "https://api.openai.com/v1", model: "gpt-4.1-nano" },
@@ -24690,6 +24780,48 @@ Rules:
   }
 });
 
+// src/rerank/policy.ts
+function parseRerankTimeoutMs(raw) {
+  const value = raw?.trim();
+  if (!value) return DEFAULT_RERANK_TIMEOUT_MS;
+  const parsed = Number(value);
+  if (!Number.isInteger(parsed) || Number.isNaN(parsed)) {
+    console.warn(
+      `[memorix] MEMORIX_RERANK_TIMEOUT_MS="${raw}" is invalid (must be a positive integer between ${RERANK_TIMEOUT_MIN_MS}-${RERANK_TIMEOUT_MAX_MS}ms). Using default ${DEFAULT_RERANK_TIMEOUT_MS}ms.`
+    );
+    return DEFAULT_RERANK_TIMEOUT_MS;
+  }
+  if (parsed < RERANK_TIMEOUT_MIN_MS) return RERANK_TIMEOUT_MIN_MS;
+  if (parsed > RERANK_TIMEOUT_MAX_MS) return RERANK_TIMEOUT_MAX_MS;
+  return parsed;
+}
+function resolveRerankTimeoutMs(explicitTimeoutMs) {
+  if (typeof explicitTimeoutMs === "number" && Number.isFinite(explicitTimeoutMs) && explicitTimeoutMs > 0) {
+    return explicitTimeoutMs;
+  }
+  return parseRerankTimeoutMs(process.env.MEMORIX_RERANK_TIMEOUT_MS);
+}
+function shouldAttemptHttpRerank(input) {
+  return input.quality === "thorough" && input.hasQuery && input.candidateCount >= MIN_RERANK_CANDIDATES;
+}
+function shouldAttemptLlmRerank(input) {
+  if (input.httpRerankConfigured) return false;
+  if (input.quality !== "thorough" || input.tier !== "heavy" || !input.hasQuery) return false;
+  if (input.candidateCount < MIN_RERANK_CANDIDATES) return false;
+  return input.topScore > 0 && input.secondScore / input.topScore > 0.7;
+}
+var DEFAULT_RERANK_TIMEOUT_MS, RERANK_TIMEOUT_MIN_MS, RERANK_TIMEOUT_MAX_MS, MIN_RERANK_CANDIDATES;
+var init_policy = __esm({
+  "src/rerank/policy.ts"() {
+    "use strict";
+    init_esm_shims();
+    DEFAULT_RERANK_TIMEOUT_MS = 3e4;
+    RERANK_TIMEOUT_MIN_MS = 1e3;
+    RERANK_TIMEOUT_MAX_MS = 3e5;
+    MIN_RERANK_CANDIDATES = 3;
+  }
+});
+
 // src/timeout.ts
 function withTimeout(promise2, ms2, label) {
   return new Promise((resolve6, reject) => {
@@ -24975,6 +25107,148 @@ var init_aliases = __esm({
   }
 });
 
+// src/rerank/http-provider.ts
+function buildRerankUrl(baseUrl) {
+  const trimmed = baseUrl.trim().replace(/\/+$/, "");
+  if (trimmed.endsWith("/rerank")) return trimmed;
+  return `${trimmed}/rerank`;
+}
+function parseRerankResponse(payload) {
+  const rows = extractRows(payload);
+  if (rows.length === 0) {
+    throw new Error("Neural rerank response contained no ranked results");
+  }
+  return rows.sort((a4, b4) => b4.score - a4.score);
+}
+function extractRows(payload) {
+  if (Array.isArray(payload)) {
+    return payload.map(rowFromUnknown).filter((row) => row !== null);
+  }
+  if (payload && typeof payload === "object" && "results" in payload) {
+    const results = payload.results;
+    if (Array.isArray(results)) {
+      return results.map(rowFromUnknown).filter((row) => row !== null);
+    }
+  }
+  throw new Error("Neural rerank response was not Cohere or TEI shaped");
+}
+function rowFromUnknown(value) {
+  if (!value || typeof value !== "object") return null;
+  const row = value;
+  if (typeof row.index !== "number" || !Number.isFinite(row.index)) return null;
+  const score = typeof row.relevance_score === "number" ? row.relevance_score : typeof row.score === "number" ? row.score : null;
+  if (score === null || !Number.isFinite(score)) return null;
+  return { index: row.index, score };
+}
+function buildRerankBody(query, documents, model) {
+  const body = {
+    query,
+    documents,
+    top_n: documents.length,
+    return_documents: false
+  };
+  const trimmed = model?.trim();
+  if (trimmed) body.model = trimmed;
+  return body;
+}
+async function rerankViaHttp(query, documents, config2) {
+  if (documents.length === 0) return [];
+  const url2 = buildRerankUrl(config2.baseUrl);
+  const headers = {
+    "content-type": "application/json"
+  };
+  if (config2.apiKey) {
+    headers.authorization = `Bearer ${config2.apiKey}`;
+  }
+  const controller = new AbortController();
+  const timeoutMs = resolveRerankTimeoutMs(config2.timeoutMs);
+  const timer = setTimeout(() => controller.abort(), timeoutMs);
+  try {
+    const fetchImpl = config2.fetchImpl ?? fetch;
+    const response = await fetchImpl(url2, {
+      method: "POST",
+      headers,
+      signal: controller.signal,
+      body: JSON.stringify(buildRerankBody(query, documents, config2.model))
+    });
+    if (!response.ok) {
+      throw new Error(`Neural rerank HTTP ${response.status} from ${url2}`);
+    }
+    return parseRerankResponse(await response.json());
+  } finally {
+    clearTimeout(timer);
+  }
+}
+var init_http_provider = __esm({
+  "src/rerank/http-provider.ts"() {
+    "use strict";
+    init_esm_shims();
+    init_policy();
+  }
+});
+
+// src/rerank/index.ts
+var rerank_exports = {};
+__export(rerank_exports, {
+  DEFAULT_RERANK_TIMEOUT_MS: () => DEFAULT_RERANK_TIMEOUT_MS,
+  MIN_RERANK_CANDIDATES: () => MIN_RERANK_CANDIDATES,
+  isNeuralRerankEnabled: () => isNeuralRerankEnabled,
+  neuralRerankCandidates: () => neuralRerankCandidates,
+  parseRerankTimeoutMs: () => parseRerankTimeoutMs,
+  resolveRerankTimeoutMs: () => resolveRerankTimeoutMs,
+  shouldAttemptHttpRerank: () => shouldAttemptHttpRerank,
+  shouldAttemptLlmRerank: () => shouldAttemptLlmRerank
+});
+function isNeuralRerankEnabled(options = {}) {
+  const lane = getResolvedRerankLane(options);
+  return lane.provider === "http" && Boolean(lane.baseUrl);
+}
+async function neuralRerankCandidates(query, candidates, options = {}) {
+  if (!isNeuralRerankEnabled(options) || candidates.length === 0) return null;
+  const lane = getResolvedRerankLane(options);
+  if (!lane.canSendRequest || !lane.baseUrl) return null;
+  const toRerank = candidates.slice(0, MAX_RERANK);
+  const rest = candidates.slice(MAX_RERANK);
+  const documents = toRerank.map((candidate2) => candidateText(candidate2));
+  const ranked = await rerankViaHttp(query, documents, {
+    provider: "http",
+    model: lane.model,
+    baseUrl: lane.baseUrl,
+    apiKey: lane.apiKey,
+    timeoutMs: resolveRerankTimeoutMs()
+  });
+  const seen = /* @__PURE__ */ new Set();
+  const reranked = [];
+  for (const row of ranked) {
+    const candidate2 = toRerank[row.index];
+    if (!candidate2 || seen.has(row.index)) continue;
+    reranked.push(candidate2);
+    seen.add(row.index);
+  }
+  for (const [index, candidate2] of toRerank.entries()) {
+    if (!seen.has(index)) reranked.push(candidate2);
+  }
+  reranked.push(...rest);
+  return reranked;
+}
+function candidateText(candidate2) {
+  const narrative = candidate2.narrative?.trim();
+  if (narrative) return `${candidate2.title} \u2014 ${narrative.slice(0, 200)}`;
+  return candidate2.title;
+}
+var MAX_RERANK;
+var init_rerank = __esm({
+  "src/rerank/index.ts"() {
+    "use strict";
+    init_esm_shims();
+    init_resolved_config();
+    init_http_provider();
+    init_policy();
+    init_policy();
+    MAX_RERANK = 10;
+  }
+});
+
 // src/llm/quality.ts
 var quality_exports = {};
 __export(quality_exports, {
@@ -25014,9 +25288,9 @@ async function rerankResults(query, candidates) {
   if (!isLLMEnabled() || candidates.length <= 2) {
     return { reranked: candidates, usedLLM: false };
   }
-  const MAX_RERANK = 10;
-  const toRerank = candidates.slice(0, MAX_RERANK);
-  const rest = candidates.slice(MAX_RERANK);
+  const MAX_RERANK2 = 10;
+  const toRerank = candidates.slice(0, MAX_RERANK2);
+  const rest = candidates.slice(MAX_RERANK2);
   try {
     const candidateList = toRerank.map(
       (c6) => `[ID: ${c6.id}] (${c6.type}) ${c6.title}${c6.narrative ? ` \u2014 ${c6.narrative.substring(0, 100)}` : ""}`
@@ -185792,46 +186066,78 @@ async function searchObservations(options) {
       }
     }
   }
-  const shouldRerank = quality === "thorough" && tier === "heavy" && hasQuery && intermediate.length > 2 && (() => {
-    const top = intermediate[0]?.score ?? 0;
-    const second2 = intermediate[1]?.score ?? 0;
-    return top > 0 && second2 / top > 0.7;
-  })();
-  if (shouldRerank) {
-    try {
-      const { rerankResults: rerankResults2 } = await Promise.resolve().then(() => (init_quality(), quality_exports));
-      const narrativeMap = /* @__PURE__ */ new Map();
-      for (const hit of results.hits) {
-        const doc = hit.document;
-        narrativeMap.set(makeEntryKey(doc.projectId, doc.observationId), doc.narrative);
-      }
-      const RERANK_TOP_K = 5;
-      const toRerank = intermediate.slice(0, RERANK_TOP_K);
-      const candidates = toRerank.map((e5, index) => ({
-        id: `r${index + 1}`,
-        title: e5.title,
-        type: e5.type,
-        score: e5.score,
-        narrative: narrativeMap.get(makeEntryKey(e5.projectId, e5.id))
-      }));
-      const _parsedRerank = parseInt(process.env.MEMORIX_RERANK_TIMEOUT_MS || "", 10);
-      const RERANK_TIMEOUT_MS = Number.isFinite(_parsedRerank) && _parsedRerank > 0 ? _parsedRerank : 5e3;
-      const { reranked, usedLLM } = await withTimeout(
-        rerankResults2(originalQuery, candidates),
-        RERANK_TIMEOUT_MS,
-        "LLM rerank"
-      );
-      mark(`rerank(usedLLM=${usedLLM})`);
-      if (usedLLM) {
-        lastSearchModeByProject.set(modeKey, (lastSearchModeByProject.get(modeKey) ?? "fulltext") + " + LLM rerank");
-        const candidateMap = new Map(candidates.map((candidate2, index) => [candidate2.id, toRerank[index]]));
-        const rerankedTop = reranked.map((r6) => candidateMap.get(r6.id)).filter((e5) => e5 != null);
-        if (rerankedTop.length > 0) {
-          intermediate = [...rerankedTop, ...intermediate.slice(RERANK_TOP_K)];
+  const httpGate = shouldAttemptHttpRerank({
+    quality,
+    hasQuery: Boolean(hasQuery),
+    candidateCount: intermediate.length
+  });
+  const llmGateWithoutHttp = shouldAttemptLlmRerank({
+    quality,
+    tier,
+    hasQuery: Boolean(hasQuery),
+    candidateCount: intermediate.length,
+    topScore: intermediate[0]?.score ?? 0,
+    secondScore: intermediate[1]?.score ?? 0,
+    httpRerankConfigured: false
+  });
+  if (httpGate || llmGateWithoutHttp) {
+    const narrativeMap = /* @__PURE__ */ new Map();
+    for (const hit of results.hits) {
+      const doc = hit.document;
+      narrativeMap.set(makeEntryKey(doc.projectId, doc.observationId), doc.narrative);
+    }
+    const RERANK_TOP_K = 5;
+    const toRerank = intermediate.slice(0, RERANK_TOP_K);
+    const candidates = toRerank.map((e5, index) => ({
+      id: `r${index + 1}`,
+      title: e5.title,
+      type: e5.type,
+      score: e5.score,
+      narrative: narrativeMap.get(makeEntryKey(e5.projectId, e5.id))
+    }));
+    const RERANK_TIMEOUT_MS = parseRerankTimeoutMs(process.env.MEMORIX_RERANK_TIMEOUT_MS);
+    const candidateMap = new Map(candidates.map((candidate2, index) => [candidate2.id, toRerank[index]]));
+    const { isNeuralRerankEnabled: isNeuralRerankEnabled2, neuralRerankCandidates: neuralRerankCandidates2 } = await Promise.resolve().then(() => (init_rerank(), rerank_exports));
+    const httpConfigured = isNeuralRerankEnabled2();
+    if (httpConfigured && httpGate) {
+      try {
+        const neural = await withTimeout(
+          neuralRerankCandidates2(originalQuery, candidates),
+          RERANK_TIMEOUT_MS,
+          "neural rerank"
+        );
+        if (neural && neural.length > 0) {
+          const rerankedTop = neural.map((row) => candidateMap.get(row.id)).filter((entry) => entry != null);
+          if (rerankedTop.length > 0) {
+            intermediate = [...rerankedTop, ...intermediate.slice(RERANK_TOP_K)];
+            lastSearchModeByProject.set(modeKey, (lastSearchModeByProject.get(modeKey) ?? "fulltext") + " + neural rerank");
+            mark("rerank(usedNeural=true)");
+          }
         }
+      } catch {
+        console.error("[memorix] neural rerank failed or timed out; keeping original order");
       }
-    } catch (error40) {
-      console.error("[memorix] LLM rerank failed or timed out, using original order");
+    } else if (!httpConfigured && llmGateWithoutHttp) {
+      try {
+        const { rerankResults: rerankResults2 } = await Promise.resolve().then(() => (init_quality(), quality_exports));
+        const { reranked, usedLLM } = await withTimeout(
+          rerankResults2(originalQuery, candidates),
+          RERANK_TIMEOUT_MS,
+          "LLM rerank"
+        );
+        mark(`rerank(usedLLM=${usedLLM})`);
+        if (usedLLM) {
+          lastSearchModeByProject.set(modeKey, (lastSearchModeByProject.get(modeKey) ?? "fulltext") + " + LLM rerank");
+          const rerankedTop = reranked.map((row) => candidateMap.get(row.id)).filter((entry) => entry != null);
+          if (rerankedTop.length > 0) {
+            intermediate = [...rerankedTop, ...intermediate.slice(RERANK_TOP_K)];
+          }
+        }
+      } catch {
+        console.error("[memorix] LLM rerank failed or timed out, using original order");
+      }
+    } else {
+      mark(`rerank(skipped,tier=${tier})`);
     }
   } else {
     mark(`rerank(skipped,tier=${tier})`);
@@ -186013,6 +186319,7 @@ var init_orama_store = __esm({
     init_project_affinity();
     init_intent_detector();
     init_query_expansion();
+    init_policy();
     init_timeout();
     db = null;
     dbInitPromise = null;
@@ -190318,6 +190625,16 @@ function buildInitTomlConfig(options) {
     }
   }
   lines.push("");
+  lines.push("[rerank]");
+  lines.push("# Optional HTTP rerank against any Cohere-compatible /rerank API.");
+  lines.push('# provider = "http"');
+  lines.push('# model = "rerank-model"');
+  lines.push("# base_url inherits [memory.llm] when unset.");
+  if (isGlobal) {
+    lines.push("# Bearer inherits the memory LLM key only when that endpoint matches.");
+    lines.push("# A different rerank URL needs MEMORIX_RERANK_API_KEY.");
+  }
+  lines.push("");
   lines.push("[git]");
   lines.push(`auto_hook = ${options.gitAutoHook}`);
   lines.push("ingest_on_commit = true");
@@ -190490,6 +190807,12 @@ var init_init = __esm({
           envLines.push("# MEMORIX_EMBEDDING_BASE_URL=https://api.openai.com/v1");
           envLines.push("");
         }
+        envLines.push("# Optional HTTP rerank (Cohere-compatible POST {base_url}/rerank)");
+        envLines.push("# MEMORIX_RERANK_PROVIDER=http");
+        envLines.push("# MEMORIX_RERANK_MODEL=rerank-model");
+        envLines.push("# MEMORIX_RERANK_BASE_URL=https://api.example.com/v1");
+        envLines.push("# MEMORIX_RERANK_API_KEY=  # required when BASE_URL is not the memory LLM endpoint");
+        envLines.push("");
         envLines.push("# Optional memory LLM simple key (does not apply to embedding or agent lanes)");
         envLines.push("# MEMORIX_API_KEY=sk-your-key-here");
         envLines.push("");
@@ -194916,6 +195239,12 @@ function serializeResolvedConfigToToml(config2, options = {}) {
     api_key: includeSecrets ? config2.embedding.apiKey : void 0,
     dimensions: config2.embedding.dimensions
   });
+  writeSection(lines, "rerank", {
+    provider: config2.rerank.provider,
+    model: config2.rerank.model,
+    base_url: config2.rerank.baseUrl,
+    api_key: includeSecrets ? config2.rerank.apiKey : void 0
+  });
   writeSection(lines, "memory", {
     inject: config2.memory.inject,
     formation: config2.memory.formation,
@@ -259680,8 +260009,7 @@ async function callVisionLLM(systemPrompt, imageBase64, mimeType) {
   if (!apiKey) {
     throw new Error("No LLM API key configured for image analysis.");
   }
-  let baseUrl = getLLMBaseUrl("https://api.openai.com/v1").replace(/\/+$/, "");
-  if (!baseUrl.endsWith("/v1")) baseUrl += "/v1";
+  const baseUrl = normalizeOpenAICompatibleBaseUrl(getLLMBaseUrl("https://api.openai.com/v1"));
   const model = getLLMModel("gpt-4o");
   const response = await fetch(`${baseUrl}/chat/completions`, {
     method: "POST",
@@ -260220,7 +260548,7 @@ The path should point to a directory containing a .git folder.`
   };
   const server = existingServer ?? new McpServer({
     name: "memorix",
-    version: true ? "1.7.2" : "1.0.1"
+    version: true ? "1.7.3" : "1.0.1"
   });
   const originalRegisterTool = server.registerTool.bind(server);
   server.registerTool = ((name, ...args) => {
@@ -268586,6 +268914,7 @@ var init_status = __esm({
           diagLines.push(`  Agent lane:      ${formatLane(agent.provider, agent.model, agent.baseUrl, agent.apiKey)}`);
           diagLines.push(`  Memory LLM lane: ${formatLane(resolved.memory.llm.provider, resolved.memory.llm.model, resolved.memory.llm.baseUrl, resolved.memory.llm.apiKey)}`);
           diagLines.push(`  Embedding lane:  ${formatLane(resolved.embedding.provider, resolved.embedding.model, resolved.embedding.baseUrl, resolved.embedding.apiKey)}`);
+          diagLines.push(`  Rerank lane:     ${formatLane(resolved.rerank.provider, resolved.rerank.model, resolved.rerank.baseUrl, resolved.rerank.apiKey)}`);
           diagLines.push(`  Memory behavior: inject=${resolved.memory.inject ?? "default"}, formation=${resolved.memory.formation ?? "default"}, autoCleanup=${resolved.memory.autoCleanup ?? "default"}`);
           diagLines.push(`  Git behavior:    autoHook=${resolved.git.autoHook ?? "default"}, ingestOnCommit=${resolved.git.ingestOnCommit ?? "default"}, maxDiffSize=${resolved.git.maxDiffSize ?? "default"}, skipMergeCommits=${resolved.git.skipMergeCommits ?? "default"}`);
           diagLines.push(`  Server:          transport=${resolved.server.transport ?? "default"}, dashboard=${resolved.server.dashboard ?? "default"}, dashboardPort=${resolved.server.dashboardPort ?? "default"}`);
@@ -268619,7 +268948,8 @@ var init_status = __esm({
             lanes: {
               agent: summarizeLane(agent.provider, agent.model, agent.baseUrl, agent.apiKey),
               memoryLlm: summarizeLane(resolved.memory.llm.provider, resolved.memory.llm.model, resolved.memory.llm.baseUrl, resolved.memory.llm.apiKey),
-              embedding: summarizeLane(resolved.embedding.provider, resolved.embedding.model, resolved.embedding.baseUrl, resolved.embedding.apiKey)
+              embedding: summarizeLane(resolved.embedding.provider, resolved.embedding.model, resolved.embedding.baseUrl, resolved.embedding.apiKey),
+              rerank: summarizeLane(resolved.rerank.provider, resolved.rerank.model, resolved.rerank.baseUrl, resolved.rerank.apiKey)
             },
             memory: {
               inject: resolved.memory.inject ?? "default",
@@ -274942,7 +275272,9 @@ var init_doctor = __esm({
           if (isLLMEnabled2()) {
             const config2 = getLLMConfig2();
             lines.push(ok(`Provider: ${config2?.provider}/${config2?.model}`));
-            lines.push(info2("Capabilities: fact extraction, auto-dedup, LLM rerank"));
+            const { isNeuralRerankEnabled: isNeuralRerankEnabled2 } = await Promise.resolve().then(() => (init_rerank(), rerank_exports));
+            const rerankCap = isNeuralRerankEnabled2() ? "HTTP rerank" : "LLM rerank";
+            lines.push(info2(`Capabilities: fact extraction, auto-dedup, ${rerankCap}`));
             report.llm = { enabled: true, provider: config2?.provider, model: config2?.model };
           } else {
             lines.push(info2("LLM mode: off (heuristic dedup only)"));