memorix 1.7.2 → 1.8.0

package/dist/vector-backfill-runner.js

@@ -95,6 +95,8 @@ function loadEnvFile(filePath) {
   const parsed = parse(readFileSync(filePath, "utf-8"));
   for (const [key, value] of Object.entries(parsed)) {
     if (!(key in process.env)) {
+      loadedEnvKeys.add(key);
+      loadedEnvValues.set(key, value);
       process.env[key] = value;
       injectedKeys.add(key);
     }
@@ -107,6 +109,8 @@ function loadDotenv(projectRoot, options = {}) {
     resetDotenv();
   }
   loadedEnvFiles.length = 0;
+  loadedEnvKeys.clear();
+  loadedEnvValues.clear();
   if (projectRoot) {
     loadEnvFile(getProjectDotenvPath(projectRoot));
   }
@@ -122,11 +126,12 @@ function resetDotenv() {
   dotenvLoaded = false;
   dotenvProjectRoot = null;
   loadedEnvFiles.length = 0;
+  loadedEnvKeys.clear();
 }
 function getLoadedEnvFiles() {
   return loadedEnvFiles;
 }
-var dotenvLoaded, dotenvProjectRoot, loadedEnvFiles, injectedKeys;
+var dotenvLoaded, dotenvProjectRoot, loadedEnvFiles, loadedEnvKeys, loadedEnvValues, injectedKeys;
 var init_dotenv_loader = __esm({
   "src/config/dotenv-loader.ts"() {
     "use strict";
@@ -135,6 +140,8 @@ var init_dotenv_loader = __esm({
     dotenvLoaded = false;
     dotenvProjectRoot = null;
     loadedEnvFiles = [];
+    loadedEnvKeys = /* @__PURE__ */ new Set();
+    loadedEnvValues = /* @__PURE__ */ new Map();
     injectedKeys = /* @__PURE__ */ new Set();
   }
 });
@@ -176,6 +183,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 },
@@ -517,7 +525,7 @@ function closeAllDatabases() {
     _dbCache.delete(key);
   }
 }
-var BetterSqlite3, CREATE_OBSERVATIONS_TABLE, CREATE_MINI_SKILLS_TABLE, CREATE_SESSIONS_TABLE, CREATE_META_TABLE, CREATE_TEAM_AGENTS_TABLE, CREATE_TEAM_MESSAGES_TABLE, CREATE_TEAM_TASKS_TABLE, CREATE_TEAM_TASK_DEPS_TABLE, CREATE_TEAM_LOCKS_TABLE, CREATE_TEAM_ROLES_TABLE, CREATE_CHAT_TRANSCRIPT_TABLE, CREATE_GRAPH_ENTITIES_TABLE, CREATE_GRAPH_RELATIONS_TABLE, CREATE_CODE_FILES_TABLE, CREATE_CODE_SYMBOLS_TABLE, CREATE_CODE_EDGES_TABLE, CREATE_OBSERVATION_CODE_REFS_TABLE, CREATE_SCHEMA_MIGRATIONS_TABLE, CREATE_CODE_STATE_SNAPSHOTS_TABLE, CREATE_CODE_STATE_SNAPSHOT_FILES_TABLE, CREATE_KNOWLEDGE_CLAIMS_TABLE, CREATE_KNOWLEDGE_CLAIM_EVIDENCE_TABLE, CREATE_KNOWLEDGE_CLAIM_EVENTS_TABLE, CREATE_KNOWLEDGE_WORKSPACES_TABLE, CREATE_KNOWLEDGE_PAGES_TABLE, CREATE_KNOWLEDGE_PAGE_CLAIMS_TABLE, CREATE_KNOWLEDGE_PAGE_LINKS_TABLE, CREATE_KNOWLEDGE_PROPOSALS_TABLE, CREATE_KNOWLEDGE_WORKFLOWS_TABLE, CREATE_KNOWLEDGE_WORKFLOW_RUNS_TABLE, CREATE_LONG_TERM_MEMORIES_TABLE, CREATE_LONG_TERM_MEMORY_EVIDENCE_TABLE, CREATE_LONG_TERM_MEMORY_EVENTS_TABLE, CREATE_MEMORY_OUTCOME_SIGNALS_TABLE, CREATE_MEDIA_ASSETS_TABLE, CREATE_MEDIA_ASSET_LINKS_TABLE, CREATE_MEDIA_DERIVATIONS_TABLE, CREATE_MEDIA_EMBEDDING_PROFILES_TABLE, CREATE_MEDIA_EMBEDDINGS_TABLE, CREATE_MEDIA_JOBS_TABLE, CREATE_MAINTENANCE_JOBS_TABLE, CREATE_MAINTENANCE_TARGETS_TABLE, CREATE_COMPACTION_CHECKPOINTS_TABLE, CREATE_INDEXES, SCHEMA_MIGRATIONS, _dbCache;
+var BetterSqlite3, CREATE_OBSERVATIONS_TABLE, CREATE_MINI_SKILLS_TABLE, CREATE_SESSIONS_TABLE, CREATE_META_TABLE, CREATE_TEAM_AGENTS_TABLE, CREATE_TEAM_MESSAGES_TABLE, CREATE_TEAM_TASKS_TABLE, CREATE_TEAM_TASK_DEPS_TABLE, CREATE_TEAM_LOCKS_TABLE, CREATE_TEAM_ROLES_TABLE, CREATE_CHAT_TRANSCRIPT_TABLE, CREATE_GRAPH_ENTITIES_TABLE, CREATE_GRAPH_RELATIONS_TABLE, CREATE_CODE_FILES_TABLE, CREATE_CODE_SYMBOLS_TABLE, CREATE_CODE_EDGES_TABLE, CREATE_OBSERVATION_CODE_REFS_TABLE, CREATE_SCHEMA_MIGRATIONS_TABLE, CREATE_CODE_STATE_SNAPSHOTS_TABLE, CREATE_CODE_STATE_SNAPSHOT_FILES_TABLE, CREATE_KNOWLEDGE_CLAIMS_TABLE, CREATE_KNOWLEDGE_CLAIM_EVIDENCE_TABLE, CREATE_KNOWLEDGE_CLAIM_EVENTS_TABLE, CREATE_KNOWLEDGE_WORKSPACES_TABLE, CREATE_KNOWLEDGE_PAGES_TABLE, CREATE_KNOWLEDGE_PAGE_CLAIMS_TABLE, CREATE_KNOWLEDGE_PAGE_LINKS_TABLE, CREATE_KNOWLEDGE_PROPOSALS_TABLE, CREATE_KNOWLEDGE_WORKFLOWS_TABLE, CREATE_KNOWLEDGE_WORKFLOW_RUNS_TABLE, CREATE_LONG_TERM_MEMORIES_TABLE, CREATE_LONG_TERM_MEMORY_EVIDENCE_TABLE, CREATE_LONG_TERM_MEMORY_EVENTS_TABLE, CREATE_MEMORY_OUTCOME_SIGNALS_TABLE, CREATE_MEDIA_ASSETS_TABLE, CREATE_MEDIA_ASSET_LINKS_TABLE, CREATE_MEDIA_DERIVATIONS_TABLE, CREATE_MEDIA_EMBEDDING_PROFILES_TABLE, CREATE_MEDIA_EMBEDDINGS_TABLE, CREATE_MEDIA_JOBS_TABLE, CREATE_MAINTENANCE_JOBS_TABLE, CREATE_MAINTENANCE_TARGETS_TABLE, CREATE_COMPACTION_CHECKPOINTS_TABLE, CREATE_EVIDENCE_CARDS_TABLE, CREATE_EVIDENCE_CARD_EVENTS_TABLE, CREATE_MEMORY_FEEDBACK_STATES_TABLE, CREATE_MEMORY_FEEDBACK_EVENTS_TABLE, CREATE_MCP_BINDINGS_TABLE, CREATE_INDEXES, SCHEMA_MIGRATIONS, _dbCache;
 var init_sqlite_db = __esm({
   "src/store/sqlite-db.ts"() {
     "use strict";
@@ -1163,6 +1171,79 @@ CREATE TABLE IF NOT EXISTS compaction_checkpoints (
   created_at           TEXT NOT NULL,
   updated_at           TEXT NOT NULL
 );
+`;
+    CREATE_EVIDENCE_CARDS_TABLE = `
+CREATE TABLE IF NOT EXISTS evidence_cards (
+  id                 TEXT PRIMARY KEY,
+  project_id         TEXT NOT NULL,
+  candidate_kind     TEXT NOT NULL,
+  candidate_id       TEXT NOT NULL,
+  title              TEXT NOT NULL,
+  summary            TEXT NOT NULL DEFAULT '',
+  entity_name        TEXT,
+  source_kind        TEXT NOT NULL,
+  source_ref         TEXT NOT NULL,
+  locator            TEXT,
+  captured_hash      TEXT,
+  session_id         TEXT,
+  status             TEXT NOT NULL DEFAULT 'active',
+  verification       TEXT NOT NULL DEFAULT 'unverified',
+  freshness          TEXT NOT NULL DEFAULT 'current',
+  stale_reason       TEXT,
+  files_json         TEXT NOT NULL DEFAULT '[]',
+  related_entities_json TEXT NOT NULL DEFAULT '[]',
+  created_at         TEXT NOT NULL,
+  updated_at         TEXT NOT NULL,
+  UNIQUE(project_id, candidate_kind, candidate_id)
+);
+`;
+    CREATE_EVIDENCE_CARD_EVENTS_TABLE = `
+CREATE TABLE IF NOT EXISTS evidence_card_events (
+  id          TEXT PRIMARY KEY,
+  project_id  TEXT NOT NULL,
+  card_id     TEXT NOT NULL,
+  kind        TEXT NOT NULL,
+  detail      TEXT,
+  created_at  TEXT NOT NULL,
+  FOREIGN KEY (card_id) REFERENCES evidence_cards(id) ON DELETE CASCADE
+);
+`;
+    CREATE_MEMORY_FEEDBACK_STATES_TABLE = `
+CREATE TABLE IF NOT EXISTS memory_feedback_states (
+  project_id       TEXT NOT NULL,
+  candidate_kind   TEXT NOT NULL,
+  candidate_id     TEXT NOT NULL,
+  weight           REAL NOT NULL DEFAULT 1.0,
+  lifecycle_status TEXT NOT NULL DEFAULT 'active',
+  updated_at       TEXT NOT NULL,
+  PRIMARY KEY (project_id, candidate_kind, candidate_id)
+);
+`;
+    CREATE_MEMORY_FEEDBACK_EVENTS_TABLE = `
+CREATE TABLE IF NOT EXISTS memory_feedback_events (
+  id              TEXT PRIMARY KEY,
+  project_id      TEXT NOT NULL,
+  candidate_kind  TEXT NOT NULL,
+  candidate_id    TEXT NOT NULL,
+  signal          TEXT NOT NULL,
+  actor           TEXT,
+  note            TEXT,
+  source_ref      TEXT NOT NULL,
+  target_event_id TEXT,
+  delta           REAL NOT NULL DEFAULT 0,
+  observed_at     TEXT NOT NULL
+);
+`;
+    CREATE_MCP_BINDINGS_TABLE = `
+CREATE TABLE IF NOT EXISTS mcp_bindings (
+  handle_id    TEXT PRIMARY KEY,
+  project_id   TEXT NOT NULL,
+  project_root TEXT NOT NULL,
+  data_dir     TEXT NOT NULL,
+  created_at   TEXT NOT NULL,
+  last_used_at TEXT NOT NULL,
+  expires_at   TEXT
+);
 `;
     CREATE_INDEXES = `
 CREATE INDEX IF NOT EXISTS idx_observations_projectId ON observations(projectId);
@@ -1225,6 +1306,12 @@ CREATE INDEX IF NOT EXISTS idx_maintenance_targets_updated ON maintenance_target
 CREATE INDEX IF NOT EXISTS idx_compaction_checkpoints_project_recent ON compaction_checkpoints(project_id, status, completed_at DESC, pre_captured_at DESC);
 CREATE INDEX IF NOT EXISTS idx_compaction_checkpoints_session_pending ON compaction_checkpoints(project_id, session_id, agent, phase, status, pre_captured_at DESC);
 CREATE INDEX IF NOT EXISTS idx_compaction_checkpoints_source ON compaction_checkpoints(project_id, source_key);
+CREATE INDEX IF NOT EXISTS idx_evidence_cards_project ON evidence_cards(project_id, status, updated_at DESC);
+CREATE INDEX IF NOT EXISTS idx_evidence_cards_candidate ON evidence_cards(project_id, candidate_kind, candidate_id);
+CREATE INDEX IF NOT EXISTS idx_evidence_card_events_card ON evidence_card_events(card_id, created_at);
+CREATE INDEX IF NOT EXISTS idx_memory_feedback_states_project ON memory_feedback_states(project_id, candidate_kind, updated_at DESC);
+CREATE INDEX IF NOT EXISTS idx_memory_feedback_events_candidate ON memory_feedback_events(project_id, candidate_kind, candidate_id, observed_at DESC);
+CREATE INDEX IF NOT EXISTS idx_mcp_bindings_project ON mcp_bindings(project_id, last_used_at DESC);
 CREATE UNIQUE INDEX IF NOT EXISTS idx_maintenance_jobs_active_dedupe
   ON maintenance_jobs(project_id, kind, dedupe_key)
   WHERE status IN ('pending', 'running', 'retry');
@@ -1380,6 +1467,22 @@ CREATE UNIQUE INDEX IF NOT EXISTS idx_maintenance_jobs_active_dedupe
           }
           db2.exec("CREATE INDEX IF NOT EXISTS idx_media_jobs_source_asset ON media_jobs(project_id, source_asset_id, status)");
         }
+      },
+      {
+        id: "1.8-context-control-plane",
+        apply: (db2) => {
+          db2.exec(CREATE_EVIDENCE_CARDS_TABLE);
+          db2.exec(CREATE_EVIDENCE_CARD_EVENTS_TABLE);
+          db2.exec(CREATE_MEMORY_FEEDBACK_STATES_TABLE);
+          db2.exec(CREATE_MEMORY_FEEDBACK_EVENTS_TABLE);
+          db2.exec(CREATE_MCP_BINDINGS_TABLE);
+          db2.exec("CREATE INDEX IF NOT EXISTS idx_evidence_cards_project ON evidence_cards(project_id, status, updated_at DESC)");
+          db2.exec("CREATE INDEX IF NOT EXISTS idx_evidence_cards_candidate ON evidence_cards(project_id, candidate_kind, candidate_id)");
+          db2.exec("CREATE INDEX IF NOT EXISTS idx_evidence_card_events_card ON evidence_card_events(card_id, created_at)");
+          db2.exec("CREATE INDEX IF NOT EXISTS idx_memory_feedback_states_project ON memory_feedback_states(project_id, candidate_kind, updated_at DESC)");
+          db2.exec("CREATE INDEX IF NOT EXISTS idx_memory_feedback_events_candidate ON memory_feedback_events(project_id, candidate_kind, candidate_id, observed_at DESC)");
+          db2.exec("CREATE INDEX IF NOT EXISTS idx_mcp_bindings_project ON mcp_bindings(project_id, last_used_at DESC)");
+        }
       }
     ];
     _dbCache = /* @__PURE__ */ new Map();
@@ -1836,6 +1939,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 },
@@ -1932,6 +2036,7 @@ __export(resolved_config_exports, {
   getResolvedConfigForCwd: () => getResolvedConfigForCwd,
   getResolvedEmbeddingLane: () => getResolvedEmbeddingLane,
   getResolvedMemoryLane: () => getResolvedMemoryLane,
+  getResolvedRerankLane: () => getResolvedRerankLane,
   resetResolvedConfigCache: () => resetResolvedConfigCache
 });
 import { homedir as homedir5 } from "os";
@@ -1964,6 +2069,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(
@@ -2004,16 +2119,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: {
@@ -2023,6 +2129,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),
@@ -2092,6 +2204,9 @@ function getResolvedMemoryLane(options = {}) {
 function getResolvedEmbeddingLane(options = {}) {
   return getResolvedConfig(options).embedding;
 }
+function getResolvedRerankLane(options = {}) {
+  return getResolvedConfig(options).rerank;
+}
 function resetResolvedConfigCache() {
 }
 function first(...values) {
@@ -2134,6 +2249,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",
@@ -2157,6 +2276,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 a = normalizeTrustedEndpoint(left);
+  const b = normalizeTrustedEndpoint(right);
+  return Boolean(a && b && a === b);
+}
+function normalizeTrustedEndpoint(value) {
+  const trimmed = value?.trim();
+  if (!trimmed) return void 0;
+  try {
+    const url = new URL(trimmed);
+    const protocol = url.protocol.toLowerCase();
+    const hostname = url.hostname.toLowerCase();
+    const port = url.port;
+    let pathname = url.pathname.replace(/\/+$/, "");
+    if (pathname.toLowerCase().endsWith("/rerank")) {
+      pathname = pathname.slice(0, -"/rerank".length).replace(/\/+$/, "");
+    }
+    return `${protocol}//${hostname}${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";
@@ -4392,9 +4568,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);
@@ -4498,8 +4692,7 @@ async function callLLM(systemPrompt, userMessage, signal) {
 }
 async function callOpenAICompatible(systemPrompt, userMessage, signal) {
   const config = currentConfig;
-  let base = config.baseUrl.replace(/\/+$/, "");
-  if (!base.endsWith("/v1")) base += "/v1";
+  const base = normalizeOpenAICompatibleBaseUrl(config.baseUrl);
   const url = `${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(url, {
@@ -4578,8 +4771,7 @@ async function callLLMWithTools(messages, tools, signal) {
 }
 async function callOpenAIWithTools(messages, tools, signal) {
   const config = currentConfig;
-  let base = config.baseUrl.replace(/\/+$/, "");
-  if (!base.endsWith("/v1")) base += "/v1";
+  const base = normalizeOpenAICompatibleBaseUrl(config.baseUrl);
   const url = `${base}/chat/completions`;
   const openaiMessages = messages.map((msg) => {
     if (msg.role === "tool") {
@@ -4729,8 +4921,7 @@ async function callAnthropicWithTools(messages, tools, signal) {
 }
 async function* callOpenAIWithToolsStream(messages, tools) {
   const config = currentConfig;
-  let base = config.baseUrl.replace(/\/+$/, "");
-  if (!base.endsWith("/v1")) base += "/v1";
+  const base = normalizeOpenAICompatibleBaseUrl(config.baseUrl);
   const url = `${base}/chat/completions`;
   const openaiMessages = messages.map((msg) => {
     if (msg.role === "tool") {
@@ -4978,7 +5169,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";
@@ -4988,6 +5179,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" },
@@ -5047,6 +5239,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(promise, ms, label) {
   return new Promise((resolve, reject) => {
@@ -5332,6 +5566,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((a, b) => b.score - a.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, config) {
+  if (documents.length === 0) return [];
+  const url = buildRerankUrl(config.baseUrl);
+  const headers = {
+    "content-type": "application/json"
+  };
+  if (config.apiKey) {
+    headers.authorization = `Bearer ${config.apiKey}`;
+  }
+  const controller = new AbortController();
+  const timeoutMs = resolveRerankTimeoutMs(config.timeoutMs);
+  const timer = setTimeout(() => controller.abort(), timeoutMs);
+  try {
+    const fetchImpl = config.fetchImpl ?? fetch;
+    const response = await fetchImpl(url, {
+      method: "POST",
+      headers,
+      signal: controller.signal,
+      body: JSON.stringify(buildRerankBody(query, documents, config.model))
+    });
+    if (!response.ok) {
+      throw new Error(`Neural rerank HTTP ${response.status} from ${url}`);
+    }
+    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((candidate) => candidateText(candidate));
+  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 candidate = toRerank[row.index];
+    if (!candidate || seen.has(row.index)) continue;
+    reranked.push(candidate);
+    seen.add(row.index);
+  }
+  for (const [index, candidate] of toRerank.entries()) {
+    if (!seen.has(index)) reranked.push(candidate);
+  }
+  reranked.push(...rest);
+  return reranked;
+}
+function candidateText(candidate) {
+  const narrative = candidate.narrative?.trim();
+  if (narrative) return `${candidate.title} \u2014 ${narrative.slice(0, 200)}`;
+  return candidate.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, {
@@ -5371,9 +5747,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(
       (c) => `[ID: ${c.id}] (${c.type}) ${c.title}${c.narrative ? ` \u2014 ${c.narrative.substring(0, 100)}` : ""}`
@@ -6266,46 +6642,78 @@ async function searchObservations(options) {
       }
     }
   }
-  const shouldRerank = quality === "thorough" && tier === "heavy" && hasQuery && intermediate.length > 2 && (() => {
-    const top = intermediate[0]?.score ?? 0;
-    const second = intermediate[1]?.score ?? 0;
-    return top > 0 && second / 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((e2, index) => ({
-        id: `r${index + 1}`,
-        title: e2.title,
-        type: e2.type,
-        score: e2.score,
-        narrative: narrativeMap.get(makeEntryKey(e2.projectId, e2.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((candidate, index) => [candidate.id, toRerank[index]]));
-        const rerankedTop = reranked.map((r2) => candidateMap.get(r2.id)).filter((e2) => e2 != 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((e2, index) => ({
+      id: `r${index + 1}`,
+      title: e2.title,
+      type: e2.type,
+      score: e2.score,
+      narrative: narrativeMap.get(makeEntryKey(e2.projectId, e2.id))
+    }));
+    const RERANK_TIMEOUT_MS = parseRerankTimeoutMs(process.env.MEMORIX_RERANK_TIMEOUT_MS);
+    const candidateMap = new Map(candidates.map((candidate, index) => [candidate.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 (error) {
-      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})`);
@@ -6486,6 +6894,7 @@ var init_orama_store = __esm({
     init_project_affinity();
     init_intent_detector();
     init_query_expansion();
+    init_policy();
     init_timeout();
     db = null;
     dbInitPromise = null;
@@ -7674,10 +8083,230 @@ var init_lifecycle = __esm({
   }
 });
 
+// src/store/evidence-store.ts
+import { createHash as createHash3, randomUUID as randomUUID3 } from "crypto";
+function safeJson(value, fallback) {
+  if (typeof value !== "string" || value.length === 0) return fallback;
+  try {
+    return JSON.parse(value);
+  } catch {
+    return fallback;
+  }
+}
+function rowToCard(row) {
+  return {
+    id: String(row.id),
+    projectId: String(row.project_id),
+    candidateKind: row.candidate_kind,
+    candidateId: String(row.candidate_id),
+    title: String(row.title),
+    summary: String(row.summary ?? ""),
+    ...row.entity_name ? { entityName: String(row.entity_name) } : {},
+    sourceKind: String(row.source_kind),
+    sourceRef: String(row.source_ref),
+    ...row.locator ? { locator: String(row.locator) } : {},
+    ...row.captured_hash ? { capturedHash: String(row.captured_hash) } : {},
+    ...row.session_id ? { sessionId: String(row.session_id) } : {},
+    status: String(row.status ?? "active"),
+    verification: row.verification,
+    freshness: row.freshness,
+    ...row.stale_reason ? { staleReason: String(row.stale_reason) } : {},
+    files: safeJson(row.files_json, []),
+    relatedEntities: safeJson(row.related_entities_json, []),
+    createdAt: String(row.created_at),
+    updatedAt: String(row.updated_at)
+  };
+}
+function observationHash(observation) {
+  return createHash3("sha256").update(JSON.stringify({
+    projectId: observation.projectId,
+    id: observation.id,
+    title: observation.title,
+    narrative: observation.narrative,
+    facts: observation.facts,
+    files: observation.filesModified,
+    relatedEntities: observation.relatedEntities
+  })).digest("hex");
+}
+function sourceKind(observation) {
+  if (observation.source === "git" || observation.sourceDetail === "git-ingest") return "git";
+  if (observation.sourceDetail === "hook") return "hook";
+  return observation.source ?? "agent";
+}
+var EvidenceCardStore;
+var init_evidence_store = __esm({
+  "src/store/evidence-store.ts"() {
+    "use strict";
+    init_esm_shims();
+    init_sqlite_db();
+    EvidenceCardStore = class {
+      db = null;
+      async init(dataDir) {
+        this.db = getDatabase(dataDir);
+      }
+      requireDb() {
+        if (!this.db) throw new Error("EvidenceCardStore is not initialized.");
+        return this.db;
+      }
+      upsertObservation(observation) {
+        const db2 = this.requireDb();
+        const now3 = (/* @__PURE__ */ new Date()).toISOString();
+        const card = {
+          id: `evidence:observation:${observation.projectId}:${observation.id}`,
+          projectId: observation.projectId,
+          candidateKind: "observation",
+          candidateId: String(observation.id),
+          title: observation.title,
+          summary: observation.narrative.slice(0, 500),
+          entityName: observation.entityName,
+          sourceKind: sourceKind(observation),
+          sourceRef: `observation:${observation.id}`,
+          locator: observation.filesModified?.join(", ") || `observation:${observation.id}`,
+          capturedHash: observationHash(observation),
+          ...observation.sessionId ? { sessionId: observation.sessionId } : {},
+          status: observation.status ?? "active",
+          verification: observation.status === "resolved" ? "verified" : "unverified",
+          freshness: "current",
+          files: observation.filesModified ?? [],
+          relatedEntities: observation.relatedEntities ?? [],
+          createdAt: observation.createdAt,
+          updatedAt: now3
+        };
+        db2.prepare(`
+      INSERT INTO evidence_cards (
+        id, project_id, candidate_kind, candidate_id, title, summary, entity_name,
+        source_kind, source_ref, locator, captured_hash, session_id, status,
+        verification, freshness, stale_reason, files_json, related_entities_json,
+        created_at, updated_at
+      ) VALUES (?, ?, ?, ?, ?, ?, ?, ?, ?, ?, ?, ?, ?, ?, ?, NULL, ?, ?, ?, ?)
+      ON CONFLICT(project_id, candidate_kind, candidate_id) DO UPDATE SET
+        title = excluded.title,
+        summary = excluded.summary,
+        entity_name = excluded.entity_name,
+        source_kind = excluded.source_kind,
+        source_ref = excluded.source_ref,
+        locator = excluded.locator,
+        captured_hash = excluded.captured_hash,
+        session_id = excluded.session_id,
+        status = excluded.status,
+        freshness = 'current',
+        stale_reason = NULL,
+        files_json = excluded.files_json,
+        related_entities_json = excluded.related_entities_json,
+        updated_at = excluded.updated_at
+    `).run(
+          card.id,
+          card.projectId,
+          card.candidateKind,
+          card.candidateId,
+          card.title,
+          card.summary,
+          card.entityName ?? null,
+          card.sourceKind,
+          card.sourceRef,
+          card.locator ?? null,
+          card.capturedHash ?? null,
+          card.sessionId ?? null,
+          card.status,
+          card.verification,
+          card.freshness,
+          JSON.stringify(card.files),
+          JSON.stringify(card.relatedEntities),
+          card.createdAt,
+          card.updatedAt
+        );
+        return this.get(card.projectId, card.candidateKind, card.candidateId) ?? card;
+      }
+      get(projectId, candidateKind, candidateId) {
+        const row = this.requireDb().prepare(`
+      SELECT * FROM evidence_cards WHERE project_id = ? AND candidate_kind = ? AND candidate_id = ?
+    `).get(projectId, candidateKind, candidateId);
+        return row ? rowToCard(row) : void 0;
+      }
+      list(projectId, options = {}) {
+        const limit2 = Math.min(100, Math.max(1, Math.floor(options.limit ?? 20)));
+        const clauses = ["project_id = ?"];
+        const args = [projectId];
+        if (options.freshness) {
+          clauses.push("freshness = ?");
+          args.push(options.freshness);
+        }
+        if (options.status) {
+          clauses.push("status = ?");
+          args.push(options.status);
+        }
+        args.push(limit2);
+        const rows = this.requireDb().prepare(`
+      SELECT * FROM evidence_cards WHERE ${clauses.join(" AND ")} ORDER BY updated_at DESC, id DESC LIMIT ?
+    `).all(...args);
+        return rows.map(rowToCard);
+      }
+      syncObservations(observations2) {
+        return observations2.map((observation) => this.upsertObservation(observation));
+      }
+      markStaleForPaths(projectId, paths, reason = "source file changed") {
+        const normalized = new Set(paths.map((value) => value.replace(/\\/g, "/").toLowerCase()));
+        if (normalized.size === 0) return 0;
+        const db2 = this.requireDb();
+        const rows = db2.prepare(`SELECT * FROM evidence_cards WHERE project_id = ? AND freshness != 'stale'`).all(projectId);
+        const update2 = db2.prepare(`
+      UPDATE evidence_cards SET freshness = 'stale', stale_reason = ?, updated_at = ?
+      WHERE id = ?
+    `);
+        let changed = 0;
+        const now3 = (/* @__PURE__ */ new Date()).toISOString();
+        const run = db2.transaction(() => {
+          for (const row of rows) {
+            const files = safeJson(row.files_json, []);
+            if (!files.some((file) => normalized.has(file.replace(/\\/g, "/").toLowerCase()))) continue;
+            update2.run(reason, now3, row.id);
+            changed++;
+          }
+        });
+        run();
+        return changed;
+      }
+      setVerification(projectId, cardId, verification) {
+        this.requireDb().prepare(`
+      UPDATE evidence_cards SET verification = ?, updated_at = ? WHERE project_id = ? AND id = ?
+    `).run(verification, (/* @__PURE__ */ new Date()).toISOString(), projectId, cardId);
+      }
+      recordEvent(projectId, cardId, kind, detail) {
+        const event = {
+          id: randomUUID3(),
+          projectId,
+          cardId,
+          kind,
+          ...detail ? { detail: detail.slice(0, 2e3) } : {},
+          createdAt: (/* @__PURE__ */ new Date()).toISOString()
+        };
+        this.requireDb().prepare(`
+      INSERT INTO evidence_card_events (id, project_id, card_id, kind, detail, created_at)
+      VALUES (?, ?, ?, ?, ?, ?)
+    `).run(event.id, event.projectId, event.cardId, event.kind, event.detail ?? null, event.createdAt);
+        return event;
+      }
+      listEvents(cardId, limit2 = 50) {
+        const rows = this.requireDb().prepare(`
+      SELECT * FROM evidence_card_events WHERE card_id = ? ORDER BY created_at DESC LIMIT ?
+    `).all(cardId, Math.min(200, Math.max(1, Math.floor(limit2))));
+        return rows.map((row) => ({
+          id: String(row.id),
+          projectId: String(row.project_id),
+          cardId: String(row.card_id),
+          kind: String(row.kind),
+          ...row.detail ? { detail: String(row.detail) } : {},
+          createdAt: String(row.created_at)
+        }));
+      }
+    };
+  }
+});
+
 // src/codegraph/ids.ts
-import { createHash as createHash3 } from "crypto";
+import { createHash as createHash4 } from "crypto";
 function digest(input) {
-  return createHash3("sha256").update(input).digest("hex").slice(0, 16);
+  return createHash4("sha256").update(input).digest("hex").slice(0, 16);
 }
 function normalizeCodePath(path21) {
   return path21.replace(/\\/g, "/").replace(/^\.\//, "").replace(/\/+/g, "/");
@@ -7712,7 +8341,7 @@ var store_exports = {};
 __export(store_exports, {
   CodeGraphStore: () => CodeGraphStore
 });
-import { randomUUID as randomUUID3 } from "crypto";
+import { randomUUID as randomUUID4 } from "crypto";
 import { posix as pathPosix } from "path";
 function rowToFile(row) {
   return {
@@ -8429,7 +9058,7 @@ var init_store = __esm({
        * so an interrupted scan cannot be advertised as complete.
        */
       recordCodeStateSnapshot(input) {
-        const id = randomUUID3();
+        const id = randomUUID4();
         let snapshot;
         const tx = this.db.transaction(() => {
           const previous = this.db.prepare(
@@ -8761,6 +9390,16 @@ async function bindObservationCodeRefsBestEffort(observation) {
   } catch {
   }
 }
+async function persistEvidenceCard(observation) {
+  if (!projectDir) return;
+  try {
+    const evidence = new EvidenceCardStore();
+    await evidence.init(projectDir);
+    evidence.upsertObservation(observation);
+  } catch (error) {
+    console.error(`[memorix] Evidence card projection failed for obs-${observation.id}: ${error instanceof Error ? error.message : String(error)}`);
+  }
+}
 function queueClaimDerivation(observation) {
   const dataDir = projectDir;
   const isExplicit = observation.sourceDetail === "explicit";
@@ -9107,6 +9746,7 @@ async function storeObservation(input) {
   }
   if (!persistedCallbackInvoked) await input.onPersisted?.(observation);
   await bindObservationCodeRefsBestEffort(observation);
+  await persistEvidenceCard(observation);
   queueObservationQualification(observation);
   if (resolveObservationVisibility(observation) === "project") {
     queueClaimDerivation(observation);
@@ -9199,6 +9839,7 @@ async function upsertObservation(existing, input, now3) {
     await store.update(existing);
   }
   await bindObservationCodeRefsBestEffort(existing);
+  await persistEvidenceCard(existing);
   queueObservationQualification(existing);
   if (resolveObservationVisibility(existing) === "project") {
     queueClaimDerivation(existing);
@@ -9332,6 +9973,7 @@ async function resolveObservations(ids, status = "resolved") {
       await Promise.all(changed.map((observation) => tx.update(observation)));
     });
   }
+  for (const observation of changed) await persistEvidenceCard(observation);
   return { resolved, notFound };
 }
 function getProjectObservations(projectId) {
@@ -9669,6 +10311,7 @@ var init_observations = __esm({
     init_secret_filter();
     init_lifecycle();
     init_visibility();
+    init_evidence_store();
     observations = [];
     nextId = 1;
     projectDir = null;
@@ -9686,7 +10329,7 @@ var init_observations = __esm({
 });
 
 // src/knowledge/workspace-store.ts
-import { randomUUID as randomUUID4 } from "crypto";
+import { randomUUID as randomUUID5 } from "crypto";
 function arrayValue(raw) {
   if (typeof raw !== "string" || !raw) return [];
   try {
@@ -9827,7 +10470,7 @@ var init_workspace_store = __esm({
       }
       createProposal(input) {
         const proposal = {
-          id: input.id ?? randomUUID4(),
+          id: input.id ?? randomUUID5(),
           ...input,
           status: input.status ?? "pending",
           createdAt: input.createdAt ?? (/* @__PURE__ */ new Date()).toISOString()
@@ -9880,13 +10523,13 @@ __export(workspace_exports, {
   loadKnowledgeWorkspace: () => loadKnowledgeWorkspace,
   resolveKnowledgeWorkspaceFile: () => resolveKnowledgeWorkspaceFile
 });
-import { createHash as createHash4 } from "crypto";
+import { createHash as createHash5 } from "crypto";
 import { execFile } from "child_process";
 import { promises as fs6 } from "fs";
 import path9 from "path";
 import { promisify } from "util";
 function hash(value) {
-  return createHash4("sha256").update(value).digest("hex");
+  return createHash5("sha256").update(value).digest("hex");
 }
 function workspaceId(projectId, mode) {
   return "workspace:" + hash(projectId + ":" + mode).slice(0, 24);
@@ -10482,7 +11125,7 @@ Respond in JSON only:
 });
 
 // src/media/media-store.ts
-import { randomUUID as randomUUID5 } from "crypto";
+import { randomUUID as randomUUID6 } from "crypto";
 function asOptionalText(value) {
   return typeof value === "string" && value.length > 0 ? value : void 0;
 }
@@ -10652,7 +11295,7 @@ var init_media_store = __esm({
           return { asset: this.getAsset(input.projectId, existing.id), deduplicated: true };
         }
         const asset = {
-          id: randomUUID5(),
+          id: randomUUID6(),
           ...input,
           createdAt: now3,
           updatedAt: now3
@@ -10732,7 +11375,7 @@ var init_media_store = __esm({
     `).get(input.assetId, input.observationId ?? null, input.role);
         if (existing) return rowToLink(existing);
         const link = {
-          id: randomUUID5(),
+          id: randomUUID6(),
           assetId: input.assetId,
           projectId: input.projectId,
           ...input.observationId !== void 0 ? { observationId: input.observationId } : {},
@@ -10771,7 +11414,7 @@ var init_media_store = __esm({
           return rowToDerivation(this.db.prepare("SELECT * FROM media_derivations WHERE id = ?").get(existing.id));
         }
         const derivation = {
-          id: randomUUID5(),
+          id: randomUUID6(),
           ...input,
           content,
           ...error ? { error } : {},
@@ -10858,7 +11501,7 @@ var init_media_store = __esm({
       createJob(input) {
         const now3 = Date.now();
         const job = {
-          id: randomUUID5(),
+          id: randomUUID6(),
           projectId: input.projectId,
           kind: input.kind,
           status: "queued",
@@ -11020,14 +11663,14 @@ var init_types2 = __esm({
 });
 
 // src/media/asset-store.ts
-import { createHash as createHash5, randomUUID as randomUUID6 } from "crypto";
+import { createHash as createHash6, randomUUID as randomUUID7 } from "crypto";
 import { copyFile, lstat, mkdir as mkdir3, open, readFile as readFile3, readdir, rename as rename2, rm, stat as stat2, writeFile as writeFile3 } from "fs/promises";
 import path10 from "path";
 function mediaRoot(dataDir) {
   return path10.resolve(dataDir, "media");
 }
 function projectStorageKey(projectId) {
-  return createHash5("sha256").update(projectId).digest("hex").slice(0, 16);
+  return createHash6("sha256").update(projectId).digest("hex").slice(0, 16);
 }
 function validateUnderRoot(root, candidate) {
   const resolved = path10.resolve(candidate);
@@ -11091,7 +11734,7 @@ async function destinationExists(destination) {
 async function persistBuffer(bytes, destination) {
   await mkdir3(path10.dirname(destination), { recursive: true });
   if (await destinationExists(destination)) return false;
-  const temporary = `${destination}.${randomUUID6()}.tmp`;
+  const temporary = `${destination}.${randomUUID7()}.tmp`;
   try {
     await writeFile3(temporary, bytes, { flag: "wx" });
     await rename2(temporary, destination);
@@ -11136,7 +11779,7 @@ async function importMediaBuffer(input) {
   if (input.bytes.length === 0) throw new Error("Media import rejects empty payloads");
   if (input.bytes.length > maxBytes) throw new Error(`Media payload is too large (${input.bytes.length} bytes; limit ${maxBytes})`);
   const detected = detectMedia(input.bytes.subarray(0, 32));
-  const sha256 = createHash5("sha256").update(input.bytes).digest("hex");
+  const sha256 = createHash6("sha256").update(input.bytes).digest("hex");
   return importKnownMedia({
     dataDir: input.dataDir,
     projectId: input.projectId,
@@ -11154,7 +11797,7 @@ async function readMediaAsset(dataDir, asset, maxBytes = DEFAULT_MAX_MEDIA_BYTES
   if (asset.byteSize > maxBytes) throw new Error(`Media asset exceeds read limit (${asset.byteSize} bytes; limit ${maxBytes})`);
   const bytes = await readFile3(getMediaAssetPath(dataDir, asset));
   if (bytes.length !== asset.byteSize) throw new Error(`Media asset size no longer matches metadata: ${asset.id}`);
-  const sha256 = createHash5("sha256").update(bytes).digest("hex");
+  const sha256 = createHash6("sha256").update(bytes).digest("hex");
   if (sha256 !== asset.sha256) throw new Error(`Media asset hash no longer matches metadata: ${asset.id}`);
   return bytes;
 }
@@ -63905,7 +64548,7 @@ var require_gaxios = __commonJS({
     var retry_js_1 = require_retry3();
     var stream_1 = __require("stream");
     var interceptor_js_1 = require_interceptor();
-    var randomUUID14 = async () => globalThis.crypto?.randomUUID() || (await import("crypto")).randomUUID();
+    var randomUUID16 = async () => globalThis.crypto?.randomUUID() || (await import("crypto")).randomUUID();
     var HTTP_STATUS_NO_CONTENT = 204;
     var Gaxios = class {
       agentCache = /* @__PURE__ */ new Map();
@@ -64178,7 +64821,7 @@ var require_gaxios = __commonJS({
          */
         ["Blob", "File", "FormData"].includes(opts.data?.constructor?.name || "");
         if (opts.multipart?.length) {
-          const boundary = await randomUUID14();
+          const boundary = await randomUUID16();
           preparedHeaders.set("content-type", `multipart/related; boundary=${boundary}`);
           opts.body = stream_1.Readable.from(this.getMultipartRequest(opts.multipart, boundary));
         } else if (shouldDirectlyPassData) {
@@ -76405,7 +77048,7 @@ var require_websocket = __commonJS({
     var http3 = __require("http");
     var net = __require("net");
     var tls = __require("tls");
-    var { randomBytes, createHash: createHash13 } = __require("crypto");
+    var { randomBytes, createHash: createHash14 } = __require("crypto");
     var { Duplex, Readable: Readable2 } = __require("stream");
     var { URL: URL2 } = __require("url");
     var PerMessageDeflate2 = require_permessage_deflate();
@@ -77073,7 +77716,7 @@ var require_websocket = __commonJS({
           abortHandshake(websocket, socket, "Invalid Upgrade header");
           return;
         }
-        const digest2 = createHash13("sha1").update(key + GUID).digest("base64");
+        const digest2 = createHash14("sha1").update(key + GUID).digest("base64");
         if (res.headers["sec-websocket-accept"] !== digest2) {
           abortHandshake(websocket, socket, "Invalid Sec-WebSocket-Accept header");
           return;
@@ -77445,7 +78088,7 @@ var require_websocket_server = __commonJS({
     var EventEmitter = __require("events");
     var http3 = __require("http");
     var { Duplex } = __require("stream");
-    var { createHash: createHash13 } = __require("crypto");
+    var { createHash: createHash14 } = __require("crypto");
     var extension3 = require_extension();
     var PerMessageDeflate2 = require_permessage_deflate();
     var subprotocol2 = require_subprotocol();
@@ -77752,7 +78395,7 @@ var require_websocket_server = __commonJS({
           );
         }
         if (this._state > RUNNING) return abortHandshake(socket, 503);
-        const digest2 = createHash13("sha1").update(key + GUID).digest("base64");
+        const digest2 = createHash14("sha1").update(key + GUID).digest("base64");
         const headers = [
           "HTTP/1.1 101 Switching Protocols",
           "Upgrade: websocket",
@@ -144890,6 +145533,186 @@ var init_audio_jobs = __esm({
   }
 });
 
+// src/memory/feedback-model.ts
+function feedbackWeightMultiplier(weight) {
+  return Math.max(0.35, Math.min(1.4, 0.35 + Math.max(0, Math.min(2, weight)) * 0.525));
+}
+var init_feedback_model = __esm({
+  "src/memory/feedback-model.ts"() {
+    "use strict";
+    init_esm_shims();
+  }
+});
+
+// src/memory/feedback.ts
+var feedback_exports = {};
+__export(feedback_exports, {
+  FEEDBACK_DELTAS: () => FEEDBACK_DELTAS,
+  MemoryFeedbackStore: () => MemoryFeedbackStore,
+  applyMemoryFeedback: () => applyMemoryFeedback,
+  feedbackWeightMultiplier: () => feedbackWeightMultiplier
+});
+import { randomUUID as randomUUID8 } from "crypto";
+function applyMemoryFeedback(current, event) {
+  const delta = event.signal === "revoke" ? 0 : FEEDBACK_DELTAS[event.signal];
+  const weight = Math.max(0, Math.min(2, current.weight + delta));
+  const status = (event.signal === "code-conflict" || event.signal === "user-correction" || event.signal === "weaken") && weight < 0.5 ? "archived" : current.status;
+  return { weight, status, audit: [...current.audit, { ...event }] };
+}
+function rowToEvent(row) {
+  return {
+    id: String(row.id),
+    projectId: String(row.project_id),
+    candidateKind: row.candidate_kind,
+    candidateId: String(row.candidate_id),
+    signal: row.signal,
+    ...row.observed_at ? { at: String(row.observed_at) } : { at: (/* @__PURE__ */ new Date()).toISOString() },
+    ...row.actor ? { actor: String(row.actor) } : {},
+    ...row.note ? { note: String(row.note) } : {},
+    ...row.source_ref ? { sourceRef: String(row.source_ref) } : {},
+    ...row.target_event_id ? { targetEventId: String(row.target_event_id) } : {},
+    delta: Number(row.delta ?? 0)
+  };
+}
+var FEEDBACK_DELTAS, MemoryFeedbackStore;
+var init_feedback = __esm({
+  "src/memory/feedback.ts"() {
+    "use strict";
+    init_esm_shims();
+    init_sqlite_db();
+    init_feedback_model();
+    FEEDBACK_DELTAS = {
+      "user-correction": -0.35,
+      "verification-success": 0.25,
+      "verification-failure": -0.25,
+      "code-change": -0.15,
+      used: 0.1,
+      "not-used": -0.05,
+      "code-conflict": -0.4,
+      strengthen: 0.2,
+      weaken: -0.2
+    };
+    MemoryFeedbackStore = class {
+      db = null;
+      async init(dataDir) {
+        this.db = getDatabase(dataDir);
+      }
+      requireDb() {
+        if (!this.db) throw new Error("MemoryFeedbackStore is not initialized.");
+        return this.db;
+      }
+      loadEvents(projectId, candidateKind, candidateId) {
+        return this.requireDb().prepare(`
+      SELECT * FROM memory_feedback_events
+      WHERE project_id = ? AND candidate_kind = ? AND candidate_id = ?
+      ORDER BY observed_at ASC, rowid ASC
+    `).all(projectId, candidateKind, candidateId).map(rowToEvent);
+      }
+      rebuild(projectId, candidateKind, candidateId) {
+        const events = this.loadEvents(projectId, candidateKind, candidateId);
+        const revoked = new Set(events.filter((event) => event.signal === "revoke" && event.targetEventId).map((event) => event.targetEventId));
+        let state = { weight: 1, status: "active", audit: [] };
+        for (const event of events) {
+          if (event.signal === "revoke" || revoked.has(event.id)) {
+            state.audit.push(event);
+            continue;
+          }
+          state = applyMemoryFeedback(state, event);
+        }
+        this.requireDb().prepare(`
+      INSERT INTO memory_feedback_states (project_id, candidate_kind, candidate_id, weight, lifecycle_status, updated_at)
+      VALUES (?, ?, ?, ?, ?, ?)
+      ON CONFLICT(project_id, candidate_kind, candidate_id) DO UPDATE SET
+        weight = excluded.weight, lifecycle_status = excluded.lifecycle_status, updated_at = excluded.updated_at
+    `).run(projectId, candidateKind, candidateId, state.weight, state.status, (/* @__PURE__ */ new Date()).toISOString());
+        return state;
+      }
+      getState(projectId, candidateKind, candidateId) {
+        const row = this.requireDb().prepare(`
+      SELECT weight, lifecycle_status FROM memory_feedback_states
+      WHERE project_id = ? AND candidate_kind = ? AND candidate_id = ?
+    `).get(projectId, candidateKind, candidateId);
+        if (!row) return { weight: 1, status: "active", audit: [] };
+        return {
+          weight: Number(row.weight ?? 1),
+          status: row.lifecycle_status ?? "active",
+          audit: this.loadEvents(projectId, candidateKind, candidateId)
+        };
+      }
+      listStates(projectId, candidateKind = "observation") {
+        return this.requireDb().prepare(`
+      SELECT candidate_id, weight, lifecycle_status, updated_at
+      FROM memory_feedback_states WHERE project_id = ? AND candidate_kind = ?
+      ORDER BY updated_at DESC
+    `).all(projectId, candidateKind).map((row) => ({
+          candidateId: String(row.candidate_id),
+          weight: Number(row.weight),
+          status: row.lifecycle_status,
+          updatedAt: String(row.updated_at)
+        }));
+      }
+      weights(projectId, candidateKind = "observation") {
+        const states = /* @__PURE__ */ new Map();
+        for (const row of this.listStates(projectId, candidateKind)) {
+          states.set(row.candidateId, this.getState(projectId, candidateKind, row.candidateId));
+        }
+        return states;
+      }
+      record(input) {
+        if (input.signal === "revoke" && !input.targetEventId) {
+          throw new Error("A revoke feedback event requires targetEventId.");
+        }
+        if (input.signal === "revoke") {
+          const target = this.requireDb().prepare(`
+        SELECT 1 FROM memory_feedback_events
+        WHERE id = ? AND project_id = ? AND candidate_kind = ? AND candidate_id = ?
+      `).get(input.targetEventId, input.projectId, input.candidateKind, input.candidateId);
+          if (!target) throw new Error("The feedback event to revoke was not found in the same candidate scope.");
+        }
+        const event = {
+          id: randomUUID8(),
+          projectId: input.projectId,
+          candidateKind: input.candidateKind,
+          candidateId: input.candidateId,
+          signal: input.signal,
+          sourceRef: input.sourceRef,
+          ...input.actor ? { actor: input.actor } : {},
+          ...input.note ? { note: input.note.slice(0, 2e3) } : {},
+          ...input.targetEventId ? { targetEventId: input.targetEventId } : {},
+          at: input.at ?? (/* @__PURE__ */ new Date()).toISOString(),
+          delta: input.signal === "revoke" ? 0 : FEEDBACK_DELTAS[input.signal]
+        };
+        this.requireDb().prepare(`
+      INSERT INTO memory_feedback_events (
+        id, project_id, candidate_kind, candidate_id, signal, actor, note,
+        source_ref, target_event_id, delta, observed_at
+      ) VALUES (?, ?, ?, ?, ?, ?, ?, ?, ?, ?, ?)
+    `).run(
+          event.id,
+          event.projectId,
+          event.candidateKind,
+          event.candidateId,
+          event.signal,
+          event.actor ?? null,
+          event.note ?? null,
+          event.sourceRef,
+          event.targetEventId ?? null,
+          event.delta,
+          event.at
+        );
+        return { event, state: this.rebuild(input.projectId, input.candidateKind, input.candidateId) };
+      }
+      audit(projectId, candidateKind, candidateId, limit2 = 100) {
+        return this.requireDb().prepare(`
+      SELECT * FROM memory_feedback_events
+      WHERE project_id = ? AND candidate_kind = ? AND candidate_id = ?
+      ORDER BY observed_at DESC, rowid DESC LIMIT ?
+    `).all(projectId, candidateKind, candidateId, Math.min(200, Math.max(1, Math.floor(limit2)))).map(rowToEvent);
+      }
+    };
+  }
+});
+
 // src/memory/retention.ts
 var retention_exports = {};
 __export(retention_exports, {
@@ -144931,6 +145754,7 @@ function getEffectiveRetentionDays(doc) {
 }
 function isImmune(doc) {
   if (doc.type === "probe") return false;
+  if (doc.feedbackStatus === "archived") return false;
   if (doc.admissionState === "candidate" || doc.admissionState === "ephemeral") return false;
   if (doc.valueCategory === "core") return true;
   const importance = getImportanceLevel(doc);
@@ -144963,7 +145787,8 @@ function calculateRelevance(doc, referenceTime) {
   const decayFactor = Math.exp(-ageDays / retention);
   const accessCount = doc.accessCount ?? 0;
   const accessBoost = Math.min(2, 1 + 0.1 * accessCount);
-  let totalScore = base * decayFactor * accessBoost;
+  const feedbackMultiplier = doc.feedbackWeight === void 0 ? 1 : feedbackWeightMultiplier(doc.feedbackWeight);
+  let totalScore = base * decayFactor * accessBoost * feedbackMultiplier;
   const immune = isImmune(doc);
   if (immune) {
     totalScore = Math.max(totalScore, 0.5);
@@ -144975,7 +145800,8 @@ function calculateRelevance(doc, referenceTime) {
     decayFactor,
     accessBoost,
     ageDays,
-    isImmune: immune
+    isImmune: immune,
+    feedbackMultiplier
   };
 }
 function rankByRelevance(docs, referenceTime) {
@@ -144983,6 +145809,7 @@ function rankByRelevance(docs, referenceTime) {
 }
 function getRetentionZone(doc, referenceTime) {
   const now3 = referenceTime ?? /* @__PURE__ */ new Date();
+  if (doc.feedbackStatus === "archived") return "archive-candidate";
   const importance = getImportanceLevel(doc);
   const retention = getEffectiveRetentionDays(doc);
   const createdAt = new Date(doc.createdAt);
@@ -145054,7 +145881,7 @@ function explainRetention(doc, referenceTime) {
     summary: parts.join(" ; ")
   };
 }
-function toRetentionDocument(obs, accessMap) {
+function toRetentionDocument(obs, accessMap, feedback) {
   const access2 = accessMap?.get(obs.id);
   return {
     id: `obs-${obs.id}`,
@@ -145076,11 +145903,12 @@ function toRetentionDocument(obs, accessMap) {
     sourceDetail: obs.sourceDetail ?? "",
     valueCategory: obs.valueCategory ?? "",
     admissionState: obs.admissionState ?? "",
-    admissionReason: obs.admissionReason ?? ""
+    admissionReason: obs.admissionReason ?? "",
+    ...feedback ? { feedbackWeight: feedback.weight, feedbackStatus: feedback.status } : {}
   };
 }
 function projectObservationRetention(observation, options = {}) {
-  const document2 = toRetentionDocument(observation, options.accessMap);
+  const document2 = toRetentionDocument(observation, options.accessMap, options.feedback);
   const relevance = calculateRelevance(document2, options.referenceTime);
   const explanation = explainRetention(document2, options.referenceTime);
   return {
@@ -145105,7 +145933,17 @@ function summarizeRetentionProjections(projections) {
   }
   return { active, stale, archiveCandidates, immune };
 }
-async function archiveExpiredBatch(_projectDir, options) {
+async function loadFeedbackStore(dataDir) {
+  try {
+    const { MemoryFeedbackStore: MemoryFeedbackStore2 } = await Promise.resolve().then(() => (init_feedback(), feedback_exports));
+    const store = new MemoryFeedbackStore2();
+    await store.init(dataDir);
+    return store;
+  } catch {
+    return void 0;
+  }
+}
+async function archiveExpiredBatch(projectDir2, options) {
   const store = getObservationStore();
   const limit2 = Math.min(500, Math.max(1, Math.floor(options.limit ?? 100)));
   const afterId = Math.max(0, Math.floor(options.afterId ?? 0));
@@ -145114,11 +145952,13 @@ async function archiveExpiredBatch(_projectDir, options) {
     afterId,
     limit: limit2 + 1
   });
+  const feedback = await loadFeedbackStore(projectDir2);
   const hasMore = page.length > limit2;
   const scanned = hasMore ? page.slice(0, limit2) : page;
   const candidateIds = scanned.filter((observation) => !options.reader || canManageObservation(observation, options.reader)).filter((observation) => projectObservationRetention(observation, {
     accessMap: options.accessMap,
-    referenceTime: options.referenceTime
+    referenceTime: options.referenceTime,
+    ...feedback ? { feedback: feedback.getState(options.projectId, "observation", String(observation.id)) } : {}
   }).zone === "archive-candidate").map((observation) => observation.id);
   const archived = candidateIds.length === 0 ? 0 : await store.atomic(async (tx) => {
     const updates = await Promise.all(
@@ -145149,6 +145989,7 @@ async function archiveExpired(projectDir2, referenceTime, accessMap, projectId,
     const remaining = reader ? remainingObservations.filter((observation) => canManageObservation(observation, reader)).length : remainingObservations.length;
     return { archived, remaining };
   }
+  const feedback = await loadFeedbackStore(projectDir2);
   return await store.atomic(async (tx) => {
     const allObs = await tx.loadAll();
     const activeObs = allObs.filter(
@@ -145156,7 +145997,11 @@ async function archiveExpired(projectDir2, referenceTime, accessMap, projectId,
     );
     const archivedIds = [];
     for (const obs of activeObs) {
-      const retention = projectObservationRetention(obs, { accessMap, referenceTime });
+      const retention = projectObservationRetention(obs, {
+        accessMap,
+        referenceTime,
+        ...feedback ? { feedback: feedback.getState(obs.projectId, "observation", String(obs.id)) } : {}
+      });
       if (retention.zone === "archive-candidate") {
         archivedIds.push(obs.id);
       }
@@ -145176,6 +146021,7 @@ var init_retention = __esm({
     init_esm_shims();
     init_obs_store();
     init_visibility();
+    init_feedback_model();
     RETENTION_DAYS = {
       critical: 365,
       high: 180,
@@ -145212,7 +146058,7 @@ var init_retention = __esm({
 });
 
 // src/memory/owner.ts
-import { randomUUID as randomUUID7 } from "crypto";
+import { randomUUID as randomUUID9 } from "crypto";
 import { promises as fs9 } from "fs";
 import path16 from "path";
 function ownerPath(dataDir) {
@@ -145242,7 +146088,7 @@ async function resolveLocalMemoryOwner(dataDir, options = {}) {
   await fs9.mkdir(path16.dirname(filePath), { recursive: true });
   const created = {
     version: 1,
-    id: "local-" + randomUUID7(),
+    id: "local-" + randomUUID9(),
     createdAt: (/* @__PURE__ */ new Date()).toISOString()
   };
   try {
@@ -145265,7 +146111,7 @@ var init_owner = __esm({
 });
 
 // src/memory/long-term-store.ts
-import { randomUUID as randomUUID8 } from "crypto";
+import { randomUUID as randomUUID10 } from "crypto";
 function optionalText2(value) {
   return typeof value === "string" && value.trim() ? value : void 0;
 }
@@ -145316,7 +146162,7 @@ function rowToEvidence(row) {
     createdAt: row.createdAt
   };
 }
-function rowToEvent(row) {
+function rowToEvent2(row) {
   return {
     id: row.id,
     memoryId: row.memoryId,
@@ -145425,7 +146271,7 @@ var init_long_term_store = __esm({
       }
       insertEvidence(input) {
         const evidence = {
-          id: randomUUID8(),
+          id: randomUUID10(),
           ...input,
           createdAt: input.createdAt ?? (/* @__PURE__ */ new Date()).toISOString()
         };
@@ -145452,7 +146298,7 @@ var init_long_term_store = __esm({
       }
       recordEvent(input) {
         const event = {
-          id: randomUUID8(),
+          id: randomUUID10(),
           ...input,
           createdAt: input.createdAt ?? (/* @__PURE__ */ new Date()).toISOString()
         };
@@ -145473,7 +146319,7 @@ var init_long_term_store = __esm({
       listEvents(memoryId) {
         return this.db.prepare(`
       SELECT * FROM long_term_memory_events WHERE memoryId = ? ORDER BY createdAt ASC, rowid ASC
-    `).all(memoryId).map(rowToEvent);
+    `).all(memoryId).map(rowToEvent2);
       }
       markAccess(ids, at = (/* @__PURE__ */ new Date()).toISOString()) {
         const unique = [...new Set(ids.filter(Boolean))];
@@ -145542,7 +146388,7 @@ __export(long_term_exports, {
   selectLongTermMemoriesForTask: () => selectLongTermMemoriesForTask,
   supersedeLongTermMemory: () => supersedeLongTermMemory
 });
-import { randomUUID as randomUUID9 } from "crypto";
+import { randomUUID as randomUUID11 } from "crypto";
 function isOneOf(value, values) {
   return typeof value === "string" && values.includes(value);
 }
@@ -145724,7 +146570,7 @@ async function createManualLongTermMemory(input) {
   const owner = await resolveLocalMemoryOwner(input.dataDir, { create: true });
   if (!owner) throw new Error("Memorix could not resolve a local memory owner.");
   assertScope(input.scope);
-  const evidence = input.scope === "user" ? [{ kind: "user", referenceId: owner.id, relation: "user-confirmed" }] : [{ kind: "manual", referenceId: "manual:" + randomUUID9(), relation: "supports" }];
+  const evidence = input.scope === "user" ? [{ kind: "user", referenceId: owner.id, relation: "user-confirmed" }] : [{ kind: "manual", referenceId: "manual:" + randomUUID11(), relation: "supports" }];
   return createLongTermMemoryWithDataDir({
     dataDir: input.dataDir,
     originProjectId: input.projectId,
@@ -145779,7 +146625,7 @@ async function createLongTermMemoryWithDataDir(input) {
   assertPortableEvidence(input.scope, portability, evidenceInputs);
   const now3 = (/* @__PURE__ */ new Date()).toISOString();
   const memory = {
-    id: randomUUID9(),
+    id: randomUUID11(),
     originProjectId: compactText(input.originProjectId, "origin project id", 1e3),
     ownerId: compactText(input.ownerId, "owner id", 160),
     scope: input.scope,
@@ -146098,7 +146944,7 @@ var init_long_term = __esm({
 
 // src/codegraph/code-state.ts
 import { execFile as execFile2 } from "child_process";
-import { createHash as createHash6 } from "crypto";
+import { createHash as createHash7 } from "crypto";
 import { promisify as promisify3 } from "util";
 async function runGit(rootPath, args) {
   try {
@@ -146127,7 +146973,7 @@ function changedPathCount(status) {
   return count2;
 }
 function fingerprint(baseRevision, status) {
-  return createHash6("sha256").update(baseRevision ?? "").update("\0").update(status).digest("hex");
+  return createHash7("sha256").update(baseRevision ?? "").update("\0").update(status).digest("hex");
 }
 async function collectCodeStateSnapshot(input) {
   const [revision, status] = await Promise.all([
@@ -146227,11 +147073,11 @@ __export(lite_provider_exports, {
   indexProjectLite: () => indexProjectLite,
   refreshProjectLite: () => refreshProjectLite
 });
-import { createHash as createHash7 } from "crypto";
+import { createHash as createHash8 } from "crypto";
 import { readdirSync as readdirSync2, readFileSync as readFileSync7, statSync as statSync3 } from "fs";
 import { join as join4, relative } from "path";
 function hashText(text2) {
-  return createHash7("sha256").update(text2).digest("hex");
+  return createHash8("sha256").update(text2).digest("hex");
 }
 function extension2(path21) {
   const index = path21.lastIndexOf(".");
@@ -146641,7 +147487,7 @@ var claim_store_exports = {};
 __export(claim_store_exports, {
   ClaimStore: () => ClaimStore
 });
-import { createHash as createHash8, randomUUID as randomUUID10 } from "crypto";
+import { createHash as createHash9, randomUUID as randomUUID12 } from "crypto";
 function optionalText3(value) {
   return typeof value === "string" && value ? value : void 0;
 }
@@ -146680,7 +147526,7 @@ function rowToEvidence2(row) {
     createdAt: row.createdAt
   };
 }
-function rowToEvent2(row) {
+function rowToEvent3(row) {
   return {
     id: row.id,
     projectId: row.projectId,
@@ -146694,7 +147540,7 @@ function rowToEvent2(row) {
   };
 }
 function evidenceKey(input) {
-  return createHash8("sha256").update(JSON.stringify([
+  return createHash9("sha256").update(JSON.stringify([
     input.evidenceKind,
     input.evidenceId,
     input.relation,
@@ -146825,7 +147671,7 @@ var init_claim_store = __esm({
         locator, capturedHash, evidenceKey, createdAt
       ) VALUES (?, ?, ?, ?, ?, ?, ?, ?, ?, ?)
     `).run(
-          randomUUID10(),
+          randomUUID12(),
           input.claimId,
           input.evidenceKind,
           input.evidenceId,
@@ -146847,7 +147693,7 @@ var init_claim_store = __esm({
       }
       recordEvent(input) {
         const event = {
-          id: randomUUID10(),
+          id: randomUUID12(),
           ...input,
           ...input.detail ? { detail: sanitizeCredentials(input.detail) } : {},
           createdAt: input.createdAt ?? (/* @__PURE__ */ new Date()).toISOString()
@@ -146875,7 +147721,7 @@ var init_claim_store = __esm({
       SELECT * FROM knowledge_claim_events
       WHERE claimId = ?
       ORDER BY createdAt ASC, id
-    `).all(claimId).map(rowToEvent2);
+    `).all(claimId).map(rowToEvent3);
       }
     };
   }
@@ -146892,7 +147738,7 @@ __export(claims_exports, {
   supersedeClaim: () => supersedeClaim,
   writeClaim: () => writeClaim
 });
-import { createHash as createHash9, randomUUID as randomUUID11 } from "crypto";
+import { createHash as createHash10, randomUUID as randomUUID13 } from "crypto";
 function compactText2(value, field) {
   if (typeof value !== "string") throw new Error("Claim " + field + " must be text");
   const sanitized = sanitizeCredentials(value).trim().replace(/\s+/g, " ");
@@ -146904,7 +147750,7 @@ function normalizedTerm(value) {
   return compactText2(value, "identity").toLocaleLowerCase("en-US");
 }
 function hashIdentity(parts) {
-  return createHash9("sha256").update(parts.join(String.fromCharCode(31))).digest("hex");
+  return createHash10("sha256").update(parts.join(String.fromCharCode(31))).digest("hex");
 }
 function buildClaimIdentity(input) {
   const subject = normalizedTerm(input.subject);
@@ -146978,7 +147824,7 @@ function normalizeClaimInput(input) {
   const now3 = (/* @__PURE__ */ new Date()).toISOString();
   return {
     claim: {
-      id: randomUUID11(),
+      id: randomUUID13(),
       projectId,
       subject,
       predicate,
@@ -147145,7 +147991,7 @@ function supersedeClaim(store, input) {
   });
 }
 function hashObservation(observation) {
-  return createHash9("sha256").update(JSON.stringify([
+  return createHash10("sha256").update(JSON.stringify([
     observation.title,
     observation.narrative,
     observation.facts,
@@ -147389,11 +148235,11 @@ var init_frontmatter = __esm({
 });
 
 // src/knowledge/markdown.ts
-import { createHash as createHash10 } from "crypto";
+import { createHash as createHash11 } from "crypto";
 import { promises as fs10 } from "fs";
 import path17 from "path";
 function hashContent(content) {
-  return createHash10("sha256").update(content).digest("hex");
+  return createHash11("sha256").update(content).digest("hex");
 }
 function stringField(data, key) {
   const value = data[key];
@@ -147519,11 +148365,11 @@ __export(wiki_exports, {
   lintKnowledgeWorkspace: () => lintKnowledgeWorkspace,
   readKnowledgePage: () => readKnowledgePage
 });
-import { createHash as createHash11 } from "crypto";
+import { createHash as createHash12 } from "crypto";
 import { promises as fs11 } from "fs";
 import path18 from "path";
 function hash2(value) {
-  return createHash11("sha256").update(value).digest("hex");
+  return createHash12("sha256").update(value).digest("hex");
 }
 function now() {
   return (/* @__PURE__ */ new Date()).toISOString();
@@ -148063,7 +148909,7 @@ var init_workflow_sync = __esm({
 });
 
 // src/knowledge/workflow-store.ts
-import { randomUUID as randomUUID12 } from "crypto";
+import { randomUUID as randomUUID14 } from "crypto";
 function parseJson(value, fallback) {
   if (typeof value !== "string" || !value) return fallback;
   try {
@@ -148163,7 +149009,7 @@ var init_workflow_store = __esm({
       }
       recordRun(input) {
         const run = {
-          id: randomUUID12(),
+          id: randomUUID14(),
           workflowId: input.workflowId,
           projectId: input.projectId,
           task: input.task.trim(),
@@ -148231,7 +149077,7 @@ var init_outcome_types = __esm({
 });
 
 // src/knowledge/outcome-store.ts
-import { randomUUID as randomUUID13 } from "crypto";
+import { randomUUID as randomUUID15 } from "crypto";
 function optionalText5(value) {
   return typeof value === "string" && value.trim() ? value : void 0;
 }
@@ -148275,7 +149121,7 @@ var init_outcome_store = __esm({
       }
       record(input) {
         const signal = {
-          id: randomUUID13(),
+          id: randomUUID15(),
           projectId: text(input.projectId, "project id"),
           candidateKind: oneOf(input.candidateKind, MEMORY_OUTCOME_CANDIDATE_KINDS, "candidate kind"),
           candidateId: text(input.candidateId, "candidate id"),
@@ -148380,11 +149226,11 @@ __export(workflows_exports, {
   syncCanonicalWorkflows: () => syncCanonicalWorkflows,
   writeCanonicalWorkflow: () => writeCanonicalWorkflow
 });
-import { createHash as createHash12 } from "crypto";
+import { createHash as createHash13 } from "crypto";
 import { promises as fs12 } from "fs";
 import path19 from "path";
 function hash3(value) {
-  return createHash12("sha256").update(value).digest("hex");
+  return createHash13("sha256").update(value).digest("hex");
 }
 function now2() {
   return (/* @__PURE__ */ new Date()).toISOString();