fix(search): durabilize verified search and reranker closure

Author: PatrickSys

src/core/reranker.ts

@@ -34,8 +34,6 @@ interface CrossEncoderModel {
 let cachedTokenizer: CrossEncoderTokenizer | null = null;
 let cachedModel: CrossEncoderModel | null = null;
 let initPromise: Promise<void> | null = null;
-/** Set permanently after a non-recoverable load failure so subsequent calls fast-fail. */
-let initFailed = false;
 
 /** Tracks reranker operational health for surfacing in search quality */
 export type RerankerStatus = 'active' | 'fallback' | 'unavailable';
@@ -46,10 +44,14 @@ export function getRerankerStatus(): RerankerStatus {
   return rerankerHealth;
 }
 
+function resetLoadedState(): void {
+  cachedTokenizer = null;
+  cachedModel = null;
+  initPromise = null;
+}
+
 async function ensureModelLoaded(): Promise<void> {
   if (cachedModel && cachedTokenizer) return;
-  // Fast-fail if a prior attempt already determined the model is unavailable.
-  if (initFailed) throw new Error('[reranker] Model unavailable (prior load failed)');
   if (initPromise) return initPromise;
 
   initPromise = (async () => {
@@ -76,13 +78,13 @@ async function ensureModelLoaded(): Promise<void> {
       console.error('[reranker] Cross-encoder loaded successfully');
     } catch (err) {
       const msg = err instanceof Error ? err.message : String(err);
-      const isCorrupt =
-        msg.includes('Protobuf') || msg.includes('parse') || msg.includes('corrupt');
+      const isCorrupt = /protobuf|parse|corrupt/i.test(msg);
+      resetLoadedState();
 
       if (isCorrupt) {
-        // Corrupted cache — clear it so next session re-downloads
+        // Corrupted cache is recoverable in-session once the bad model files are removed.
         console.error(`[reranker] Cache corruption detected: ${msg}`);
-        console.error('[reranker] Clearing corrupted cache. Next startup will re-download.');
+        console.error('[reranker] Clearing corrupted cache. Next call will re-download.');
         try {
           const cacheDir = env.cacheDir ?? null;
           if (cacheDir) {
@@ -97,14 +99,11 @@ async function ensureModelLoaded(): Promise<void> {
           // Cache clear is best-effort
         }
         rerankerHealth = 'unavailable';
-        // Permanent fail — corrupt cache can't be retried in this session.
-        initFailed = true;
         throw err;
       }
 
       // Transient error (network, timeout, etc.) — allow retry on next call.
       rerankerHealth = 'unavailable';
-      initPromise = null;
       throw err;
     }
   })();

src/tools/types.ts

@@ -67,34 +67,70 @@ export interface SearchQuality {
   status: 'ok' | 'low_confidence';
   confidence: number | string;
   hint?: string;
+  tokenEstimate?: number;
+  warning?: string;
+  rerankerStatus?: 'unavailable';
+}
+
+export interface SearchResultRelationships {
+  importedByCount?: number;
+  hasTests?: boolean;
+}
+
+export interface SearchResultHints {
+  callers?: string[];
+  tests?: string[];
+}
+
+export interface SearchNextHop {
+  tool: string;
+  why: string;
+  args?: Record<string, string>;
+}
+
+export interface SearchBudget {
+  mode: 'compact' | 'full';
+  resultCount: number;
+}
+
+export interface SearchLitePreflight extends Partial<Omit<DecisionCard, 'ready'>> {
+  ready: boolean;
+  reason?: string;
 }
 
 export interface SearchResultItem {
   file: string; // "path:startLine-endLine"
   summary: string;
   score: number;
+  relevanceReason?: string;
   type?: string; // "componentType:layer"
   trend?: 'Rising' | 'Declining';
   patternWarning?: string;
-  relationships?: {
-    importedByCount?: number;
-    hasTests?: boolean;
-  };
-  hints?: {
-    callers?: string[];
-    tests?: string[];
-  };
+  relationships?: SearchResultRelationships;
+  hints?: SearchResultHints;
+  importedByCount?: number;
+  topExports?: string[];
+  layer?: string;
+  symbol?: string;
+  symbolKind?: string;
+  scope?: string;
+  signaturePreview?: string;
   imports?: string[];
   exports?: string[];
+  complexity?: number;
   snippet?: string;
 }
 
 export interface SearchResponse {
   status: string;
   searchQuality: SearchQuality;
-  preflight?: DecisionCard;
+  budget?: SearchBudget;
+  preflight?: DecisionCard | SearchLitePreflight;
+  patternSummary?: string;
+  bestExample?: string;
+  nextHops?: SearchNextHop[];
   results: SearchResultItem[];
-  totalResults: number;
+  totalResults?: number;
   relatedMemories?: string[];
 }
 

tests/reranker-recovery.test.ts

@@ -0,0 +1,95 @@
+import { afterEach, beforeEach, describe, expect, it, vi } from 'vitest';
+import { promises as fs } from 'fs';
+import os from 'os';
+import path from 'path';
+import type { SearchResult } from '../src/types/index.js';
+import { rmWithRetries } from './test-helpers.js';
+
+const transformersMocks = vi.hoisted(() => ({
+  tokenizerFromPretrained: vi.fn(),
+  modelFromPretrained: vi.fn(),
+  env: { cacheDir: null as string | null }
+}));
+
+vi.mock('@huggingface/transformers', () => ({
+  AutoTokenizer: {
+    from_pretrained: transformersMocks.tokenizerFromPretrained
+  },
+  AutoModelForSequenceClassification: {
+    from_pretrained: transformersMocks.modelFromPretrained
+  },
+  env: transformersMocks.env
+}));
+
+function makeResult(score: number, filePath: string): SearchResult {
+  return {
+    summary: `Result from ${filePath}`,
+    snippet: 'export class Foo {}',
+    filePath,
+    startLine: 1,
+    endLine: 10,
+    score,
+    language: 'typescript',
+    metadata: {}
+  } as SearchResult;
+}
+
+describe('reranker corruption recovery', () => {
+  let tempCacheRoot: string | null = null;
+  let consoleErrorSpy: ReturnType<typeof vi.spyOn>;
+
+  beforeEach(async () => {
+    vi.resetModules();
+    transformersMocks.tokenizerFromPretrained.mockReset();
+    transformersMocks.modelFromPretrained.mockReset();
+    tempCacheRoot = await fs.mkdtemp(path.join(os.tmpdir(), 'reranker-cache-'));
+    transformersMocks.env.cacheDir = tempCacheRoot;
+    consoleErrorSpy = vi.spyOn(console, 'error').mockImplementation(() => {});
+  });
+
+  afterEach(async () => {
+    consoleErrorSpy.mockRestore();
+    transformersMocks.env.cacheDir = null;
+    if (tempCacheRoot) {
+      await rmWithRetries(tempCacheRoot);
+      tempCacheRoot = null;
+    }
+  });
+
+  it('clears corrupt cache and retries on the next same-process call', async () => {
+    if (!tempCacheRoot) throw new Error('tempCacheRoot not initialized');
+
+    const modelCacheDir = path.join(tempCacheRoot, 'Xenova', 'ms-marco-MiniLM-L-6-v2');
+    await fs.mkdir(modelCacheDir, { recursive: true });
+    await fs.writeFile(path.join(modelCacheDir, 'model.onnx'), 'corrupt');
+
+    const tokenizer = vi.fn((query: string, passage: string) => ({ query, passage }));
+    const model = vi.fn(async (inputs: { passage: string }) => {
+      if (inputs.passage.includes('/a.ts')) return { logits: { data: [1] } };
+      if (inputs.passage.includes('/b.ts')) return { logits: { data: [3] } };
+      return { logits: { data: [2] } };
+    });
+
+    transformersMocks.tokenizerFromPretrained.mockResolvedValue(tokenizer);
+    transformersMocks.modelFromPretrained
+      .mockRejectedValueOnce(new Error('Protobuf parse failure while loading model'))
+      .mockResolvedValueOnce(model);
+
+    const { rerank, getRerankerStatus } = await import('../src/core/reranker.js');
+    const results = [
+      makeResult(0.85, '/a.ts'),
+      makeResult(0.83, '/b.ts'),
+      makeResult(0.82, '/c.ts')
+    ];
+
+    await expect(rerank('auth token', results)).rejects.toThrow(/Protobuf|parse/i);
+    await expect(fs.access(modelCacheDir)).rejects.toThrow();
+    expect(getRerankerStatus()).toBe('unavailable');
+
+    const reranked = await rerank('auth token', results);
+    expect(transformersMocks.tokenizerFromPretrained).toHaveBeenCalledTimes(2);
+    expect(transformersMocks.modelFromPretrained).toHaveBeenCalledTimes(2);
+    expect(reranked.map((result) => result.filePath)).toEqual(['/b.ts', '/c.ts', '/a.ts']);
+    expect(getRerankerStatus()).toBe('active');
+  });
+});