memorix 1.7.2 → 1.8.0

package/dist/cli/index.js

@@ -3232,7 +3232,7 @@ ${import_picocolors.default.gray(m3)}  ${s4}
 
 // src/cli/version.ts
 function getCliVersion() {
-  return true ? "1.7.2" : pkg.version;
+  return true ? "1.8.0" : pkg.version;
 }
 var init_version = __esm({
   "src/cli/version.ts"() {
@@ -9465,7 +9465,7 @@ function closeAllDatabases() {
     _dbCache.delete(key);
   }
 }
-var BetterSqlite3, CREATE_OBSERVATIONS_TABLE, CREATE_MINI_SKILLS_TABLE, CREATE_SESSIONS_TABLE, CREATE_META_TABLE, CREATE_TEAM_AGENTS_TABLE, CREATE_TEAM_MESSAGES_TABLE, CREATE_TEAM_TASKS_TABLE, CREATE_TEAM_TASK_DEPS_TABLE, CREATE_TEAM_LOCKS_TABLE, CREATE_TEAM_ROLES_TABLE, CREATE_CHAT_TRANSCRIPT_TABLE, CREATE_GRAPH_ENTITIES_TABLE, CREATE_GRAPH_RELATIONS_TABLE, CREATE_CODE_FILES_TABLE, CREATE_CODE_SYMBOLS_TABLE, CREATE_CODE_EDGES_TABLE, CREATE_OBSERVATION_CODE_REFS_TABLE, CREATE_SCHEMA_MIGRATIONS_TABLE, CREATE_CODE_STATE_SNAPSHOTS_TABLE, CREATE_CODE_STATE_SNAPSHOT_FILES_TABLE, CREATE_KNOWLEDGE_CLAIMS_TABLE, CREATE_KNOWLEDGE_CLAIM_EVIDENCE_TABLE, CREATE_KNOWLEDGE_CLAIM_EVENTS_TABLE, CREATE_KNOWLEDGE_WORKSPACES_TABLE, CREATE_KNOWLEDGE_PAGES_TABLE, CREATE_KNOWLEDGE_PAGE_CLAIMS_TABLE, CREATE_KNOWLEDGE_PAGE_LINKS_TABLE, CREATE_KNOWLEDGE_PROPOSALS_TABLE, CREATE_KNOWLEDGE_WORKFLOWS_TABLE, CREATE_KNOWLEDGE_WORKFLOW_RUNS_TABLE, CREATE_LONG_TERM_MEMORIES_TABLE, CREATE_LONG_TERM_MEMORY_EVIDENCE_TABLE, CREATE_LONG_TERM_MEMORY_EVENTS_TABLE, CREATE_MEMORY_OUTCOME_SIGNALS_TABLE, CREATE_MEDIA_ASSETS_TABLE, CREATE_MEDIA_ASSET_LINKS_TABLE, CREATE_MEDIA_DERIVATIONS_TABLE, CREATE_MEDIA_EMBEDDING_PROFILES_TABLE, CREATE_MEDIA_EMBEDDINGS_TABLE, CREATE_MEDIA_JOBS_TABLE, CREATE_MAINTENANCE_JOBS_TABLE, CREATE_MAINTENANCE_TARGETS_TABLE, CREATE_COMPACTION_CHECKPOINTS_TABLE, CREATE_INDEXES, SCHEMA_MIGRATIONS, _dbCache;
+var BetterSqlite3, CREATE_OBSERVATIONS_TABLE, CREATE_MINI_SKILLS_TABLE, CREATE_SESSIONS_TABLE, CREATE_META_TABLE, CREATE_TEAM_AGENTS_TABLE, CREATE_TEAM_MESSAGES_TABLE, CREATE_TEAM_TASKS_TABLE, CREATE_TEAM_TASK_DEPS_TABLE, CREATE_TEAM_LOCKS_TABLE, CREATE_TEAM_ROLES_TABLE, CREATE_CHAT_TRANSCRIPT_TABLE, CREATE_GRAPH_ENTITIES_TABLE, CREATE_GRAPH_RELATIONS_TABLE, CREATE_CODE_FILES_TABLE, CREATE_CODE_SYMBOLS_TABLE, CREATE_CODE_EDGES_TABLE, CREATE_OBSERVATION_CODE_REFS_TABLE, CREATE_SCHEMA_MIGRATIONS_TABLE, CREATE_CODE_STATE_SNAPSHOTS_TABLE, CREATE_CODE_STATE_SNAPSHOT_FILES_TABLE, CREATE_KNOWLEDGE_CLAIMS_TABLE, CREATE_KNOWLEDGE_CLAIM_EVIDENCE_TABLE, CREATE_KNOWLEDGE_CLAIM_EVENTS_TABLE, CREATE_KNOWLEDGE_WORKSPACES_TABLE, CREATE_KNOWLEDGE_PAGES_TABLE, CREATE_KNOWLEDGE_PAGE_CLAIMS_TABLE, CREATE_KNOWLEDGE_PAGE_LINKS_TABLE, CREATE_KNOWLEDGE_PROPOSALS_TABLE, CREATE_KNOWLEDGE_WORKFLOWS_TABLE, CREATE_KNOWLEDGE_WORKFLOW_RUNS_TABLE, CREATE_LONG_TERM_MEMORIES_TABLE, CREATE_LONG_TERM_MEMORY_EVIDENCE_TABLE, CREATE_LONG_TERM_MEMORY_EVENTS_TABLE, CREATE_MEMORY_OUTCOME_SIGNALS_TABLE, CREATE_MEDIA_ASSETS_TABLE, CREATE_MEDIA_ASSET_LINKS_TABLE, CREATE_MEDIA_DERIVATIONS_TABLE, CREATE_MEDIA_EMBEDDING_PROFILES_TABLE, CREATE_MEDIA_EMBEDDINGS_TABLE, CREATE_MEDIA_JOBS_TABLE, CREATE_MAINTENANCE_JOBS_TABLE, CREATE_MAINTENANCE_TARGETS_TABLE, CREATE_COMPACTION_CHECKPOINTS_TABLE, CREATE_EVIDENCE_CARDS_TABLE, CREATE_EVIDENCE_CARD_EVENTS_TABLE, CREATE_MEMORY_FEEDBACK_STATES_TABLE, CREATE_MEMORY_FEEDBACK_EVENTS_TABLE, CREATE_MCP_BINDINGS_TABLE, CREATE_INDEXES, SCHEMA_MIGRATIONS, _dbCache;
 var init_sqlite_db = __esm({
   "src/store/sqlite-db.ts"() {
     "use strict";
@@ -10111,6 +10111,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);
@@ -10173,6 +10246,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');
@@ -10328,6 +10407,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();
@@ -20748,6 +20843,7 @@ function loadYamlConfig(projectRoot) {
     llm: { ...userConfig.llm, ...projectConfig.llm },
     agent: { ...userConfig.agent, ...projectConfig.agent },
     embedding: { ...userConfig.embedding, ...projectConfig.embedding },
+    rerank: { ...userConfig.rerank, ...projectConfig.rerank },
     git: { ...userConfig.git, ...projectConfig.git },
     codegraph: { ...userConfig.codegraph, ...projectConfig.codegraph },
     behavior: { ...userConfig.behavior, ...projectConfig.behavior },
@@ -21024,6 +21120,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 },
@@ -21512,6 +21609,8 @@ var require_main = __commonJS({
 var dotenv_loader_exports = {};
 __export(dotenv_loader_exports, {
   getLoadedEnvFiles: () => getLoadedEnvFiles,
+  getLoadedEnvKeys: () => getLoadedEnvKeys,
+  getLoadedEnvValue: () => getLoadedEnvValue,
   loadDotenv: () => loadDotenv,
   resetDotenv: () => resetDotenv
 });
@@ -21522,6 +21621,8 @@ function loadEnvFile(filePath) {
   const parsed = (0, import_dotenv.parse)(readFileSync7(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);
     }
@@ -21534,6 +21635,8 @@ function loadDotenv(projectRoot, options = {}) {
     resetDotenv();
   }
   loadedEnvFiles.length = 0;
+  loadedEnvKeys.clear();
+  loadedEnvValues.clear();
   if (projectRoot) {
     loadEnvFile(getProjectDotenvPath(projectRoot));
   }
@@ -21549,11 +21652,18 @@ function resetDotenv() {
   dotenvLoaded = false;
   dotenvProjectRoot = null;
   loadedEnvFiles.length = 0;
+  loadedEnvKeys.clear();
 }
 function getLoadedEnvFiles() {
   return loadedEnvFiles;
 }
-var import_dotenv, dotenvLoaded, dotenvProjectRoot, loadedEnvFiles, injectedKeys;
+function getLoadedEnvKeys() {
+  return loadedEnvKeys;
+}
+function getLoadedEnvValue(key) {
+  return loadedEnvValues.get(key);
+}
+var import_dotenv, dotenvLoaded, dotenvProjectRoot, loadedEnvFiles, loadedEnvKeys, loadedEnvValues, injectedKeys;
 var init_dotenv_loader = __esm({
   "src/config/dotenv-loader.ts"() {
     "use strict";
@@ -21563,6 +21673,8 @@ var init_dotenv_loader = __esm({
     dotenvLoaded = false;
     dotenvProjectRoot = null;
     loadedEnvFiles = [];
+    loadedEnvKeys = /* @__PURE__ */ new Set();
+    loadedEnvValues = /* @__PURE__ */ new Map();
     injectedKeys = /* @__PURE__ */ new Set();
   }
 });
@@ -21575,6 +21687,7 @@ __export(resolved_config_exports, {
   getResolvedConfigForCwd: () => getResolvedConfigForCwd,
   getResolvedEmbeddingLane: () => getResolvedEmbeddingLane,
   getResolvedMemoryLane: () => getResolvedMemoryLane,
+  getResolvedRerankLane: () => getResolvedRerankLane,
   resetResolvedConfigCache: () => resetResolvedConfigCache
 });
 import { homedir as homedir5 } from "os";
@@ -21607,6 +21720,16 @@ function getResolvedConfig(options = {}) {
     legacy.llm?.baseUrl
   );
   const openRouterMemoryLlmApiKey = isOpenRouterMemoryLane(memoryLlmProvider, memoryLlmBaseUrl) ? process.env.OPENROUTER_API_KEY : void 0;
+  const memoryLlmApiKey = first(
+    process.env.MEMORIX_LLM_API_KEY,
+    process.env.MEMORIX_API_KEY,
+    toml.memory?.llm?.api_key,
+    yaml.llm?.apiKey,
+    legacy.llm?.apiKey,
+    process.env.OPENAI_API_KEY,
+    process.env.ANTHROPIC_API_KEY,
+    openRouterMemoryLlmApiKey
+  );
   const resolved = {
     agent: {
       provider: first(
@@ -21647,16 +21770,7 @@ function getResolvedConfig(options = {}) {
         provider: memoryLlmProvider,
         model: memoryLlmModel,
         baseUrl: memoryLlmBaseUrl,
-        apiKey: first(
-          process.env.MEMORIX_LLM_API_KEY,
-          process.env.MEMORIX_API_KEY,
-          toml.memory?.llm?.api_key,
-          yaml.llm?.apiKey,
-          legacy.llm?.apiKey,
-          process.env.OPENAI_API_KEY,
-          process.env.ANTHROPIC_API_KEY,
-          openRouterMemoryLlmApiKey
-        )
+        apiKey: memoryLlmApiKey
       }
     },
     embedding: {
@@ -21666,6 +21780,12 @@ function getResolvedConfig(options = {}) {
       apiKey: first(process.env.MEMORIX_EMBEDDING_API_KEY, toml.embedding?.api_key, yaml.embedding?.apiKey, legacy.embeddingApi?.apiKey, openRouterEmbeddingApiKey),
       dimensions: firstNumber(parseNumber(process.env.MEMORIX_EMBEDDING_DIMENSIONS), toml.embedding?.dimensions, yaml.embedding?.dimensions, legacy.embeddingApi?.dimensions)
     },
+    rerank: resolveRerankLane({
+      toml,
+      yaml,
+      memoryLlmApiKey,
+      memoryLlmBaseUrl
+    }),
     git: {
       autoHook: firstBool(toml.git?.auto_hook, yaml.git?.autoHook),
       ingestOnCommit: firstBool(toml.git?.ingest_on_commit, yaml.git?.ingestOnCommit),
@@ -21735,6 +21855,9 @@ function getResolvedMemoryLane(options = {}) {
 function getResolvedEmbeddingLane(options = {}) {
   return getResolvedConfig(options).embedding;
 }
+function getResolvedRerankLane(options = {}) {
+  return getResolvedConfig(options).rerank;
+}
 function resetResolvedConfigCache() {
 }
 function first(...values) {
@@ -21777,6 +21900,10 @@ function getEnvSourceNames() {
     "MEMORIX_EMBEDDING_BASE_URL",
     "MEMORIX_EMBEDDING_MODEL",
     "MEMORIX_EMBEDDING_DIMENSIONS",
+    "MEMORIX_RERANK_PROVIDER",
+    "MEMORIX_RERANK_MODEL",
+    "MEMORIX_RERANK_BASE_URL",
+    "MEMORIX_RERANK_API_KEY",
     "MEMORIX_CODEGRAPH_EXTERNAL_CONTEXT",
     "MEMORIX_CODEGRAPH_EXTERNAL_COMMAND",
     "MEMORIX_CODEGRAPH_EXTERNAL_TIMEOUT_MS",
@@ -21800,6 +21927,63 @@ function normalizeExternalContext(value) {
   if (normalized === "auto" || normalized === "off") return normalized;
   return void 0;
 }
+function normalizeRerankProvider(value) {
+  const normalized = value?.trim().toLowerCase();
+  if (normalized === "http") return "http";
+  return "off";
+}
+function resolveRerankLane(args) {
+  const provider2 = normalizeRerankProvider(first(
+    process.env.MEMORIX_RERANK_PROVIDER,
+    args.toml.rerank?.provider,
+    args.yaml.rerank?.provider,
+    "off"
+  ));
+  const model = first(
+    process.env.MEMORIX_RERANK_MODEL,
+    args.toml.rerank?.model,
+    args.yaml.rerank?.model
+  );
+  const explicitBaseUrl = first(
+    process.env.MEMORIX_RERANK_BASE_URL,
+    args.toml.rerank?.base_url,
+    args.yaml.rerank?.baseUrl
+  );
+  const baseUrl = provider2 === "http" ? first(explicitBaseUrl, args.memoryLlmBaseUrl) : explicitBaseUrl;
+  const dedicatedApiKey = first(
+    process.env.MEMORIX_RERANK_API_KEY,
+    args.toml.rerank?.api_key,
+    args.yaml.rerank?.apiKey
+  );
+  const sameEndpoint = provider2 === "http" && sameTrustedEndpoint(baseUrl, args.memoryLlmBaseUrl);
+  const inheritedApiKey = sameEndpoint ? args.memoryLlmApiKey : void 0;
+  const apiKey = first(dedicatedApiKey, inheritedApiKey);
+  const canSendRequest = provider2 === "http" && Boolean(baseUrl) && (Boolean(apiKey) || !args.memoryLlmApiKey || sameEndpoint);
+  return { provider: provider2, model, baseUrl, apiKey, canSendRequest };
+}
+function sameTrustedEndpoint(left, right) {
+  const a4 = normalizeTrustedEndpoint(left);
+  const b4 = normalizeTrustedEndpoint(right);
+  return Boolean(a4 && b4 && a4 === b4);
+}
+function normalizeTrustedEndpoint(value) {
+  const trimmed = value?.trim();
+  if (!trimmed) return void 0;
+  try {
+    const url2 = new URL(trimmed);
+    const protocol = url2.protocol.toLowerCase();
+    const hostname2 = url2.hostname.toLowerCase();
+    const port = url2.port;
+    let pathname = url2.pathname.replace(/\/+$/, "");
+    if (pathname.toLowerCase().endsWith("/rerank")) {
+      pathname = pathname.slice(0, -"/rerank".length).replace(/\/+$/, "");
+    }
+    return `${protocol}//${hostname2}${port ? `:${port}` : ""}${pathname}`;
+  } catch {
+    const fallback = trimmed.replace(/\/+$/, "").replace(/\/rerank$/i, "").replace(/\/+$/, "");
+    return fallback.toLowerCase() || void 0;
+  }
+}
 var init_resolved_config = __esm({
   "src/config/resolved-config.ts"() {
     "use strict";
@@ -24035,9 +24219,27 @@ __export(provider_exports2, {
   getLLMConfig: () => getLLMConfig,
   initLLM: () => initLLM,
   isLLMEnabled: () => isLLMEnabled,
+  normalizeOpenAICompatibleBaseUrl: () => normalizeOpenAICompatibleBaseUrl,
   parseLLMTimeoutMs: () => parseLLMTimeoutMs,
   setLLMConfig: () => setLLMConfig
 });
+function normalizeOpenAICompatibleBaseUrl(baseUrl) {
+  const base = baseUrl.trim().replace(/\/+$/, "");
+  if (!base) return base;
+  let pathname = "";
+  try {
+    pathname = new URL(base).pathname.replace(/\/+$/, "");
+  } catch {
+    pathname = base.split(/[?#]/, 1)[0].replace(/\/+$/, "");
+  }
+  const lastSegment = pathname.split("/").filter(Boolean).at(-1);
+  if (lastSegment && OPENAI_API_VERSION_SEGMENT.test(lastSegment)) {
+    return base;
+  }
+  const queryOrHash = base.match(/[?#].*$/)?.[0] ?? "";
+  const pathWithoutQuery = base.slice(0, base.length - queryOrHash.length).replace(/\/+$/, "");
+  return `${pathWithoutQuery}/v1${queryOrHash}`;
+}
 function parseLLMTimeoutMs(raw) {
   if (raw === void 0 || raw.trim() === "") return LLM_TIMEOUT_DEFAULT_MS;
   const parsed = Number(raw);
@@ -24141,8 +24343,7 @@ async function callLLM(systemPrompt, userMessage, signal) {
 }
 async function callOpenAICompatible(systemPrompt, userMessage, signal) {
   const config2 = currentConfig;
-  let base = config2.baseUrl.replace(/\/+$/, "");
-  if (!base.endsWith("/v1")) base += "/v1";
+  const base = normalizeOpenAICompatibleBaseUrl(config2.baseUrl);
   const url2 = `${base}/chat/completions`;
   const fetchSignal = signal ? AbortSignal.any([signal, AbortSignal.timeout(LLM_CALL_TIMEOUT_MS)]) : AbortSignal.timeout(LLM_CALL_TIMEOUT_MS);
   const response = await fetch(url2, {
@@ -24221,8 +24422,7 @@ async function callLLMWithTools(messages, tools, signal) {
 }
 async function callOpenAIWithTools(messages, tools, signal) {
   const config2 = currentConfig;
-  let base = config2.baseUrl.replace(/\/+$/, "");
-  if (!base.endsWith("/v1")) base += "/v1";
+  const base = normalizeOpenAICompatibleBaseUrl(config2.baseUrl);
   const url2 = `${base}/chat/completions`;
   const openaiMessages = messages.map((msg) => {
     if (msg.role === "tool") {
@@ -24372,8 +24572,7 @@ async function callAnthropicWithTools(messages, tools, signal) {
 }
 async function* callOpenAIWithToolsStream(messages, tools) {
   const config2 = currentConfig;
-  let base = config2.baseUrl.replace(/\/+$/, "");
-  if (!base.endsWith("/v1")) base += "/v1";
+  const base = normalizeOpenAICompatibleBaseUrl(config2.baseUrl);
   const url2 = `${base}/chat/completions`;
   const openaiMessages = messages.map((msg) => {
     if (msg.role === "tool") {
@@ -24621,7 +24820,7 @@ async function* callAnthropicWithToolsStream(messages, tools) {
     }
   };
 }
-var LLM_TIMEOUT_DEFAULT_MS, LLM_TIMEOUT_MIN_MS, LLM_TIMEOUT_MAX_MS, MAX_LLM_RESPONSE_BYTES, LLM_CALL_TIMEOUT_MS, PROVIDER_DEFAULTS, currentConfig;
+var LLM_TIMEOUT_DEFAULT_MS, LLM_TIMEOUT_MIN_MS, LLM_TIMEOUT_MAX_MS, MAX_LLM_RESPONSE_BYTES, OPENAI_API_VERSION_SEGMENT, LLM_CALL_TIMEOUT_MS, PROVIDER_DEFAULTS, currentConfig;
 var init_provider2 = __esm({
   "src/llm/provider.ts"() {
     "use strict";
@@ -24631,6 +24830,7 @@ var init_provider2 = __esm({
     LLM_TIMEOUT_MIN_MS = 1e3;
     LLM_TIMEOUT_MAX_MS = 3e5;
     MAX_LLM_RESPONSE_BYTES = 2 * 1024 * 1024;
+    OPENAI_API_VERSION_SEGMENT = /^v\d+(?:[a-z][a-z0-9-]*)?$/i;
     LLM_CALL_TIMEOUT_MS = parseLLMTimeoutMs(process.env.MEMORIX_LLM_TIMEOUT_MS);
     PROVIDER_DEFAULTS = {
       openai: { baseUrl: "https://api.openai.com/v1", model: "gpt-4.1-nano" },
@@ -24690,6 +24890,48 @@ Rules:
   }
 });
 
+// src/rerank/policy.ts
+function parseRerankTimeoutMs(raw) {
+  const value = raw?.trim();
+  if (!value) return DEFAULT_RERANK_TIMEOUT_MS;
+  const parsed = Number(value);
+  if (!Number.isInteger(parsed) || Number.isNaN(parsed)) {
+    console.warn(
+      `[memorix] MEMORIX_RERANK_TIMEOUT_MS="${raw}" is invalid (must be a positive integer between ${RERANK_TIMEOUT_MIN_MS}-${RERANK_TIMEOUT_MAX_MS}ms). Using default ${DEFAULT_RERANK_TIMEOUT_MS}ms.`
+    );
+    return DEFAULT_RERANK_TIMEOUT_MS;
+  }
+  if (parsed < RERANK_TIMEOUT_MIN_MS) return RERANK_TIMEOUT_MIN_MS;
+  if (parsed > RERANK_TIMEOUT_MAX_MS) return RERANK_TIMEOUT_MAX_MS;
+  return parsed;
+}
+function resolveRerankTimeoutMs(explicitTimeoutMs) {
+  if (typeof explicitTimeoutMs === "number" && Number.isFinite(explicitTimeoutMs) && explicitTimeoutMs > 0) {
+    return explicitTimeoutMs;
+  }
+  return parseRerankTimeoutMs(process.env.MEMORIX_RERANK_TIMEOUT_MS);
+}
+function shouldAttemptHttpRerank(input) {
+  return input.quality === "thorough" && input.hasQuery && input.candidateCount >= MIN_RERANK_CANDIDATES;
+}
+function shouldAttemptLlmRerank(input) {
+  if (input.httpRerankConfigured) return false;
+  if (input.quality !== "thorough" || input.tier !== "heavy" || !input.hasQuery) return false;
+  if (input.candidateCount < MIN_RERANK_CANDIDATES) return false;
+  return input.topScore > 0 && input.secondScore / input.topScore > 0.7;
+}
+var DEFAULT_RERANK_TIMEOUT_MS, RERANK_TIMEOUT_MIN_MS, RERANK_TIMEOUT_MAX_MS, MIN_RERANK_CANDIDATES;
+var init_policy = __esm({
+  "src/rerank/policy.ts"() {
+    "use strict";
+    init_esm_shims();
+    DEFAULT_RERANK_TIMEOUT_MS = 3e4;
+    RERANK_TIMEOUT_MIN_MS = 1e3;
+    RERANK_TIMEOUT_MAX_MS = 3e5;
+    MIN_RERANK_CANDIDATES = 3;
+  }
+});
+
 // src/timeout.ts
 function withTimeout(promise2, ms2, label) {
   return new Promise((resolve6, reject) => {
@@ -24975,6 +25217,148 @@ var init_aliases = __esm({
   }
 });
 
+// src/rerank/http-provider.ts
+function buildRerankUrl(baseUrl) {
+  const trimmed = baseUrl.trim().replace(/\/+$/, "");
+  if (trimmed.endsWith("/rerank")) return trimmed;
+  return `${trimmed}/rerank`;
+}
+function parseRerankResponse(payload) {
+  const rows = extractRows(payload);
+  if (rows.length === 0) {
+    throw new Error("Neural rerank response contained no ranked results");
+  }
+  return rows.sort((a4, b4) => b4.score - a4.score);
+}
+function extractRows(payload) {
+  if (Array.isArray(payload)) {
+    return payload.map(rowFromUnknown).filter((row) => row !== null);
+  }
+  if (payload && typeof payload === "object" && "results" in payload) {
+    const results = payload.results;
+    if (Array.isArray(results)) {
+      return results.map(rowFromUnknown).filter((row) => row !== null);
+    }
+  }
+  throw new Error("Neural rerank response was not Cohere or TEI shaped");
+}
+function rowFromUnknown(value) {
+  if (!value || typeof value !== "object") return null;
+  const row = value;
+  if (typeof row.index !== "number" || !Number.isFinite(row.index)) return null;
+  const score = typeof row.relevance_score === "number" ? row.relevance_score : typeof row.score === "number" ? row.score : null;
+  if (score === null || !Number.isFinite(score)) return null;
+  return { index: row.index, score };
+}
+function buildRerankBody(query, documents, model) {
+  const body = {
+    query,
+    documents,
+    top_n: documents.length,
+    return_documents: false
+  };
+  const trimmed = model?.trim();
+  if (trimmed) body.model = trimmed;
+  return body;
+}
+async function rerankViaHttp(query, documents, config2) {
+  if (documents.length === 0) return [];
+  const url2 = buildRerankUrl(config2.baseUrl);
+  const headers = {
+    "content-type": "application/json"
+  };
+  if (config2.apiKey) {
+    headers.authorization = `Bearer ${config2.apiKey}`;
+  }
+  const controller = new AbortController();
+  const timeoutMs = resolveRerankTimeoutMs(config2.timeoutMs);
+  const timer = setTimeout(() => controller.abort(), timeoutMs);
+  try {
+    const fetchImpl = config2.fetchImpl ?? fetch;
+    const response = await fetchImpl(url2, {
+      method: "POST",
+      headers,
+      signal: controller.signal,
+      body: JSON.stringify(buildRerankBody(query, documents, config2.model))
+    });
+    if (!response.ok) {
+      throw new Error(`Neural rerank HTTP ${response.status} from ${url2}`);
+    }
+    return parseRerankResponse(await response.json());
+  } finally {
+    clearTimeout(timer);
+  }
+}
+var init_http_provider = __esm({
+  "src/rerank/http-provider.ts"() {
+    "use strict";
+    init_esm_shims();
+    init_policy();
+  }
+});
+
+// src/rerank/index.ts
+var rerank_exports = {};
+__export(rerank_exports, {
+  DEFAULT_RERANK_TIMEOUT_MS: () => DEFAULT_RERANK_TIMEOUT_MS,
+  MIN_RERANK_CANDIDATES: () => MIN_RERANK_CANDIDATES,
+  isNeuralRerankEnabled: () => isNeuralRerankEnabled,
+  neuralRerankCandidates: () => neuralRerankCandidates,
+  parseRerankTimeoutMs: () => parseRerankTimeoutMs,
+  resolveRerankTimeoutMs: () => resolveRerankTimeoutMs,
+  shouldAttemptHttpRerank: () => shouldAttemptHttpRerank,
+  shouldAttemptLlmRerank: () => shouldAttemptLlmRerank
+});
+function isNeuralRerankEnabled(options = {}) {
+  const lane = getResolvedRerankLane(options);
+  return lane.provider === "http" && Boolean(lane.baseUrl);
+}
+async function neuralRerankCandidates(query, candidates, options = {}) {
+  if (!isNeuralRerankEnabled(options) || candidates.length === 0) return null;
+  const lane = getResolvedRerankLane(options);
+  if (!lane.canSendRequest || !lane.baseUrl) return null;
+  const toRerank = candidates.slice(0, MAX_RERANK);
+  const rest = candidates.slice(MAX_RERANK);
+  const documents = toRerank.map((candidate2) => candidateText(candidate2));
+  const ranked = await rerankViaHttp(query, documents, {
+    provider: "http",
+    model: lane.model,
+    baseUrl: lane.baseUrl,
+    apiKey: lane.apiKey,
+    timeoutMs: resolveRerankTimeoutMs()
+  });
+  const seen = /* @__PURE__ */ new Set();
+  const reranked = [];
+  for (const row of ranked) {
+    const candidate2 = toRerank[row.index];
+    if (!candidate2 || seen.has(row.index)) continue;
+    reranked.push(candidate2);
+    seen.add(row.index);
+  }
+  for (const [index, candidate2] of toRerank.entries()) {
+    if (!seen.has(index)) reranked.push(candidate2);
+  }
+  reranked.push(...rest);
+  return reranked;
+}
+function candidateText(candidate2) {
+  const narrative = candidate2.narrative?.trim();
+  if (narrative) return `${candidate2.title} \u2014 ${narrative.slice(0, 200)}`;
+  return candidate2.title;
+}
+var MAX_RERANK;
+var init_rerank = __esm({
+  "src/rerank/index.ts"() {
+    "use strict";
+    init_esm_shims();
+    init_resolved_config();
+    init_http_provider();
+    init_policy();
+    init_policy();
+    MAX_RERANK = 10;
+  }
+});
+
 // src/llm/quality.ts
 var quality_exports = {};
 __export(quality_exports, {
@@ -25014,9 +25398,9 @@ async function rerankResults(query, candidates) {
   if (!isLLMEnabled() || candidates.length <= 2) {
     return { reranked: candidates, usedLLM: false };
   }
-  const MAX_RERANK = 10;
-  const toRerank = candidates.slice(0, MAX_RERANK);
-  const rest = candidates.slice(MAX_RERANK);
+  const MAX_RERANK2 = 10;
+  const toRerank = candidates.slice(0, MAX_RERANK2);
+  const rest = candidates.slice(MAX_RERANK2);
   try {
     const candidateList = toRerank.map(
       (c6) => `[ID: ${c6.id}] (${c6.type}) ${c6.title}${c6.narrative ? ` \u2014 ${c6.narrative.substring(0, 100)}` : ""}`
@@ -26334,6 +26718,234 @@ var init_lifecycle = __esm({
   }
 });
 
+// src/store/evidence-store.ts
+var evidence_store_exports = {};
+__export(evidence_store_exports, {
+  EvidenceCardStore: () => EvidenceCardStore,
+  buildEvidenceCardId: () => buildEvidenceCardId
+});
+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";
+}
+function buildEvidenceCardId(projectId, candidateKind, candidateId) {
+  return `evidence:${candidateKind}:${projectId}:${candidateId}`;
+}
+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((file2) => normalized.has(file2.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 existsSync10 } from "fs";
@@ -26495,7 +27107,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 {
@@ -26636,7 +27248,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()
@@ -26689,13 +27301,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 fs8 } from "fs";
 import path12 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);
@@ -27295,7 +27907,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;
 }
@@ -27465,7 +28077,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
@@ -27545,7 +28157,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 } : {},
@@ -27584,7 +28196,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,
           ...error40 ? { error: error40 } : {},
@@ -27671,7 +28283,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",
@@ -27847,14 +28459,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 path13 from "path";
 function mediaRoot(dataDir) {
   return path13.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, candidate2) {
   const resolved = path13.resolve(candidate2);
@@ -27914,14 +28526,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, sha2562, extension3) {
   const relative3 = path13.join("assets", projectStorageKey(projectId), sha2562.slice(0, 2), `${sha2562}${extension3}`);
   return { relative: relative3, absolute: validateUnderRoot(root, path13.join(root, relative3)) };
 }
 function deletionStagingPath(root, assetId) {
-  return validateUnderRoot(root, path13.join(root, ".trash", `${assetId}.${randomUUID5()}.pending-delete`));
+  return validateUnderRoot(root, path13.join(root, ".trash", `${assetId}.${randomUUID6()}.pending-delete`));
 }
 async function destinationExists(destination) {
   try {
@@ -27935,7 +28547,7 @@ async function destinationExists(destination) {
 async function persistFile(source, destination) {
   await mkdir3(path13.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);
@@ -27951,7 +28563,7 @@ async function persistFile(source, destination) {
 async function persistBuffer(bytes, destination) {
   await mkdir3(path13.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);
@@ -28020,7 +28632,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 sha2562 = createHash4("sha256").update(input.bytes).digest("hex");
+  const sha2562 = createHash5("sha256").update(input.bytes).digest("hex");
   return importKnownMedia({
     dataDir: input.dataDir,
     projectId: input.projectId,
@@ -28038,7 +28650,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 sha2562 = createHash4("sha256").update(bytes).digest("hex");
+  const sha2562 = createHash5("sha256").update(bytes).digest("hex");
   if (sha2562 !== asset.sha256) throw new Error(`Media asset hash no longer matches metadata: ${asset.id}`);
   return bytes;
 }
@@ -80908,7 +81520,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 randomUUID20 = async () => globalThis.crypto?.randomUUID() || (await import("crypto")).randomUUID();
     var HTTP_STATUS_NO_CONTENT = 204;
     var Gaxios = class {
       agentCache = /* @__PURE__ */ new Map();
@@ -81181,7 +81793,7 @@ var require_gaxios = __commonJS({
          */
         ["Blob", "File", "FormData"].includes(opts.data?.constructor?.name || "");
         if (opts.multipart?.length) {
-          const boundary = await randomUUID17();
+          const boundary = await randomUUID20();
           preparedHeaders.set("content-type", `multipart/related; boundary=${boundary}`);
           opts.body = stream_1.Readable.from(this.getMultipartRequest(opts.multipart, boundary));
         } else if (shouldDirectlyPassData) {
@@ -93408,7 +94020,7 @@ var require_websocket = __commonJS({
     var http3 = __require("http");
     var net = __require("net");
     var tls = __require("tls");
-    var { randomBytes: randomBytes3, createHash: createHash20 } = __require("crypto");
+    var { randomBytes: randomBytes3, createHash: createHash22 } = __require("crypto");
     var { Duplex, Readable: Readable3 } = __require("stream");
     var { URL: URL2 } = __require("url");
     var PerMessageDeflate2 = require_permessage_deflate();
@@ -94076,7 +94688,7 @@ var require_websocket = __commonJS({
           abortHandshake(websocket, socket, "Invalid Upgrade header");
           return;
         }
-        const digest2 = createHash20("sha1").update(key + GUID).digest("base64");
+        const digest2 = createHash22("sha1").update(key + GUID).digest("base64");
         if (res.headers["sec-websocket-accept"] !== digest2) {
           abortHandshake(websocket, socket, "Invalid Sec-WebSocket-Accept header");
           return;
@@ -94448,7 +95060,7 @@ var require_websocket_server = __commonJS({
     var EventEmitter2 = __require("events");
     var http3 = __require("http");
     var { Duplex } = __require("stream");
-    var { createHash: createHash20 } = __require("crypto");
+    var { createHash: createHash22 } = __require("crypto");
     var extension3 = require_extension();
     var PerMessageDeflate2 = require_permessage_deflate();
     var subprotocol2 = require_subprotocol();
@@ -94755,7 +95367,7 @@ var require_websocket_server = __commonJS({
           );
         }
         if (this._state > RUNNING) return abortHandshake(socket, 503);
-        const digest2 = createHash20("sha1").update(key + GUID).digest("base64");
+        const digest2 = createHash22("sha1").update(key + GUID).digest("base64");
         const headers = [
           "HTTP/1.1 101 Switching Protocols",
           "Upgrade: websocket",
@@ -168158,8 +168770,8 @@ var init_session_resources = __esm({
 });
 
 // packages/ai/dist/utils/abort-signals.js
-function combineAbortSignals(signals) {
-  const activeSignals = signals.filter((signal) => signal !== void 0);
+function combineAbortSignals(signals2) {
+  const activeSignals = signals2.filter((signal) => signal !== void 0);
   if (activeSignals.length === 0) {
     return { cleanup: () => {
     } };
@@ -177872,6 +178484,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, {
@@ -177913,6 +178705,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);
@@ -177945,7 +178738,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);
@@ -177957,7 +178751,8 @@ function calculateRelevance(doc, referenceTime) {
     decayFactor,
     accessBoost,
     ageDays,
-    isImmune: immune
+    isImmune: immune,
+    feedbackMultiplier
   };
 }
 function rankByRelevance(docs, referenceTime) {
@@ -177965,6 +178760,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);
@@ -178036,7 +178832,7 @@ function explainRetention(doc, referenceTime) {
     summary: parts.join(" ; ")
   };
 }
-function toRetentionDocument(obs, accessMap) {
+function toRetentionDocument(obs, accessMap, feedback) {
   const access4 = accessMap?.get(obs.id);
   return {
     id: `obs-${obs.id}`,
@@ -178058,11 +178854,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 {
@@ -178087,7 +178884,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 store2 = new MemoryFeedbackStore2();
+    await store2.init(dataDir);
+    return store2;
+  } catch {
+    return void 0;
+  }
+}
+async function archiveExpiredBatch(projectDir2, options) {
   const store2 = getObservationStore();
   const limit2 = Math.min(500, Math.max(1, Math.floor(options.limit ?? 100)));
   const afterId = Math.max(0, Math.floor(options.afterId ?? 0));
@@ -178096,11 +178903,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 store2.atomic(async (tx) => {
     const updates = await Promise.all(
@@ -178131,6 +178940,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 store2.atomic(async (tx) => {
     const allObs = await tx.loadAll();
     const activeObs = allObs.filter(
@@ -178138,7 +178948,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);
       }
@@ -178158,6 +178972,7 @@ var init_retention = __esm({
     init_esm_shims();
     init_obs_store();
     init_visibility();
+    init_feedback_model();
     RETENTION_DAYS = {
       critical: 365,
       high: 180,
@@ -178198,7 +179013,7 @@ var owner_exports = {};
 __export(owner_exports, {
   resolveLocalMemoryOwner: () => resolveLocalMemoryOwner
 });
-import { randomUUID as randomUUID6 } from "crypto";
+import { randomUUID as randomUUID8 } from "crypto";
 import { promises as fs11 } from "fs";
 import path19 from "path";
 function ownerPath(dataDir) {
@@ -178228,7 +179043,7 @@ async function resolveLocalMemoryOwner(dataDir, options = {}) {
   await fs11.mkdir(path19.dirname(filePath), { recursive: true });
   const created = {
     version: 1,
-    id: "local-" + randomUUID6(),
+    id: "local-" + randomUUID8(),
     createdAt: (/* @__PURE__ */ new Date()).toISOString()
   };
   try {
@@ -178255,7 +179070,7 @@ var long_term_store_exports = {};
 __export(long_term_store_exports, {
   LongTermMemoryStore: () => LongTermMemoryStore
 });
-import { randomUUID as randomUUID7 } from "crypto";
+import { randomUUID as randomUUID9 } from "crypto";
 function optionalText2(value) {
   return typeof value === "string" && value.trim() ? value : void 0;
 }
@@ -178306,7 +179121,7 @@ function rowToEvidence(row) {
     createdAt: row.createdAt
   };
 }
-function rowToEvent(row) {
+function rowToEvent2(row) {
   return {
     id: row.id,
     memoryId: row.memoryId,
@@ -178415,7 +179230,7 @@ var init_long_term_store = __esm({
       }
       insertEvidence(input) {
         const evidence = {
-          id: randomUUID7(),
+          id: randomUUID9(),
           ...input,
           createdAt: input.createdAt ?? (/* @__PURE__ */ new Date()).toISOString()
         };
@@ -178442,7 +179257,7 @@ var init_long_term_store = __esm({
       }
       recordEvent(input) {
         const event = {
-          id: randomUUID7(),
+          id: randomUUID9(),
           ...input,
           createdAt: input.createdAt ?? (/* @__PURE__ */ new Date()).toISOString()
         };
@@ -178463,7 +179278,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, at2 = (/* @__PURE__ */ new Date()).toISOString()) {
         const unique3 = [...new Set(ids.filter(Boolean))];
@@ -178532,7 +179347,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);
 }
@@ -178714,7 +179529,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,
@@ -178769,7 +179584,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,
@@ -179087,9 +179902,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(path48) {
   return path48.replace(/\\/g, "/").replace(/^\.\//, "").replace(/\/+/g, "/");
@@ -179124,7 +179939,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 {
@@ -179841,7 +180656,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(
@@ -179919,7 +180734,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 {
@@ -179948,7 +180763,7 @@ function changedPathCount(status) {
   return count3;
 }
 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([
@@ -180048,11 +180863,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 readFileSync8, statSync as statSync4 } from "fs";
 import { join as join5, relative } from "path";
 function hashText(text2) {
-  return createHash7("sha256").update(text2).digest("hex");
+  return createHash8("sha256").update(text2).digest("hex");
 }
 function extension2(path48) {
   const index = path48.lastIndexOf(".");
@@ -180619,7 +181434,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;
 }
@@ -180658,7 +181473,7 @@ function rowToEvidence2(row) {
     createdAt: row.createdAt
   };
 }
-function rowToEvent2(row) {
+function rowToEvent3(row) {
   return {
     id: row.id,
     projectId: row.projectId,
@@ -180672,7 +181487,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,
@@ -180803,7 +181618,7 @@ var init_claim_store = __esm({
         locator, capturedHash, evidenceKey, createdAt
       ) VALUES (?, ?, ?, ?, ?, ?, ?, ?, ?, ?)
     `).run(
-          randomUUID10(),
+          randomUUID12(),
           input.claimId,
           input.evidenceKind,
           input.evidenceId,
@@ -180825,7 +181640,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()
@@ -180853,7 +181668,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);
       }
     };
   }
@@ -180870,7 +181685,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, " ");
@@ -180882,7 +181697,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);
@@ -180956,7 +181771,7 @@ function normalizeClaimInput(input) {
   const now3 = (/* @__PURE__ */ new Date()).toISOString();
   return {
     claim: {
-      id: randomUUID11(),
+      id: randomUUID13(),
       projectId,
       subject,
       predicate,
@@ -181123,7 +181938,7 @@ function supersedeClaim(store2, input) {
   });
 }
 function hashObservation(observation) {
-  return createHash9("sha256").update(JSON.stringify([
+  return createHash10("sha256").update(JSON.stringify([
     observation.title,
     observation.narrative,
     observation.facts,
@@ -181367,11 +182182,11 @@ var init_frontmatter = __esm({
 });
 
 // src/knowledge/markdown.ts
-import { createHash as createHash10 } from "crypto";
+import { createHash as createHash11 } from "crypto";
 import { promises as fs12 } from "fs";
 import path20 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];
@@ -181497,11 +182312,11 @@ __export(wiki_exports, {
   lintKnowledgeWorkspace: () => lintKnowledgeWorkspace,
   readKnowledgePage: () => readKnowledgePage
 });
-import { createHash as createHash11 } from "crypto";
+import { createHash as createHash12 } from "crypto";
 import { promises as fs13 } from "fs";
 import path21 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();
@@ -182045,7 +182860,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 {
@@ -182145,7 +182960,7 @@ var init_workflow_store = __esm({
       }
       recordRun(input) {
         const run = {
-          id: randomUUID12(),
+          id: randomUUID14(),
           workflowId: input.workflowId,
           projectId: input.projectId,
           task: input.task.trim(),
@@ -182223,7 +183038,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;
 }
@@ -182267,7 +183082,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"),
@@ -182694,11 +183509,11 @@ __export(workflows_exports, {
   syncCanonicalWorkflows: () => syncCanonicalWorkflows,
   writeCanonicalWorkflow: () => writeCanonicalWorkflow
 });
-import { createHash as createHash12 } from "crypto";
+import { createHash as createHash13 } from "crypto";
 import { promises as fs14 } from "fs";
 import path22 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();
@@ -184095,6 +184910,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 (error40) {
+    console.error(`[memorix] Evidence card projection failed for obs-${observation.id}: ${error40 instanceof Error ? error40.message : String(error40)}`);
+  }
+}
 function queueClaimDerivation(observation) {
   const dataDir = projectDir;
   const isExplicit = observation.sourceDetail === "explicit";
@@ -184441,6 +185266,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);
@@ -184533,6 +185359,7 @@ async function upsertObservation(existing, input, now3) {
     await store2.update(existing);
   }
   await bindObservationCodeRefsBestEffort(existing);
+  await persistEvidenceCard(existing);
   queueObservationQualification(existing);
   if (resolveObservationVisibility(existing) === "project") {
     queueClaimDerivation(existing);
@@ -184666,6 +185493,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) {
@@ -185003,6 +185831,7 @@ var init_observations = __esm({
     init_secret_filter();
     init_lifecycle();
     init_visibility();
+    init_evidence_store();
     observations = [];
     nextId = 1;
     projectDir = null;
@@ -185792,46 +186621,78 @@ async function searchObservations(options) {
       }
     }
   }
-  const shouldRerank = quality === "thorough" && tier === "heavy" && hasQuery && intermediate.length > 2 && (() => {
-    const top = intermediate[0]?.score ?? 0;
-    const second2 = intermediate[1]?.score ?? 0;
-    return top > 0 && second2 / top > 0.7;
-  })();
-  if (shouldRerank) {
-    try {
-      const { rerankResults: rerankResults2 } = await Promise.resolve().then(() => (init_quality(), quality_exports));
-      const narrativeMap = /* @__PURE__ */ new Map();
-      for (const hit of results.hits) {
-        const doc = hit.document;
-        narrativeMap.set(makeEntryKey(doc.projectId, doc.observationId), doc.narrative);
-      }
-      const RERANK_TOP_K = 5;
-      const toRerank = intermediate.slice(0, RERANK_TOP_K);
-      const candidates = toRerank.map((e5, index) => ({
-        id: `r${index + 1}`,
-        title: e5.title,
-        type: e5.type,
-        score: e5.score,
-        narrative: narrativeMap.get(makeEntryKey(e5.projectId, e5.id))
-      }));
-      const _parsedRerank = parseInt(process.env.MEMORIX_RERANK_TIMEOUT_MS || "", 10);
-      const RERANK_TIMEOUT_MS = Number.isFinite(_parsedRerank) && _parsedRerank > 0 ? _parsedRerank : 5e3;
-      const { reranked, usedLLM } = await withTimeout(
-        rerankResults2(originalQuery, candidates),
-        RERANK_TIMEOUT_MS,
-        "LLM rerank"
-      );
-      mark(`rerank(usedLLM=${usedLLM})`);
-      if (usedLLM) {
-        lastSearchModeByProject.set(modeKey, (lastSearchModeByProject.get(modeKey) ?? "fulltext") + " + LLM rerank");
-        const candidateMap = new Map(candidates.map((candidate2, index) => [candidate2.id, toRerank[index]]));
-        const rerankedTop = reranked.map((r6) => candidateMap.get(r6.id)).filter((e5) => e5 != null);
-        if (rerankedTop.length > 0) {
-          intermediate = [...rerankedTop, ...intermediate.slice(RERANK_TOP_K)];
+  const httpGate = shouldAttemptHttpRerank({
+    quality,
+    hasQuery: Boolean(hasQuery),
+    candidateCount: intermediate.length
+  });
+  const llmGateWithoutHttp = shouldAttemptLlmRerank({
+    quality,
+    tier,
+    hasQuery: Boolean(hasQuery),
+    candidateCount: intermediate.length,
+    topScore: intermediate[0]?.score ?? 0,
+    secondScore: intermediate[1]?.score ?? 0,
+    httpRerankConfigured: false
+  });
+  if (httpGate || llmGateWithoutHttp) {
+    const narrativeMap = /* @__PURE__ */ new Map();
+    for (const hit of results.hits) {
+      const doc = hit.document;
+      narrativeMap.set(makeEntryKey(doc.projectId, doc.observationId), doc.narrative);
+    }
+    const RERANK_TOP_K = 5;
+    const toRerank = intermediate.slice(0, RERANK_TOP_K);
+    const candidates = toRerank.map((e5, index) => ({
+      id: `r${index + 1}`,
+      title: e5.title,
+      type: e5.type,
+      score: e5.score,
+      narrative: narrativeMap.get(makeEntryKey(e5.projectId, e5.id))
+    }));
+    const RERANK_TIMEOUT_MS = parseRerankTimeoutMs(process.env.MEMORIX_RERANK_TIMEOUT_MS);
+    const candidateMap = new Map(candidates.map((candidate2, index) => [candidate2.id, toRerank[index]]));
+    const { isNeuralRerankEnabled: isNeuralRerankEnabled2, neuralRerankCandidates: neuralRerankCandidates2 } = await Promise.resolve().then(() => (init_rerank(), rerank_exports));
+    const httpConfigured = isNeuralRerankEnabled2();
+    if (httpConfigured && httpGate) {
+      try {
+        const neural = await withTimeout(
+          neuralRerankCandidates2(originalQuery, candidates),
+          RERANK_TIMEOUT_MS,
+          "neural rerank"
+        );
+        if (neural && neural.length > 0) {
+          const rerankedTop = neural.map((row) => candidateMap.get(row.id)).filter((entry) => entry != null);
+          if (rerankedTop.length > 0) {
+            intermediate = [...rerankedTop, ...intermediate.slice(RERANK_TOP_K)];
+            lastSearchModeByProject.set(modeKey, (lastSearchModeByProject.get(modeKey) ?? "fulltext") + " + neural rerank");
+            mark("rerank(usedNeural=true)");
+          }
         }
+      } catch {
+        console.error("[memorix] neural rerank failed or timed out; keeping original order");
       }
-    } catch (error40) {
-      console.error("[memorix] LLM rerank failed or timed out, using original order");
+    } else if (!httpConfigured && llmGateWithoutHttp) {
+      try {
+        const { rerankResults: rerankResults2 } = await Promise.resolve().then(() => (init_quality(), quality_exports));
+        const { reranked, usedLLM } = await withTimeout(
+          rerankResults2(originalQuery, candidates),
+          RERANK_TIMEOUT_MS,
+          "LLM rerank"
+        );
+        mark(`rerank(usedLLM=${usedLLM})`);
+        if (usedLLM) {
+          lastSearchModeByProject.set(modeKey, (lastSearchModeByProject.get(modeKey) ?? "fulltext") + " + LLM rerank");
+          const rerankedTop = reranked.map((row) => candidateMap.get(row.id)).filter((entry) => entry != null);
+          if (rerankedTop.length > 0) {
+            intermediate = [...rerankedTop, ...intermediate.slice(RERANK_TOP_K)];
+          }
+        }
+      } catch {
+        console.error("[memorix] LLM rerank failed or timed out, using original order");
+      }
+    } else {
+      mark(`rerank(skipped,tier=${tier})`);
     }
   } else {
     mark(`rerank(skipped,tier=${tier})`);
@@ -186013,6 +186874,7 @@ var init_orama_store = __esm({
     init_project_affinity();
     init_intent_detector();
     init_query_expansion();
+    init_policy();
     init_timeout();
     db = null;
     dbInitPromise = null;
@@ -186402,9 +187264,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((a4, b4) => (b4.score ?? 0) - (a4.score ?? 0));
+    } catch {
+    }
+  }
   let formatted = formatIndexTable(entries, searchOptions.query, !options.projectId, surface);
   if (entries.length === 0 && options.projectId) {
     const allObservations = filterReadableObservations(getAllObservations(), options.reader);
@@ -186723,6 +187603,8 @@ var init_engine3 = __esm({
     init_mini_skills();
     init_secret_filter();
     init_visibility();
+    init_persistence();
+    init_feedback();
   }
 });
 
@@ -186737,7 +187619,7 @@ __export(team_store_exports, {
   isTeamStoreInitialized: () => isTeamStoreInitialized,
   resetTeamStore: () => resetTeamStore
 });
-import { randomUUID as randomUUID14 } from "crypto";
+import { randomUUID as randomUUID16 } from "crypto";
 import path24 from "path";
 import fs15 from "fs";
 function getTeamStore() {
@@ -187026,7 +187908,7 @@ var init_team_store = __esm({
        * reactivate it (preserving agent_id). Otherwise create a new one.
        */
       registerAgent(input) {
-        const instanceId = input.instanceId || randomUUID14();
+        const instanceId = input.instanceId || randomUUID16();
         const now3 = Date.now();
         const existing = this.stmtAgentFindByInstance.get(
           input.projectId,
@@ -187052,7 +187934,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 = randomUUID14();
+        const agentId = randomUUID16();
         this.stmtAgentUpsert.run({
           agent_id: agentId,
           project_id: input.projectId,
@@ -187154,7 +188036,7 @@ var init_team_store = __esm({
             return { error: `Recipient agent '${input.recipientAgentId}' not found \u2014 cannot send to unknown agent` };
           }
         }
-        const id = randomUUID14();
+        const id = randomUUID16();
         const now3 = Date.now();
         const row = {
           id,
@@ -187204,7 +188086,7 @@ var init_team_store = __esm({
       // Task Operations (with atomic claim semantics)
       // ═══════════════════════════════════════════════════════════════════
       createTask(input) {
-        const taskId = randomUUID14();
+        const taskId = randomUUID16();
         const now3 = Date.now();
         const row = {
           task_id: taskId,
@@ -187476,7 +188358,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 ?? randomUUID14(),
+                    id: msg.id ?? randomUUID16(),
                     project_id: "migrated",
                     sender_agent_id: msg.from ?? "unknown",
                     recipient_agent_id: msg.to === "__broadcast__" ? null : msg.to ?? agentId,
@@ -190318,6 +191200,16 @@ function buildInitTomlConfig(options) {
     }
   }
   lines.push("");
+  lines.push("[rerank]");
+  lines.push("# Optional HTTP rerank against any Cohere-compatible /rerank API.");
+  lines.push('# provider = "http"');
+  lines.push('# model = "rerank-model"');
+  lines.push("# base_url inherits [memory.llm] when unset.");
+  if (isGlobal) {
+    lines.push("# Bearer inherits the memory LLM key only when that endpoint matches.");
+    lines.push("# A different rerank URL needs MEMORIX_RERANK_API_KEY.");
+  }
+  lines.push("");
   lines.push("[git]");
   lines.push(`auto_hook = ${options.gitAutoHook}`);
   lines.push("ingest_on_commit = true");
@@ -190490,6 +191382,12 @@ var init_init = __esm({
           envLines.push("# MEMORIX_EMBEDDING_BASE_URL=https://api.openai.com/v1");
           envLines.push("");
         }
+        envLines.push("# Optional HTTP rerank (Cohere-compatible POST {base_url}/rerank)");
+        envLines.push("# MEMORIX_RERANK_PROVIDER=http");
+        envLines.push("# MEMORIX_RERANK_MODEL=rerank-model");
+        envLines.push("# MEMORIX_RERANK_BASE_URL=https://api.example.com/v1");
+        envLines.push("# MEMORIX_RERANK_API_KEY=  # required when BASE_URL is not the memory LLM endpoint");
+        envLines.push("");
         envLines.push("# Optional memory LLM simple key (does not apply to embedding or agent lanes)");
         envLines.push("# MEMORIX_API_KEY=sk-your-key-here");
         envLines.push("");
@@ -191893,8 +192791,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>"` |',
@@ -191907,7 +192805,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.",
@@ -193166,7 +194064,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.",
@@ -194916,6 +195814,12 @@ function serializeResolvedConfigToToml(config2, options = {}) {
     api_key: includeSecrets ? config2.embedding.apiKey : void 0,
     dimensions: config2.embedding.dimensions
   });
+  writeSection(lines, "rerank", {
+    provider: config2.rerank.provider,
+    model: config2.rerank.model,
+    base_url: config2.rerank.baseUrl,
+    api_key: includeSecrets ? config2.rerank.apiKey : void 0
+  });
   writeSection(lines, "memory", {
     inject: config2.memory.inject,
     formation: config2.memory.formation,
@@ -197668,7 +198572,7 @@ var compaction_checkpoint_store_exports = {};
 __export(compaction_checkpoint_store_exports, {
   CompactionCheckpointStore: () => CompactionCheckpointStore
 });
-import { createHash as createHash13, randomUUID as randomUUID15 } from "crypto";
+import { createHash as createHash14, randomUUID as randomUUID17 } from "crypto";
 function optionalText7(value) {
   return typeof value === "string" && value ? value : void 0;
 }
@@ -197710,7 +198614,7 @@ function sourceKeyFor(input, summary) {
     input.tokensBefore ?? "",
     input.firstKeptEntryId ?? ""
   ].join("\0");
-  return `derived:${createHash13("sha256").update(material).digest("hex").slice(0, 32)}`;
+  return `derived:${createHash14("sha256").update(material).digest("hex").slice(0, 32)}`;
 }
 function rowToCheckpoint(row) {
   return {
@@ -197769,7 +198673,7 @@ var init_compaction_checkpoint_store = __esm({
         if (pending) return rowToCheckpoint(pending);
         const now3 = input.capturedAt ?? (/* @__PURE__ */ new Date()).toISOString();
         const checkpoint = {
-          id: randomUUID15(),
+          id: randomUUID17(),
           projectId: input.projectId,
           sessionId: input.sessionId,
           agent: input.agent,
@@ -197777,7 +198681,7 @@ var init_compaction_checkpoint_store = __esm({
           captureKind: "preflight",
           reason: safeReason(input.reason),
           sourceEvent: input.sourceEvent,
-          sourceKey: `pre:${randomUUID15()}`,
+          sourceKey: `pre:${randomUUID17()}`,
           transcriptAvailable: Boolean(input.transcriptAvailable),
           status: "active",
           preCapturedAt: now3,
@@ -197843,7 +198747,7 @@ var init_compaction_checkpoint_store = __esm({
           return this.get(checkpoint2.id);
         }
         const checkpoint = {
-          id: randomUUID15(),
+          id: randomUUID17(),
           projectId: input.projectId,
           sessionId: input.sessionId,
           agent: input.agent,
@@ -198591,6 +199495,59 @@ var init_context_receipt = __esm({
   }
 });
 
+// src/cli/fallback-budget.ts
+import { createHash as createHash15 } from "crypto";
+function fallbackRequestKey(projectId, task) {
+  const normalized = (task ?? "").trim().toLowerCase().replace(/\s+/g, " ");
+  return createHash15("sha256").update(`${projectId}
+${normalized}`).digest("hex").slice(0, 32);
+}
+var DEFAULT_FALLBACK_TTL_MS, CliFallbackBudget;
+var init_fallback_budget = __esm({
+  "src/cli/fallback-budget.ts"() {
+    "use strict";
+    init_esm_shims();
+    init_sqlite_db();
+    DEFAULT_FALLBACK_TTL_MS = 10 * 60 * 1e3;
+    CliFallbackBudget = class {
+      db = null;
+      async init(dataDir) {
+        this.db = getDatabase(dataDir);
+        this.db.exec(`
+      CREATE TABLE IF NOT EXISTS cli_fallback_attempts (
+        project_id TEXT NOT NULL,
+        request_key TEXT NOT NULL,
+        count INTEGER NOT NULL DEFAULT 0,
+        last_attempt_at INTEGER NOT NULL,
+        expires_at INTEGER NOT NULL,
+        PRIMARY KEY (project_id, request_key)
+      )
+    `);
+      }
+      claim(projectId, task, now3 = Date.now(), ttlMs = DEFAULT_FALLBACK_TTL_MS) {
+        if (!this.db) throw new Error("CliFallbackBudget is not initialized.");
+        const key = fallbackRequestKey(projectId, task);
+        const current = this.db.prepare(`
+      SELECT count, expires_at FROM cli_fallback_attempts WHERE project_id = ? AND request_key = ?
+    `).get(projectId, key);
+        const count3 = Number(current?.count ?? 0);
+        if (current && Number(current.expires_at) > now3 && count3 >= 1) {
+          return { allowed: false, key, count: count3, reason: "Fallback budget exhausted for this task. Stop probing and continue with the current project files." };
+        }
+        this.db.prepare(`
+      INSERT INTO cli_fallback_attempts (project_id, request_key, count, last_attempt_at, expires_at)
+      VALUES (?, ?, 1, ?, ?)
+      ON CONFLICT(project_id, request_key) DO UPDATE SET
+        count = CASE WHEN excluded.expires_at > cli_fallback_attempts.expires_at THEN 1 ELSE cli_fallback_attempts.count + 1 END,
+        last_attempt_at = excluded.last_attempt_at,
+        expires_at = CASE WHEN excluded.expires_at > cli_fallback_attempts.expires_at THEN excluded.expires_at ELSE cli_fallback_attempts.expires_at END
+    `).run(projectId, key, now3, now3 + Math.max(1e3, ttlMs));
+        return { allowed: true, key, count: 1 };
+      }
+    };
+  }
+});
+
 // src/cli/commands/context.ts
 var context_exports = {};
 __export(context_exports, {
@@ -198619,6 +199576,7 @@ var init_context2 = __esm({
     init_context_receipt();
     init_workflows2();
     init_operator_shared();
+    init_fallback_budget();
     context_default = defineCommand({
       meta: {
         name: "context",
@@ -198635,13 +199593,23 @@ var init_context2 = __esm({
         refresh: { type: "string", description: "Project scan policy: auto, always, or never" },
         agent: { type: "string", description: "Optional target agent for compatible workflow selection" },
         json: { type: "boolean", description: "Emit machine-readable JSON output" },
-        briefJson: { type: "boolean", description: "Emit only the bounded agent brief and receipt JSON" }
+        briefJson: { type: "boolean", description: "Emit only the bounded agent brief and receipt JSON" },
+        fallback: { type: "boolean", description: "Mark this as the one-shot MCP-unavailable fallback for the task" }
       },
       run: async ({ args }) => {
         const asJson = !!args.json || !!args.briefJson;
         const task = args.task?.trim() || args.input?.trim() || void 0;
         try {
           const { project, dataDir, reader: reader2 } = await getCliProjectContext();
+          if (args.fallback) {
+            const budget = new CliFallbackBudget();
+            await budget.init(dataDir);
+            const claim = budget.claim(project.id, task);
+            if (!claim.allowed) {
+              emitError(claim.reason ?? "CLI fallback budget exhausted for this task.", asJson);
+              return;
+            }
+          }
           const context = await buildAutoProjectContext({
             project,
             dataDir,
@@ -198699,7 +199667,8 @@ var init_resume = __esm({
         refresh: { type: "string", description: "Project scan policy: auto, always, or never" },
         agent: { type: "string", description: "Optional target agent for compatible workflow selection" },
         json: { type: "boolean", description: "Emit machine-readable JSON output" },
-        briefJson: { type: "boolean", description: "Emit only the bounded agent brief and receipt JSON" }
+        briefJson: { type: "boolean", description: "Emit only the bounded agent brief and receipt JSON" },
+        fallback: { type: "boolean", description: "Mark this as the one-shot MCP-unavailable fallback for the task" }
       },
       async run({ args }) {
         await context_default.run?.({
@@ -198710,6 +199679,7 @@ var init_resume = __esm({
             agent: args.agent,
             json: args.json,
             briefJson: args.briefJson,
+            fallback: args.fallback,
             resume: true
           },
           rawArgs: [],
@@ -199965,6 +200935,166 @@ var init_knowledge = __esm({
   }
 });
 
+// src/cli/commands/evidence.ts
+var evidence_exports = {};
+__export(evidence_exports, {
+  default: () => evidence_default
+});
+var evidence_default;
+var init_evidence = __esm({
+  "src/cli/commands/evidence.ts"() {
+    "use strict";
+    init_esm_shims();
+    init_dist2();
+    init_obs_store();
+    init_evidence_store();
+    init_operator_shared();
+    evidence_default = defineCommand({
+      meta: { name: "evidence", description: "Inspect project-scoped evidence cards and provenance" },
+      args: {
+        action: { type: "positional", description: "list, get, sync, stale, or events", required: false },
+        id: { type: "string", description: "Candidate id, usually an observation id" },
+        paths: { type: "string", description: "Comma-separated changed paths for stale" },
+        reason: { type: "string", description: "Why the source became stale" },
+        query: { type: "string", description: "Search title/source fields" },
+        limit: { type: "string", description: "Maximum cards/events" },
+        json: { type: "boolean", description: "Emit JSON" }
+      },
+      async run({ args }) {
+        const action = args.action || "list";
+        const asJson = !!args.json;
+        try {
+          const context = action === "list" || action === "get" || action === "events" ? await getCliReadContext() : await getCliProjectContext({ searchIndex: false });
+          const { project, dataDir } = context;
+          const store2 = new EvidenceCardStore();
+          await store2.init(dataDir);
+          const limit2 = Math.min(100, Math.max(1, Number(args.limit || 20)));
+          if (action === "sync") {
+            const synced = store2.syncObservations(await getObservationStore().loadByProject(project.id));
+            emitResult({ project, synced: synced.length }, `Synced ${synced.length} evidence card(s).`, asJson);
+            return;
+          }
+          if (action === "stale") {
+            const paths = String(args.paths || "").split(",").map((value) => value.trim()).filter(Boolean);
+            const changed = store2.markStaleForPaths(project.id, paths, String(args.reason || "source file changed"));
+            emitResult({ project, staleMarked: changed, paths }, `Marked ${changed} evidence card(s) stale.`, asJson);
+            return;
+          }
+          const id = String(args.id || "").trim();
+          if (action === "get" || action === "events") {
+            if (!id) {
+              emitError(`--id is required for evidence ${action}.`, asJson);
+              return;
+            }
+            const card = store2.get(project.id, "observation", id);
+            if (!card) {
+              emitError(`Evidence card for observation ${id} was not found.`, asJson);
+              return;
+            }
+            const result = action === "events" ? store2.listEvents(card.id, limit2) : { card, events: store2.listEvents(card.id) };
+            emitResult({ project, result }, JSON.stringify(result, null, 2), asJson);
+            return;
+          }
+          if (action !== "list") {
+            emitError("action must be list, get, sync, stale, or events.", asJson);
+            return;
+          }
+          const query = String(args.query || "").trim().toLowerCase();
+          const cards = store2.list(project.id, { limit: 100 }).filter((card) => !query || [card.title, card.summary, card.sourceRef, card.locator || ""].join(" ").toLowerCase().includes(query)).slice(0, limit2);
+          emitResult({ project, cards }, cards.length === 0 ? "No evidence cards found." : cards.map((card) => `- ${card.candidateId} ${card.title} [${card.freshness}] ${card.sourceRef}`).join("\n"), asJson);
+        } catch (error40) {
+          emitError(error40 instanceof Error ? error40.message : String(error40), asJson);
+        }
+      }
+    });
+  }
+});
+
+// src/cli/commands/feedback.ts
+var feedback_exports2 = {};
+__export(feedback_exports2, {
+  default: () => feedback_default
+});
+var signals, feedback_default;
+var init_feedback2 = __esm({
+  "src/cli/commands/feedback.ts"() {
+    "use strict";
+    init_esm_shims();
+    init_dist2();
+    init_feedback();
+    init_operator_shared();
+    signals = ["user-correction", "verification-success", "verification-failure", "code-change", "used", "not-used", "code-conflict", "strengthen", "weaken", "revoke"];
+    feedback_default = defineCommand({
+      meta: { name: "feedback", description: "Record and audit memory feedback" },
+      args: {
+        action: { type: "positional", description: "record, show, or audit", required: false },
+        id: { type: "string", description: "Candidate id" },
+        kind: { type: "string", description: "observation, claim, durable-memory, or workflow" },
+        signal: { type: "string", description: "Feedback signal" },
+        source: { type: "string", description: "Source reference for the feedback" },
+        actor: { type: "string", description: "Actor id or human label" },
+        note: { type: "string", description: "Short audit note" },
+        targetEventId: { type: "string", description: "Event id to revoke" },
+        limit: { type: "string", description: "Maximum audit rows" },
+        json: { type: "boolean", description: "Emit JSON" }
+      },
+      async run({ args }) {
+        const action = args.action || "show";
+        const asJson = !!args.json;
+        try {
+          const context = action === "show" || action === "audit" ? await getCliReadContext() : await getCliProjectContext({ searchIndex: false });
+          const { project, dataDir } = context;
+          const id = String(args.id || "").trim();
+          const kind = String(args.kind || "observation").trim() || "observation";
+          if (!id) {
+            emitError("--id is required.", asJson);
+            return;
+          }
+          if (!["observation", "claim", "durable-memory", "workflow"].includes(kind)) {
+            emitError("Invalid --kind.", asJson);
+            return;
+          }
+          const store2 = new MemoryFeedbackStore();
+          await store2.init(dataDir);
+          if (action === "show") {
+            const result2 = store2.getState(project.id, kind, id);
+            emitResult({ project, result: result2 }, JSON.stringify(result2, null, 2), asJson);
+            return;
+          }
+          if (action === "audit") {
+            const result2 = store2.audit(project.id, kind, id, Number(args.limit || 100));
+            emitResult({ project, result: result2 }, JSON.stringify(result2, null, 2), asJson);
+            return;
+          }
+          if (action !== "record") {
+            emitError("action must be record, show, or audit.", asJson);
+            return;
+          }
+          const signal = String(args.signal || "").trim();
+          const sourceRef = String(args.source || "").trim();
+          if (!signals.includes(signal) || !sourceRef) {
+            emitError(`record requires --signal (${signals.join(", ")}) and --source.`, asJson);
+            return;
+          }
+          const result = store2.record({
+            projectId: project.id,
+            candidateKind: kind,
+            candidateId: id,
+            signal,
+            sourceRef,
+            ...args.actor ? { actor: String(args.actor) } : {},
+            ...args.note ? { note: String(args.note) } : {},
+            ...args.targetEventId ? { targetEventId: String(args.targetEventId) } : {}
+          });
+          emitResult({ project, result }, `Recorded ${signal} for ${kind}:${id}; weight=${result.state.weight.toFixed(2)}.`, asJson);
+        } catch (error40) {
+          emitError(error40 instanceof Error ? error40.message : String(error40), asJson);
+        }
+      }
+    });
+  }
+});
+
 // src/cli/commands/reasoning.ts
 var reasoning_exports = {};
 __export(reasoning_exports, {
@@ -203165,7 +204295,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 {
@@ -203223,7 +204353,7 @@ function seedAutonomousPipeline(teamStore, projectId, config2, opts) {
   const maxIterations = config2.maxIterations ?? 3;
   const taskBudget = config2.taskBudget ?? 15;
   const structuredPlan = opts?.structuredPlan ?? true;
-  const pipelineId = randomUUID16();
+  const pipelineId = randomUUID18();
   const meta = {
     plannerType: "plan",
     pipelineId,
@@ -204142,11 +205272,11 @@ __export(receipt_service_exports, {
   buildHandoffReceipt: () => buildHandoffReceipt,
   formatHandoffReceipt: () => formatHandoffReceipt
 });
-import { createHash as createHash14 } from "crypto";
+import { createHash as createHash16 } from "crypto";
 import { existsSync as existsSync21, readFileSync as readFileSync13 } from "fs";
 import path36 from "path";
 function sha256(value) {
-  return `sha256:${createHash14("sha256").update(value).digest("hex")}`;
+  return `sha256:${createHash16("sha256").update(value).digest("hex")}`;
 }
 function hashId(projectId, id) {
   return sha256(`${projectId}:obs:${id}`);
@@ -204367,6 +205497,10 @@ var init_tool_profile = __esm({
       // 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"],
@@ -216321,9 +217455,9 @@ var init_graph_scope = __esm({
 });
 
 // src/rules/utils.ts
-import { createHash as createHash15 } from "crypto";
+import { createHash as createHash17 } from "crypto";
 function hashContent2(content) {
-  return createHash15("sha256").update(content.trim()).digest("hex").substring(0, 16);
+  return createHash17("sha256").update(content.trim()).digest("hex").substring(0, 16);
 }
 function generateRuleId(source, filePath) {
   const sanitized = filePath.replace(/[\/\\]/g, "-").replace(/^\./, "");
@@ -218027,6 +219161,18 @@ var init_cleanup = __esm({
 });
 
 // src/dashboard/maintenance.ts
+var maintenance_exports = {};
+__export(maintenance_exports, {
+  DashboardMaintenanceError: () => DashboardMaintenanceError,
+  executeCleanup: () => executeCleanup,
+  executeConsolidate: () => executeConsolidate,
+  executeDeduplicate: () => executeDeduplicate,
+  executeRetentionArchive: () => executeRetentionArchive,
+  previewCleanup: () => previewCleanup,
+  previewConsolidate: () => previewConsolidate,
+  previewDeduplicate: () => previewDeduplicate,
+  previewRetentionArchive: () => previewRetentionArchive
+});
 import { createHmac, randomBytes, timingSafeEqual } from "crypto";
 function reader(projectId) {
   return { projectId };
@@ -218268,6 +219414,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, {
@@ -219047,6 +220210,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 = url2.searchParams.get("q") || "";
+        const limit2 = Number(url2.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);
@@ -219094,8 +220271,13 @@ async function handleApi(req, res, dataDir, projectId, projectName, baseDir, pro
           filesModified: o4.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,
@@ -219189,9 +220371,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((a4, b4) => b4.retention.displayScore - a4.retention.displayScore);
         const summary = summarizeRetentionProjections(rows.map((row) => row.retention));
         const scored = rows.map(({ observation, retention }) => ({
@@ -219262,23 +220449,13 @@ async function handleApi(req, res, dataDir, projectId, projectName, baseDir, pro
         const os9 = await import("os");
         const { existsSync: existsSync34 } = await import("fs");
         const { join: join34 } = 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: "" }
@@ -219288,6 +220465,8 @@ async function handleApi(req, res, dataDir, projectId, projectName, baseDir, pro
           const paths = {
             "project memorix.yml": configProjectRoot ? join34(configProjectRoot, "memorix.yml") : null,
             "user memorix.yml": join34(home, ".memorix", "memorix.yml"),
+            "project memorix.toml": configProjectRoot ? join34(configProjectRoot, "memorix.toml") : null,
+            "user config.toml": join34(home, ".memorix", "config.toml"),
             "project .env": configProjectRoot ? join34(configProjectRoot, ".env") : null,
             "user .env": join34(home, ".memorix", ".env"),
             "legacy config.json": join34(home, ".memorix", "config.json")
@@ -219302,67 +220481,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 src2 = "unknown";
-          if (process.env.MEMORIX_LLM_API_KEY) src2 = await getEnvSource("MEMORIX_LLM_API_KEY");
-          else if (process.env.MEMORIX_API_KEY) src2 = await getEnvSource("MEMORIX_API_KEY");
-          else if (yml.llm?.apiKey) src2 = "memorix.yml (move to .env!)";
-          else if (process.env.OPENAI_API_KEY) src2 = await getEnvSource("OPENAI_API_KEY");
+          const src2 = resolveDashboardKeySource({ value: llmKey, envKeys: memoryKeyEnv, configSource });
           values.push({ key: "llm.apiKey", value: "****" + llmKey.slice(-4), source: src2, 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 src2 = "unknown";
-          if (process.env.MEMORIX_AGENT_API_KEY) src2 = await getEnvSource("MEMORIX_AGENT_API_KEY");
-          else if (process.env.MEMORIX_AGENT_LLM_API_KEY) src2 = `${await getEnvSource("MEMORIX_AGENT_LLM_API_KEY")} (legacy)`;
-          else if (yml.agent?.apiKey) src2 = "memorix.yml (move to .env!)";
+          const src2 = resolveDashboardKeySource({
+            value: agentKey,
+            envKeys: ["MEMORIX_AGENT_API_KEY", "MEMORIX_AGENT_LLM_API_KEY"],
+            configSource
+          });
           values.push({ key: "agent.apiKey", value: "****" + agentKey.slice(-4), source: src2, 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;
       }
@@ -219810,10 +220983,14 @@ var init_server3 = __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",
@@ -259680,8 +260857,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",
@@ -259846,7 +261022,7 @@ __export(server_exports2, {
   createMemorixServer: () => createMemorixServer,
   shouldAwaitProjectRuntime: () => shouldAwaitProjectRuntime
 });
-import { createHash as createHash16 } from "crypto";
+import { createHash as createHash18 } from "crypto";
 function formatFormationStageDurations(stageDurationsMs) {
   const orderedStages = ["extract", "resolve", "evaluate"];
   const parts = orderedStages.filter((stage) => stageDurationsMs[stage] !== void 0).map((stage) => `${stage}=${stageDurationsMs[stage]}ms`);
@@ -259928,7 +261104,7 @@ function coerceObjectArray(val) {
   return [];
 }
 function createDeterministicInstanceId(projectId, agentType, agentName) {
-  const digest2 = createHash16("sha256").update(projectId).update("\n").update(agentType).update("\n").update(agentName ?? "").digest("hex").slice(0, 24);
+  const digest2 = createHash18("sha256").update(projectId).update("\n").update(agentType).update("\n").update(agentName ?? "").digest("hex").slice(0, 24);
   return `auto-${digest2}`;
 }
 function shouldAwaitProjectRuntime(toolName) {
@@ -260220,7 +261396,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) => {
@@ -263399,7 +264575,7 @@ ${json4}
         dashboardRunning = true;
         const { exec: execCmd } = await import("child_process");
         const openCmd = process.platform === "win32" ? `start "" "${url2}"` : process.platform === "darwin" ? `open "${url2}"` : `xdg-open "${url2}"`;
-        execCmd(openCmd, () => {
+        execCmd(openCmd, { windowsHide: true }, () => {
         });
         return {
           content: [{
@@ -263423,6 +264599,113 @@ ${json4}
       }
     }
   );
+  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: external_exports2.enum(["list", "get", "sync", "stale", "events"]).describe("Evidence operation"),
+        candidateKind: external_exports2.enum(["observation", "code", "git", "test", "document", "workflow", "graph"]).optional().default("observation"),
+        candidateId: external_exports2.string().optional().describe("Candidate id, usually an observation id"),
+        query: external_exports2.string().optional().describe("Optional title/source query for list"),
+        paths: external_exports2.array(external_exports2.string()).max(200).optional().describe("Changed source paths for stale"),
+        reason: external_exports2.string().max(500).optional().describe("Why evidence became stale"),
+        limit: external_exports2.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: external_exports2.enum(["record", "show", "audit"]).describe("Feedback operation"),
+        candidateKind: external_exports2.enum(["observation", "claim", "durable-memory", "workflow"]).optional().default("observation"),
+        candidateId: external_exports2.string().describe("Memory or knowledge candidate id"),
+        signal: external_exports2.enum(["user-correction", "verification-success", "verification-failure", "code-change", "used", "not-used", "code-conflict", "strengthen", "weaken", "revoke"]).optional(),
+        sourceRef: external_exports2.string().max(500).optional().describe("Source of this feedback, such as test:run-42 or user:chat"),
+        actor: external_exports2.string().max(200).optional(),
+        note: external_exports2.string().max(2e3).optional(),
+        targetEventId: external_exports2.string().optional().describe("Existing event id when action=record and signal=revoke"),
+        limit: external_exports2.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 (error40) {
+        return { content: [{ type: "text", text: error40 instanceof Error ? error40.message : String(error40) }], isError: true };
+      }
+    }
+  );
   if (teamFeaturesEnabled) {
     const { initTeamStore: initTeamStore2 } = await Promise.resolve().then(() => (init_team_store(), team_store_exports));
     initTeamStoreForProject = initTeamStore2;
@@ -264478,6 +265761,8 @@ var init_server4 = __esm({
     init_launch_root();
     init_aliases();
     init_persistence();
+    init_evidence_store();
+    init_feedback();
     init_syncer();
     init_engine5();
     init_tool_profile();
@@ -264964,6 +266249,35 @@ var init_serve = __esm({
   }
 });
 
+// src/server/mcp-diagnostics.ts
+function getMcpDiagnostics() {
+  return {
+    serverName: MCP_SERVER_NAME,
+    protocol: {
+      current: CURRENT_MCP_PROTOCOL_VERSION,
+      legacy: LEGACY_MCP_PROTOCOL_VERSION,
+      statelessRequests: "supported",
+      statefulStreamableHttp: "supported"
+    },
+    capabilities: {
+      tasks: "unsupported",
+      polling: "unsupported",
+      listCache: "supported",
+      explicitProjectHandle: "supported"
+    }
+  };
+}
+var CURRENT_MCP_PROTOCOL_VERSION, LEGACY_MCP_PROTOCOL_VERSION, MCP_SERVER_NAME;
+var init_mcp_diagnostics = __esm({
+  "src/server/mcp-diagnostics.ts"() {
+    "use strict";
+    init_esm_shims();
+    CURRENT_MCP_PROTOCOL_VERSION = "2026-07-28";
+    LEGACY_MCP_PROTOCOL_VERSION = "2024-11-05";
+    MCP_SERVER_NAME = "io.github.AVIDS2/memorix";
+  }
+});
+
 // src/cli/port.ts
 function parseTcpPort(value, defaultPort) {
   const raw = value?.trim() || String(defaultPort);
@@ -267060,6 +268374,79 @@ var init_streamableHttp = __esm({
   }
 });
 
+// src/server/mcp-binding-store.ts
+var mcp_binding_store_exports = {};
+__export(mcp_binding_store_exports, {
+  McpBindingStore: () => McpBindingStore
+});
+import { randomUUID as randomUUID19 } from "crypto";
+function rowToBinding(row) {
+  return {
+    handleId: String(row.handle_id),
+    projectId: String(row.project_id),
+    projectRoot: String(row.project_root),
+    dataDir: String(row.data_dir),
+    createdAt: String(row.created_at),
+    lastUsedAt: String(row.last_used_at),
+    ...row.expires_at ? { expiresAt: String(row.expires_at) } : {}
+  };
+}
+var McpBindingStore;
+var init_mcp_binding_store = __esm({
+  "src/server/mcp-binding-store.ts"() {
+    "use strict";
+    init_esm_shims();
+    init_sqlite_db();
+    McpBindingStore = class {
+      db = null;
+      async init(dataDir) {
+        this.db = getDatabase(dataDir);
+      }
+      requireDb() {
+        if (!this.db) throw new Error("McpBindingStore is not initialized.");
+        return this.db;
+      }
+      create(input) {
+        const now3 = /* @__PURE__ */ new Date();
+        const binding = {
+          handleId: `mxh_${randomUUID19().replace(/-/g, "")}`,
+          projectId: input.projectId,
+          projectRoot: input.projectRoot,
+          dataDir: input.dataDir,
+          createdAt: now3.toISOString(),
+          lastUsedAt: now3.toISOString(),
+          ...input.ttlMs && input.ttlMs > 0 ? { expiresAt: new Date(now3.getTime() + input.ttlMs).toISOString() } : {}
+        };
+        this.requireDb().prepare(`
+      INSERT INTO mcp_bindings (handle_id, project_id, project_root, data_dir, created_at, last_used_at, expires_at)
+      VALUES (?, ?, ?, ?, ?, ?, ?)
+    `).run(binding.handleId, binding.projectId, binding.projectRoot, binding.dataDir, binding.createdAt, binding.lastUsedAt, binding.expiresAt ?? null);
+        return binding;
+      }
+      get(handleId) {
+        const row = this.requireDb().prepare(`SELECT * FROM mcp_bindings WHERE handle_id = ?`).get(handleId);
+        if (!row) return void 0;
+        const binding = rowToBinding(row);
+        if (binding.expiresAt && Date.parse(binding.expiresAt) <= Date.now()) {
+          this.delete(handleId);
+          return void 0;
+        }
+        return binding;
+      }
+      touch(handleId) {
+        const binding = this.get(handleId);
+        if (!binding) return void 0;
+        const lastUsedAt = (/* @__PURE__ */ new Date()).toISOString();
+        this.requireDb().prepare(`UPDATE mcp_bindings SET last_used_at = ? WHERE handle_id = ?`).run(lastUsedAt, handleId);
+        return { ...binding, lastUsedAt };
+      }
+      delete(handleId) {
+        this.requireDb().prepare(`DELETE FROM mcp_bindings WHERE handle_id = ?`).run(handleId);
+      }
+    };
+  }
+});
+
 // src/runtime/control-plane-maintenance.ts
 var control_plane_maintenance_exports = {};
 __export(control_plane_maintenance_exports, {
@@ -267127,6 +268514,7 @@ var serve_http_exports = {};
 __export(serve_http_exports, {
   DEFAULT_SESSION_TIMEOUT_MS: () => DEFAULT_SESSION_TIMEOUT_MS,
   EXPIRED_SESSION_TTL_MS: () => EXPIRED_SESSION_TTL_MS,
+  MCP_SDK_COMPAT_PROTOCOL_VERSION: () => MCP_SDK_COMPAT_PROTOCOL_VERSION,
   _testing: () => _testing2,
   default: () => serve_http_default,
   parseSessionTimeoutMs: () => parseSessionTimeoutMs,
@@ -267148,7 +268536,7 @@ function resolveServeHttpDefaults(argsPort, configured) {
   const transportNotice = configured.transport === "stdio" ? '[memorix] config server.transport = "stdio"; serve-http continues on HTTP (the explicit command wins).' : void 0;
   return { port, transportNotice };
 }
-var DEFAULT_SESSION_TIMEOUT_MS, EXPIRED_SESSION_TTL_MS, serve_http_default, _testing2;
+var DEFAULT_SESSION_TIMEOUT_MS, EXPIRED_SESSION_TTL_MS, MCP_SDK_COMPAT_PROTOCOL_VERSION, serve_http_default, _testing2;
 var init_serve_http = __esm({
   "src/cli/commands/serve-http.ts"() {
     "use strict";
@@ -267158,10 +268546,12 @@ var init_serve_http = __esm({
     init_graph_scope();
     init_retention();
     init_visibility();
+    init_mcp_diagnostics();
     init_port();
     init_mcp_root_path();
     DEFAULT_SESSION_TIMEOUT_MS = 12 * 60 * 60 * 1e3;
     EXPIRED_SESSION_TTL_MS = 10 * 60 * 1e3;
+    MCP_SDK_COMPAT_PROTOCOL_VERSION = "2025-11-25";
     serve_http_default = defineCommand({
       meta: {
         name: "serve-http",
@@ -267191,7 +268581,7 @@ var init_serve_http = __esm({
       },
       run: async ({ args }) => {
         const { createServer: createServer3 } = await import("http");
-        const { randomUUID: randomUUID17 } = await import("crypto");
+        const { randomUUID: randomUUID20 } = await import("crypto");
         const { StreamableHTTPServerTransport: StreamableHTTPServerTransport2 } = await Promise.resolve().then(() => (init_streamableHttp(), streamableHttp_exports));
         const { isInitializeRequest: isInitializeRequest2 } = await Promise.resolve().then(() => (init_types8(), types_exports3));
         const { createMemorixServer: createMemorixServer2 } = await Promise.resolve().then(() => (init_server4(), server_exports2));
@@ -267199,6 +268589,8 @@ var init_serve_http = __esm({
         const { findGitInSubdirs: findGitInSubdirs2 } = await Promise.resolve().then(() => (init_detector(), detector_exports));
         const { writeFileSync: writeFileSync12, mkdirSync: mkdirSync12 } = await import("fs");
         const { homedir: homedir36 } = await import("os");
+        const { McpBindingStore: McpBindingStore2 } = await Promise.resolve().then(() => (init_mcp_binding_store(), mcp_binding_store_exports));
+        const { MemoryFeedbackStore: MemoryFeedbackStore2 } = await Promise.resolve().then(() => (init_feedback(), feedback_exports));
         let configuredDefaults = {};
         try {
           const { getServerConfig: getServerConfig2 } = await Promise.resolve().then(() => (init_config(), config_exports));
@@ -267251,9 +268643,8 @@ var init_serve_http = __esm({
           teamStoreCache.set(dataDir, store2);
           return store2;
         }
-        const detectedProj = serveResolution.detectedProject ?? detectorMod.detectProject(projectRoot);
-        const teamDataDir = await persistMod.getProjectDataDir(detectedProj?.id ?? "__unresolved__");
-        const sharedTeamStore = await getTeamStore2(teamDataDir);
+        const statelessBindingStore = new McpBindingStore2();
+        await statelessBindingStore.init(persistMod.getBaseDataDir());
         const sessions = /* @__PURE__ */ new Map();
         const sessionLastActivity = /* @__PURE__ */ new Map();
         const expiredSessions = /* @__PURE__ */ new Map();
@@ -267393,12 +268784,91 @@ var init_serve_http = __esm({
             res.setHeader("Vary", "Origin");
           }
           res.setHeader("Access-Control-Allow-Methods", "GET, POST, DELETE, OPTIONS");
-          res.setHeader("Access-Control-Allow-Headers", "Content-Type, Accept, Mcp-Session-Id, Last-Event-Id");
-          res.setHeader("Access-Control-Expose-Headers", "Mcp-Session-Id");
+          res.setHeader("Access-Control-Allow-Headers", "Content-Type, Accept, Mcp-Session-Id, Mcp-Project-Handle, Mcp-Project-Root, Mcp-Stateless, Last-Event-Id");
+          res.setHeader("Access-Control-Expose-Headers", "Mcp-Session-Id, Mcp-Project-Handle, Mcp-Protocol-Version, Mcp-Method, Mcp-Name");
+          res.setHeader("Mcp-Protocol-Version", req.headers["mcp-protocol-version"] || CURRENT_MCP_PROTOCOL_VERSION);
+          res.setHeader("Mcp-Method", req.method || "UNKNOWN");
+          res.setHeader("Mcp-Name", MCP_SERVER_NAME);
+        }
+        async function handleStatelessPost(req, res, body) {
+          const handleId = typeof req.headers["mcp-project-handle"] === "string" ? req.headers["mcp-project-handle"] : void 0;
+          const persisted = handleId ? statelessBindingStore.touch(handleId) : void 0;
+          if (handleId && !persisted) {
+            res.writeHead(404, { "Content-Type": "application/json" });
+            res.end(JSON.stringify({ jsonrpc: "2.0", error: { code: -32001, message: "MCP project handle not found or expired; initialize again." }, id: null }));
+            return;
+          }
+          const requestedRoot = typeof req.headers["mcp-project-root"] === "string" ? req.headers["mcp-project-root"] : void 0;
+          const root = persisted?.projectRoot ?? requestedRoot ?? projectRoot;
+          if (!persisted && !isInitializeRequest2(body)) {
+            res.writeHead(400, { "Content-Type": "application/json" });
+            res.end(JSON.stringify({ jsonrpc: "2.0", error: { code: -32e3, message: "Stateless MCP requests require Mcp-Project-Handle; initialize first." }, id: null }));
+            return;
+          }
+          const { createMemorixServer: createMemorixServer3 } = await Promise.resolve().then(() => (init_server4(), server_exports2));
+          const { createProjectBindingController: createProjectBindingController3 } = await Promise.resolve().then(() => (init_request_context(), request_context_exports));
+          const binding = createProjectBindingController3(root);
+          const { server, projectId, handleTransportClose } = await createMemorixServer3(
+            root,
+            void 0,
+            void 0,
+            {
+              allowUntrackedFallback: false,
+              deferProjectInitUntilBound: true,
+              deferProjectRuntimeInit: true,
+              dashboardMode: "control-plane",
+              dashboardPort: port,
+              toolProfile,
+              projectBinding: binding
+            }
+          );
+          const transport = new StreamableHTTPServerTransport2({
+            // No Mcp-Session-Id: the protocol state is carried by our explicit
+            // durable project handle and reconstructed on every request.
+            sessionIdGenerator: void 0,
+            enableJsonResponse: true
+          });
+          try {
+            await server.connect(transport);
+            let effectiveHandle = persisted;
+            if (!effectiveHandle && projectId !== "__unresolved__") {
+              effectiveHandle = statelessBindingStore.create({
+                projectId,
+                projectRoot: root,
+                dataDir: await persistMod.getProjectDataDir(projectId)
+              });
+            }
+            if (effectiveHandle) res.setHeader("Mcp-Project-Handle", effectiveHandle.handleId);
+            const sdkBody = body && typeof body === "object" ? JSON.parse(JSON.stringify(body)) : body;
+            const sdkRequest = sdkBody;
+            if (sdkRequest && typeof sdkRequest === "object" && sdkRequest.method === "initialize" && sdkRequest.params) {
+              sdkRequest.params.protocolVersion = MCP_SDK_COMPAT_PROTOCOL_VERSION;
+            }
+            if (req.headers["mcp-protocol-version"]) {
+              req.headers["mcp-protocol-version"] = MCP_SDK_COMPAT_PROTOCOL_VERSION;
+              for (let i4 = 0; i4 < req.rawHeaders.length; i4 += 2) {
+                if (req.rawHeaders[i4].toLowerCase() === "mcp-protocol-version") {
+                  req.rawHeaders[i4 + 1] = MCP_SDK_COMPAT_PROTOCOL_VERSION;
+                  break;
+                }
+              }
+            }
+            patchMcpResponse(res);
+            await transport.handleRequest(req, res, sdkBody);
+          } finally {
+            handleTransportClose();
+            await transport.close().catch(() => void 0);
+          }
         }
         async function handlePost(req, res) {
           const sessionId = req.headers["mcp-session-id"];
           const body = await parseBody(req);
+          const requestedProtocol = req.headers["mcp-protocol-version"];
+          const statelessRequested = req.headers["mcp-stateless"] === "true" || requestedProtocol === CURRENT_MCP_PROTOCOL_VERSION;
+          if (!sessionId && statelessRequested) {
+            await handleStatelessPost(req, res, body);
+            return;
+          }
           if (sessionId && sessions.has(sessionId)) {
             sessionLastActivity.set(sessionId, Date.now());
             patchMcpResponse(res);
@@ -267412,7 +268882,7 @@ var init_serve_http = __esm({
           if (!sessionId && isInitializeRequest2(body)) {
             let createdState = null;
             const transport = new StreamableHTTPServerTransport2({
-              sessionIdGenerator: () => randomUUID17(),
+              sessionIdGenerator: () => randomUUID20(),
               enableJsonResponse: true,
               onsessioninitialized: (sid) => {
                 if (createdState) sessions.set(sid, createdState);
@@ -267445,7 +268915,7 @@ var init_serve_http = __esm({
             const { server, switchProject, handleTransportClose } = await createMemorixServer2(
               projectRoot,
               void 0,
-              { teamStore: sharedTeamStore },
+              void 0,
               {
                 allowUntrackedFallback: false,
                 deferProjectInitUntilBound: true,
@@ -267587,6 +269057,18 @@ var init_serve_http = __esm({
             { projectId }
           );
         }
+        async function loadProjectFeedback(dataDir, projectId) {
+          const result = /* @__PURE__ */ new Map();
+          try {
+            const feedback = new MemoryFeedbackStore2();
+            await feedback.init(dataDir);
+            for (const state of feedback.listStates(projectId, "observation")) {
+              result.set(state.candidateId, { weight: state.weight, status: state.status });
+            }
+          } catch {
+          }
+          return result;
+        }
         const cliDir = pathModule.default.dirname(fileURLToPath10(import.meta.url));
         const dashStaticDir = pathModule.default.join(cliDir, "..", "dashboard", "static");
         const MIME_TYPES2 = {
@@ -267645,9 +269127,41 @@ var init_serve_http = __esm({
               sendJson2({ ok: true, scope: "per-request" });
               return;
             }
+            const maintenanceMatch = apiPath.match(/^\/maintenance\/(cleanup|deduplicate|consolidate|retention)\/(preview|execute)$/);
+            if (maintenanceMatch) {
+              if (req.method !== "POST") {
+                sendJson2({ error: "Maintenance actions require POST." }, 405);
+                return;
+              }
+              const bodyValue = await parseBody(req);
+              const body = bodyValue && typeof bodyValue === "object" && !Array.isArray(bodyValue) ? bodyValue : {};
+              const { projectId: maintenanceProjectId, dataDir: maintenanceDataDir } = await resolveRequestProject(url2);
+              const maintenanceStore = await getDashboardObservationStore(maintenanceDataDir);
+              const context = {
+                dataDir: maintenanceDataDir,
+                projectId: maintenanceProjectId,
+                projectRoot: maintenanceProjectId === defaultProject.id ? projectRoot : null,
+                store: maintenanceStore
+              };
+              const maintenance = await Promise.resolve().then(() => (init_maintenance(), maintenance_exports));
+              const action = maintenanceMatch[1];
+              const phase = maintenanceMatch[2];
+              let result;
+              if (action === "cleanup") {
+                result = phase === "preview" ? await maintenance.previewCleanup(context, body.includeNoise === true) : await maintenance.executeCleanup(context, body.payload, body.token);
+              } else if (action === "deduplicate") {
+                result = phase === "preview" ? await maintenance.previewDeduplicate(context) : await maintenance.executeDeduplicate(context, body.payload, body.token);
+              } else if (action === "consolidate") {
+                result = phase === "preview" ? await maintenance.previewConsolidate(context) : await maintenance.executeConsolidate(context, body.payload, body.token);
+              } else {
+                result = phase === "preview" ? await maintenance.previewRetentionArchive(context) : await maintenance.executeRetentionArchive(context, body.payload, body.token);
+              }
+              sendJson2(result);
+              return;
+            }
             if (apiPath === "/team") {
-              const { projectId: teamProjectId } = await resolveRequestProject(url2);
-              const ts2 = sharedTeamStore;
+              const { projectId: teamProjectId, dataDir: teamDataDir } = await resolveRequestProject(url2);
+              const ts2 = await getTeamStore2(teamDataDir);
               const scope = url2.searchParams.get("scope") || "project";
               const effectiveTeamProjectId = scope === "global" ? void 0 : teamProjectId;
               const agents = effectiveTeamProjectId ? ts2.listAgents(effectiveTeamProjectId) : ts2.listAllAgents();
@@ -267748,6 +269262,7 @@ var init_serve_http = __esm({
               await initGraphStore2(statsDataDir);
               const graph = { entities: getGraphStore2().loadEntities(), relations: getGraphStore2().loadRelations() };
               const observations2 = await loadDashboardProjectObservations(statsDataDir, statsProjectId, "active");
+              const feedback = await loadProjectFeedback(statsDataDir, statsProjectId);
               const statsStore = await getDashboardObservationStore(statsDataDir);
               const nextId2 = await statsStore.loadIdCounter();
               const typeCounts = {};
@@ -267782,7 +269297,10 @@ var init_serve_http = __esm({
                 filesModified: o4.filesModified
               }));
               const retention = summarizeRetentionProjections(
-                observations2.filter((observation) => observation.type !== "probe").map((observation) => projectObservationRetention(observation, { referenceTime: new Date(now3) }))
+                observations2.filter((observation) => observation.type !== "probe").map((observation) => projectObservationRetention(observation, {
+                  referenceTime: new Date(now3),
+                  feedback: feedback.get(String(observation.id))
+                }))
               );
               const retentionSummary = {
                 active: retention.active,
@@ -267889,6 +269407,19 @@ var init_serve_http = __esm({
               sendJson2(await loadDashboardProjectObservations(obsDataDir, obsProjectId, "active"));
               return;
             }
+            if (apiPath === "/evidence") {
+              const { projectId: evidenceProjectId, dataDir: evidenceDataDir } = await resolveRequestProject(url2);
+              const { EvidenceCardStore: EvidenceCardStore2 } = await Promise.resolve().then(() => (init_evidence_store(), evidence_store_exports));
+              const evidenceStore = new EvidenceCardStore2();
+              await evidenceStore.init(evidenceDataDir);
+              const observations2 = await loadDashboardProjectObservations(evidenceDataDir, evidenceProjectId, "active");
+              evidenceStore.syncObservations(observations2);
+              const query = (url2.searchParams.get("q") || "").trim().toLowerCase();
+              const limit2 = Math.min(100, Math.max(1, Number(url2.searchParams.get("limit") || 20)));
+              const cards = evidenceStore.list(evidenceProjectId, { limit: 100 }).filter((card) => !query || [card.title, card.summary, card.sourceRef, card.locator ?? ""].join(" ").toLowerCase().includes(query)).slice(0, limit2).map((card) => ({ ...card, events: evidenceStore.listEvents(card.id, 8) }));
+              sendJson2({ projectId: evidenceProjectId, cards });
+              return;
+            }
             if (apiPath === "/graph") {
               const { projectId: graphProjectId, dataDir: graphDataDir } = await resolveRequestProject(url2);
               const { initGraphStore: initGraphStore2, getGraphStore: getGraphStore2 } = await Promise.resolve().then(() => (init_graph_store(), graph_store_exports));
@@ -267910,10 +269441,11 @@ var init_serve_http = __esm({
             if (apiPath === "/retention") {
               const { projectId: retProjectId, dataDir: retDataDir } = await resolveRequestProject(url2);
               const observations2 = await loadDashboardProjectObservations(retDataDir, retProjectId, "active");
+              const feedback = await loadProjectFeedback(retDataDir, retProjectId);
               const referenceTime = /* @__PURE__ */ new Date();
               const rows = observations2.filter((observation) => observation.type !== "probe").map((observation) => ({
                 observation,
-                retention: projectObservationRetention(observation, { referenceTime })
+                retention: projectObservationRetention(observation, { referenceTime, feedback: feedback.get(String(observation.id)) })
               })).sort((a4, b4) => b4.retention.displayScore - a4.retention.displayScore);
               const summary = summarizeRetentionProjections(rows.map((row) => row.retention));
               const items = rows.map(({ observation, retention }) => ({
@@ -268290,6 +269822,11 @@ var init_serve_http = __esm({
             }));
             return;
           }
+          if (url2.pathname === "/protocol-diagnostics") {
+            res.writeHead(200, { "Content-Type": "application/json; charset=utf-8", "Cache-Control": "public, max-age=60" });
+            res.end(JSON.stringify(getMcpDiagnostics()));
+            return;
+          }
           if (url2.pathname === "/mcp") {
             const accept = req.headers["accept"] || "";
             const needs = [];
@@ -268586,6 +270123,7 @@ var init_status = __esm({
           diagLines.push(`  Agent lane:      ${formatLane(agent.provider, agent.model, agent.baseUrl, agent.apiKey)}`);
           diagLines.push(`  Memory LLM lane: ${formatLane(resolved.memory.llm.provider, resolved.memory.llm.model, resolved.memory.llm.baseUrl, resolved.memory.llm.apiKey)}`);
           diagLines.push(`  Embedding lane:  ${formatLane(resolved.embedding.provider, resolved.embedding.model, resolved.embedding.baseUrl, resolved.embedding.apiKey)}`);
+          diagLines.push(`  Rerank lane:     ${formatLane(resolved.rerank.provider, resolved.rerank.model, resolved.rerank.baseUrl, resolved.rerank.apiKey)}`);
           diagLines.push(`  Memory behavior: inject=${resolved.memory.inject ?? "default"}, formation=${resolved.memory.formation ?? "default"}, autoCleanup=${resolved.memory.autoCleanup ?? "default"}`);
           diagLines.push(`  Git behavior:    autoHook=${resolved.git.autoHook ?? "default"}, ingestOnCommit=${resolved.git.ingestOnCommit ?? "default"}, maxDiffSize=${resolved.git.maxDiffSize ?? "default"}, skipMergeCommits=${resolved.git.skipMergeCommits ?? "default"}`);
           diagLines.push(`  Server:          transport=${resolved.server.transport ?? "default"}, dashboard=${resolved.server.dashboard ?? "default"}, dashboardPort=${resolved.server.dashboardPort ?? "default"}`);
@@ -268619,7 +270157,8 @@ var init_status = __esm({
             lanes: {
               agent: summarizeLane(agent.provider, agent.model, agent.baseUrl, agent.apiKey),
               memoryLlm: summarizeLane(resolved.memory.llm.provider, resolved.memory.llm.model, resolved.memory.llm.baseUrl, resolved.memory.llm.apiKey),
-              embedding: summarizeLane(resolved.embedding.provider, resolved.embedding.model, resolved.embedding.baseUrl, resolved.embedding.apiKey)
+              embedding: summarizeLane(resolved.embedding.provider, resolved.embedding.model, resolved.embedding.baseUrl, resolved.embedding.apiKey),
+              rerank: summarizeLane(resolved.rerank.provider, resolved.rerank.model, resolved.rerank.baseUrl, resolved.rerank.apiKey)
             },
             memory: {
               inject: resolved.memory.inject ?? "default",
@@ -270162,10 +271701,10 @@ __export(handler_exports, {
   resetCooldowns: () => resetCooldowns,
   runHook: () => runHook
 });
-import { createHash as createHash17 } from "crypto";
+import { createHash as createHash19 } from "crypto";
 function deriveHookActorId(input) {
   const material = `${input.agent ?? "unknown"}\0${input.sessionId ?? "unknown"}`;
-  return `hook:${createHash17("sha256").update(material).digest("hex").slice(0, 24)}`;
+  return `hook:${createHash19("sha256").update(material).digest("hex").slice(0, 24)}`;
 }
 function classifyTool(input) {
   if (input.event === "post_edit") return "file_modify";
@@ -272110,10 +273649,10 @@ var init_ingest = __esm({
 });
 
 // src/media/embedding.ts
-import { createHash as createHash18 } from "crypto";
+import { createHash as createHash20 } from "crypto";
 function profileKey(provider2, asset) {
   const identity = `${provider2.name}\0${provider2.dimensions}\0${asset.kind}`;
-  return `media:${createHash18("sha256").update(identity).digest("hex").slice(0, 20)}`;
+  return `media:${createHash20("sha256").update(identity).digest("hex").slice(0, 20)}`;
 }
 function supportsAsset(provider2, asset) {
   return !!provider2.embedInput && (provider2.supportedModalities?.includes(asset.kind) ?? false);
@@ -274942,7 +276481,9 @@ var init_doctor = __esm({
           if (isLLMEnabled2()) {
             const config2 = getLLMConfig2();
             lines.push(ok(`Provider: ${config2?.provider}/${config2?.model}`));
-            lines.push(info2("Capabilities: fact extraction, auto-dedup, LLM rerank"));
+            const { isNeuralRerankEnabled: isNeuralRerankEnabled2 } = await Promise.resolve().then(() => (init_rerank(), rerank_exports));
+            const rerankCap = isNeuralRerankEnabled2() ? "HTTP rerank" : "LLM rerank";
+            lines.push(info2(`Capabilities: fact extraction, auto-dedup, ${rerankCap}`));
             report.llm = { enabled: true, provider: config2?.provider, model: config2?.model };
           } else {
             lines.push(info2("LLM mode: off (heuristic dedup only)"));
@@ -277724,7 +279265,7 @@ function safeWrite(path48, content) {
   } catch {
   }
 }
-var init_evidence = __esm({
+var init_evidence2 = __esm({
   "src/orchestrate/evidence.ts"() {
     "use strict";
     init_esm_shims();
@@ -277850,7 +279391,7 @@ var init_permission = __esm({
 });
 
 // src/orchestrate/memorix-bridge.ts
-import { createHash as createHash19 } from "crypto";
+import { createHash as createHash21 } from "crypto";
 async function getStoreObservation() {
   if (!_storeObservation) {
     const mod = await Promise.resolve().then(() => (init_observations(), observations_exports));
@@ -277866,7 +279407,7 @@ async function getSearchObservations() {
   return _searchObservations;
 }
 function automaticActorId(...parts) {
-  return `orchestrator:${createHash19("sha256").update(parts.join("\0")).digest("hex").slice(0, 24)}`;
+  return `orchestrator:${createHash21("sha256").update(parts.join("\0")).digest("hex").slice(0, 24)}`;
 }
 function isEligibleAutomaticLesson(entry) {
   return entry.admissionState !== "candidate" && entry.admissionState !== "ephemeral";
@@ -278013,7 +279554,7 @@ function sanitizeErrorPattern(text2) {
 }
 function hashErrorPattern(errorOutput) {
   const sanitized = sanitizeErrorPattern(errorOutput).slice(0, 500);
-  return createHash19("sha256").update(sanitized).digest("hex").slice(0, 12);
+  return createHash21("sha256").update(sanitized).digest("hex").slice(0, 12);
 }
 function sleep6(ms2) {
   return new Promise((resolve6) => setTimeout(() => resolve6([]), ms2));
@@ -279019,7 +280560,7 @@ var init_coordinator = __esm({
     init_verify_gate();
     init_error_recovery();
     init_cost_tracker();
-    init_evidence();
+    init_evidence2();
     init_permission();
     init_memorix_bridge();
   }
@@ -284270,6 +285811,8 @@ var main2 = defineCommand({
     codegraph: () => Promise.resolve().then(() => (init_codegraph(), codegraph_exports)).then((m6) => m6.default),
     checkpoint: () => Promise.resolve().then(() => (init_checkpoint2(), checkpoint_exports)).then((m6) => m6.default),
     knowledge: () => Promise.resolve().then(() => (init_knowledge(), knowledge_exports)).then((m6) => m6.default),
+    evidence: () => Promise.resolve().then(() => (init_evidence(), evidence_exports)).then((m6) => m6.default),
+    feedback: () => Promise.resolve().then(() => (init_feedback2(), feedback_exports2)).then((m6) => m6.default),
     reasoning: () => Promise.resolve().then(() => (init_reasoning(), reasoning_exports)).then((m6) => m6.default),
     retention: () => Promise.resolve().then(() => (init_retention2(), retention_exports2)).then((m6) => m6.default),
     formation: () => Promise.resolve().then(() => (init_formation2(), formation_exports2)).then((m6) => m6.default),
@@ -284368,6 +285911,8 @@ var main2 = defineCommand({
       "lock",
       "handoff",
       "poll",
+      "evidence",
+      "feedback",
       "receipt",
       "serve",
       "serve-http",
@@ -284425,6 +285970,8 @@ var main2 = defineCommand({
       console.error("  codegraph  Refresh/status/context-pack for CodeGraph Memory");
       console.error("  checkpoint Inspect native compact continuity checkpoints");
       console.error("  knowledge  Review source-backed knowledge pages and project workflows");
+      console.error("  evidence   Inspect source-backed evidence cards");
+      console.error("  feedback   Record or audit memory feedback");
       console.error("  reasoning  Store/search decision rationale");
       console.error("  retention  Inspect stale/archive status");
       console.error("  formation  Inspect Memory Formation metrics");