claude-memory-layer 1.0.11 → 1.0.12

package/src/services/memory-service.ts

@@ -45,6 +45,13 @@ import { ConsolidatedStore, createConsolidatedStore } from '../core/consolidated
 import { ConsolidationWorker, createConsolidationWorker } from '../core/consolidation-worker.js';
 import { ContinuityManager, createContinuityManager } from '../core/continuity-manager.js';
 import { GraduationWorker, createGraduationWorker, GraduationRunResult } from '../core/graduation-worker.js';
+import { MarkdownMirror } from '../core/md-mirror.js';
+import {
+  IngestInterceptor,
+  IngestInterceptorRegistry,
+  mergeHierarchicalMetadata
+} from '../core/ingest-interceptor.js';
+import { normalizeTags } from '../core/tag-taxonomy.js';
 
 export interface MemoryServiceConfig {
   storagePath: string;
@@ -185,6 +192,7 @@ export class MemoryService {
   private vectorWorker: VectorWorker | null = null;
   private graduationWorker: GraduationWorker | null = null;
   private initialized = false;
+  private readonly ingestInterceptors = new IngestInterceptorRegistry();
 
   // Endless Mode components
   private workingSetStore: WorkingSetStore | null = null;
@@ -200,14 +208,17 @@ export class MemoryService {
   private sharedPromoter: SharedPromoter | null = null;
   private sharedStoreConfig: SharedStoreConfig | null = null;
   private projectHash: string | null = null;
+  private projectPath: string | null = null;
 
   private readonly readOnly: boolean;
   private readonly lightweightMode: boolean;
+  private readonly mdMirror: MarkdownMirror;
 
-  constructor(config: MemoryServiceConfig & { projectHash?: string; sharedStoreConfig?: SharedStoreConfig }) {
+  constructor(config: MemoryServiceConfig & { projectHash?: string; projectPath?: string; sharedStoreConfig?: SharedStoreConfig }) {
     const storagePath = this.expandPath(config.storagePath);
     this.readOnly = config.readOnly ?? false;
     this.lightweightMode = config.lightweightMode ?? false;
+    this.mdMirror = new MarkdownMirror(process.cwd());
 
     // Ensure storage directory exists (only if not read-only)
     if (!this.readOnly && !fs.existsSync(storagePath)) {
@@ -216,6 +227,7 @@ export class MemoryService {
 
     // Store project hash for shared store operations
     this.projectHash = config.projectHash || null;
+    this.projectPath = config.projectPath || null;
     // Default: shared store enabled
     this.sharedStoreConfig = config.sharedStoreConfig ?? { enabled: true };
 
@@ -223,7 +235,10 @@ export class MemoryService {
     // This is always used for writes and is the source of truth
     this.sqliteStore = new SQLiteEventStore(
       path.join(storagePath, 'events.sqlite'),
-      { readonly: this.readOnly }
+      {
+        readonly: this.readOnly,
+        markdownMirrorRoot: storagePath
+      }
     );
 
     // Initialize ANALYTICS store: DuckDB (optional, for server reads)
@@ -264,6 +279,7 @@ export class MemoryService {
       this.embedder,
       this.matcher
     );
+    this.retriever.setQueryRewriter((q) => this.rewriteQueryIntent(q));
     this.graduation = createGraduationPipeline(this.sqliteStore as unknown as EventStore);
   }
 
@@ -377,6 +393,105 @@ export class MemoryService {
     this.retriever.setSharedStores(this.sharedStore, this.sharedVectorStore);
   }
 
+  registerIngestBefore(interceptor: IngestInterceptor): () => void {
+    return this.ingestInterceptors.registerBefore(interceptor);
+  }
+
+  registerIngestAfter(interceptor: IngestInterceptor): () => void {
+    return this.ingestInterceptors.registerAfter(interceptor);
+  }
+
+  registerIngestOnError(interceptor: IngestInterceptor): () => void {
+    return this.ingestInterceptors.registerOnError(interceptor);
+  }
+
+  private async ingestWithInterceptors(
+    operation: 'user_prompt' | 'agent_response' | 'session_summary' | 'tool_observation',
+    input: MemoryEventInput,
+    onSuccess?: (eventId: string) => Promise<void>
+  ): Promise<AppendResult> {
+    const normalizedInput: MemoryEventInput = {
+      ...input,
+      metadata: mergeHierarchicalMetadata(
+        {
+          ingest: {
+            operation,
+            pipeline: 'default',
+            ts: new Date().toISOString()
+          },
+          ...(this.projectHash
+            ? {
+                scope: {
+                  project: {
+                    hash: this.projectHash,
+                    ...(this.projectPath ? { path: this.projectPath } : {})
+                  }
+                },
+                tags: [`proj:${this.projectHash}`]
+              }
+            : {})
+        },
+        input.metadata
+      )
+    };
+
+    if (this.projectHash && normalizedInput.metadata) {
+      const meta = normalizedInput.metadata as Record<string, unknown>;
+      const currentTags = Array.isArray(meta.tags)
+        ? meta.tags.filter((x): x is string => typeof x === 'string')
+        : [];
+      const projectTag = `proj:${this.projectHash}`;
+      if (!currentTags.includes(projectTag)) {
+        meta.tags = [...currentTags, projectTag];
+      }
+    }
+
+    if (normalizedInput.metadata) {
+      const meta = normalizedInput.metadata as Record<string, unknown>;
+      const normalizedTags = normalizeTags(meta.tags);
+      if (normalizedTags.length > 0) {
+        meta.tags = normalizedTags;
+      }
+    }
+
+    await this.ingestInterceptors.run('before', {
+      operation,
+      sessionId: normalizedInput.sessionId,
+      event: normalizedInput
+    });
+
+    try {
+      const result = await this.sqliteStore.append(normalizedInput);
+      if (result.success && !result.isDuplicate) {
+        if (onSuccess) {
+          await onSuccess(result.eventId);
+        }
+        try {
+          await this.mdMirror.append(normalizedInput, result.eventId);
+        } catch {
+          // non-breaking markdown mirror write
+        }
+      }
+
+      await this.ingestInterceptors.run('after', {
+        operation,
+        sessionId: normalizedInput.sessionId,
+        event: normalizedInput
+      });
+
+      return result;
+    } catch (error) {
+      const normalizedError = error instanceof Error ? error : new Error(String(error));
+      await this.ingestInterceptors.run('error', {
+        operation,
+        sessionId: normalizedInput.sessionId,
+        event: normalizedInput,
+        error: normalizedError
+      });
+      throw error;
+    }
+  }
+
   /**
    * Start a new session
    */
@@ -413,20 +528,19 @@ export class MemoryService {
   ): Promise<AppendResult> {
     await this.initialize();
 
-    const result = await this.sqliteStore.append({
-      eventType: 'user_prompt',
-      sessionId,
-      timestamp: new Date(),
-      content,
-      metadata
-    });
-
-    // Enqueue for embedding if new
-    if (result.success && !result.isDuplicate) {
-      await this.sqliteStore.enqueueForEmbedding(result.eventId, content);
-    }
-
-    return result;
+    return this.ingestWithInterceptors(
+      'user_prompt',
+      {
+        eventType: 'user_prompt',
+        sessionId,
+        timestamp: new Date(),
+        content,
+        metadata
+      },
+      async (eventId) => {
+        await this.sqliteStore.enqueueForEmbedding(eventId, content);
+      }
+    );
   }
 
   /**
@@ -439,20 +553,19 @@ export class MemoryService {
   ): Promise<AppendResult> {
     await this.initialize();
 
-    const result = await this.sqliteStore.append({
-      eventType: 'agent_response',
-      sessionId,
-      timestamp: new Date(),
-      content,
-      metadata
-    });
-
-    // Enqueue for embedding if new
-    if (result.success && !result.isDuplicate) {
-      await this.sqliteStore.enqueueForEmbedding(result.eventId, content);
-    }
-
-    return result;
+    return this.ingestWithInterceptors(
+      'agent_response',
+      {
+        eventType: 'agent_response',
+        sessionId,
+        timestamp: new Date(),
+        content,
+        metadata
+      },
+      async (eventId) => {
+        await this.sqliteStore.enqueueForEmbedding(eventId, content);
+      }
+    );
   }
 
   /**
@@ -460,22 +573,24 @@ export class MemoryService {
    */
   async storeSessionSummary(
     sessionId: string,
-    summary: string
+    summary: string,
+    metadata?: Record<string, unknown>
   ): Promise<AppendResult> {
     await this.initialize();
 
-    const result = await this.sqliteStore.append({
-      eventType: 'session_summary',
-      sessionId,
-      timestamp: new Date(),
-      content: summary
-    });
-
-    if (result.success && !result.isDuplicate) {
-      await this.sqliteStore.enqueueForEmbedding(result.eventId, summary);
-    }
-
-    return result;
+    return this.ingestWithInterceptors(
+      'session_summary',
+      {
+        eventType: 'session_summary',
+        sessionId,
+        timestamp: new Date(),
+        content: summary,
+        metadata
+      },
+      async (eventId) => {
+        await this.sqliteStore.enqueueForEmbedding(eventId, summary);
+      }
+    );
   }
 
   /**
@@ -493,29 +608,28 @@ export class MemoryService {
     // Extract turnId from payload metadata if present (set by PostToolUse hook)
     const turnId = payload.metadata?.turnId;
 
-    const result = await this.sqliteStore.append({
-      eventType: 'tool_observation',
-      sessionId,
-      timestamp: new Date(),
-      content,
-      metadata: {
-        toolName: payload.toolName,
-        success: payload.success,
-        ...(turnId ? { turnId } : {})
+    return this.ingestWithInterceptors(
+      'tool_observation',
+      {
+        eventType: 'tool_observation',
+        sessionId,
+        timestamp: new Date(),
+        content,
+        metadata: {
+          toolName: payload.toolName,
+          success: payload.success,
+          ...(turnId ? { turnId } : {})
+        }
+      },
+      async (eventId) => {
+        const embeddingContent = createToolObservationEmbedding(
+          payload.toolName,
+          payload.metadata || {},
+          payload.success
+        );
+        await this.sqliteStore.enqueueForEmbedding(eventId, embeddingContent);
       }
-    });
-
-    // Create embedding content (optimized for search)
-    if (result.success && !result.isDuplicate) {
-      const embeddingContent = createToolObservationEmbedding(
-        payload.toolName,
-        payload.metadata || {},
-        payload.success
-      );
-      await this.sqliteStore.enqueueForEmbedding(result.eventId, embeddingContent);
-    }
-
-    return result;
+    );
   }
 
   /**
@@ -528,6 +642,10 @@ export class MemoryService {
       minScore?: number;
       sessionId?: string;
       includeShared?: boolean;
+      adaptiveRerank?: boolean;
+      intentRewrite?: boolean;
+      projectScopeMode?: 'strict' | 'prefer' | 'global';
+      allowedProjectHashes?: string[];
     }
   ): Promise<UnifiedRetrievalResult> {
     await this.initialize();
@@ -535,16 +653,177 @@ export class MemoryService {
     // Note: Pending embeddings are processed by the background worker
     // Don't block retrieval - search with whatever vectors are available
 
+    const rerankWeights = await this.getRerankWeights(options?.adaptiveRerank === true);
+
     // Use unified retrieval if shared search is requested
+    let result: UnifiedRetrievalResult;
+
     if (options?.includeShared && this.sharedStore) {
-      return this.retriever.retrieveUnified(query, {
+      result = await this.retriever.retrieveUnified(query, {
         ...options,
+        intentRewrite: options?.intentRewrite === true,
+        rerankWeights,
         includeShared: true,
-        projectHash: this.projectHash || undefined
+        projectHash: this.projectHash || undefined,
+        projectScopeMode: options?.projectScopeMode ?? (this.projectHash ? 'strict' : 'global'),
+        allowedProjectHashes: options?.allowedProjectHashes
+      });
+    } else {
+      result = await this.retriever.retrieve(query, {
+        ...options,
+        intentRewrite: options?.intentRewrite === true,
+        rerankWeights,
+        projectHash: this.projectHash || undefined,
+        projectScopeMode: options?.projectScopeMode ?? (this.projectHash ? 'strict' : 'global'),
+        allowedProjectHashes: options?.allowedProjectHashes
+      });
+    }
+
+    try {
+      const selectedEventIds = result.memories.map((m) => m.event.id);
+      const selectedDetails = (result.selectedDebug || []).map((d) => ({
+        eventId: d.eventId,
+        score: d.score,
+        semanticScore: d.semanticScore,
+        lexicalScore: d.lexicalScore,
+        recencyScore: d.recencyScore,
+      }));
+      const candidateDetails = (result.candidateDebug || []).map((d) => ({
+        eventId: d.eventId,
+        score: d.score,
+        semanticScore: d.semanticScore,
+        lexicalScore: d.lexicalScore,
+        recencyScore: d.recencyScore,
+      }));
+      const candidateEventIds = candidateDetails.length > 0
+        ? candidateDetails.map((d) => d.eventId)
+        : selectedEventIds;
+      await this.sqliteStore.recordRetrievalTrace({
+        sessionId: options?.sessionId,
+        projectHash: this.projectHash || undefined,
+        queryText: query,
+        strategy: options?.strategy || 'auto',
+        candidateEventIds,
+        selectedEventIds,
+        candidateDetails,
+        selectedDetails,
+        confidence: result.matchResult.confidence,
+        fallbackTrace: result.fallbackTrace || []
+      });
+    } catch {
+      // non-blocking telemetry
+    }
+
+    return result;
+  }
+
+  private getConfiguredRerankWeights(): { semantic: number; lexical: number; recency: number } | undefined {
+    const semantic = Number(process.env.MEMORY_RERANK_WEIGHT_SEMANTIC ?? '');
+    const lexical = Number(process.env.MEMORY_RERANK_WEIGHT_LEXICAL ?? '');
+    const recency = Number(process.env.MEMORY_RERANK_WEIGHT_RECENCY ?? '');
+
+    const allFinite = [semantic, lexical, recency].every((v) => Number.isFinite(v));
+    if (!allFinite) return undefined;
+
+    const nonNegative = [semantic, lexical, recency].every((v) => v >= 0);
+    const total = semantic + lexical + recency;
+    if (!nonNegative || total <= 0) return undefined;
+
+    return {
+      semantic: semantic / total,
+      lexical: lexical / total,
+      recency: recency / total,
+    };
+  }
+
+  private async getRerankWeights(adaptive: boolean): Promise<{ semantic: number; lexical: number; recency: number } | undefined> {
+    const configured = this.getConfiguredRerankWeights();
+    if (configured) return configured;
+    if (adaptive) return this.getAdaptiveRerankWeights();
+    return undefined;
+  }
+
+  private async rewriteQueryIntent(query: string): Promise<string | null> {
+    if (process.env.MEMORY_INTENT_REWRITE_ENABLED !== '1') return null;
+
+    const apiUrl = process.env.COMPANY_STOCK_API_URL || process.env.COMPANY_INT_API_URL;
+    if (!apiUrl) return null;
+
+    const controller = new AbortController();
+    const timeoutMs = Number(process.env.MEMORY_INTENT_REWRITE_TIMEOUT_MS || 5000);
+    const timeout = setTimeout(() => controller.abort(), timeoutMs);
+
+    try {
+      const prompt = [
+        'Rewrite user query for memory retrieval intent expansion.',
+        'Return plain text only, one line, no markdown.',
+        `Query: ${query}`,
+      ].join('\n');
+
+      const res = await fetch(apiUrl, {
+        method: 'POST',
+        headers: {
+          'Content-Type': 'application/json',
+          Accept: '*/*',
+          Origin: process.env.COMPANY_INT_ORIGIN || 'http://company-int.aplusai.ai',
+          Referer: process.env.COMPANY_INT_REFERER || 'http://company-int.aplusai.ai/',
+        },
+        body: JSON.stringify({
+          question: prompt,
+          company_name: null,
+          conversation_id: null,
+        }),
+        signal: controller.signal,
       });
+
+      const text = (await res.text()).trim();
+      if (!text) return null;
+
+      const oneLine = text
+        .replace(/^data:\s*/gm, '')
+        .split(/\r?\n/)
+        .map((x) => x.trim())
+        .filter(Boolean)
+        .join(' ')
+        .slice(0, 240);
+
+      if (!oneLine || oneLine.toLowerCase() === query.toLowerCase()) return null;
+      return oneLine;
+    } catch {
+      return null;
+    } finally {
+      clearTimeout(timeout);
     }
+  }
+
+  private async getAdaptiveRerankWeights(): Promise<{ semantic: number; lexical: number; recency: number } | undefined> {
+    try {
+      const s = await this.sqliteStore.getHelpfulnessStats();
+      if (s.totalEvaluated < 20) return undefined;
+
+      // base weights
+      let semantic = 0.7;
+      let lexical = 0.2;
+      let recency = 0.1;
+
+      if (s.avgScore < 0.45) {
+        semantic -= 0.1;
+        lexical += 0.1;
+      } else if (s.avgScore > 0.75) {
+        semantic += 0.05;
+        lexical -= 0.05;
+      }
+
+      if (s.unhelpful > s.helpful) {
+        recency += 0.05;
+        semantic -= 0.03;
+        lexical -= 0.02;
+      }
 
-    return this.retriever.retrieve(query, options);
+      return { semantic, lexical, recency };
+    } catch {
+      return undefined;
+    }
   }
 
   /**
@@ -598,6 +877,30 @@ export class MemoryService {
   /**
    * Get memory statistics
    */
+
+  async getOutboxStats(): Promise<{
+    embedding: { pending: number; processing: number; failed: number; total: number };
+    vector: { pending: number; processing: number; failed: number; total: number };
+  }> {
+    await this.initialize();
+    return this.sqliteStore.getOutboxStats();
+  }
+
+  async getRetrievalTraceStats(): Promise<{
+    totalQueries: number;
+    avgCandidateCount: number;
+    avgSelectedCount: number;
+    selectionRate: number;
+  }> {
+    await this.initialize();
+    return this.sqliteStore.getRetrievalTraceStats();
+  }
+
+  async getRecentRetrievalTraces(limit: number = 50) {
+    await this.initialize();
+    return this.sqliteStore.getRecentRetrievalTraces(limit);
+  }
+
   async getStats(): Promise<{
     totalEvents: number;
     vectorCount: number;
@@ -1278,6 +1581,7 @@ export function getMemoryServiceForProject(
     serviceCache.set(hash, new MemoryService({
       storagePath,
       projectHash: hash,
+      projectPath,
       // Override shared store config - hooks don't need DuckDB
       sharedStoreConfig: sharedStoreConfig ?? { enabled: false },
       analyticsEnabled: false  // Hooks don't need DuckDB
@@ -1319,6 +1623,7 @@ export function getLightweightMemoryService(sessionId: string): MemoryService {
     serviceCache.set(key, new MemoryService({
       storagePath,
       projectHash: projectInfo?.projectHash,
+      projectPath: projectInfo?.projectPath,
       lightweightMode: true,  // Skip embedder/vector/workers
       analyticsEnabled: false,
       sharedStoreConfig: { enabled: false }

package/src/ui/app.js

@@ -11,6 +11,7 @@ const state = {
   sharedStats: null,
   mostAccessed: null,
   helpfulness: null,
+  retrievalTraces: null,
   currentLevel: 'L0',
   currentSort: 'recent',
   currentView: 'overview',
@@ -235,17 +236,19 @@ async function refreshData() {
   if(btn) btn.classList.add('loading');
 
   try {
-    const [stats, shared, mostAccessed, helpfulness] = await Promise.all([
+    const [stats, shared, mostAccessed, helpfulness, retrievalTraces] = await Promise.all([
       fetch(apiUrl(`${API_BASE}/stats`)).then(r => r.json()).catch(() => null),
       fetch(apiUrl(`${API_BASE}/stats/shared`)).then(r => r.json()).catch(() => null),
       fetch(apiUrl(`${API_BASE}/stats/most-accessed`, { limit: 10 })).then(r => r.json()).catch(() => null),
-      fetch(apiUrl(`${API_BASE}/stats/helpfulness`, { limit: 5 })).then(r => r.json()).catch(() => null)
+      fetch(apiUrl(`${API_BASE}/stats/helpfulness`, { limit: 5 })).then(r => r.json()).catch(() => null),
+      fetch(apiUrl(`${API_BASE}/stats/retrieval-traces`, { limit: 20 })).then(r => r.json()).catch(() => null)
     ]);
 
     state.stats = stats;
     state.sharedStats = shared;
     state.mostAccessed = mostAccessed;
     state.helpfulness = helpfulness;
+    state.retrievalTraces = retrievalTraces;
 
     updateStatsUI();
     updateSharedUI();
@@ -397,6 +400,7 @@ function updateMemoryUsageUI() {
   updateGraduationBars();
   updateHelpfulnessUI();
   updateMostHelpfulList();
+  updateRetrievalTraceUI();
 }
 
 function updateGraduationBars() {
@@ -483,6 +487,69 @@ function updateMostHelpfulList() {
   }).join('');
 }
 
+
+function updateRetrievalTraceUI() {
+  const summaryEl = document.getElementById('retrieval-trace-summary');
+  const listEl = document.getElementById('retrieval-trace-list');
+  if (!summaryEl || !listEl) return;
+
+  const payload = state.retrievalTraces;
+  const stats = payload?.stats;
+  const traces = payload?.traces || [];
+
+  if (!stats || !Number.isFinite(stats.totalQueries) || stats.totalQueries === 0) {
+    summaryEl.innerHTML = '<span style="color:var(--text-muted);">No retrieval traces yet.</span>';
+    listEl.innerHTML = '<div style="padding:12px; text-align:center; color:var(--text-muted); font-size:13px;">No query/context trace data</div>';
+    return;
+  }
+
+  const selectionRate = ((stats.selectionRate || 0) * 100).toFixed(1);
+  summaryEl.innerHTML = `
+    <div style="display:flex; gap:14px; flex-wrap:wrap; font-size:12px;">
+      <span><strong>${formatNumber(stats.totalQueries)}</strong> queries</span>
+      <span><strong>${Number(stats.avgCandidateCount || 0).toFixed(1)}</strong> avg candidates</span>
+      <span><strong>${Number(stats.avgSelectedCount || 0).toFixed(1)}</strong> avg selected</span>
+      <span><strong>${selectionRate}%</strong> selection rate</span>
+    </div>
+  `;
+
+  listEl.innerHTML = traces.slice(0, 8).map((t) => {
+    const ts = t.createdAt ? new Date(t.createdAt).toLocaleString() : '-';
+    const confidence = t.confidence || 'n/a';
+    const selected = Number(t.selectedCount || 0);
+    const candidates = Number(t.candidateCount || 0);
+    const selectedDetails = (t.selectedDetails || []).slice(0, 2);
+    const candidateDetails = (t.candidateDetails || []).slice(0, 3);
+    const selectedIdsHtml = selectedDetails.length > 0
+      ? selectedDetails.map((d) => {
+          const breakdown = `score=${Number(d.score || 0).toFixed(3)} · s=${Number(d.semanticScore || 0).toFixed(3)} · l=${Number(d.lexicalScore || 0).toFixed(3)} · r=${Number(d.recencyScore || 0).toFixed(3)}`;
+          return `<span class="event-type-badge" style="cursor:pointer;" onclick="openDetailModal('${d.eventId}')" title="${escapeHtml(breakdown)}">${escapeHtml((d.eventId || '').slice(0, 8))}...</span>`;
+        }).join(' ')
+      : ((t.selectedEventIds || []).slice(0, 2).map((id) => `<span class="event-type-badge" style="cursor:pointer;" onclick="openDetailModal('${id}')">${escapeHtml((id || '').slice(0, 8))}...</span>`).join(' ') || '-');
+
+    const scoreBreakdownHtml = selectedDetails.length > 0
+      ? selectedDetails.map((d) => `<div style="font-size:10px; color:var(--text-muted);">${escapeHtml((d.eventId || '').slice(0, 8))}... → score ${Number(d.score || 0).toFixed(3)} (s ${Number(d.semanticScore || 0).toFixed(3)}, l ${Number(d.lexicalScore || 0).toFixed(3)}, r ${Number(d.recencyScore || 0).toFixed(3)})</div>`).join('')
+      : '';
+
+    return `
+      <div class="shared-item" style="align-items:flex-start;">
+        <div class="shared-info" style="align-items:flex-start; flex-direction:column; gap:4px;">
+          <span style="font-size:12px; color:var(--text-secondary);"><strong>Q:</strong> ${escapeHtml((t.queryText || '').slice(0, 120))}</span>
+          <span style="font-size:11px; color:var(--text-muted);">${ts} · strategy=${escapeHtml(t.strategy || 'auto')} · conf=${escapeHtml(confidence)}</span>
+          <span style="font-size:11px; color:var(--text-muted);">selected IDs: ${selectedIdsHtml}</span>
+          <span style="font-size:11px; color:var(--text-muted);">candidates: ${candidateDetails.map((d) => `<span class=\"event-type-badge\" style=\"cursor:pointer;\" onclick=\"openDetailModal('${d.eventId}')\">${escapeHtml((d.eventId || '').slice(0, 8))}...</span>`).join(' ') || '-'}</span>
+          ${scoreBreakdownHtml}
+        </div>
+        <div style="display:flex; flex-direction:column; align-items:flex-end; gap:2px; min-width:68px;">
+          <span style="font-size:13px; font-weight:600; color:var(--accent-primary);">${selected}/${candidates}</span>
+          <span style="font-size:10px; color:var(--text-muted);">sel/cand</span>
+        </div>
+      </div>
+    `;
+  }).join('');
+}
+
+
 // --- Charts ---
 
 async function initActivityChart() {

package/src/ui/index.html

@@ -271,6 +271,14 @@
                   <div style="padding:12px; text-align:center; color:var(--text-muted); font-size:13px;">Loading...</div>
                 </div>
               </div>
+
+              <div style="margin-top:20px;">
+                <div class="section-label">Retrieval Trace (1:1)</div>
+                <div id="retrieval-trace-summary" style="padding:8px 0; font-size:13px; color:var(--text-muted);">Loading...</div>
+                <div id="retrieval-trace-list" class="shared-list">
+                  <div style="padding:12px; text-align:center; color:var(--text-muted); font-size:13px;">Loading...</div>
+                </div>
+              </div>
             </div>
 
           </div>