memorix 1.7.2 → 1.8.0

package/src/compact/engine.ts

@@ -22,6 +22,8 @@ import { getMiniSkillStore } from '../store/mini-skill-store.js';
 import { miniSkillToDocument, resolveProvenanceStatus, type ProvenanceStatus } from '../skills/mini-skills.js';
 import { redactCredentials } from '../memory/secret-filter.js';
 import { canReadObservation, filterReadableObservations } from '../memory/visibility.js';
+import { getProjectDataDir } from '../store/persistence.js';
+import { MemoryFeedbackStore, feedbackWeightMultiplier } from '../memory/feedback.js';
 
 export function normalizeMemoryBrowseQuery(query: string): string {
   const trimmed = query.trim();
@@ -71,9 +73,32 @@ export async function compactSearch(options: SearchOptions, surface: RetrievalSu
 }> {
   await ensureFreshIndex();
   const searchOptions = { ...options, query: normalizeMemoryBrowseQuery(options.query) };
-  const entries = (await searchObservations(searchOptions)).map((entry) =>
+  let entries = (await searchObservations(searchOptions)).map((entry) =>
     entry.projectId || !options.projectId ? entry : { ...entry, projectId: options.projectId },
   );
+  if (options.projectId) {
+    try {
+      const feedback = new MemoryFeedbackStore();
+      await feedback.init(await getProjectDataDir(options.projectId));
+      const states = feedback.weights(options.projectId, 'observation');
+      entries = entries
+        .map((entry) => {
+          const state = states.get(String(entry.id));
+          if (!state) return entry;
+          return {
+            ...entry,
+            score: (entry.score ?? 0) * feedbackWeightMultiplier(state.weight),
+            feedbackWeight: state.weight,
+            feedbackStatus: state.status,
+          };
+        })
+        .filter((entry) => entry.feedbackStatus !== 'archived' || options.status === 'all')
+        .sort((a, b) => (b.score ?? 0) - (a.score ?? 0));
+    } catch {
+      // Feedback is an enrichment lane. Retrieval remains available if an old
+      // local database has not yet run the 1.8 schema migration.
+    }
+  }
   let formatted = formatIndexTable(entries, searchOptions.query, !options.projectId, surface);
 
   if (entries.length === 0 && options.projectId) {

package/src/config/dotenv-loader.ts

@@ -31,6 +31,8 @@ let dotenvProjectRoot: string | null = null;
 
 /** Track which .env files were loaded (for diagnostics) */
 const loadedEnvFiles: string[] = [];
+const loadedEnvKeys = new Set<string>();
+const loadedEnvValues = new Map<string, string>();
 /** Track keys injected by .env so project switches can cleanly restore process.env */
 const injectedKeys = new Set<string>();
 
@@ -40,6 +42,8 @@ function loadEnvFile(filePath: string): void {
   const parsed = parse(readFileSync(filePath, 'utf-8'));
   for (const [key, value] of Object.entries(parsed)) {
     if (!(key in process.env)) {
+      loadedEnvKeys.add(key);
+      loadedEnvValues.set(key, value);
       process.env[key] = value;
       injectedKeys.add(key);
     }
@@ -68,6 +72,8 @@ export function loadDotenv(projectRoot?: string, options: DotenvLoadOptions = {}
   }
 
   loadedEnvFiles.length = 0;
+  loadedEnvKeys.clear();
+  loadedEnvValues.clear();
 
   // Loading order = priority order (with override: false, first value wins).
   // System env vars already exist in process.env, so they always win.
@@ -96,6 +102,7 @@ export function resetDotenv(): void {
   dotenvLoaded = false;
   dotenvProjectRoot = null;
   loadedEnvFiles.length = 0;
+  loadedEnvKeys.clear();
 }
 
 /**
@@ -105,6 +112,16 @@ export function getLoadedEnvFiles(): readonly string[] {
   return loadedEnvFiles;
 }
 
+/** Get names found in loaded .env files without exposing their values. */
+export function getLoadedEnvKeys(): ReadonlySet<string> {
+  return loadedEnvKeys;
+}
+
+/** Get the value injected by .env, if the current process still has that value. */
+export function getLoadedEnvValue(key: string): string | undefined {
+  return loadedEnvValues.get(key);
+}
+
 // ─── Supported .env variables ───
 // These are the ONLY variables Memorix reads from .env.
 // All are secrets or endpoint URLs — no behavior config.

package/src/config/resolved-config.ts

@@ -9,8 +9,8 @@ import {
   getProjectYamlPath,
 } from './config-paths.js';
 import { loadFileConfig } from './legacy-loader.js';
-import { loadTomlConfig } from './toml-loader.js';
-import { loadYamlConfig } from './yaml-loader.js';
+import { loadTomlConfig, type MemorixTomlConfig } from './toml-loader.js';
+import { loadYamlConfig, type MemorixYamlConfig } from './yaml-loader.js';
 import { loadDotenv } from './dotenv-loader.js';
 
 export interface ResolvedLaneOptions {
@@ -44,6 +44,14 @@ export interface ResolvedMemorixConfig {
     apiKey?: string;
     dimensions?: number;
   };
+  rerank: {
+    provider: 'off' | 'http';
+    model?: string;
+    baseUrl?: string;
+    apiKey?: string;
+    /** False when a Memory LLM key exists and the rerank URL is a different host without a dedicated key. */
+    canSendRequest: boolean;
+  };
   git: {
     autoHook?: boolean;
     ingestOnCommit?: boolean;
@@ -109,6 +117,16 @@ export function getResolvedConfig(options: ResolvedLaneOptions = {}): ResolvedMe
   const openRouterMemoryLlmApiKey = isOpenRouterMemoryLane(memoryLlmProvider, memoryLlmBaseUrl)
     ? process.env.OPENROUTER_API_KEY
     : undefined;
+  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: ResolvedMemorixConfig = {
     agent: {
@@ -150,16 +168,7 @@ export function getResolvedConfig(options: ResolvedLaneOptions = {}): ResolvedMe
         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: {
@@ -169,6 +178,12 @@ export function getResolvedConfig(options: ResolvedLaneOptions = {}): ResolvedMe
       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),
@@ -244,6 +259,10 @@ export function getResolvedEmbeddingLane(options: ResolvedLaneOptions = {}): Res
   return getResolvedConfig(options).embedding;
 }
 
+export function getResolvedRerankLane(options: ResolvedLaneOptions = {}): ResolvedMemorixConfig['rerank'] {
+  return getResolvedConfig(options).rerank;
+}
+
 export function resetResolvedConfigCache(): void {
   // Kept as a public test helper. File-level caches live in individual loaders.
 }
@@ -294,6 +313,10 @@ function getEnvSourceNames(): string[] {
     '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',
@@ -320,3 +343,78 @@ function normalizeExternalContext(value: string | undefined): 'auto' | 'off' | u
   if (normalized === 'auto' || normalized === 'off') return normalized;
   return undefined;
 }
+
+function normalizeRerankProvider(value: string | undefined): 'off' | 'http' {
+  const normalized = value?.trim().toLowerCase();
+  if (normalized === 'http') return 'http';
+  return 'off';
+}
+
+function resolveRerankLane(args: {
+  toml: MemorixTomlConfig;
+  yaml: MemorixYamlConfig;
+  memoryLlmApiKey?: string;
+  memoryLlmBaseUrl?: string;
+}): ResolvedMemorixConfig['rerank'] {
+  const provider = 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 = provider === '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 = provider === 'http' && sameTrustedEndpoint(baseUrl, args.memoryLlmBaseUrl);
+  const inheritedApiKey = sameEndpoint ? args.memoryLlmApiKey : undefined;
+  const apiKey = first(dedicatedApiKey, inheritedApiKey);
+  const canSendRequest = provider === 'http' && Boolean(baseUrl)
+    && (Boolean(apiKey) || !args.memoryLlmApiKey || sameEndpoint);
+
+  return { provider, model, baseUrl, apiKey, canSendRequest };
+}
+
+/**
+ * True when two API roots are the same host+path after trailing-slash
+ * and optional `/rerank` normalization. Used so a Memory LLM bearer is
+ * never sent to a different rerank provider.
+ */
+function sameTrustedEndpoint(left?: string, right?: string): boolean {
+  const a = normalizeTrustedEndpoint(left);
+  const b = normalizeTrustedEndpoint(right);
+  return Boolean(a && b && a === b);
+}
+
+function normalizeTrustedEndpoint(value?: string): string | undefined {
+  const trimmed = value?.trim();
+  if (!trimmed) return undefined;
+  try {
+    const url = new URL(trimmed);
+    const protocol = url.protocol.toLowerCase();
+    const hostname = url.hostname.toLowerCase();
+    const port = url.port;
+    let pathname = url.pathname.replace(/\/+$/, '');
+    if (pathname.toLowerCase().endsWith('/rerank')) {
+      pathname = pathname.slice(0, -'/rerank'.length).replace(/\/+$/, '');
+    }
+    return `${protocol}//${hostname}${port ? `:${port}` : ''}${pathname}`;
+  } catch {
+    const fallback = trimmed.replace(/\/+$/, '').replace(/\/rerank$/i, '').replace(/\/+$/, '');
+    return fallback.toLowerCase() || undefined;
+  }
+}

package/src/config/toml-loader.ts

@@ -28,6 +28,13 @@ export interface MemorixTomlConfig {
     api_key?: string;
     dimensions?: number;
   };
+  /** Optional HTTP rerank against a compatible /rerank API. */
+  rerank?: {
+    provider?: 'off' | 'http' | string;
+    model?: string;
+    base_url?: string;
+    api_key?: string;
+  };
   hooks?: {
     native_memcode?: boolean;
     external_agents?: boolean;
@@ -97,6 +104,7 @@ function mergeTomlConfig(base: MemorixTomlConfig, override: MemorixTomlConfig):
       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 },

package/src/config/yaml-loader.ts

@@ -48,6 +48,14 @@ export interface MemorixYamlConfig {
     dimensions?: number;
   };
 
+  /** Remote neural rerank (HTTP only) */
+  rerank?: {
+    provider?: 'off' | 'http' | string;
+    model?: string;
+    apiKey?: string;
+    baseUrl?: string;
+  };
+
   /** Git-Memory pipeline configuration */
   git?: {
     /** Auto-install post-commit hook on first run (default: false) */
@@ -190,6 +198,7 @@ export function loadYamlConfig(projectRoot?: string | null): MemorixYamlConfig {
     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 },

package/src/dashboard/config-provenance.ts

@@ -0,0 +1,17 @@
+import { getLoadedEnvValue } from '../config/dotenv-loader.js';
+
+export interface DashboardKeySourceOptions {
+  value: string;
+  envKeys: readonly string[];
+  configSource: string;
+}
+
+/** Resolve a secret source using the ordered environment fallback candidates. */
+export function resolveDashboardKeySource({ value, envKeys, configSource }: DashboardKeySourceOptions): string {
+  for (const envKey of envKeys) {
+    const envValue = process.env[envKey];
+    if (envValue !== value) continue;
+    return getLoadedEnvValue(envKey) === envValue ? '.env' : `env:${envKey}`;
+  }
+  return configSource;
+}

package/src/dashboard/evidence.ts

@@ -0,0 +1,63 @@
+import type { Entity, Relation, Observation } from '../types.js';
+
+export interface EvidenceCard {
+  id: number;
+  title: string;
+  type: string;
+  entityName: string;
+  why: string;
+  source: string;
+  sessionId?: string;
+  createdAt: string;
+  updatedAt?: string;
+  status: string;
+  verification: 'unverified' | 'verified' | 'conflicted';
+  files: string[];
+  relatedEntities: string[];
+  correctionHistory: string[];
+}
+
+function relationNeighbors(entityName: string, relations: Relation[]): string[] {
+  return [...new Set(relations.flatMap((relation) => {
+    if (relation.from === entityName) return [relation.to];
+    if (relation.to === entityName) return [relation.from];
+    return [];
+  }))].slice(0, 8);
+}
+
+/** Build bounded, operator-readable evidence cards from persisted records. */
+export function buildEvidenceCards(
+  observations: Observation[],
+  graph: { entities: Entity[]; relations: Relation[] },
+  query = '',
+  limit = 20,
+): EvidenceCard[] {
+  const needle = query.trim().toLowerCase();
+  return observations
+    .filter((observation) => !needle || [observation.title, observation.narrative, observation.entityName, ...(observation.concepts ?? [])]
+      .join(' ').toLowerCase().includes(needle))
+    .sort((a, b) => b.id - a.id)
+    .slice(0, Math.max(1, Math.min(100, limit)))
+    .map((observation) => {
+      const neighbors = relationNeighbors(observation.entityName, graph.relations);
+      const entity = graph.entities.find((candidate) => candidate.name === observation.entityName);
+      const verification = observation.status === 'resolved' ? 'verified' :
+        observation.status === 'archived' ? 'conflicted' : 'unverified';
+      return {
+        id: observation.id,
+        title: observation.title,
+        type: observation.type,
+        entityName: observation.entityName,
+        why: entity ? 'Matched persisted entity and project-scoped evidence.' : 'Matched project-scoped memory record.',
+        source: observation.sourceDetail || observation.source || 'unknown',
+        ...(observation.sessionId ? { sessionId: observation.sessionId } : {}),
+        createdAt: observation.createdAt,
+        ...(observation.updatedAt ? { updatedAt: observation.updatedAt } : {}),
+        status: observation.status || 'active',
+        verification,
+        files: observation.filesModified || [],
+        relatedEntities: neighbors,
+        correctionHistory: [],
+      };
+    });
+}

package/src/dashboard/server.ts

@@ -22,10 +22,13 @@ import { loadDotenv } from '../config/dotenv-loader.js';
 import { resetDotenv } from '../config/dotenv-loader.js';
 import { initProjectRoot } from '../config/yaml-loader.js';
 import { clearProjectRoot } from '../config/yaml-loader.js';
+import { getResolvedConfig } from '../config/resolved-config.js';
 import { scopeKnowledgeGraphToProject } from '../memory/graph-scope.js';
 import { projectObservationRetention, summarizeRetentionProjections } from '../memory/retention.js';
 import { canManageObservation, filterReadableObservations } from '../memory/visibility.js';
 import type { Observation } from '../types.js';
+import { EvidenceCardStore } from '../store/evidence-store.js';
+import { MemoryFeedbackStore } from '../memory/feedback.js';
 import {
     DashboardMaintenanceError,
     executeCleanup,
@@ -37,6 +40,7 @@ import {
     previewDeduplicate,
     previewRetentionArchive,
 } from './maintenance.js';
+import { resolveDashboardKeySource } from './config-provenance.js';
 
 // MIME types for static file serving
 const MIME_TYPES: Record<string, string> = {
@@ -326,6 +330,22 @@ async function handleApi(
                 break;
             }
 
+            case '/evidence': {
+                const observations = filterDashboardObservations(
+                    await getObservationStore().loadByProject(effectiveProjectId, { status: 'active' }),
+                    effectiveProjectId,
+                );
+                const evidenceStore = new EvidenceCardStore();
+                await evidenceStore.init(effectiveDataDir);
+                evidenceStore.syncObservations(observations);
+                const query = url.searchParams.get('q') || '';
+                const limit = Number(url.searchParams.get('limit') || 20);
+                const cards = evidenceStore.list(effectiveProjectId, { limit: Math.min(100, Math.max(1, limit)) })
+                    .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 as Array<{ projectId?: string }>, effectiveProjectId);
@@ -381,10 +401,15 @@ async function handleApi(
                 }));
 
                 const retentionReferenceTime = new Date(now);
+                const feedback = new MemoryFeedbackStore();
+                await feedback.init(effectiveDataDir).catch(() => undefined);
                 const retention = summarizeRetentionProjections(
                     observations
                         .filter((observation) => observation.type !== 'probe')
-                        .map((observation) => projectObservationRetention(observation, { referenceTime: retentionReferenceTime })),
+                        .map((observation) => projectObservationRetention(observation, {
+                            referenceTime: retentionReferenceTime,
+                            feedback: feedback.getState(effectiveProjectId, 'observation', String(observation.id)),
+                        })),
                 );
                 const retentionSummary = {
                     active: retention.active,
@@ -489,11 +514,16 @@ async function handleApi(
                 );
 
                 const referenceTime = new Date();
+                const feedback = new MemoryFeedbackStore();
+                await feedback.init(effectiveDataDir).catch(() => undefined);
                 const rows = observations
                     .filter((observation) => observation.type !== 'probe')
                     .map((observation) => ({
                         observation,
-                        retention: projectObservationRetention(observation, { referenceTime }),
+                        retention: projectObservationRetention(observation, {
+                            referenceTime,
+                            feedback: feedback.getState(effectiveProjectId, 'observation', String(observation.id)),
+                        }),
                     }))
                     .sort((a, b) => b.retention.displayScore - a.retention.displayScore);
                 const summary = summarizeRetentionProjections(rows.map((row) => row.retention));
@@ -580,26 +610,18 @@ async function handleApi(
                 const { existsSync } = await import('node:fs');
                 const { join } = await import('node:path');
 
-                let yml: any = {};
                 // Use the real project root from dashboard state, not process.cwd()
                 const configProjectRoot = effectiveProjectRoot;
-                try {
-                    const { loadYamlConfig } = await import('../config/yaml-loader.js');
-                    yml = configProjectRoot ? loadYamlConfig(configProjectRoot) : loadYamlConfig(null);
-                } catch { /* best effort */ }
-
-                // Load .env files so process.env reflects actual config (fixes #74, #62)
-                if (configProjectRoot) {
-                    try {
-                        const { loadDotenv } = await import('../config/dotenv-loader.js');
-                        loadDotenv(configProjectRoot);
-                    } catch { /* best effort */ }
-                }
+                // This is the same TOML-first chain used by status and runtime lanes.
+                // Do not fall back to user config if a bound project cannot resolve.
+                const resolved = getResolvedConfig({ projectRoot: configProjectRoot });
 
                 // Check which config files exist
                 const files: Record<string, { exists: boolean; path: string; unavailable?: boolean }> = {
                     '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: '' },
@@ -609,6 +631,8 @@ async function handleApi(
                     const paths: Record<string, string | null> = {
                         'project memorix.yml': configProjectRoot ? join(configProjectRoot, 'memorix.yml') : null,
                         'user memorix.yml': join(home, '.memorix', 'memorix.yml'),
+                        'project memorix.toml': configProjectRoot ? join(configProjectRoot, 'memorix.toml') : null,
+                        'user config.toml': join(home, '.memorix', 'config.toml'),
                         'project .env': configProjectRoot ? join(configProjectRoot, '.env') : null,
                         'user .env': join(home, '.memorix', '.env'),
                         'legacy config.json': join(home, '.memorix', 'config.json'),
@@ -626,82 +650,83 @@ async function handleApi(
                 const values: Array<{ key: string; value: string; source: string; sensitive?: boolean }> = [];
 
                 // LLM
-                // Helper: determine source label (distinguishes .env file vs system env)
-                const getEnvSource = async (envKey: string, ymlSource?: string): Promise<string> => {
-                    if (process.env[envKey]) {
-                        // Check if this key was injected by dotenv-loader (from .env file)
-                        try {
-                            const { getLoadedEnvFiles } = await import('../config/dotenv-loader.js');
-                            const envFiles = getLoadedEnvFiles();
-                            if (envFiles.length > 0) return `.env (${envKey})`;
-                        } catch { /* ignore */ }
-                        return `env:${envKey}`;
-                    }
-                    return ymlSource ?? 'default';
-                };
+                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: string): string => resolveDashboardKeySource({
+                    value: process.env[envKey] ?? '',
+                    envKeys: [envKey],
+                    configSource,
+                });
 
-                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' : undefined) });
+                if (resolved.memory.llm.provider) values.push({ key: 'llm.provider', value: resolved.memory.llm.provider, source: source('MEMORIX_LLM_PROVIDER') });
 
-                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' : undefined) });
+                if (resolved.memory.llm.model) values.push({ key: 'llm.model', value: resolved.memory.llm.model, source: source('MEMORIX_LLM_MODEL') });
 
-                const llmKey = process.env.MEMORIX_LLM_API_KEY || process.env.MEMORIX_API_KEY || yml.llm?.apiKey || process.env.OPENAI_API_KEY;
+                const llmKey = resolved.memory.llm.apiKey;
+                const memoryKeyEnv = [
+                    'MEMORIX_LLM_API_KEY',
+                    'MEMORIX_API_KEY',
+                    'OPENAI_API_KEY',
+                    'ANTHROPIC_API_KEY',
+                    ...(resolved.memory.llm.provider === 'openrouter' || resolved.memory.llm.baseUrl?.includes('openrouter.ai')
+                        ? ['OPENROUTER_API_KEY']
+                        : []),
+                ];
                 if (llmKey) {
-                    let src = 'unknown';
-                    if (process.env.MEMORIX_LLM_API_KEY) src = await getEnvSource('MEMORIX_LLM_API_KEY');
-                    else if (process.env.MEMORIX_API_KEY) src = await getEnvSource('MEMORIX_API_KEY');
-                    else if (yml.llm?.apiKey) src = 'memorix.yml (move to .env!)';
-                    else if (process.env.OPENAI_API_KEY) src = await getEnvSource('OPENAI_API_KEY');
+                    const src = resolveDashboardKeySource({ value: llmKey, envKeys: memoryKeyEnv, configSource });
                     values.push({ key: 'llm.apiKey', value: '****' + llmKey.slice(-4), source: src, sensitive: true });
                 } else {
                     values.push({ key: 'llm.apiKey', value: 'not set', source: 'none' });
                 }
 
-                const agentProvider = process.env.MEMORIX_AGENT_PROVIDER || process.env.MEMORIX_AGENT_LLM_PROVIDER || yml.agent?.provider;
-                if (agentProvider) {
-                    let source: string;
-                    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 });
+                if (resolved.agent.provider) {
+                    values.push({ key: 'agent.provider', value: resolved.agent.provider, source: source('MEMORIX_AGENT_PROVIDER') });
                 }
 
-                const agentModel = process.env.MEMORIX_AGENT_MODEL || process.env.MEMORIX_AGENT_LLM_MODEL || yml.agent?.model;
-                if (agentModel) {
-                    let source: string;
-                    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 });
+                if (resolved.agent.model) {
+                    values.push({ key: 'agent.model', value: resolved.agent.model, source: source('MEMORIX_AGENT_MODEL') });
                 }
 
-                const agentKey = process.env.MEMORIX_AGENT_API_KEY || process.env.MEMORIX_AGENT_LLM_API_KEY || yml.agent?.apiKey;
+                const agentKey = resolved.agent.apiKey;
                 if (agentKey) {
-                    let src = 'unknown';
-                    if (process.env.MEMORIX_AGENT_API_KEY) src = await getEnvSource('MEMORIX_AGENT_API_KEY');
-                    else if (process.env.MEMORIX_AGENT_LLM_API_KEY) src = `${await getEnvSource('MEMORIX_AGENT_LLM_API_KEY')} (legacy)`;
-                    else if (yml.agent?.apiKey) src = 'memorix.yml (move to .env!)';
+                    const src = resolveDashboardKeySource({
+                        value: agentKey,
+                        envKeys: ['MEMORIX_AGENT_API_KEY', 'MEMORIX_AGENT_LLM_API_KEY'],
+                        configSource,
+                    });
                     values.push({ key: 'agent.apiKey', value: '****' + agentKey.slice(-4), source: src, sensitive: true });
                 } else {
-                    values.push({ key: 'agent.apiKey', value: 'fallback to llm.apiKey', source: 'default' });
+                    values.push({
+                        key: 'agent.apiKey',
+                        value: 'fallback to llm.apiKey',
+                        source: llmKey
+                            ? resolveDashboardKeySource({ value: llmKey, envKeys: memoryKeyEnv, configSource })
+                            : 'default',
+                    });
                 }
 
                 // Embedding
-                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' : undefined) });
+                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') });
 
-                // Git
-                values.push({ key: 'git.autoHook', value: String(yml.git?.autoHook ?? false), source: yml.git?.autoHook !== undefined ? 'memorix.yml' : 'default' });
-                values.push({ key: 'git.skipMergeCommits', value: String(yml.git?.skipMergeCommits ?? true), source: yml.git?.skipMergeCommits !== undefined ? 'memorix.yml' : 'default' });
+                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') });
+                }
 
-                // Behavior
-                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' });
+                // Git
+                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 });
 
                 // Server
-                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 !== undefined ? 'memorix.yml' : 'default' });
+                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;