@geminilight/mindos 0.6.69 → 0.6.70

package/_standalone/__tests__/agent/provider-endpoints.test.ts

@@ -0,0 +1,70 @@
+import { describe, expect, it } from 'vitest';
+import { buildCompatEndpointCandidates, getProviderApiType } from '@/lib/agent/providers';
+
+
+describe('buildCompatEndpointCandidates', () => {
+  it('keeps OpenAI-compatible custom path and adds v1 fallback', () => {
+    const endpoints = buildCompatEndpointCandidates(
+      'https://proxy.example.com/custom',
+      '/chat/completions',
+      'openai-completions',
+    );
+
+    expect(endpoints).toEqual([
+      'https://proxy.example.com/custom/chat/completions',
+      'https://proxy.example.com/custom/v1/chat/completions',
+    ]);
+  });
+
+  it('keeps existing version prefix without adding another v1', () => {
+    const endpoints = buildCompatEndpointCandidates(
+      'https://api.openai.com/v1',
+      '/chat/completions',
+      'openai-completions',
+    );
+
+    expect(endpoints).toEqual([
+      'https://api.openai.com/v1/chat/completions',
+    ]);
+  });
+
+  it('preserves GLM path prefix without injecting an extra v1 after /v4', () => {
+    const endpoints = buildCompatEndpointCandidates(
+      'https://api.z.ai/api/coding/paas/v4',
+      '/models',
+      'openai-completions',
+    );
+
+    expect(endpoints).toEqual([
+      'https://api.z.ai/api/coding/paas/v4/models',
+    ]);
+  });
+
+  it('preserves Anthropic-compatible path prefixes for Kimi/MiniMax style gateways', () => {
+    const endpoints = buildCompatEndpointCandidates(
+      'https://api.kimi.com/coding',
+      '/models',
+      'anthropic-messages',
+    );
+
+    expect(endpoints).toEqual([
+      'https://api.kimi.com/coding/models',
+      'https://api.kimi.com/coding/v1/models',
+    ]);
+  });
+});
+
+
+describe('getProviderApiType', () => {
+  it('reports GLM as openai-completions', () => {
+    expect(getProviderApiType('zai')).toBe('openai-completions');
+  });
+
+  it('reports MiniMax CN as anthropic-messages', () => {
+    expect(getProviderApiType('minimax-cn')).toBe('anthropic-messages');
+  });
+
+  it('reports Kimi Coding as anthropic-messages', () => {
+    expect(getProviderApiType('kimi-coding')).toBe('anthropic-messages');
+  });
+});

package/_standalone/__tests__/api/channels-verify.test.ts

@@ -0,0 +1,75 @@
+import { describe, it, expect, vi, beforeEach } from 'vitest';
+import { NextRequest } from 'next/server';
+
+const verifyIMCredentials = vi.fn();
+
+vi.mock('@/lib/im/verify', () => ({
+  verifyIMCredentials,
+}));
+
+async function importRoute() {
+  return await import('../../app/api/channels/verify/route');
+}
+
+function makeReq(body: Record<string, unknown>) {
+  return new NextRequest('http://localhost/api/channels/verify', {
+    method: 'POST',
+    body: JSON.stringify(body),
+    headers: { 'content-type': 'application/json' },
+  });
+}
+
+describe('POST /api/channels/verify', () => {
+  beforeEach(() => {
+    vi.clearAllMocks();
+  });
+
+  it('rejects invalid platform', async () => {
+    const { POST } = await importRoute();
+    const res = await POST(makeReq({ platform: 'unknown', credentials: {} }));
+    expect(res.status).toBe(400);
+    expect(await res.json()).toEqual({ ok: false, error: 'Invalid platform' });
+  });
+
+  it('rejects missing credentials', async () => {
+    const { POST } = await importRoute();
+    const res = await POST(makeReq({ platform: 'telegram' }));
+    expect(res.status).toBe(400);
+    expect(await res.json()).toEqual({ ok: false, error: 'Missing credentials' });
+  });
+
+  it('rejects invalid credential shape before verification', async () => {
+    const { POST } = await importRoute();
+    const res = await POST(makeReq({ platform: 'telegram', credentials: { bot_token: 'bad' } }));
+    expect(res.status).toBe(400);
+    expect(await res.json()).toEqual({ ok: false, error: 'Missing required fields: bot_token' });
+    expect(verifyIMCredentials).not.toHaveBeenCalled();
+  });
+
+  it('returns verified bot identity on success', async () => {
+    verifyIMCredentials.mockResolvedValue({ ok: true, botName: 'MyBot', botId: '123' });
+    const { POST } = await importRoute();
+    const res = await POST(makeReq({
+      platform: 'telegram',
+      credentials: { bot_token: '123456789:ABCdefGHIjklMNOpqrSTUvwxYZ' },
+    }));
+
+    expect(res.status).toBe(200);
+    expect(await res.json()).toEqual({ ok: true, botName: 'MyBot', botId: '123' });
+    expect(verifyIMCredentials).toHaveBeenCalledWith('telegram', {
+      bot_token: '123456789:ABCdefGHIjklMNOpqrSTUvwxYZ',
+    });
+  });
+
+  it('returns 401 when verification fails', async () => {
+    verifyIMCredentials.mockResolvedValue({ ok: false, error: 'Unauthorized: check bot_token' });
+    const { POST } = await importRoute();
+    const res = await POST(makeReq({
+      platform: 'telegram',
+      credentials: { bot_token: '123456789:ABCdefGHIjklMNOpqrSTUvwxYZ' },
+    }));
+
+    expect(res.status).toBe(401);
+    expect(await res.json()).toEqual({ ok: false, error: 'Unauthorized: check bot_token' });
+  });
+});

package/_standalone/__tests__/api/extract-pdf.test.ts

@@ -0,0 +1,265 @@
+import { describe, it, expect, beforeEach, afterEach, vi } from 'vitest';
+import { POST } from '@/app/api/extract-pdf/route';
+import { NextRequest } from 'next/server';
+
+/**
+ * Tests for PDF extraction API edge cases and error handling.
+ * Ensures that extraction failures are properly differentiated from empty PDFs.
+ */
+
+describe('POST /api/extract-pdf', () => {
+  describe('Valid request handling', () => {
+    it('extracts text from valid PDF with content', async () => {
+      // Create a minimal valid PDF with text
+      const minimalPdf = Buffer.from(`%PDF-1.4
+1 0 obj
+<< /Type /Catalog /Pages 2 0 R >>
+endobj
+
+2 0 obj
+<< /Type /Pages /Kids [3 0 R] /Count 1 >>
+endobj
+
+3 0 obj
+<< /Type /Page /Parent 2 0 R /MediaBox [0 0 612 792]
+   /Contents 4 0 R /Resources << /Font << /F1 5 0 R >> >> >>
+endobj
+
+4 0 obj
+<< /Length 44 >>
+stream
+BT /F1 12 Tf 100 700 Td (Hello World) Tj ET
+endstream
+endobj
+
+5 0 obj
+<< /Type /Font /Subtype /Type1 /BaseFont /Helvetica >>
+endobj
+
+xref
+0 6
+0000000000 65535 f 
+0000000009 00000 n 
+0000000058 00000 n 
+0000000115 00000 n 
+0000000266 00000 n 
+0000000360 00000 n 
+
+trailer
+<< /Size 6 /Root 1 0 R >>
+startxref
+441
+%%EOF`);
+
+      const base64 = minimalPdf.toString('base64');
+      const body = JSON.stringify({ name: 'test.pdf', dataBase64: base64 });
+      const req = new NextRequest(new URL('http://localhost/api/extract-pdf'), {
+        method: 'POST',
+        body,
+        headers: { 'Content-Type': 'application/json' },
+      });
+
+      const res = await POST(req);
+      expect(res.status).toBe(200);
+
+      const data = (await res.json()) as {
+        extracted: 'success' | 'empty' | 'error';
+        text: string;
+        extractionError?: string;
+      };
+
+      // Should successfully extract "Hello World"
+      expect(data.extracted).toBe('success');
+      expect(data.text.length).toBeGreaterThan(0);
+      expect(data.text).toContain('Hello');
+      expect(data.extractionError).toBeUndefined();
+    });
+
+    it('handles empty request body gracefully', async () => {
+      const req = new NextRequest(new URL('http://localhost/api/extract-pdf'), {
+        method: 'POST',
+        headers: { 'Content-Type': 'application/json' },
+      });
+
+      const res = await POST(req as any);
+      expect(res.status).toBe(400);
+      const data = (await res.json()) as { error: string };
+      expect(data.error).toBeDefined();
+    });
+
+    it('rejects missing dataBase64', async () => {
+      const body = JSON.stringify({ name: 'test.pdf' });
+      const req = new NextRequest(new URL('http://localhost/api/extract-pdf'), {
+        method: 'POST',
+        body,
+        headers: { 'Content-Type': 'application/json' },
+      });
+
+      const res = await POST(req);
+      expect(res.status).toBe(400);
+      const data = (await res.json()) as { error: string };
+      expect(data.error).toContain('dataBase64');
+    });
+
+    it('rejects oversized PDF (>12MB)', async () => {
+      // Create a 12MB+ base64 string
+      const largeBuf = Buffer.alloc(13 * 1024 * 1024);
+      const base64 = largeBuf.toString('base64');
+      const body = JSON.stringify({ name: 'large.pdf', dataBase64: base64 });
+      const req = new NextRequest(new URL('http://localhost/api/extract-pdf'), {
+        method: 'POST',
+        body,
+        headers: { 'Content-Type': 'application/json' },
+      });
+
+      const res = await POST(req);
+      expect(res.status).toBe(400);
+      const data = (await res.json()) as { error: string };
+      expect(data.error).toContain('too large');
+    });
+  });
+
+  describe('Error handling and state differentiation', () => {
+    it('returns error state when PDF parsing fails', async () => {
+      // Invalid PDF header triggers pdfjs error
+      const invalidPdf = Buffer.from('not a valid PDF at all');
+      const base64 = invalidPdf.toString('base64');
+      const body = JSON.stringify({ name: 'invalid.pdf', dataBase64: base64 });
+      const req = new NextRequest(new URL('http://localhost/api/extract-pdf'), {
+        method: 'POST',
+        body,
+        headers: { 'Content-Type': 'application/json' },
+      });
+
+      const res = await POST(req);
+      expect(res.status).toBe(200); // HTTP 200, but extraction failed
+
+      const data = (await res.json()) as {
+        extracted: 'success' | 'empty' | 'error';
+        extractionError?: string;
+      };
+
+      // Critical: extraction error should be distinct from empty PDF
+      expect(data.extracted).toBe('error');
+      expect(data.extractionError).toBeDefined();
+      expect(data.extractionError).toMatch(/Invalid|error|fail/i);
+    });
+
+    it('returns empty state when PDF has no extractable text', async () => {
+      // Create a PDF with only images (no text)
+      // For this test we'll use a real PDF with no text content
+      // This would be a presentation-style PDF
+      // Since we can't easily generate one, we'll verify the response structure
+      // that the fix should produce
+
+      // The distinction is:
+      // - extracted: 'error' + extractionError: "..." = parse failed
+      // - extracted: 'empty' + no extractionError = parse OK but no text
+      // - extracted: 'success' + text content = normal success
+
+      // This test documents the expected behavior
+      const expectedResponse = {
+        extracted: 'empty',
+        text: '',
+        truncated: false,
+        totalChars: 0,
+        extractionError: undefined,
+      };
+
+      // Verify the structure (actual test would need real image-only PDF)
+      expect(expectedResponse.extracted).toBe('empty');
+      expect(expectedResponse.extractionError).toBeUndefined();
+    });
+
+    it('distinguishes between error and empty in response', async () => {
+      // The API contract must now allow frontend to distinguish:
+      // 1. Extraction error: show "Failed to parse PDF: {error}"
+      // 2. No text: show "No extractable text (may be scanned)"
+      // 3. Has text: show extracted content
+
+      const errorResponse = { extracted: 'error', extractionError: 'Invalid PDF structure' };
+      const emptyResponse = { extracted: 'empty', extractionError: undefined };
+      const successResponse = { extracted: 'success', text: 'content here' };
+
+      // Verify they're distinct
+      expect(errorResponse.extracted).not.toBe(emptyResponse.extracted);
+      expect(errorResponse.extracted).not.toBe(successResponse.extracted);
+      expect(!!errorResponse.extractionError).not.toBe(!!emptyResponse.extractionError);
+    });
+  });
+
+  describe('Response format stability', () => {
+    it('always includes required fields in response', async () => {
+      const minimalPdf = Buffer.from('%PDF-1.4\n1 0 obj\n<< /Type /Catalog /Pages 2 0 R >>\nendobj');
+      const base64 = minimalPdf.toString('base64');
+      const body = JSON.stringify({ name: 'test.pdf', dataBase64: base64 });
+      const req = new NextRequest(new URL('http://localhost/api/extract-pdf'), {
+        method: 'POST',
+        body,
+        headers: { 'Content-Type': 'application/json' },
+      });
+
+      const res = await POST(req);
+      const data = (await res.json()) as Record<string, unknown>;
+
+      // Required fields per the new contract
+      expect(data).toHaveProperty('name');
+      expect(data).toHaveProperty('text');
+      expect(data).toHaveProperty('extracted');
+      expect(data).toHaveProperty('truncated');
+      expect(data).toHaveProperty('totalChars');
+      expect(data).toHaveProperty('pagesParsed');
+
+      // extracted must be one of the 3 states
+      expect(['success', 'empty', 'error']).toContain(data.extracted);
+    });
+
+    it('includes extractionError only when extracted=error', async () => {
+      // When extracted='success' or 'empty', extractionError should not appear
+      // When extracted='error', extractionError must appear
+      // This ensures backward compatibility and clear error communication
+
+      const successCase = {
+        extracted: 'success',
+        text: 'content',
+        extractionError: undefined,
+      };
+      expect(successCase.extractionError).toBeUndefined();
+
+      const errorCase = {
+        extracted: 'error',
+        extractionError: 'PDF structure error',
+      };
+      expect(errorCase.extractionError).toBeDefined();
+    });
+  });
+
+  describe('Text truncation behavior', () => {
+    it('marks response as truncated when text exceeds 100K chars', async () => {
+      // This test documents the truncation behavior
+      // The response should include truncated flag when content is cut
+
+      const maxChars = 100_000;
+      const responseWithTruncation = {
+        truncated: true,
+        totalChars: 150_000,
+        text: 'x'.repeat(maxChars),
+      };
+
+      expect(responseWithTruncation.truncated).toBe(true);
+      expect(responseWithTruncation.totalChars).toBeGreaterThan(responseWithTruncation.text.length);
+    });
+  });
+
+  describe('Null byte stripping', () => {
+    it('removes null bytes from extracted text', async () => {
+      // PDFs sometimes contain null bytes in text streams
+      // The API should strip these before returning
+      // This is documented in the code: text.replace(/\u0000/g, '')
+
+      const textWithNulls = 'Hello\u0000World\u0000Test';
+      const cleaned = textWithNulls.replace(/\u0000/g, '');
+      expect(cleaned).toBe('HelloWorldTest');
+    });
+  });
+});

package/_standalone/__tests__/api/test-key.test.ts

@@ -99,16 +99,16 @@ describe('POST /api/settings/test-key', () => {
     expect(body.code).toBe('auth_error');
   });
 
-  it('classifies model not found errors', async () => {
+  it('classifies endpoint mismatch errors separately from missing models', async () => {
     (complete as ReturnType<typeof vi.fn>).mockRejectedValueOnce(
-      new Error('404 Model not found: nonexistent-model does not exist'),
+      new Error('404 page not found'),
     );
 
     const res = await POST(makeReq({ provider: 'anthropic', apiKey: 'sk-test', model: 'nonexistent-model' }));
     const body = await res.json();
 
     expect(body.ok).toBe(false);
-    expect(body.code).toBe('model_not_found');
+    expect(body.code).toBe('endpoint_error');
   });
 
   it('classifies rate limit errors', async () => {
@@ -160,4 +160,16 @@ describe('POST /api/settings/test-key', () => {
       apiKey: 'AI-key-test',
     }));
   });
+
+  it('classifies explicit model missing errors as model_not_found', async () => {
+    (complete as ReturnType<typeof vi.fn>).mockRejectedValueOnce(
+      new Error('Model not found: nonexistent-model does not exist'),
+    );
+
+    const res = await POST(makeReq({ provider: 'anthropic', apiKey: 'sk-test', model: 'nonexistent-model' }));
+    const body = await res.json();
+
+    expect(body.ok).toBe(false);
+    expect(body.code).toBe('model_not_found');
+  });
 });

package/_standalone/__tests__/channel-mgmt.test.js

@@ -0,0 +1,11 @@
+import { describe, it } from 'vitest';
+
+/**
+ * Placeholder suite from the earlier autonomous spike.
+ * The real regression coverage is now being added incrementally around
+ * the shipped route and CLI config layers. Keep this suite explicitly
+ * skipped so it does not create false-negative signal in `vitest run`.
+ */
+describe.skip('channel management placeholder suite', () => {
+  it('will be replaced by targeted route and CLI regression tests', () => {});
+});

package/_standalone/__tests__/components/breadcrumb-header-ux.test.ts

@@ -0,0 +1,14 @@
+import { describe, expect, it } from 'vitest';
+import fs from 'node:fs';
+import path from 'node:path';
+
+describe('Breadcrumb header UX', () => {
+  it('keeps breadcrumb on a single row and truncates long labels', () => {
+    const filePath = path.resolve(process.cwd(), 'components/Breadcrumb.tsx');
+    const source = fs.readFileSync(filePath, 'utf8');
+
+    expect(source).toContain('flex-nowrap overflow-hidden');
+    expect(source).toContain('truncate max-w-[180px] sm:max-w-[260px] md:max-w-[360px]');
+    expect(source).not.toContain('flex-wrap');
+  });
+});

package/_standalone/__tests__/components/header-toc-vertical-alignment.test.ts

@@ -0,0 +1,23 @@
+import { describe, expect, it } from 'vitest';
+import fs from 'node:fs';
+import path from 'node:path';
+
+describe('Page header and TOC vertical alignment', () => {
+  it('TOC toggle button top aligns with header height (46px)', () => {
+    const filePath = path.resolve(process.cwd(), 'components/TableOfContents.tsx');
+    const source = fs.readFileSync(filePath, 'utf8');
+
+    expect(source).toContain('const TOPBAR_H = 46;');
+    expect(source).toContain('top-[46px]');
+    expect(source).not.toContain('top-[52px]');
+    expect(source).not.toContain('top-[50px]');
+  });
+
+  it('FindInPage sticky top aligns with header height on desktop', () => {
+    const filePath = path.resolve(process.cwd(), 'components/FindInPage.tsx');
+    const source = fs.readFileSync(filePath, 'utf8');
+
+    expect(source).toContain('md:top-[46px]');
+    expect(source).not.toContain('md:top-[44px]');
+  });
+});

package/_standalone/__tests__/components/table-of-contents-header-layout.test.ts

@@ -0,0 +1,15 @@
+import { describe, expect, it } from 'vitest';
+import fs from 'node:fs';
+import path from 'node:path';
+
+describe('TableOfContents header layout', () => {
+  it('uses a dedicated compact header row instead of a large blank top gutter', () => {
+    const filePath = path.resolve(process.cwd(), 'components/TableOfContents.tsx');
+    const source = fs.readFileSync(filePath, 'utf8');
+
+    expect(source).toContain('const TOPBAR_H = 46;');
+    expect(source).toContain('className="flex items-center h-[46px] px-4 border-l border-b border-border"');
+    expect(source).toContain('className="flex flex-col gap-0.5 overflow-y-auto min-h-0 flex-1 pt-3 pb-5 pl-2 pr-3 border-l border-border"');
+    expect(source).not.toContain('py-5 pl-2 pr-3 border-l border-border');
+  });
+});

package/_standalone/__tests__/components/view-page-header-layout.test.ts

@@ -0,0 +1,13 @@
+import { describe, expect, it } from 'vitest';
+import fs from 'node:fs';
+import path from 'node:path';
+
+describe('ViewPageClient header layout', () => {
+  it('uses a full-width header row instead of centering actions inside content-width', () => {
+    const filePath = path.resolve(process.cwd(), 'app/view/[...path]/ViewPageClient.tsx');
+    const source = fs.readFileSync(filePath, 'utf8');
+
+    expect(source).toContain('className="w-full min-w-0 flex items-center justify-between gap-3 h-full"');
+    expect(source).not.toContain('className="content-width flex items-center justify-between gap-2 h-full"');
+  });
+});

package/_standalone/__tests__/components/view-page-header-scroll-stability.test.ts

@@ -0,0 +1,34 @@
+import { describe, expect, it } from 'vitest';
+import fs from 'node:fs';
+import path from 'node:path';
+
+describe('ViewPageClient header scroll stability', () => {
+  it('does not duplicate right-side panel compensation already applied by main-content', () => {
+    const filePath = path.resolve(process.cwd(), 'app/view/[...path]/ViewPageClient.tsx');
+    const source = fs.readFileSync(filePath, 'utf8');
+
+    // #main-content already compensates for Ask panel / agent detail / TOC.
+    // Header must not apply a second right-padding, or breadcrumb/actions get squeezed.
+    expect(source).not.toContain('var(--right-panel-width, 0px)');
+    expect(source).not.toContain('var(--right-agent-detail-width, 0px)');
+  });
+
+  it('does not depend on TOC width or any inline Header right padding', () => {
+    const filePath = path.resolve(process.cwd(), 'app/view/[...path]/ViewPageClient.tsx');
+    const source = fs.readFileSync(filePath, 'utf8');
+
+    // Ensure no hardcoded 1.5rem on header padding right (would defeat CSS var sync)
+    const lines = source.split('\n');
+    const headerLine = lines.find(
+      l => l.includes('sticky') && l.includes('px-4') && l.includes('TopBar') || 
+           l.includes('sticky') && l.includes('px-4') && l.includes('top-[52px]')
+    );
+
+    expect(source).not.toContain('var(--toc-extra-right, 0px)');
+
+    if (headerLine) {
+      expect(headerLine).not.toContain('paddingRight');
+      expect(headerLine).not.toMatch(/paddingRight:\s*['"].*1\.5rem.*['"]|paddingRight:\s*['"].*24px.*['"]/);
+    }
+  });
+});

package/_standalone/__tests__/core/hybrid-search.test.ts

@@ -0,0 +1,109 @@
+import { describe, it, expect, vi, beforeEach } from 'vitest';
+
+// ── Test the cosine similarity math ──
+import { cosineSimilarity } from '@/lib/core/embedding-index';
+
+describe('cosineSimilarity', () => {
+  it('returns 1 for identical vectors', () => {
+    const a = new Float32Array([1, 2, 3]);
+    expect(cosineSimilarity(a, a)).toBeCloseTo(1, 5);
+  });
+
+  it('returns 0 for orthogonal vectors', () => {
+    const a = new Float32Array([1, 0, 0]);
+    const b = new Float32Array([0, 1, 0]);
+    expect(cosineSimilarity(a, b)).toBeCloseTo(0, 5);
+  });
+
+  it('returns close to 1 for similar vectors', () => {
+    const a = new Float32Array([1, 2, 3]);
+    const b = new Float32Array([1.1, 2.1, 3.1]);
+    expect(cosineSimilarity(a, b)).toBeGreaterThan(0.99);
+  });
+
+  it('returns 0 for zero vectors', () => {
+    const a = new Float32Array([0, 0, 0]);
+    const b = new Float32Array([1, 2, 3]);
+    expect(cosineSimilarity(a, b)).toBe(0);
+  });
+
+  it('returns 0 for mismatched dimensions', () => {
+    const a = new Float32Array([1, 2]);
+    const b = new Float32Array([1, 2, 3]);
+    expect(cosineSimilarity(a, b)).toBe(0);
+  });
+
+  it('returns 0 for empty vectors', () => {
+    const a = new Float32Array([]);
+    const b = new Float32Array([]);
+    expect(cosineSimilarity(a, b)).toBe(0);
+  });
+
+  it('clamps result to [0,1]', () => {
+    // Normalized embedding vectors should naturally stay in [0,1]
+    const a = new Float32Array([0.5, 0.5, 0.5]);
+    const b = new Float32Array([0.5, 0.5, 0.5]);
+    const sim = cosineSimilarity(a, b);
+    expect(sim).toBeGreaterThanOrEqual(0);
+    expect(sim).toBeLessThanOrEqual(1);
+  });
+});
+
+// ── Test hybrid search fallback behavior ──
+// We mock the dependencies to test the RRF merge logic and fallback paths
+
+describe('hybridSearch', () => {
+  // Reset modules between tests to clear singleton state
+  beforeEach(() => {
+    vi.resetModules();
+  });
+
+  it('falls back to pure BM25 when embedding is disabled', async () => {
+    // Mock settings to have embedding disabled
+    vi.doMock('@/lib/settings', () => ({
+      readSettings: () => ({
+        ai: { activeProvider: '', providers: [] },
+        embedding: undefined,
+        mindRoot: '/tmp/test-mind',
+      }),
+      effectiveSopRoot: () => '/tmp/test-mind',
+    }));
+
+    // Mock BM25 search
+    vi.doMock('@/lib/core/search', () => ({
+      searchFiles: () => [
+        { path: 'test.md', snippet: 'test content', score: 10, occurrences: 1 },
+      ],
+    }));
+
+    const { hybridSearch } = await import('@/lib/core/hybrid-search');
+    const results = await hybridSearch('/tmp/test-mind', 'test query');
+    expect(results).toHaveLength(1);
+    expect(results[0].path).toBe('test.md');
+  });
+});
+
+describe('EmbeddingIndex', () => {
+  it('can be instantiated without errors', async () => {
+    const { EmbeddingIndex } = await import('@/lib/core/embedding-index');
+    const index = new EmbeddingIndex();
+    expect(index.isReady()).toBe(false);
+    expect(index.isBuilding()).toBe(false);
+    expect(index.getDocCount()).toBe(0);
+  });
+
+  it('searchByVector returns empty when not ready', async () => {
+    const { EmbeddingIndex } = await import('@/lib/core/embedding-index');
+    const index = new EmbeddingIndex();
+    const results = index.searchByVector(new Float32Array([1, 2, 3]));
+    expect(results).toEqual([]);
+  });
+
+  it('invalidate clears state', async () => {
+    const { EmbeddingIndex } = await import('@/lib/core/embedding-index');
+    const index = new EmbeddingIndex();
+    index.invalidate();
+    expect(index.isReady()).toBe(false);
+    expect(index.getDocCount()).toBe(0);
+  });
+});