memorix 1.7.2 → 1.8.0

package/dist/sdk.js

@@ -437,7 +437,7 @@ function isSqliteAvailable() {
     return false;
   }
 }
-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";
@@ -1083,6 +1083,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);
@@ -1145,6 +1218,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');
@@ -1300,6 +1379,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();
@@ -2781,6 +2876,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 },
@@ -3056,6 +3152,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 },
@@ -3148,6 +3245,8 @@ var init_toml_loader = __esm({
 var dotenv_loader_exports = {};
 __export(dotenv_loader_exports, {
   getLoadedEnvFiles: () => getLoadedEnvFiles,
+  getLoadedEnvKeys: () => getLoadedEnvKeys,
+  getLoadedEnvValue: () => getLoadedEnvValue,
   loadDotenv: () => loadDotenv,
   resetDotenv: () => resetDotenv
 });
@@ -3159,6 +3258,8 @@ function loadEnvFile(filePath) {
   const parsed = parse(readFileSync6(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);
     }
@@ -3171,6 +3272,8 @@ function loadDotenv(projectRoot, options = {}) {
     resetDotenv();
   }
   loadedEnvFiles.length = 0;
+  loadedEnvKeys.clear();
+  loadedEnvValues.clear();
   if (projectRoot) {
     loadEnvFile(getProjectDotenvPath(projectRoot));
   }
@@ -3186,11 +3289,18 @@ function resetDotenv() {
   dotenvLoaded = false;
   dotenvProjectRoot = null;
   loadedEnvFiles.length = 0;
+  loadedEnvKeys.clear();
 }
 function getLoadedEnvFiles() {
   return loadedEnvFiles;
 }
-var dotenvLoaded, dotenvProjectRoot, loadedEnvFiles, injectedKeys;
+function getLoadedEnvKeys() {
+  return loadedEnvKeys;
+}
+function getLoadedEnvValue(key) {
+  return loadedEnvValues.get(key);
+}
+var dotenvLoaded, dotenvProjectRoot, loadedEnvFiles, loadedEnvKeys, loadedEnvValues, injectedKeys;
 var init_dotenv_loader = __esm({
   "src/config/dotenv-loader.ts"() {
     "use strict";
@@ -3199,6 +3309,8 @@ var init_dotenv_loader = __esm({
     dotenvLoaded = false;
     dotenvProjectRoot = null;
     loadedEnvFiles = [];
+    loadedEnvKeys = /* @__PURE__ */ new Set();
+    loadedEnvValues = /* @__PURE__ */ new Map();
     injectedKeys = /* @__PURE__ */ new Set();
   }
 });
@@ -3211,6 +3323,7 @@ __export(resolved_config_exports, {
   getResolvedConfigForCwd: () => getResolvedConfigForCwd,
   getResolvedEmbeddingLane: () => getResolvedEmbeddingLane,
   getResolvedMemoryLane: () => getResolvedMemoryLane,
+  getResolvedRerankLane: () => getResolvedRerankLane,
   resetResolvedConfigCache: () => resetResolvedConfigCache
 });
 import { homedir as homedir5 } from "os";
@@ -3243,6 +3356,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(
@@ -3283,16 +3406,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: {
@@ -3302,6 +3416,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),
@@ -3371,6 +3491,9 @@ function getResolvedMemoryLane(options = {}) {
 function getResolvedEmbeddingLane(options = {}) {
   return getResolvedConfig(options).embedding;
 }
+function getResolvedRerankLane(options = {}) {
+  return getResolvedConfig(options).rerank;
+}
 function resetResolvedConfigCache() {
 }
 function first(...values) {
@@ -3413,6 +3536,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",
@@ -3436,6 +3563,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";
@@ -5671,9 +5855,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);
@@ -5777,8 +5979,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, {
@@ -5857,8 +6058,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") {
@@ -6008,8 +6208,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") {
@@ -6257,7 +6456,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";
@@ -6267,6 +6466,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" },
@@ -6326,6 +6526,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((resolve2, reject) => {
@@ -6611,6 +6853,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, {
@@ -6650,9 +7034,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)}` : ""}`
@@ -7545,46 +7929,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})`);
@@ -7765,6 +8181,7 @@ var init_orama_store = __esm({
     init_project_affinity();
     init_intent_detector();
     init_query_expansion();
+    init_policy();
     init_timeout();
     db = null;
     dbInitPromise = null;
@@ -8984,6 +9401,226 @@ 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/runtime/isolated-maintenance.ts
 import { spawn } from "child_process";
 import { existsSync as existsSync8 } from "fs";
@@ -9145,7 +9782,7 @@ var workspace_store_exports = {};
 __export(workspace_store_exports, {
   KnowledgeWorkspaceStore: () => KnowledgeWorkspaceStore
 });
-import { randomUUID as randomUUID3 } from "crypto";
+import { randomUUID as randomUUID4 } from "crypto";
 function arrayValue(raw) {
   if (typeof raw !== "string" || !raw) return [];
   try {
@@ -9286,7 +9923,7 @@ var init_workspace_store = __esm({
       }
       createProposal(input) {
         const proposal = {
-          id: input.id ?? randomUUID3(),
+          id: input.id ?? randomUUID4(),
           ...input,
           status: input.status ?? "pending",
           createdAt: input.createdAt ?? (/* @__PURE__ */ new Date()).toISOString()
@@ -9339,13 +9976,13 @@ __export(workspace_exports, {
   loadKnowledgeWorkspace: () => loadKnowledgeWorkspace,
   resolveKnowledgeWorkspaceFile: () => resolveKnowledgeWorkspaceFile
 });
-import { createHash as createHash3 } from "crypto";
+import { createHash as createHash4 } from "crypto";
 import { execFile } from "child_process";
 import { promises as fs9 } from "fs";
 import path13 from "path";
 import { promisify } from "util";
 function hash(value) {
-  return createHash3("sha256").update(value).digest("hex");
+  return createHash4("sha256").update(value).digest("hex");
 }
 function workspaceId(projectId, mode) {
   return "workspace:" + hash(projectId + ":" + mode).slice(0, 24);
@@ -9945,7 +10582,7 @@ var media_store_exports = {};
 __export(media_store_exports, {
   MediaStore: () => MediaStore
 });
-import { randomUUID as randomUUID4 } from "crypto";
+import { randomUUID as randomUUID5 } from "crypto";
 function asOptionalText(value) {
   return typeof value === "string" && value.length > 0 ? value : void 0;
 }
@@ -10115,7 +10752,7 @@ var init_media_store = __esm({
           return { asset: this.getAsset(input.projectId, existing.id), deduplicated: true };
         }
         const asset = {
-          id: randomUUID4(),
+          id: randomUUID5(),
           ...input,
           createdAt: now3,
           updatedAt: now3
@@ -10195,7 +10832,7 @@ var init_media_store = __esm({
     `).get(input.assetId, input.observationId ?? null, input.role);
         if (existing) return rowToLink(existing);
         const link = {
-          id: randomUUID4(),
+          id: randomUUID5(),
           assetId: input.assetId,
           projectId: input.projectId,
           ...input.observationId !== void 0 ? { observationId: input.observationId } : {},
@@ -10234,7 +10871,7 @@ var init_media_store = __esm({
           return rowToDerivation(this.db.prepare("SELECT * FROM media_derivations WHERE id = ?").get(existing.id));
         }
         const derivation = {
-          id: randomUUID4(),
+          id: randomUUID5(),
           ...input,
           content,
           ...error ? { error } : {},
@@ -10321,7 +10958,7 @@ var init_media_store = __esm({
       createJob(input) {
         const now3 = Date.now();
         const job = {
-          id: randomUUID4(),
+          id: randomUUID5(),
           projectId: input.projectId,
           kind: input.kind,
           status: "queued",
@@ -10497,14 +11134,14 @@ __export(asset_store_exports, {
   readMediaAsset: () => readMediaAsset,
   removeMediaAsset: () => removeMediaAsset
 });
-import { createHash as createHash4, randomUUID as randomUUID5 } from "crypto";
+import { createHash as createHash5, randomUUID as randomUUID6 } 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 path14 from "path";
 function mediaRoot(dataDir) {
   return path14.resolve(dataDir, "media");
 }
 function projectStorageKey(projectId) {
-  return createHash4("sha256").update(projectId).digest("hex").slice(0, 16);
+  return createHash5("sha256").update(projectId).digest("hex").slice(0, 16);
 }
 function validateUnderRoot(root, candidate) {
   const resolved = path14.resolve(candidate);
@@ -10564,14 +11201,14 @@ async function readHeader(filePath, bytes = 32) {
 }
 async function sha256File(filePath) {
   const bytes = await readFile3(filePath);
-  return createHash4("sha256").update(bytes).digest("hex");
+  return createHash5("sha256").update(bytes).digest("hex");
 }
 function destinationFor(root, projectId, sha256, extension3) {
   const relative3 = path14.join("assets", projectStorageKey(projectId), sha256.slice(0, 2), `${sha256}${extension3}`);
   return { relative: relative3, absolute: validateUnderRoot(root, path14.join(root, relative3)) };
 }
 function deletionStagingPath(root, assetId) {
-  return validateUnderRoot(root, path14.join(root, ".trash", `${assetId}.${randomUUID5()}.pending-delete`));
+  return validateUnderRoot(root, path14.join(root, ".trash", `${assetId}.${randomUUID6()}.pending-delete`));
 }
 async function destinationExists(destination) {
   try {
@@ -10585,7 +11222,7 @@ async function destinationExists(destination) {
 async function persistFile(source, destination) {
   await mkdir3(path14.dirname(destination), { recursive: true });
   if (await destinationExists(destination)) return false;
-  const temporary = `${destination}.${randomUUID5()}.tmp`;
+  const temporary = `${destination}.${randomUUID6()}.tmp`;
   try {
     await copyFile(source, temporary);
     await rename2(temporary, destination);
@@ -10601,7 +11238,7 @@ async function persistFile(source, destination) {
 async function persistBuffer(bytes, destination) {
   await mkdir3(path14.dirname(destination), { recursive: true });
   if (await destinationExists(destination)) return false;
-  const temporary = `${destination}.${randomUUID5()}.tmp`;
+  const temporary = `${destination}.${randomUUID6()}.tmp`;
   try {
     await writeFile3(temporary, bytes, { flag: "wx" });
     await rename2(temporary, destination);
@@ -10670,7 +11307,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 = createHash4("sha256").update(input.bytes).digest("hex");
+  const sha256 = createHash5("sha256").update(input.bytes).digest("hex");
   return importKnownMedia({
     dataDir: input.dataDir,
     projectId: input.projectId,
@@ -10688,7 +11325,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 = createHash4("sha256").update(bytes).digest("hex");
+  const sha256 = createHash5("sha256").update(bytes).digest("hex");
   if (sha256 !== asset.sha256) throw new Error(`Media asset hash no longer matches metadata: ${asset.id}`);
   return bytes;
 }
@@ -63558,7 +64195,7 @@ var require_gaxios = __commonJS({
     var retry_js_1 = require_retry3();
     var stream_1 = __require("stream");
     var interceptor_js_1 = require_interceptor();
-    var randomUUID17 = async () => globalThis.crypto?.randomUUID() || (await import("crypto")).randomUUID();
+    var randomUUID19 = async () => globalThis.crypto?.randomUUID() || (await import("crypto")).randomUUID();
     var HTTP_STATUS_NO_CONTENT = 204;
     var Gaxios = class {
       agentCache = /* @__PURE__ */ new Map();
@@ -63831,7 +64468,7 @@ var require_gaxios = __commonJS({
          */
         ["Blob", "File", "FormData"].includes(opts.data?.constructor?.name || "");
         if (opts.multipart?.length) {
-          const boundary = await randomUUID17();
+          const boundary = await randomUUID19();
           preparedHeaders.set("content-type", `multipart/related; boundary=${boundary}`);
           opts.body = stream_1.Readable.from(this.getMultipartRequest(opts.multipart, boundary));
         } else if (shouldDirectlyPassData) {
@@ -76058,7 +76695,7 @@ var require_websocket = __commonJS({
     var http3 = __require("http");
     var net = __require("net");
     var tls = __require("tls");
-    var { randomBytes: randomBytes2, createHash: createHash16 } = __require("crypto");
+    var { randomBytes: randomBytes2, createHash: createHash17 } = __require("crypto");
     var { Duplex, Readable: Readable2 } = __require("stream");
     var { URL: URL2 } = __require("url");
     var PerMessageDeflate2 = require_permessage_deflate();
@@ -76726,7 +77363,7 @@ var require_websocket = __commonJS({
           abortHandshake(websocket, socket, "Invalid Upgrade header");
           return;
         }
-        const digest2 = createHash16("sha1").update(key + GUID).digest("base64");
+        const digest2 = createHash17("sha1").update(key + GUID).digest("base64");
         if (res.headers["sec-websocket-accept"] !== digest2) {
           abortHandshake(websocket, socket, "Invalid Sec-WebSocket-Accept header");
           return;
@@ -77098,7 +77735,7 @@ var require_websocket_server = __commonJS({
     var EventEmitter2 = __require("events");
     var http3 = __require("http");
     var { Duplex } = __require("stream");
-    var { createHash: createHash16 } = __require("crypto");
+    var { createHash: createHash17 } = __require("crypto");
     var extension3 = require_extension();
     var PerMessageDeflate2 = require_permessage_deflate();
     var subprotocol2 = require_subprotocol();
@@ -77405,7 +78042,7 @@ var require_websocket_server = __commonJS({
           );
         }
         if (this._state > RUNNING) return abortHandshake(socket, 503);
-        const digest2 = createHash16("sha1").update(key + GUID).digest("base64");
+        const digest2 = createHash17("sha1").update(key + GUID).digest("base64");
         const headers = [
           "HTTP/1.1 101 Switching Protocols",
           "Upgrade: websocket",
@@ -144659,6 +145296,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 randomUUID7 } 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: randomUUID7(),
+          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, {
@@ -144700,6 +145517,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);
@@ -144732,7 +145550,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);
@@ -144744,7 +145563,8 @@ function calculateRelevance(doc, referenceTime) {
     decayFactor,
     accessBoost,
     ageDays,
-    isImmune: immune
+    isImmune: immune,
+    feedbackMultiplier
   };
 }
 function rankByRelevance(docs, referenceTime) {
@@ -144752,6 +145572,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);
@@ -144823,7 +145644,7 @@ function explainRetention(doc, referenceTime) {
     summary: parts.join(" ; ")
   };
 }
-function toRetentionDocument(obs, accessMap) {
+function toRetentionDocument(obs, accessMap, feedback) {
   const access3 = accessMap?.get(obs.id);
   return {
     id: `obs-${obs.id}`,
@@ -144845,11 +145666,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 {
@@ -144874,7 +145696,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));
@@ -144883,11 +145715,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(
@@ -144918,6 +145752,7 @@ async function archiveExpired(projectDir2, referenceTime, accessMap, projectId,
     const remaining = reader2 ? remainingObservations.filter((observation) => canManageObservation(observation, reader2)).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(
@@ -144925,7 +145760,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);
       }
@@ -144945,6 +145784,7 @@ var init_retention = __esm({
     init_esm_shims();
     init_obs_store();
     init_visibility();
+    init_feedback_model();
     RETENTION_DAYS = {
       critical: 365,
       high: 180,
@@ -144985,7 +145825,7 @@ var owner_exports = {};
 __export(owner_exports, {
   resolveLocalMemoryOwner: () => resolveLocalMemoryOwner
 });
-import { randomUUID as randomUUID6 } from "crypto";
+import { randomUUID as randomUUID8 } from "crypto";
 import { promises as fs12 } from "fs";
 import path20 from "path";
 function ownerPath(dataDir) {
@@ -145015,7 +145855,7 @@ async function resolveLocalMemoryOwner(dataDir, options = {}) {
   await fs12.mkdir(path20.dirname(filePath), { recursive: true });
   const created = {
     version: 1,
-    id: "local-" + randomUUID6(),
+    id: "local-" + randomUUID8(),
     createdAt: (/* @__PURE__ */ new Date()).toISOString()
   };
   try {
@@ -145038,7 +145878,7 @@ var init_owner = __esm({
 });
 
 // src/memory/long-term-store.ts
-import { randomUUID as randomUUID7 } from "crypto";
+import { randomUUID as randomUUID9 } from "crypto";
 function optionalText2(value) {
   return typeof value === "string" && value.trim() ? value : void 0;
 }
@@ -145089,7 +145929,7 @@ function rowToEvidence(row) {
     createdAt: row.createdAt
   };
 }
-function rowToEvent(row) {
+function rowToEvent2(row) {
   return {
     id: row.id,
     memoryId: row.memoryId,
@@ -145198,7 +146038,7 @@ var init_long_term_store = __esm({
       }
       insertEvidence(input) {
         const evidence = {
-          id: randomUUID7(),
+          id: randomUUID9(),
           ...input,
           createdAt: input.createdAt ?? (/* @__PURE__ */ new Date()).toISOString()
         };
@@ -145225,7 +146065,7 @@ var init_long_term_store = __esm({
       }
       recordEvent(input) {
         const event = {
-          id: randomUUID7(),
+          id: randomUUID9(),
           ...input,
           createdAt: input.createdAt ?? (/* @__PURE__ */ new Date()).toISOString()
         };
@@ -145246,7 +146086,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 unique2 = [...new Set(ids.filter(Boolean))];
@@ -145315,7 +146155,7 @@ __export(long_term_exports, {
   selectLongTermMemoriesForTask: () => selectLongTermMemoriesForTask,
   supersedeLongTermMemory: () => supersedeLongTermMemory
 });
-import { randomUUID as randomUUID8 } from "crypto";
+import { randomUUID as randomUUID10 } from "crypto";
 function isOneOf(value, values) {
   return typeof value === "string" && values.includes(value);
 }
@@ -145497,7 +146337,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:" + randomUUID8(), relation: "supports" }];
+  const evidence = input.scope === "user" ? [{ kind: "user", referenceId: owner.id, relation: "user-confirmed" }] : [{ kind: "manual", referenceId: "manual:" + randomUUID10(), relation: "supports" }];
   return createLongTermMemoryWithDataDir({
     dataDir: input.dataDir,
     originProjectId: input.projectId,
@@ -145552,7 +146392,7 @@ async function createLongTermMemoryWithDataDir(input) {
   assertPortableEvidence(input.scope, portability, evidenceInputs);
   const now3 = (/* @__PURE__ */ new Date()).toISOString();
   const memory = {
-    id: randomUUID8(),
+    id: randomUUID10(),
     originProjectId: compactText(input.originProjectId, "origin project id", 1e3),
     ownerId: compactText(input.ownerId, "owner id", 160),
     scope: input.scope,
@@ -145870,9 +146710,9 @@ var init_long_term = __esm({
 });
 
 // src/codegraph/ids.ts
-import { createHash as createHash5 } from "crypto";
+import { createHash as createHash6 } from "crypto";
 function digest(input) {
-  return createHash5("sha256").update(input).digest("hex").slice(0, 16);
+  return createHash6("sha256").update(input).digest("hex").slice(0, 16);
 }
 function normalizeCodePath(path35) {
   return path35.replace(/\\/g, "/").replace(/^\.\//, "").replace(/\/+/g, "/");
@@ -145907,7 +146747,7 @@ var store_exports = {};
 __export(store_exports, {
   CodeGraphStore: () => CodeGraphStore
 });
-import { randomUUID as randomUUID9 } from "crypto";
+import { randomUUID as randomUUID11 } from "crypto";
 import { posix as pathPosix } from "path";
 function rowToFile(row) {
   return {
@@ -146624,7 +147464,7 @@ var init_store = __esm({
        * so an interrupted scan cannot be advertised as complete.
        */
       recordCodeStateSnapshot(input) {
-        const id = randomUUID9();
+        const id = randomUUID11();
         let snapshot;
         const tx = this.db.transaction(() => {
           const previous = this.db.prepare(
@@ -146702,7 +147542,7 @@ var init_store = __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 {
@@ -146731,7 +147571,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([
@@ -146831,11 +147671,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(path35) {
   const index = path35.lastIndexOf(".");
@@ -147402,7 +148242,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;
 }
@@ -147441,7 +148281,7 @@ function rowToEvidence2(row) {
     createdAt: row.createdAt
   };
 }
-function rowToEvent2(row) {
+function rowToEvent3(row) {
   return {
     id: row.id,
     projectId: row.projectId,
@@ -147455,7 +148295,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,
@@ -147586,7 +148426,7 @@ var init_claim_store = __esm({
         locator, capturedHash, evidenceKey, createdAt
       ) VALUES (?, ?, ?, ?, ?, ?, ?, ?, ?, ?)
     `).run(
-          randomUUID10(),
+          randomUUID12(),
           input.claimId,
           input.evidenceKind,
           input.evidenceId,
@@ -147608,7 +148448,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()
@@ -147636,7 +148476,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);
       }
     };
   }
@@ -147653,7 +148493,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, " ");
@@ -147665,7 +148505,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);
@@ -147739,7 +148579,7 @@ function normalizeClaimInput(input) {
   const now3 = (/* @__PURE__ */ new Date()).toISOString();
   return {
     claim: {
-      id: randomUUID11(),
+      id: randomUUID13(),
       projectId,
       subject,
       predicate,
@@ -147906,7 +148746,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,
@@ -148150,11 +148990,11 @@ var init_frontmatter = __esm({
 });
 
 // src/knowledge/markdown.ts
-import { createHash as createHash10 } from "crypto";
+import { createHash as createHash11 } from "crypto";
 import { promises as fs13 } from "fs";
 import path21 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];
@@ -148280,11 +149120,11 @@ __export(wiki_exports, {
   lintKnowledgeWorkspace: () => lintKnowledgeWorkspace,
   readKnowledgePage: () => readKnowledgePage
 });
-import { createHash as createHash11 } from "crypto";
+import { createHash as createHash12 } from "crypto";
 import { promises as fs14 } from "fs";
 import path22 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();
@@ -148828,7 +149668,7 @@ var workflow_store_exports = {};
 __export(workflow_store_exports, {
   WorkflowStore: () => WorkflowStore
 });
-import { randomUUID as randomUUID12 } from "crypto";
+import { randomUUID as randomUUID14 } from "crypto";
 function parseJson(value, fallback) {
   if (typeof value !== "string" || !value) return fallback;
   try {
@@ -148928,7 +149768,7 @@ var init_workflow_store = __esm({
       }
       recordRun(input) {
         const run = {
-          id: randomUUID12(),
+          id: randomUUID14(),
           workflowId: input.workflowId,
           projectId: input.projectId,
           task: input.task.trim(),
@@ -149006,7 +149846,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;
 }
@@ -149050,7 +149890,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"),
@@ -149477,11 +150317,11 @@ __export(workflows_exports, {
   syncCanonicalWorkflows: () => syncCanonicalWorkflows,
   writeCanonicalWorkflow: () => writeCanonicalWorkflow
 });
-import { createHash as createHash12 } from "crypto";
+import { createHash as createHash13 } from "crypto";
 import { promises as fs15 } from "fs";
 import path23 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();
@@ -150878,6 +151718,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";
@@ -151224,6 +152074,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);
@@ -151316,6 +152167,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);
@@ -151449,6 +152301,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) {
@@ -151786,6 +152639,7 @@ var init_observations = __esm({
     init_secret_filter();
     init_lifecycle();
     init_visibility();
+    init_evidence_store();
     observations = [];
     nextId = 1;
     projectDir = null;
@@ -155465,7 +156319,7 @@ var compaction_checkpoint_store_exports = {};
 __export(compaction_checkpoint_store_exports, {
   CompactionCheckpointStore: () => CompactionCheckpointStore
 });
-import { createHash as createHash14, randomUUID as randomUUID14 } from "crypto";
+import { createHash as createHash15, randomUUID as randomUUID16 } from "crypto";
 function optionalText7(value) {
   return typeof value === "string" && value ? value : void 0;
 }
@@ -155507,7 +156361,7 @@ function sourceKeyFor(input, summary) {
     input.tokensBefore ?? "",
     input.firstKeptEntryId ?? ""
   ].join("\0");
-  return `derived:${createHash14("sha256").update(material).digest("hex").slice(0, 32)}`;
+  return `derived:${createHash15("sha256").update(material).digest("hex").slice(0, 32)}`;
 }
 function rowToCheckpoint(row) {
   return {
@@ -155566,7 +156420,7 @@ var init_compaction_checkpoint_store = __esm({
         if (pending) return rowToCheckpoint(pending);
         const now3 = input.capturedAt ?? (/* @__PURE__ */ new Date()).toISOString();
         const checkpoint = {
-          id: randomUUID14(),
+          id: randomUUID16(),
           projectId: input.projectId,
           sessionId: input.sessionId,
           agent: input.agent,
@@ -155574,7 +156428,7 @@ var init_compaction_checkpoint_store = __esm({
           captureKind: "preflight",
           reason: safeReason(input.reason),
           sourceEvent: input.sourceEvent,
-          sourceKey: `pre:${randomUUID14()}`,
+          sourceKey: `pre:${randomUUID16()}`,
           transcriptAvailable: Boolean(input.transcriptAvailable),
           status: "active",
           preCapturedAt: now3,
@@ -155640,7 +156494,7 @@ var init_compaction_checkpoint_store = __esm({
           return this.get(checkpoint2.id);
         }
         const checkpoint = {
-          id: randomUUID14(),
+          id: randomUUID16(),
           projectId: input.projectId,
           sessionId: input.sessionId,
           agent: input.agent,
@@ -157004,7 +157858,7 @@ __export(team_store_exports, {
   isTeamStoreInitialized: () => isTeamStoreInitialized,
   resetTeamStore: () => resetTeamStore
 });
-import { randomUUID as randomUUID15 } from "crypto";
+import { randomUUID as randomUUID17 } from "crypto";
 import path30 from "path";
 import fs18 from "fs";
 function getTeamStore() {
@@ -157293,7 +158147,7 @@ var init_team_store = __esm({
        * reactivate it (preserving agent_id). Otherwise create a new one.
        */
       registerAgent(input) {
-        const instanceId = input.instanceId || randomUUID15();
+        const instanceId = input.instanceId || randomUUID17();
         const now3 = Date.now();
         const existing = this.stmtAgentFindByInstance.get(
           input.projectId,
@@ -157319,7 +158173,7 @@ var init_team_store = __esm({
           this.eventBus?.emit("agent:joined", { agentId: row2.agent_id, projectId: input.projectId, agentType: input.agentType });
           return row2;
         }
-        const agentId = randomUUID15();
+        const agentId = randomUUID17();
         this.stmtAgentUpsert.run({
           agent_id: agentId,
           project_id: input.projectId,
@@ -157421,7 +158275,7 @@ var init_team_store = __esm({
             return { error: `Recipient agent '${input.recipientAgentId}' not found \u2014 cannot send to unknown agent` };
           }
         }
-        const id = randomUUID15();
+        const id = randomUUID17();
         const now3 = Date.now();
         const row = {
           id,
@@ -157471,7 +158325,7 @@ var init_team_store = __esm({
       // Task Operations (with atomic claim semantics)
       // ═══════════════════════════════════════════════════════════════════
       createTask(input) {
-        const taskId = randomUUID15();
+        const taskId = randomUUID17();
         const now3 = Date.now();
         const row = {
           task_id: taskId,
@@ -157743,7 +158597,7 @@ var init_team_store = __esm({
               for (const [agentId, msgs] of Object.entries(snap.messages.inboxes)) {
                 for (const msg of msgs) {
                   this.stmtMsgInsert.run({
-                    id: msg.id ?? randomUUID15(),
+                    id: msg.id ?? randomUUID17(),
                     project_id: "migrated",
                     sender_agent_id: msg.from ?? "unknown",
                     recipient_agent_id: msg.to === "__broadcast__" ? null : msg.to ?? agentId,
@@ -158614,6 +159468,23 @@ var init_maintenance = __esm({
   }
 });
 
+// src/dashboard/config-provenance.ts
+function resolveDashboardKeySource({ value, envKeys, configSource }) {
+  for (const envKey of envKeys) {
+    const envValue = process.env[envKey];
+    if (envValue !== value) continue;
+    return getLoadedEnvValue(envKey) === envValue ? ".env" : `env:${envKey}`;
+  }
+  return configSource;
+}
+var init_config_provenance = __esm({
+  "src/dashboard/config-provenance.ts"() {
+    "use strict";
+    init_esm_shims();
+    init_dotenv_loader();
+  }
+});
+
 // src/dashboard/project-classification.ts
 var project_classification_exports = {};
 __export(project_classification_exports, {
@@ -159393,6 +160264,20 @@ async function handleApi(req, res, dataDir, projectId, projectName, baseDir, pro
         sendJson(res, observations2);
         break;
       }
+      case "/evidence": {
+        const observations2 = filterDashboardObservations(
+          await getObservationStore().loadByProject(effectiveProjectId, { status: "active" }),
+          effectiveProjectId
+        );
+        const evidenceStore = new EvidenceCardStore();
+        await evidenceStore.init(effectiveDataDir);
+        evidenceStore.syncObservations(observations2);
+        const query = url.searchParams.get("q") || "";
+        const limit2 = Number(url.searchParams.get("limit") || 20);
+        const cards = evidenceStore.list(effectiveProjectId, { limit: Math.min(100, Math.max(1, limit2)) }).filter((card) => !query || [card.title, card.summary, card.sourceRef, card.locator ?? ""].join(" ").toLowerCase().includes(query.toLowerCase()));
+        sendJson(res, { cards, projectId: effectiveProjectId });
+        break;
+      }
       case "/sessions": {
         const allSessions = await getSessionStore().loadAll();
         const sessions = filterByProject(allSessions, effectiveProjectId);
@@ -159440,8 +160325,13 @@ async function handleApi(req, res, dataDir, projectId, projectName, baseDir, pro
           filesModified: o.filesModified
         }));
         const retentionReferenceTime = new Date(now3);
+        const feedback = new MemoryFeedbackStore();
+        await feedback.init(effectiveDataDir).catch(() => void 0);
         const retention = summarizeRetentionProjections(
-          observations2.filter((observation) => observation.type !== "probe").map((observation) => projectObservationRetention(observation, { referenceTime: retentionReferenceTime }))
+          observations2.filter((observation) => observation.type !== "probe").map((observation) => projectObservationRetention(observation, {
+            referenceTime: retentionReferenceTime,
+            feedback: feedback.getState(effectiveProjectId, "observation", String(observation.id))
+          }))
         );
         const retentionSummary = {
           active: retention.active,
@@ -159535,9 +160425,14 @@ async function handleApi(req, res, dataDir, projectId, projectName, baseDir, pro
           effectiveProjectId
         );
         const referenceTime = /* @__PURE__ */ new Date();
+        const feedback = new MemoryFeedbackStore();
+        await feedback.init(effectiveDataDir).catch(() => void 0);
         const rows = observations2.filter((observation) => observation.type !== "probe").map((observation) => ({
           observation,
-          retention: projectObservationRetention(observation, { referenceTime })
+          retention: projectObservationRetention(observation, {
+            referenceTime,
+            feedback: feedback.getState(effectiveProjectId, "observation", String(observation.id))
+          })
         })).sort((a, b) => b.retention.displayScore - a.retention.displayScore);
         const summary = summarizeRetentionProjections(rows.map((row) => row.retention));
         const scored = rows.map(({ observation, retention }) => ({
@@ -159608,23 +160503,13 @@ async function handleApi(req, res, dataDir, projectId, projectName, baseDir, pro
         const os6 = await import("os");
         const { existsSync: existsSync21 } = await import("fs");
         const { join: join25 } = await import("path");
-        let yml = {};
         const configProjectRoot = effectiveProjectRoot;
-        try {
-          const { loadYamlConfig: loadYamlConfig2 } = await Promise.resolve().then(() => (init_yaml_loader(), yaml_loader_exports));
-          yml = configProjectRoot ? loadYamlConfig2(configProjectRoot) : loadYamlConfig2(null);
-        } catch {
-        }
-        if (configProjectRoot) {
-          try {
-            const { loadDotenv: loadDotenv2 } = await Promise.resolve().then(() => (init_dotenv_loader(), dotenv_loader_exports));
-            loadDotenv2(configProjectRoot);
-          } catch {
-          }
-        }
+        const resolved = getResolvedConfig({ projectRoot: configProjectRoot });
         const files = {
           "project memorix.yml": { exists: false, path: "", unavailable: !configProjectRoot },
           "user memorix.yml": { exists: false, path: "" },
+          "project memorix.toml": { exists: false, path: "", unavailable: !configProjectRoot },
+          "user config.toml": { exists: false, path: "" },
           "project .env": { exists: false, path: "", unavailable: !configProjectRoot },
           "user .env": { exists: false, path: "" },
           "legacy config.json": { exists: false, path: "" }
@@ -159634,6 +160519,8 @@ async function handleApi(req, res, dataDir, projectId, projectName, baseDir, pro
           const paths = {
             "project memorix.yml": configProjectRoot ? join25(configProjectRoot, "memorix.yml") : null,
             "user memorix.yml": join25(home, ".memorix", "memorix.yml"),
+            "project memorix.toml": configProjectRoot ? join25(configProjectRoot, "memorix.toml") : null,
+            "user config.toml": join25(home, ".memorix", "config.toml"),
             "project .env": configProjectRoot ? join25(configProjectRoot, ".env") : null,
             "user .env": join25(home, ".memorix", ".env"),
             "legacy config.json": join25(home, ".memorix", "config.json")
@@ -159648,67 +160535,61 @@ async function handleApi(req, res, dataDir, projectId, projectName, baseDir, pro
         } catch {
         }
         const values = [];
-        const getEnvSource = async (envKey, ymlSource) => {
-          if (process.env[envKey]) {
-            try {
-              const { getLoadedEnvFiles: getLoadedEnvFiles2 } = await Promise.resolve().then(() => (init_dotenv_loader(), dotenv_loader_exports));
-              const envFiles = getLoadedEnvFiles2();
-              if (envFiles.length > 0) return `.env (${envKey})`;
-            } catch {
-            }
-            return `env:${envKey}`;
-          }
-          return ymlSource ?? "default";
-        };
-        const llmProvider = process.env.MEMORIX_LLM_PROVIDER || yml.llm?.provider;
-        if (llmProvider) values.push({ key: "llm.provider", value: llmProvider, source: await getEnvSource("MEMORIX_LLM_PROVIDER", yml.llm?.provider ? "memorix.yml" : void 0) });
-        const llmModel = process.env.MEMORIX_LLM_MODEL || yml.llm?.model;
-        if (llmModel) values.push({ key: "llm.model", value: llmModel, source: await getEnvSource("MEMORIX_LLM_MODEL", yml.llm?.model ? "memorix.yml" : void 0) });
-        const llmKey = process.env.MEMORIX_LLM_API_KEY || process.env.MEMORIX_API_KEY || yml.llm?.apiKey || process.env.OPENAI_API_KEY;
+        const tomlSource = configProjectRoot && files["project memorix.toml"].exists ? "memorix.toml" : files["user config.toml"].exists ? "config.toml" : "default";
+        const legacySource = files["project memorix.yml"].exists || files["user memorix.yml"].exists ? "memorix.yml" : files["legacy config.json"].exists ? "config.json" : "default";
+        const configSource = resolved.sources.toml.length > 0 ? tomlSource : resolved.sources.legacy.length > 0 ? legacySource : "default";
+        const source = (envKey) => resolveDashboardKeySource({
+          value: process.env[envKey] ?? "",
+          envKeys: [envKey],
+          configSource
+        });
+        if (resolved.memory.llm.provider) values.push({ key: "llm.provider", value: resolved.memory.llm.provider, source: source("MEMORIX_LLM_PROVIDER") });
+        if (resolved.memory.llm.model) values.push({ key: "llm.model", value: resolved.memory.llm.model, source: source("MEMORIX_LLM_MODEL") });
+        const llmKey = resolved.memory.llm.apiKey;
+        const memoryKeyEnv = [
+          "MEMORIX_LLM_API_KEY",
+          "MEMORIX_API_KEY",
+          "OPENAI_API_KEY",
+          "ANTHROPIC_API_KEY",
+          ...resolved.memory.llm.provider === "openrouter" || resolved.memory.llm.baseUrl?.includes("openrouter.ai") ? ["OPENROUTER_API_KEY"] : []
+        ];
         if (llmKey) {
-          let src = "unknown";
-          if (process.env.MEMORIX_LLM_API_KEY) src = await getEnvSource("MEMORIX_LLM_API_KEY");
-          else if (process.env.MEMORIX_API_KEY) src = await getEnvSource("MEMORIX_API_KEY");
-          else if (yml.llm?.apiKey) src = "memorix.yml (move to .env!)";
-          else if (process.env.OPENAI_API_KEY) src = await getEnvSource("OPENAI_API_KEY");
+          const src = resolveDashboardKeySource({ value: llmKey, envKeys: memoryKeyEnv, configSource });
           values.push({ key: "llm.apiKey", value: "****" + llmKey.slice(-4), source: src, sensitive: true });
         } else {
           values.push({ key: "llm.apiKey", value: "not set", source: "none" });
         }
-        const agentProvider = process.env.MEMORIX_AGENT_PROVIDER || process.env.MEMORIX_AGENT_LLM_PROVIDER || yml.agent?.provider;
-        if (agentProvider) {
-          let source;
-          if (process.env.MEMORIX_AGENT_PROVIDER) source = await getEnvSource("MEMORIX_AGENT_PROVIDER");
-          else if (process.env.MEMORIX_AGENT_LLM_PROVIDER) source = `${await getEnvSource("MEMORIX_AGENT_LLM_PROVIDER")} (legacy)`;
-          else source = yml.agent?.provider ? "memorix.yml" : "default";
-          values.push({ key: "agent.provider", value: agentProvider, source });
-        }
-        const agentModel = process.env.MEMORIX_AGENT_MODEL || process.env.MEMORIX_AGENT_LLM_MODEL || yml.agent?.model;
-        if (agentModel) {
-          let source;
-          if (process.env.MEMORIX_AGENT_MODEL) source = await getEnvSource("MEMORIX_AGENT_MODEL");
-          else if (process.env.MEMORIX_AGENT_LLM_MODEL) source = `${await getEnvSource("MEMORIX_AGENT_LLM_MODEL")} (legacy)`;
-          else source = yml.agent?.model ? "memorix.yml" : "default";
-          values.push({ key: "agent.model", value: agentModel, source });
-        }
-        const agentKey = process.env.MEMORIX_AGENT_API_KEY || process.env.MEMORIX_AGENT_LLM_API_KEY || yml.agent?.apiKey;
+        if (resolved.agent.provider) {
+          values.push({ key: "agent.provider", value: resolved.agent.provider, source: source("MEMORIX_AGENT_PROVIDER") });
+        }
+        if (resolved.agent.model) {
+          values.push({ key: "agent.model", value: resolved.agent.model, source: source("MEMORIX_AGENT_MODEL") });
+        }
+        const agentKey = resolved.agent.apiKey;
         if (agentKey) {
-          let src = "unknown";
-          if (process.env.MEMORIX_AGENT_API_KEY) src = await getEnvSource("MEMORIX_AGENT_API_KEY");
-          else if (process.env.MEMORIX_AGENT_LLM_API_KEY) src = `${await getEnvSource("MEMORIX_AGENT_LLM_API_KEY")} (legacy)`;
-          else if (yml.agent?.apiKey) src = "memorix.yml (move to .env!)";
+          const src = resolveDashboardKeySource({
+            value: agentKey,
+            envKeys: ["MEMORIX_AGENT_API_KEY", "MEMORIX_AGENT_LLM_API_KEY"],
+            configSource
+          });
           values.push({ key: "agent.apiKey", value: "****" + agentKey.slice(-4), source: src, sensitive: true });
         } else {
-          values.push({ key: "agent.apiKey", value: "fallback to llm.apiKey", source: "default" });
-        }
-        const embProvider = process.env.MEMORIX_EMBEDDING || yml.embedding?.provider || "off";
-        values.push({ key: "embedding.provider", value: embProvider, source: await getEnvSource("MEMORIX_EMBEDDING", yml.embedding?.provider ? "memorix.yml" : void 0) });
-        values.push({ key: "git.autoHook", value: String(yml.git?.autoHook ?? false), source: yml.git?.autoHook !== void 0 ? "memorix.yml" : "default" });
-        values.push({ key: "git.skipMergeCommits", value: String(yml.git?.skipMergeCommits ?? true), source: yml.git?.skipMergeCommits !== void 0 ? "memorix.yml" : "default" });
-        if (yml.behavior?.formationMode) values.push({ key: "behavior.formationMode", value: yml.behavior.formationMode, source: "memorix.yml" });
-        if (yml.behavior?.sessionInject) values.push({ key: "behavior.sessionInject", value: yml.behavior.sessionInject, source: "memorix.yml" });
-        values.push({ key: "server.transport", value: yml.server?.transport || "stdio", source: yml.server?.transport ? "memorix.yml" : "default" });
-        values.push({ key: "server.dashboard", value: String(yml.server?.dashboard ?? true), source: yml.server?.dashboard !== void 0 ? "memorix.yml" : "default" });
+          values.push({
+            key: "agent.apiKey",
+            value: "fallback to llm.apiKey",
+            source: llmKey ? resolveDashboardKeySource({ value: llmKey, envKeys: memoryKeyEnv, configSource }) : "default"
+          });
+        }
+        values.push({ key: "embedding.provider", value: resolved.embedding.provider || "off", source: source("MEMORIX_EMBEDDING") });
+        if (resolved.embedding.model) values.push({ key: "embedding.model", value: resolved.embedding.model, source: source("MEMORIX_EMBEDDING_MODEL") });
+        if (resolved.rerank.provider !== "off") {
+          values.push({ key: "rerank.provider", value: resolved.rerank.provider, source: source("MEMORIX_RERANK_PROVIDER") });
+          if (resolved.rerank.model) values.push({ key: "rerank.model", value: resolved.rerank.model, source: source("MEMORIX_RERANK_MODEL") });
+        }
+        values.push({ key: "git.autoHook", value: String(resolved.git.autoHook ?? false), source: configSource });
+        values.push({ key: "git.skipMergeCommits", value: String(resolved.git.skipMergeCommits ?? true), source: configSource });
+        values.push({ key: "server.transport", value: resolved.server.transport || "stdio", source: configSource });
+        values.push({ key: "server.dashboard", value: String(resolved.server.dashboard ?? true), source: configSource });
         sendJson(res, { files, values });
         break;
       }
@@ -160156,10 +161037,14 @@ var init_server = __esm({
     init_dotenv_loader();
     init_yaml_loader();
     init_yaml_loader();
+    init_resolved_config();
     init_graph_scope();
     init_retention();
     init_visibility();
+    init_evidence_store();
+    init_feedback();
     init_maintenance();
+    init_config_provenance();
     MIME_TYPES = {
       ".html": "text/html; charset=utf-8",
       ".css": "text/css; charset=utf-8",
@@ -160627,7 +161512,7 @@ __export(planner_exports, {
   materializeTaskGraph: () => materializeTaskGraph,
   seedAutonomousPipeline: () => seedAutonomousPipeline
 });
-import { randomUUID as randomUUID16 } from "crypto";
+import { randomUUID as randomUUID18 } from "crypto";
 function isPlannerTask(metadata) {
   if (!metadata) return null;
   try {
@@ -160685,7 +161570,7 @@ function seedAutonomousPipeline(teamStore, projectId, config, opts) {
   const maxIterations = config.maxIterations ?? 3;
   const taskBudget = config.taskBudget ?? 15;
   const structuredPlan = opts?.structuredPlan ?? true;
-  const pipelineId = randomUUID16();
+  const pipelineId = randomUUID18();
   const meta = {
     plannerType: "plan",
     pipelineId,
@@ -161220,8 +162105,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",
@@ -161358,8 +162242,8 @@ var init_official_skills = __esm({
           "",
           "| Situation | Prefer | CLI fallback |",
           "|---|---|---|",
-          '| Starting a coding task and needing the best task-lensed project map | `memorix_project_context` with the user\'s task | `memorix context "<task>" --brief-json` |',
-          '| Continuing prior project work | `memorix_project_context` with the user\'s task | `memorix resume "<task>" --brief-json` |',
+          '| Starting a coding task and needing the best task-lensed project map | `memorix_project_context` with the user\'s task | `memorix context "<task>" --fallback --brief-json` |',
+          '| Continuing prior project work | `memorix_project_context` with the user\'s task | `memorix resume "<task>" --fallback --brief-json` |',
           '| Need structured refs/freshness for code-bound memories | `memorix_context_pack` | `memorix codegraph context-pack --task "<topic>"` |',
           '| Explicit memory graph question | `memorix_graph_context` | `memorix memory graph-context --query "<topic>"` |',
           '| Specific past decision, bug, file, or change | `memorix_search` | `memorix memory search --query "<topic>"` |',
@@ -161372,7 +162256,7 @@ var init_official_skills = __esm({
           "",
           "- Default first step for non-trivial coding work: call `memorix_project_context` before progress files, dev-log reads, ad-hoc file reads, or git archaeology. Pass the user's actual task so Memorix can choose a bugfix, feature, release, onboarding, refactor, docs, test, or general brief. Start by reading its suggested files.",
           "- In Claude Code headless/print-mode, an initial MCP `pending` status is not a failure by itself. Prefer MCP first: use the client's tool discovery/dynamic loading to find `memorix_project_context` when it is not in the first visible tool list.",
-          '- Continuation fallback is mandatory: when the user asks to continue, resume, take over, or explain prior work and MCP cannot be called in this turn, run `memorix resume "<task>" --brief-json` exactly once before inspecting files, Git history, progress notes, or guessing. The absence of `.memorix` or visible memory files never proves project memory is empty. For a new task, use `memorix context "<task>" --brief-json` instead. Use `--json` only when a diagnostic needs the detailed legacy payload. If that one command fails, report it and proceed normally; do not probe help, enumerate commands, or chain broad searches.',
+          '- Continuation fallback is mandatory: when the user asks to continue, resume, take over, or explain prior work and MCP cannot be called in this turn, run `memorix resume "<task>" --fallback --brief-json` exactly once before inspecting files, Git history, progress notes, or guessing. The absence of `.memorix` or visible memory files never proves project memory is empty. For a new task, use `memorix context "<task>" --fallback --brief-json` instead. Use `--json` only when a diagnostic needs the detailed legacy payload. If that one command fails, report it and proceed normally; do not probe help, enumerate commands, or chain broad searches.',
           "- After a successful `memorix_project_context`, the brief is the default retrieval boundary. Do not call more Memorix retrieval tools after a complete brief. Use Context Pack, search, or detail only when the brief lacks a specific reference, freshness field, or fact needed for the task, or when the user explicitly asks for deeper history. In MCP, name that missing fact in `purpose` when intentionally expanding beyond the brief. Do not retrieve the same decision twice just to confirm an already-complete brief.",
           "- If the user asks for read-only work or says not to modify files, do not call `memorix_store` just to record an assessment. Store only when the user explicitly asks to preserve it.",
           "- Use `memorix_search` for a specific decision, bug, file, or prior change that the project context did not answer. Fetch detail only for a result you still need after the brief.",
@@ -162631,7 +163515,7 @@ alwaysApply: true
     "",
     `Default first step for non-trivial coding work: call \`memorix_project_context\` with the user's actual task before progress files, dev-log reads, ad-hoc file reads, or git archaeology. Memorix will choose a task-lensed brief (bugfix, feature, release, onboarding, refactor, docs, test, or general). When the task is continuing prior work, the same brief also includes a bounded prior-work projection. Treat its "Start here" files as the first ${contextNoun} files to inspect.`,
     "",
-    'If the MCP tool is not visible yet but the client supports tool discovery or dynamic loading, search/select `memorix_project_context` first. Continuation fallback is mandatory: when the user asks to continue, resume, take over, or explain prior work and MCP cannot be called in this turn, run exactly one CLI brief with the user\'s real task before inspecting files, Git history, progress notes, or guessing: `memorix resume "<task>" --brief-json`. For a new task, use `memorix context "<task>" --brief-json` instead. The absence of `.memorix` or visible memory files never proves project memory is empty. Use `--json` only when a diagnostic needs the detailed legacy payload. If that one command fails, report it and proceed normally. Do not probe help, enumerate commands, chain broad searches, wait indefinitely on MCP startup, or hand-write tool-call syntax.',
+    'If the MCP tool is not visible yet but the client supports tool discovery or dynamic loading, search/select `memorix_project_context` first. Continuation fallback is mandatory: when the user asks to continue, resume, take over, or explain prior work and MCP cannot be called in this turn, run exactly one CLI brief with the user\'s real task before inspecting files, Git history, progress notes, or guessing: `memorix resume "<task>" --fallback --brief-json`. For a new task, use `memorix context "<task>" --fallback --brief-json` instead. The absence of `.memorix` or visible memory files never proves project memory is empty. Use `--json` only when a diagnostic needs the detailed legacy payload. If that one command fails, report it and proceed normally. Do not probe help, enumerate commands, chain broad searches, wait indefinitely on MCP startup, or hand-write tool-call syntax.',
     "",
     "After a successful `memorix_project_context` result, the brief is the default retrieval boundary. Do not call more Memorix retrieval tools after a complete brief. Use `memorix_context_pack`, `memorix_search`, or `memorix_detail` only when the brief lacks a specific reference, freshness field, or fact needed for the task, or when the user explicitly asks for deeper history. In MCP, name that missing fact in `purpose` when intentionally expanding beyond the brief. Do not retrieve the same decision twice just to confirm an already-complete brief.",
     "If the user asks for read-only work or says not to modify files, do not call `memorix_store` just to record an assessment. Store only when the user explicitly asks to preserve it.",
@@ -162934,7 +163818,7 @@ init_freshness();
 init_obs_store();
 init_mini_skill_store();
 init_session_store();
-import { createHash as createHash15 } from "crypto";
+import { createHash as createHash16 } from "crypto";
 import { McpServer } from "@modelcontextprotocol/sdk/server/mcp.js";
 import { z as z626 } from "zod";
 
@@ -163414,6 +164298,8 @@ init_mini_skill_store();
 init_mini_skills();
 init_secret_filter();
 init_visibility();
+init_persistence();
+init_feedback();
 function normalizeMemoryBrowseQuery(query) {
   const trimmed = query.trim();
   if (!trimmed) return "";
@@ -163451,9 +164337,27 @@ function normalizeMemoryBrowseQuery(query) {
 async function compactSearch(options, surface = "mcp") {
   await ensureFreshIndex();
   const searchOptions = { ...options, query: normalizeMemoryBrowseQuery(options.query) };
-  const entries = (await searchObservations(searchOptions)).map(
+  let entries = (await searchObservations(searchOptions)).map(
     (entry) => entry.projectId || !options.projectId ? entry : { ...entry, projectId: options.projectId }
   );
+  if (options.projectId) {
+    try {
+      const feedback = new MemoryFeedbackStore();
+      await feedback.init(await getProjectDataDir(options.projectId));
+      const states = feedback.weights(options.projectId, "observation");
+      entries = entries.map((entry) => {
+        const state = states.get(String(entry.id));
+        if (!state) return entry;
+        return {
+          ...entry,
+          score: (entry.score ?? 0) * feedbackWeightMultiplier(state.weight),
+          feedbackWeight: state.weight,
+          feedbackStatus: state.status
+        };
+      }).filter((entry) => entry.feedbackStatus !== "archived" || options.status === "all").sort((a, b) => (b.score ?? 0) - (a.score ?? 0));
+    } catch {
+    }
+  }
   let formatted = formatIndexTable(entries, searchOptions.query, !options.projectId, surface);
   if (entries.length === 0 && options.projectId) {
     const allObservations = filterReadableObservations(getAllObservations(), options.reader);
@@ -164282,6 +165186,8 @@ init_detector();
 init_launch_root();
 init_aliases();
 init_persistence();
+init_evidence_store();
+init_feedback();
 
 // src/rules/syncer.ts
 init_esm_shims();
@@ -164294,9 +165200,9 @@ init_frontmatter();
 
 // src/rules/utils.ts
 init_esm_shims();
-import { createHash as createHash13 } from "crypto";
+import { createHash as createHash14 } from "crypto";
 function hashContent2(content) {
-  return createHash13("sha256").update(content.trim()).digest("hex").substring(0, 16);
+  return createHash14("sha256").update(content.trim()).digest("hex").substring(0, 16);
 }
 function generateRuleId(source, filePath) {
   const sanitized = filePath.replace(/[\/\\]/g, "-").replace(/^\./, "");
@@ -166498,6 +167404,10 @@ var TOOL_PROFILES = Object.freeze({
   // multimodal support to one additional schema rather than enabling lite.
   memorix_session_start: ["micro", "lite", "team", "full"],
   memorix_media: ["micro", "lite", "team", "full"],
+  // Evidence and feedback are deliberate operator/context-control surfaces;
+  // keep the default micro profile at its nine-tool token budget.
+  memorix_evidence: ["lite", "team", "full"],
+  memorix_feedback: ["lite", "team", "full"],
   // ── lite: extended solo memory surface ────────────────────────────
   memorix_graph_context: ["lite", "team", "full"],
   memorix_timeline: ["lite", "team", "full"],
@@ -166796,7 +167706,7 @@ function coerceObjectArray(val) {
   return [];
 }
 function createDeterministicInstanceId(projectId, agentType, agentName) {
-  const digest2 = createHash15("sha256").update(projectId).update("\n").update(agentType).update("\n").update(agentName ?? "").digest("hex").slice(0, 24);
+  const digest2 = createHash16("sha256").update(projectId).update("\n").update(agentType).update("\n").update(agentName ?? "").digest("hex").slice(0, 24);
   return `auto-${digest2}`;
 }
 var BOOTSTRAP_SAFE_TOOL_NAMES = /* @__PURE__ */ new Set([
@@ -167097,7 +168007,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.8.0" : "1.0.1"
   });
   const originalRegisterTool = server.registerTool.bind(server);
   server.registerTool = ((name, ...args) => {
@@ -170276,7 +171186,7 @@ ${json2}
         dashboardRunning = true;
         const { exec: execCmd } = await import("child_process");
         const openCmd = process.platform === "win32" ? `start "" "${url}"` : process.platform === "darwin" ? `open "${url}"` : `xdg-open "${url}"`;
-        execCmd(openCmd, () => {
+        execCmd(openCmd, { windowsHide: true }, () => {
         });
         return {
           content: [{
@@ -170300,6 +171210,113 @@ ${json2}
       }
     }
   );
+  server.registerTool(
+    "memorix_evidence",
+    {
+      title: "Evidence Cards",
+      description: "Inspect the bounded, project-scoped provenance cards behind Memorix context. Use list for a compact index, get/events for one source, sync to repair the projection, and stale when known source files changed. Cards expose sourceRef, locator, capturedHash, and freshness.",
+      inputSchema: {
+        action: z626.enum(["list", "get", "sync", "stale", "events"]).describe("Evidence operation"),
+        candidateKind: z626.enum(["observation", "code", "git", "test", "document", "workflow", "graph"]).optional().default("observation"),
+        candidateId: z626.string().optional().describe("Candidate id, usually an observation id"),
+        query: z626.string().optional().describe("Optional title/source query for list"),
+        paths: z626.array(z626.string()).max(200).optional().describe("Changed source paths for stale"),
+        reason: z626.string().max(500).optional().describe("Why evidence became stale"),
+        limit: z626.number().int().positive().max(100).optional().default(20)
+      }
+    },
+    async ({ action, candidateKind, candidateId, query, paths, reason, limit: limit2 }) => {
+      const unresolved = requireResolvedProject("inspect evidence cards for the current project");
+      if (unresolved) return unresolved;
+      const cards = new EvidenceCardStore();
+      await cards.init(projectDir2);
+      if (action === "sync") {
+        const observations2 = await getObservationStore().loadByProject(project.id);
+        const synced = cards.syncObservations(observations2);
+        return { content: [{ type: "text", text: JSON.stringify({ projectId: project.id, synced: synced.length, cards: synced.slice(0, limit2 ?? 20) }, null, 2) }] };
+      }
+      if (action === "stale") {
+        const changed = cards.markStaleForPaths(project.id, paths ?? [], reason ?? "source file changed");
+        return { content: [{ type: "text", text: JSON.stringify({ projectId: project.id, staleMarked: changed, paths: paths ?? [] }, null, 2) }] };
+      }
+      if (action === "get") {
+        if (!candidateId?.trim()) return { content: [{ type: "text", text: "candidateId is required for evidence get." }], isError: true };
+        const card = cards.get(project.id, candidateKind ?? "observation", candidateId.trim());
+        if (!card) return { content: [{ type: "text", text: "Evidence card not found." }], isError: true };
+        return { content: [{ type: "text", text: JSON.stringify({ card, events: cards.listEvents(card.id), projectId: project.id }, null, 2) }] };
+      }
+      if (action === "events") {
+        if (!candidateId?.trim()) return { content: [{ type: "text", text: "candidateId is required for evidence events." }], isError: true };
+        const card = cards.get(project.id, candidateKind ?? "observation", candidateId.trim());
+        if (!card) return { content: [{ type: "text", text: "Evidence card not found." }], isError: true };
+        return { content: [{ type: "text", text: JSON.stringify(cards.listEvents(card.id, limit2), null, 2) }] };
+      }
+      const needle = query?.trim().toLowerCase();
+      const listed = cards.list(project.id, { limit: Math.max(limit2 ?? 20, 100) }).filter((card) => !needle || [card.title, card.summary, card.sourceRef, card.locator ?? ""].join(" ").toLowerCase().includes(needle)).slice(0, limit2 ?? 20);
+      return { content: [{ type: "text", text: JSON.stringify({ projectId: project.id, cards: listed }, null, 2) }] };
+    }
+  );
+  server.registerTool(
+    "memorix_feedback",
+    {
+      title: "Memory Feedback",
+      description: "Record or inspect auditable memory outcomes. Positive verification/use strengthens recall; correction, conflict, source change, or weaken lowers it. Use revoke with targetEventId to undo one prior signal without deleting audit history.",
+      inputSchema: {
+        action: z626.enum(["record", "show", "audit"]).describe("Feedback operation"),
+        candidateKind: z626.enum(["observation", "claim", "durable-memory", "workflow"]).optional().default("observation"),
+        candidateId: z626.string().describe("Memory or knowledge candidate id"),
+        signal: z626.enum(["user-correction", "verification-success", "verification-failure", "code-change", "used", "not-used", "code-conflict", "strengthen", "weaken", "revoke"]).optional(),
+        sourceRef: z626.string().max(500).optional().describe("Source of this feedback, such as test:run-42 or user:chat"),
+        actor: z626.string().max(200).optional(),
+        note: z626.string().max(2e3).optional(),
+        targetEventId: z626.string().optional().describe("Existing event id when action=record and signal=revoke"),
+        limit: z626.number().int().positive().max(200).optional().default(100)
+      }
+    },
+    async ({ action, candidateKind, candidateId, signal, sourceRef, actor, note, targetEventId, limit: limit2 }) => {
+      const unresolved = requireResolvedProject("record memory feedback for the current project");
+      if (unresolved) return unresolved;
+      const feedback = new MemoryFeedbackStore();
+      await feedback.init(projectDir2);
+      const kind = candidateKind ?? "observation";
+      if (action === "show") {
+        return { content: [{ type: "text", text: JSON.stringify(feedback.getState(project.id, kind, candidateId), null, 2) }] };
+      }
+      if (action === "audit") {
+        return { content: [{ type: "text", text: JSON.stringify(feedback.audit(project.id, kind, candidateId, limit2), null, 2) }] };
+      }
+      if (!signal || !sourceRef?.trim()) {
+        return { content: [{ type: "text", text: "record requires signal and sourceRef." }], isError: true };
+      }
+      try {
+        const result = feedback.record({
+          projectId: project.id,
+          candidateKind: kind,
+          candidateId,
+          signal,
+          sourceRef,
+          ...actor || currentAgentId ? { actor: actor ?? currentAgentId } : {},
+          ...note ? { note } : {},
+          ...targetEventId ? { targetEventId } : {}
+        });
+        if (kind === "observation") {
+          const cards = new EvidenceCardStore();
+          await cards.init(projectDir2);
+          const card = cards.get(project.id, "observation", candidateId);
+          if (card) {
+            const verification = signal === "verification-success" || signal === "strengthen" ? "verified" : signal === "user-correction" || signal === "code-conflict" || signal === "weaken" ? "conflicted" : card.verification;
+            cards.recordEvent(project.id, card.id, `feedback:${signal}`, note);
+            if (verification !== card.verification) {
+              cards.setVerification(project.id, card.id, verification);
+            }
+          }
+        }
+        return { content: [{ type: "text", text: JSON.stringify(result, null, 2) }] };
+      } catch (error) {
+        return { content: [{ type: "text", text: error instanceof Error ? error.message : String(error) }], isError: true };
+      }
+    }
+  );
   if (teamFeaturesEnabled) {
     const { initTeamStore: initTeamStore2 } = await Promise.resolve().then(() => (init_team_store(), team_store_exports));
     initTeamStoreForProject = initTeamStore2;