nano-brain 2026.3.5 → 2026.3.7

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "nano-brain",
-  "version": "2026.3.5",
+  "version": "2026.3.7",
   "type": "module",
   "bin": {
     "nano-brain": "./bin/cli.js"

package/src/chunker.ts

@@ -141,7 +141,7 @@ export function chunkMarkdown(
 ): MemoryChunk[] {
   const maxChunkSize = options?.maxChunkSize ?? 3600;
   const minChunkSize = options?.minChunkSize ?? 200;
-  const overlap = options?.overlap ?? 540;
+  const overlap = options?.overlap ?? 200;
   const windowSize = 800;
 
   if (content.trim().length === 0) {

package/src/codebase.ts

@@ -22,7 +22,7 @@ import * as fs from 'fs'
 import * as path from 'path'
 import fg from 'fast-glob'
 
-const DEFAULT_MAX_FILE_SIZE = 5 * 1024 * 1024
+const DEFAULT_MAX_FILE_SIZE = 300 * 1024
 const DEFAULT_CODEBASE_MAX_SIZE = 2 * 1024 * 1024 * 1024
 
 const BUILTIN_EXCLUDE_PATTERNS = [
@@ -133,6 +133,27 @@ const BUILTIN_EXCLUDE_PATTERNS = [
   '**/*.sum',
   '**/*.snap',
   '**/docker-data/**',
+
+  // Lock files (zero search value, massive token waste)
+  '**/package-lock.json',
+  '**/yarn.lock',
+  '**/pnpm-lock.yaml',
+  '**/Pipfile.lock',
+  '**/poetry.lock',
+  '**/composer.lock',
+  '**/Gemfile.lock',
+  '**/Cargo.lock',
+  '**/go.sum',
+
+  // Bundled/minified assets (already built, not source)
+  '**/public/vs/**',
+  '**/assets/index-*.js',
+  '**/*.bundle.js',
+  '**/*.chunk.js',
+
+  // i18n/locale data (large, repetitive, low search value)
+  '**/nls.messages.*.js',
+  '**/locales/*.json',
 ]
 
 const PROJECT_TYPE_MARKERS: Record<string, string[]> = {
@@ -310,6 +331,9 @@ export async function indexCodebase(
         }
         continue
       }
+      if (existingDoc) {
+        store.cleanupVectorsForHash(existingDoc.hash)
+      }
       store.insertContent(hash, content)
       const chunks = chunkSourceCode(content, hash, filePath, workspaceRoot)
       chunksCreated += chunks.length
@@ -427,6 +451,7 @@ export async function embedPendingCodebase(
   projectHash?: string
 ): Promise<number> {
   const maxChars = embedder.getMaxChars?.() ?? 6000
+  const vectorStore = store.getVectorStore?.() ?? null
   let embedded = 0
   const failedHashes = new Set<string>()
   while (true) {
@@ -463,12 +488,12 @@ export async function embedPendingCodebase(
       if (embedder.embedBatch && texts.length > 1) {
         const results = await embedder.embedBatch(texts)
         for (let i = 0; i < allChunks.length; i++) {
-          store.insertEmbedding(allChunks[i].hash, allChunks[i].seq, allChunks[i].pos, results[i].embedding, modelName)
+          store.insertEmbedding(allChunks[i].hash, allChunks[i].seq, allChunks[i].pos, results[i].embedding, modelName, vectorStore ?? undefined)
         }
       } else {
         for (let i = 0; i < allChunks.length; i++) {
           const result = await embedder.embed(texts[i])
-          store.insertEmbedding(allChunks[i].hash, allChunks[i].seq, allChunks[i].pos, result.embedding, result.model || modelName)
+          store.insertEmbedding(allChunks[i].hash, allChunks[i].seq, allChunks[i].pos, result.embedding, result.model || modelName, vectorStore ?? undefined)
         }
       }
       embedded += batch.length
@@ -479,7 +504,7 @@ export async function embedPendingCodebase(
       for (let i = 0; i < allChunks.length; i++) {
         try {
           const result = await embedder.embed(texts[i])
-          store.insertEmbedding(allChunks[i].hash, allChunks[i].seq, allChunks[i].pos, result.embedding, result.model || modelName)
+          store.insertEmbedding(allChunks[i].hash, allChunks[i].seq, allChunks[i].pos, result.embedding, result.model || modelName, vectorStore ?? undefined)
           succeededHashes.add(allChunks[i].hash)
         } catch {
           console.warn(`[embed] Skipping chunk ${allChunks[i].hash}:${allChunks[i].seq}`)

package/src/server.ts

@@ -1147,13 +1147,33 @@ export async function startServer(options: ServerOptions): Promise<void> {
   const store = createStore(effectiveDbPath);
   const symbolGraphDb = new Database(effectiveDbPath);
   
+  const validateInterval = (value: number | undefined, name: string, defaultVal: number): number => {
+    if (value === undefined) return defaultVal;
+    if (value <= 0 || value > 3600) {
+      console.error(`[memory] Warning: intervals.${name}=${value} invalid (must be 1-3600), using default ${defaultVal}`);
+      return defaultVal;
+    }
+    return value;
+  };
+  const validatedIntervals = config?.intervals ? {
+    embed: validateInterval(config.intervals.embed, 'embed', 60),
+    sessionPoll: validateInterval(config.intervals.sessionPoll, 'sessionPoll', 120),
+    reindexPoll: validateInterval(config.intervals.reindexPoll, 'reindexPoll', 120),
+  } : undefined;
+  
   let vectorStore: VectorStore | null = null;
+  const configuredDimensions = config?.vector?.dimensions;
   if (config?.vector?.provider === 'qdrant') {
     try {
       vectorStore = createVectorStore(config.vector);
       vectorStore.health().then((health) => {
         log('server', 'vector provider=' + health.provider + ' ok=' + health.ok + ' vectors=' + health.vectorCount);
         console.error(`[memory] Vector store: ${health.provider} (ok=${health.ok}, vectors=${health.vectorCount})`);
+        if (health.dimensions && configuredDimensions && health.dimensions !== configuredDimensions) {
+          console.error(`[memory] FATAL: Vector dimension mismatch! Configured=${configuredDimensions}, Qdrant collection=${health.dimensions}`);
+          console.error(`[memory] Either update config.yml vector.dimensions or recreate the Qdrant collection.`);
+          process.exit(1);
+        }
       }).catch((err) => {
         log('server', 'vector health check failed error=' + (err instanceof Error ? err.message : String(err)));
         console.error(`[memory] Vector store health check failed:`, err);
@@ -1215,9 +1235,9 @@ export async function startServer(options: ServerOptions): Promise<void> {
       collections,
       embedder: providers.embedder,
       debounceMs: watcherConfig?.debounceMs ?? 2000,
-      pollIntervalMs: watcherConfig?.pollIntervalMs ?? 120000,
-      sessionPollMs: watcherConfig?.sessionPollMs ?? 120000,
-      embedIntervalMs: watcherConfig?.embedIntervalMs ?? 60000,
+      pollIntervalMs: validatedIntervals?.reindexPoll ? validatedIntervals.reindexPoll * 1000 : (watcherConfig?.pollIntervalMs ?? 120000),
+      sessionPollMs: validatedIntervals?.sessionPoll ? validatedIntervals.sessionPoll * 1000 : (watcherConfig?.sessionPollMs ?? 120000),
+      embedIntervalMs: validatedIntervals?.embed ? validatedIntervals.embed * 1000 : (watcherConfig?.embedIntervalMs ?? 60000),
       sessionStorageDir: path.join(homeDir, '.local/share/opencode/storage'),
       outputDir: path.join(outputDir, 'sessions'),
       storageConfig,

package/src/store.ts

@@ -1,7 +1,8 @@
 import Database from 'better-sqlite3';
 import * as sqliteVec from 'sqlite-vec';
 import type { Store, Document, SearchResult, IndexHealth, StoreSearchOptions } from './types.js';
-import type { VectorStore } from './vector-store.js';
+import type { VectorStore, VectorPoint } from './vector-store.js';
+import { SqliteVecStore } from './providers/sqlite-vec.js';
 import * as fs from 'fs';
 import * as path from 'path';
 import * as crypto from 'crypto';
@@ -135,6 +136,8 @@ export function createStore(dbPath: string): Store {
     );
     CREATE INDEX IF NOT EXISTS idx_symbols_type_pattern ON symbols(type, pattern);
     CREATE INDEX IF NOT EXISTS idx_symbols_repo ON symbols(repo);
+    CREATE INDEX IF NOT EXISTS idx_symbols_file_project ON symbols(file_path, project_hash);
+    CREATE INDEX IF NOT EXISTS idx_documents_modified ON documents(modified_at) WHERE active = 1;
 
     CREATE TABLE IF NOT EXISTS code_symbols (
       id INTEGER PRIMARY KEY AUTOINCREMENT,
@@ -286,10 +289,7 @@ export function createStore(dbPath: string): Store {
     UPDATE documents SET active = 0 WHERE collection = ? AND path = ?
   `);
   
-  const bulkDeactivateExceptStmt = db.prepare(`
-    UPDATE documents SET active = 0 
-    WHERE collection = ? AND path NOT IN (SELECT value FROM json_each(?))
-  `);
+
   
   const searchFTSStmt = db.prepare(`
     SELECT 
@@ -378,6 +378,7 @@ export function createStore(dbPath: string): Store {
     JOIN documents d ON d.hash = c.hash AND d.active = 1
     LEFT JOIN content_vectors cv ON cv.hash = c.hash
     WHERE cv.hash IS NULL
+    LIMIT ?
   `);
 
   const getHashesNeedingEmbeddingByWorkspaceStmt = db.prepare(`
@@ -386,6 +387,7 @@ export function createStore(dbPath: string): Store {
     JOIN documents d ON d.hash = c.hash AND d.active = 1
     LEFT JOIN content_vectors cv ON cv.hash = c.hash
     WHERE cv.hash IS NULL AND d.project_hash IN (?, 'global')
+    LIMIT ?
   `);
   const getNextHashNeedingEmbeddingStmt = db.prepare(`
     SELECT c.hash, c.body, d.path
@@ -515,30 +517,67 @@ export function createStore(dbPath: string): Store {
     },
     
     bulkDeactivateExcept(collection: string, activePaths: string[]): number {
-      const result = bulkDeactivateExceptStmt.run(collection, JSON.stringify(activePaths));
+      const beforeHashes = new Set<string>();
+      if (vectorStore) {
+        const rows = db.prepare('SELECT DISTINCT hash FROM documents WHERE collection = ? AND active = 1').all(collection) as Array<{ hash: string }>;
+        for (const r of rows) beforeHashes.add(r.hash);
+      }
+      
+      db.exec('CREATE TEMP TABLE IF NOT EXISTS _active_paths(path TEXT PRIMARY KEY)');
+      db.exec('DELETE FROM _active_paths');
+      const insertPath = db.prepare('INSERT OR IGNORE INTO _active_paths(path) VALUES(?)');
+      const insertMany = db.transaction((paths: string[]) => {
+        for (const p of paths) insertPath.run(p);
+      });
+      insertMany(activePaths);
+      const updateStmt = db.prepare('UPDATE documents SET active = 0 WHERE collection = ? AND path NOT IN (SELECT path FROM _active_paths)');
+      const result = updateStmt.run(collection);
+      db.exec('DROP TABLE IF EXISTS _active_paths');
+      
+      if (vectorStore && beforeHashes.size > 0) {
+        const afterRows = db.prepare('SELECT DISTINCT hash FROM documents WHERE collection = ? AND active = 1').all(collection) as Array<{ hash: string }>;
+        const afterHashes = new Set(afterRows.map(r => r.hash));
+        for (const hash of beforeHashes) {
+          if (!afterHashes.has(hash)) {
+            vectorStore.deleteByHash(hash).catch(err => {
+              log('store', 'bulkDeactivateExcept vector cleanup failed hash=' + hash.substring(0, 8));
+              console.warn('[store] Failed to cleanup vector:', err);
+            });
+          }
+        }
+      }
+      
       return result.changes;
     },
     
-    insertEmbedding(hash: string, seq: number, pos: number, embedding: number[], model: string) {
+    insertEmbedding(hash: string, seq: number, pos: number, embedding: number[], model: string, externalVectorStore?: VectorStore) {
       log('store', 'insertEmbedding hash=' + hash.substring(0, 8) + ' seq=' + seq);
       insertEmbeddingStmt.run(hash, seq, pos, model);
       
-      if (vecAvailable) {
+      const useExternalStore = externalVectorStore && !(externalVectorStore instanceof SqliteVecStore);
+      
+      if (useExternalStore) {
+        const point: VectorPoint = {
+          id: `${hash}:${seq}`,
+          embedding,
+          metadata: { hash, seq, pos, model },
+        };
+        externalVectorStore.upsert(point).catch((err) => {
+          log('store', 'insertEmbedding external vector store upsert failed hash=' + hash.substring(0, 8));
+          console.warn(`[store] External vector store upsert failed for ${hash.substring(0, 8)}:${seq}, will retry on next embedding cycle:`, err);
+        });
+      } else if (vecAvailable) {
         try {
           const hashSeq = `${hash}:${seq}`;
-          // sqlite-vec virtual tables don't support INSERT OR REPLACE,
-          // so delete first then insert to handle re-embedding
           try {
             db.prepare(`DELETE FROM vectors_vec WHERE hash_seq = ?`).run(hashSeq);
           } catch {
-            // Ignore if row doesn't exist
           }
           const insertVecStmt = db.prepare(`
             INSERT INTO vectors_vec (hash_seq, embedding) VALUES (?, ?)
           `);
           insertVecStmt.run(hashSeq, new Float32Array(embedding));
         } catch (err) {
-          // Silently ignore duplicate key errors (vector already exists)
           const msg = err instanceof Error ? err.message : String(err);
           if (!msg.includes('UNIQUE constraint')) {
             log('store', 'insertEmbedding vector insert failed hash=' + hash.substring(0, 8));
@@ -733,6 +772,19 @@ export function createStore(dbPath: string): Store {
       vectorStore = vs;
     },
     
+    getVectorStore(): VectorStore | null {
+      return vectorStore;
+    },
+    
+    cleanupVectorsForHash(hash: string): void {
+      if (vectorStore) {
+        vectorStore.deleteByHash(hash).catch(err => {
+          log('store', 'cleanupVectorsForHash failed hash=' + hash.substring(0, 8));
+          console.warn('[store] Failed to cleanup vectors for hash:', err);
+        });
+      }
+    },
+    
     async searchVecAsync(query: string, embedding: number[], options: StoreSearchOptions = {}): Promise<SearchResult[]> {
       const { limit = 10, collection, projectHash, tags, since, until } = options;
       
@@ -828,7 +880,7 @@ export function createStore(dbPath: string): Store {
       const docCount = (getDocumentCountStmt.get() as { count: number }).count;
       const embeddedCount = (getEmbeddedCountStmt.get() as { count: number }).count;
       const collections = getCollectionStatsStmt.all() as Array<{ name: string; documentCount: number; path: string }>;
-      const pending = (getHashesNeedingEmbeddingStmt.all() as unknown[]).length;
+      const pending = (getHashesNeedingEmbeddingStmt.all(1000000) as unknown[]).length;
       const workspaceStats = this.getWorkspaceStats();
       
       let dbSize = 0;
@@ -850,11 +902,12 @@ export function createStore(dbPath: string): Store {
       };
     },
     
-    getHashesNeedingEmbedding(projectHash?: string): Array<{ hash: string; body: string; path: string }> {
+    getHashesNeedingEmbedding(projectHash?: string, limit?: number): Array<{ hash: string; body: string; path: string }> {
+      const effectiveLimit = limit ?? 1000000;
       if (projectHash && projectHash !== 'all') {
-        return getHashesNeedingEmbeddingByWorkspaceStmt.all(projectHash) as Array<{ hash: string; body: string; path: string }>;
+        return getHashesNeedingEmbeddingByWorkspaceStmt.all(projectHash, effectiveLimit) as Array<{ hash: string; body: string; path: string }>;
       }
-      return getHashesNeedingEmbeddingStmt.all() as Array<{ hash: string; body: string; path: string }>;
+      return getHashesNeedingEmbeddingStmt.all(effectiveLimit) as Array<{ hash: string; body: string; path: string }>;
     },
 
     getNextHashNeedingEmbedding(projectHash?: string): { hash: string; body: string; path: string } | null {
@@ -928,6 +981,13 @@ export function createStore(dbPath: string): Store {
     cleanOrphanedEmbeddings(): number {
       let totalDeleted = 0;
       
+      let orphanedHashes: string[] = [];
+      if (vectorStore) {
+        orphanedHashes = (db.prepare(`
+          SELECT DISTINCT hash FROM content_vectors WHERE hash NOT IN (SELECT DISTINCT hash FROM documents WHERE active = 1)
+        `).all() as Array<{ hash: string }>).map(r => r.hash);
+      }
+      
       const deleteContentVectorsStmt = db.prepare(`
         DELETE FROM content_vectors WHERE hash NOT IN (SELECT DISTINCT hash FROM documents WHERE active = 1)
       `);
@@ -945,6 +1005,16 @@ export function createStore(dbPath: string): Store {
         }
       }
       
+      if (vectorStore && orphanedHashes.length > 0) {
+        for (const hash of orphanedHashes) {
+          vectorStore.deleteByHash(hash).catch(err => {
+            log('store', 'cleanOrphanedEmbeddings vector cleanup failed hash=' + hash.substring(0, 8));
+            console.warn('[store] Failed to cleanup orphaned vector:', err);
+          });
+        }
+        log('store', 'cleanOrphanedEmbeddings queued ' + orphanedHashes.length + ' vector store deletes');
+      }
+      
       log('store', 'cleanOrphanedEmbeddings deleted=' + totalDeleted);
       return totalDeleted;
     },
@@ -1269,6 +1339,10 @@ export function indexDocument(
     return { hash, chunks: 0, skipped: true };
   }
   
+  if (existingDoc && existingDoc.hash !== hash) {
+    store.cleanupVectorsForHash(existingDoc.hash);
+  }
+  
   store.insertContent(hash, content);
   
   const chunks = chunkMarkdown(content, hash);

package/src/types.ts

@@ -85,6 +85,11 @@ export interface CollectionConfig {
     collection?: string
     dimensions?: number
   }
+  intervals?: {
+    embed?: number
+    sessionPoll?: number
+    reindexPoll?: number
+  }
 }
 
 export interface CodebaseConfig {
@@ -255,13 +260,14 @@ export interface Store {
   
   insertContent(hash: string, body: string): void;
   
-  insertEmbedding(hash: string, seq: number, pos: number, embedding: number[], model: string): void;
+  insertEmbedding(hash: string, seq: number, pos: number, embedding: number[], model: string, vectorStore?: import('./vector-store.js').VectorStore): void;
   ensureVecTable(dimensions: number): void;
   
   searchFTS(query: string, options?: StoreSearchOptions): SearchResult[];
   searchVec(query: string, embedding: number[], options?: StoreSearchOptions): SearchResult[];
   searchVecAsync(query: string, embedding: number[], options?: StoreSearchOptions): Promise<SearchResult[]>;
   setVectorStore(vs: import('./vector-store.js').VectorStore): void;
+  getVectorStore(): import('./vector-store.js').VectorStore | null;
   
   getCachedResult(hash: string, projectHash?: string): string | null;
   setCachedResult(hash: string, result: string, projectHash?: string, type?: string): void;
@@ -273,7 +279,7 @@ export interface Store {
   clearQueryEmbeddingCache(): void;
   
   getIndexHealth(): IndexHealth;
-  getHashesNeedingEmbedding(projectHash?: string): Array<{ hash: string; body: string; path: string }>;
+  getHashesNeedingEmbedding(projectHash?: string, limit?: number): Array<{ hash: string; body: string; path: string }>;
   getNextHashNeedingEmbedding(projectHash?: string): { hash: string; body: string; path: string } | null;
   getWorkspaceStats(): Array<{ projectHash: string; count: number }>;
   
@@ -347,4 +353,6 @@ export interface Store {
     filePath: string;
     lineNumber: number;
   }>;
+
+  cleanupVectorsForHash(hash: string): void;
 }

package/src/watcher.ts

@@ -76,8 +76,11 @@ export function startWatcher(options: WatcherOptions): Watcher {
   let watcher: FSWatcher | null = null;
   let harvestCycleCount = 0;
   const watchedPaths = new Set<string>();
-  let embeddingInterval: NodeJS.Timeout | null = null;
+  let embeddingTimeout: NodeJS.Timeout | null = null;
   let isEmbedding = false;
+  let consecutiveEmptyCycles = 0;
+  let consecutiveFailures = 0;
+  let currentEmbedInterval = embedIntervalMs;
 
   const handleFileChange = (filePath: string) => {
     if (stopped) return
@@ -296,21 +299,42 @@ export function startWatcher(options: WatcherOptions): Watcher {
     }, sessionPollMs);
 
     if (embedder) {
-      embeddingInterval = setInterval(async () => {
-        if (stopped || isEmbedding) return;
-        isEmbedding = true;
-        try {
-          const count = await embedPendingCodebase(store, embedder, 50, projectHash);
-          if (count > 0) {
-            log('watcher', 'Embedding cycle: ' + count + ' document(s) embedded')
-            console.log(`[embed] Embedded ${count} document(s)`);
+      const scheduleNextEmbedCycle = () => {
+        if (stopped) return;
+        embeddingTimeout = setTimeout(async () => {
+          if (stopped || isEmbedding) {
+            scheduleNextEmbedCycle();
+            return;
           }
-        } catch (err) {
-          console.warn('[embed] Embedding cycle failed:', err);
-        } finally {
-          isEmbedding = false;
-        }
-      }, embedIntervalMs);
+          isEmbedding = true;
+          try {
+            const count = await embedPendingCodebase(store, embedder, 50, projectHash);
+            if (count > 0) {
+              log('watcher', 'Embedding cycle: ' + count + ' document(s) embedded')
+              console.log(`[embed] Embedded ${count} document(s)`);
+              consecutiveEmptyCycles = 0;
+              currentEmbedInterval = embedIntervalMs;
+            } else {
+              consecutiveEmptyCycles++;
+              if (consecutiveEmptyCycles >= 3) {
+                currentEmbedInterval = Math.min(currentEmbedInterval * 1.5, 300000);
+              }
+            }
+            consecutiveFailures = 0;
+          } catch (err) {
+            consecutiveFailures++;
+            if (consecutiveFailures >= 5) {
+              console.warn(`[embed] WARNING: ${consecutiveFailures} consecutive embedding failures. Check embedding provider configuration. Last error:`, err);
+            } else {
+              console.warn('[embed] Embedding cycle failed:', err);
+            }
+          } finally {
+            isEmbedding = false;
+            scheduleNextEmbedCycle();
+          }
+        }, currentEmbedInterval);
+      };
+      scheduleNextEmbedCycle();
     }
   };
 
@@ -355,9 +379,9 @@ export function startWatcher(options: WatcherOptions): Watcher {
         sessionPollInterval = null;
       }
 
-      if (embeddingInterval) {
-        clearInterval(embeddingInterval);
-        embeddingInterval = null;
+      if (embeddingTimeout) {
+        clearTimeout(embeddingTimeout);
+        embeddingTimeout = null;
       }
       
       if (watcher) {

package/test/store.test.ts

@@ -1,4 +1,4 @@
-import { describe, it, expect, beforeEach, afterEach } from 'vitest';
+import { describe, it, expect, beforeEach, afterEach, vi } from 'vitest';
 import { createStore, computeHash, indexDocument, extractProjectHashFromPath } from '../src/store.js';
 import type { Store } from '../src/types.js';
 import Database from 'better-sqlite3';
@@ -867,4 +867,309 @@ describe('Store', () => {
     });
   });
 
+  describe('Qdrant migration features', () => {
+    describe('getVectorStore/setVectorStore', () => {
+      it('should return null when no vector store is set', () => {
+        expect(store.getVectorStore()).toBeNull();
+      });
+
+      it('should set and get vector store correctly', () => {
+        const mockVectorStore = {
+          upsert: async () => {},
+          batchUpsert: async () => {},
+          search: async () => [],
+          delete: async () => {},
+          deleteByHash: async () => {},
+          health: async () => ({ ok: true, provider: 'mock', vectorCount: 0 }),
+          close: async () => {},
+        };
+        store.setVectorStore(mockVectorStore as unknown as import('../src/vector-store.js').VectorStore);
+        expect(store.getVectorStore()).toBe(mockVectorStore);
+      });
+    });
+
+    describe('insertEmbedding with external vector store', () => {
+      it('should route to external vector store when non-SqliteVecStore is provided', async () => {
+        const body = '# Test Content';
+        const hash = computeHash(body);
+        store.insertContent(hash, body);
+        store.insertDocument({
+          collection: 'test',
+          path: 'test/doc.md',
+          title: 'Test',
+          hash,
+          createdAt: new Date().toISOString(),
+          modifiedAt: new Date().toISOString(),
+          active: true,
+        });
+
+        const mockVectorStore = {
+          upsert: vi.fn().mockResolvedValue(undefined),
+          batchUpsert: vi.fn().mockResolvedValue(undefined),
+          search: vi.fn().mockResolvedValue([]),
+          delete: vi.fn().mockResolvedValue(undefined),
+          deleteByHash: vi.fn().mockResolvedValue(undefined),
+          health: vi.fn().mockResolvedValue({ ok: true, provider: 'mock', vectorCount: 0 }),
+          close: vi.fn().mockResolvedValue(undefined),
+        };
+
+        const embedding = new Array(768).fill(0.1);
+        store.insertEmbedding(hash, 0, 0, embedding, 'test-model', mockVectorStore as unknown as import('../src/vector-store.js').VectorStore);
+
+        await vi.waitFor(() => expect(mockVectorStore.upsert).toHaveBeenCalled());
+        expect(mockVectorStore.upsert).toHaveBeenCalledWith({
+          id: `${hash}:0`,
+          embedding,
+          metadata: { hash, seq: 0, pos: 0, model: 'test-model' },
+        });
+      });
+
+      it('should fall back to sqlite-vec when no externalVectorStore is provided', () => {
+        const body = '# Fallback Content';
+        const hash = computeHash(body);
+        store.insertContent(hash, body);
+        store.insertDocument({
+          collection: 'test',
+          path: 'test/fallback.md',
+          title: 'Fallback',
+          hash,
+          createdAt: new Date().toISOString(),
+          modifiedAt: new Date().toISOString(),
+          active: true,
+        });
+
+        const embedding = new Array(768).fill(0.2);
+        store.insertEmbedding(hash, 0, 0, embedding, 'test-model');
+
+        const db = new Database(dbPath);
+        const row = db.prepare('SELECT * FROM content_vectors WHERE hash = ?').get(hash);
+        expect(row).toBeDefined();
+        db.close();
+      });
+
+      it('should always write content_vectors tracking row regardless of vector store', async () => {
+        const body = '# Tracking Test';
+        const hash = computeHash(body);
+        store.insertContent(hash, body);
+        store.insertDocument({
+          collection: 'test',
+          path: 'test/tracking.md',
+          title: 'Tracking',
+          hash,
+          createdAt: new Date().toISOString(),
+          modifiedAt: new Date().toISOString(),
+          active: true,
+        });
+
+        const mockVectorStore = {
+          upsert: vi.fn().mockResolvedValue(undefined),
+          batchUpsert: vi.fn().mockResolvedValue(undefined),
+          search: vi.fn().mockResolvedValue([]),
+          delete: vi.fn().mockResolvedValue(undefined),
+          deleteByHash: vi.fn().mockResolvedValue(undefined),
+          health: vi.fn().mockResolvedValue({ ok: true, provider: 'mock', vectorCount: 0 }),
+          close: vi.fn().mockResolvedValue(undefined),
+        };
+
+        const embedding = new Array(768).fill(0.3);
+        store.insertEmbedding(hash, 0, 0, embedding, 'test-model', mockVectorStore as unknown as import('../src/vector-store.js').VectorStore);
+
+        const db = new Database(dbPath);
+        const row = db.prepare('SELECT * FROM content_vectors WHERE hash = ?').get(hash);
+        expect(row).toBeDefined();
+        db.close();
+      });
+    });
+
+    describe('cleanupVectorsForHash', () => {
+      it('should call vectorStore.deleteByHash fire-and-forget when vectorStore is set', async () => {
+        const mockVectorStore = {
+          upsert: vi.fn().mockResolvedValue(undefined),
+          batchUpsert: vi.fn().mockResolvedValue(undefined),
+          search: vi.fn().mockResolvedValue([]),
+          delete: vi.fn().mockResolvedValue(undefined),
+          deleteByHash: vi.fn().mockResolvedValue(undefined),
+          health: vi.fn().mockResolvedValue({ ok: true, provider: 'mock', vectorCount: 0 }),
+          close: vi.fn().mockResolvedValue(undefined),
+        };
+
+        store.setVectorStore(mockVectorStore as unknown as import('../src/vector-store.js').VectorStore);
+        store.cleanupVectorsForHash('abc123');
+
+        await vi.waitFor(() => expect(mockVectorStore.deleteByHash).toHaveBeenCalled());
+        expect(mockVectorStore.deleteByHash).toHaveBeenCalledWith('abc123');
+      });
+
+      it('should not throw when no vectorStore is set', () => {
+        expect(() => store.cleanupVectorsForHash('abc123')).not.toThrow();
+      });
+    });
+
+    describe('cleanOrphanedEmbeddings with vectorStore', () => {
+      it('should collect orphan hashes before delete and call vectorStore.deleteByHash', async () => {
+        const body = '# Orphan Content';
+        const hash = computeHash(body);
+        store.insertContent(hash, body);
+        const docId = store.insertDocument({
+          collection: 'test',
+          path: 'test/orphan.md',
+          title: 'Orphan',
+          hash,
+          createdAt: new Date().toISOString(),
+          modifiedAt: new Date().toISOString(),
+          active: true,
+        });
+
+        const embedding = new Array(768).fill(0.4);
+        store.insertEmbedding(hash, 0, 0, embedding, 'test-model');
+
+        store.deactivateDocument('test', 'test/orphan.md');
+
+        const mockVectorStore = {
+          upsert: vi.fn().mockResolvedValue(undefined),
+          batchUpsert: vi.fn().mockResolvedValue(undefined),
+          search: vi.fn().mockResolvedValue([]),
+          delete: vi.fn().mockResolvedValue(undefined),
+          deleteByHash: vi.fn().mockResolvedValue(undefined),
+          health: vi.fn().mockResolvedValue({ ok: true, provider: 'mock', vectorCount: 0 }),
+          close: vi.fn().mockResolvedValue(undefined),
+        };
+
+        store.setVectorStore(mockVectorStore as unknown as import('../src/vector-store.js').VectorStore);
+        const deleted = store.cleanOrphanedEmbeddings();
+
+        expect(deleted).toBeGreaterThan(0);
+        await vi.waitFor(() => expect(mockVectorStore.deleteByHash).toHaveBeenCalled());
+        expect(mockVectorStore.deleteByHash).toHaveBeenCalledWith(hash);
+      });
+    });
+
+    describe('bulkDeactivateExcept with vectorStore', () => {
+      it('should compute before/after hash diff and delete orphaned vectors', async () => {
+        const body1 = '# Keep Content';
+        const hash1 = computeHash(body1);
+        store.insertContent(hash1, body1);
+        store.insertDocument({
+          collection: 'bulk-test',
+          path: 'keep.md',
+          title: 'Keep',
+          hash: hash1,
+          createdAt: new Date().toISOString(),
+          modifiedAt: new Date().toISOString(),
+          active: true,
+        });
+
+        const body2 = '# Remove Content';
+        const hash2 = computeHash(body2);
+        store.insertContent(hash2, body2);
+        store.insertDocument({
+          collection: 'bulk-test',
+          path: 'remove.md',
+          title: 'Remove',
+          hash: hash2,
+          createdAt: new Date().toISOString(),
+          modifiedAt: new Date().toISOString(),
+          active: true,
+        });
+
+        const mockVectorStore = {
+          upsert: vi.fn().mockResolvedValue(undefined),
+          batchUpsert: vi.fn().mockResolvedValue(undefined),
+          search: vi.fn().mockResolvedValue([]),
+          delete: vi.fn().mockResolvedValue(undefined),
+          deleteByHash: vi.fn().mockResolvedValue(undefined),
+          health: vi.fn().mockResolvedValue({ ok: true, provider: 'mock', vectorCount: 0 }),
+          close: vi.fn().mockResolvedValue(undefined),
+        };
+
+        store.setVectorStore(mockVectorStore as unknown as import('../src/vector-store.js').VectorStore);
+        const deactivated = store.bulkDeactivateExcept('bulk-test', ['keep.md']);
+
+        expect(deactivated).toBe(1);
+        await vi.waitFor(() => expect(mockVectorStore.deleteByHash).toHaveBeenCalled());
+        expect(mockVectorStore.deleteByHash).toHaveBeenCalledWith(hash2);
+        expect(mockVectorStore.deleteByHash).not.toHaveBeenCalledWith(hash1);
+      });
+    });
+
+    describe('new indexes', () => {
+      it('should create idx_symbols_file_project index after createStore()', () => {
+        const db = new Database(dbPath);
+        const indexes = db.prepare("SELECT name FROM sqlite_master WHERE type='index' AND name='idx_symbols_file_project'").all();
+        expect(indexes.length).toBe(1);
+        db.close();
+      });
+
+      it('should create idx_documents_modified index after createStore()', () => {
+        const db = new Database(dbPath);
+        const indexes = db.prepare("SELECT name FROM sqlite_master WHERE type='index' AND name='idx_documents_modified'").all();
+        expect(indexes.length).toBe(1);
+        db.close();
+      });
+    });
+
+    describe('getHashesNeedingEmbedding', () => {
+      it('should respect LIMIT param', () => {
+        for (let i = 0; i < 5; i++) {
+          const body = `# Content ${i}`;
+          const hash = computeHash(body);
+          store.insertContent(hash, body);
+          store.insertDocument({
+            collection: 'limit-test',
+            path: `doc${i}.md`,
+            title: `Doc ${i}`,
+            hash,
+            createdAt: new Date().toISOString(),
+            modifiedAt: new Date().toISOString(),
+            active: true,
+          });
+        }
+
+        const limited = store.getHashesNeedingEmbedding(undefined, 2);
+        expect(limited.length).toBe(2);
+
+        const all = store.getHashesNeedingEmbedding(undefined, 100);
+        expect(all.length).toBe(5);
+      });
+
+      it('should filter by projectHash when provided', () => {
+        const body1 = '# Project A Content';
+        const hash1 = computeHash(body1);
+        store.insertContent(hash1, body1);
+        store.insertDocument({
+          collection: 'project-test',
+          path: 'a.md',
+          title: 'A',
+          hash: hash1,
+          createdAt: new Date().toISOString(),
+          modifiedAt: new Date().toISOString(),
+          active: true,
+          projectHash: 'project_a',
+        });
+
+        const body2 = '# Project B Content';
+        const hash2 = computeHash(body2);
+        store.insertContent(hash2, body2);
+        store.insertDocument({
+          collection: 'project-test',
+          path: 'b.md',
+          title: 'B',
+          hash: hash2,
+          createdAt: new Date().toISOString(),
+          modifiedAt: new Date().toISOString(),
+          active: true,
+          projectHash: 'project_b',
+        });
+
+        const projectA = store.getHashesNeedingEmbedding('project_a');
+        expect(projectA.length).toBe(1);
+        expect(projectA[0].hash).toBe(hash1);
+
+        const projectB = store.getHashesNeedingEmbedding('project_b');
+        expect(projectB.length).toBe(1);
+        expect(projectB[0].hash).toBe(hash2);
+      });
+    });
+  });
+
 });

package/test/watcher.test.ts

@@ -66,6 +66,15 @@ describe('Watcher', () => {
       insertTags: vi.fn(),
       getDocumentTags: vi.fn().mockReturnValue([]),
       listAllTags: vi.fn().mockReturnValue([]),
+      getVectorStore: vi.fn().mockReturnValue(null),
+      setVectorStore: vi.fn(),
+      cleanupVectorsForHash: vi.fn(),
+      searchVecAsync: vi.fn().mockResolvedValue([]),
+      getFileDependencies: vi.fn().mockReturnValue([]),
+      getFileDependents: vi.fn().mockReturnValue([]),
+      getDocumentCentrality: vi.fn().mockReturnValue(null),
+      getClusterMembers: vi.fn().mockReturnValue([]),
+      getGraphStats: vi.fn().mockReturnValue({ nodeCount: 0, edgeCount: 0, clusterCount: 0, topCentrality: [] }),
     } as unknown as Store;
 
     collections = [
@@ -619,10 +628,10 @@ describe('Watcher', () => {
         embed: vi.fn().mockResolvedValue({ embedding: new Array(768).fill(0.1), model: 'test-model' }),
       };
 
-      // embedPendingCodebase calls getNextHashNeedingEmbedding in a loop
-      vi.mocked(mockStore.getNextHashNeedingEmbedding)
-        .mockReturnValueOnce({ hash: 'abc123', body: 'Content to embed', path: testFile })
-        .mockReturnValue(null);
+      // embedPendingCodebase calls getHashesNeedingEmbedding in a loop
+      vi.mocked(mockStore.getHashesNeedingEmbedding)
+        .mockReturnValueOnce([{ hash: 'abc123', body: 'Content to embed', path: testFile }])
+        .mockReturnValue([]);
 
       const watcher = startWatcher({
         store: mockStore,
@@ -738,4 +747,290 @@ describe('Watcher', () => {
       watcher.stop();
     });
   });
+
+  describe('adaptive embedding backoff', () => {
+    beforeEach(() => {
+      vi.useFakeTimers();
+    });
+
+    afterEach(() => {
+      vi.useRealTimers();
+    });
+
+    it('should increase embedding interval after 3 consecutive empty cycles (×1.5 multiplier)', async () => {
+      const mockEmbedder = {
+        embed: vi.fn().mockResolvedValue({ embedding: new Array(768).fill(0.1), model: 'test-model' }),
+      };
+
+      vi.mocked(mockStore.getHashesNeedingEmbedding).mockReturnValue([]);
+      vi.mocked(mockStore.getNextHashNeedingEmbedding).mockReturnValue(null);
+
+      const watcher = startWatcher({
+        store: mockStore,
+        collections,
+        embedder: mockEmbedder,
+        embedIntervalMs: 1000,
+      });
+
+      await vi.advanceTimersByTimeAsync(5000);
+      await vi.advanceTimersByTimeAsync(1000);
+      await vi.advanceTimersByTimeAsync(1000);
+      await vi.advanceTimersByTimeAsync(1000);
+      await vi.advanceTimersByTimeAsync(1500);
+
+      watcher.stop();
+    });
+
+    it('should cap interval at 300000ms (5 minutes)', async () => {
+      const mockEmbedder = {
+        embed: vi.fn().mockResolvedValue({ embedding: new Array(768).fill(0.1), model: 'test-model' }),
+      };
+
+      vi.mocked(mockStore.getHashesNeedingEmbedding).mockReturnValue([]);
+      vi.mocked(mockStore.getNextHashNeedingEmbedding).mockReturnValue(null);
+
+      const watcher = startWatcher({
+        store: mockStore,
+        collections,
+        embedder: mockEmbedder,
+        embedIntervalMs: 200000,
+      });
+
+      await vi.advanceTimersByTimeAsync(5000);
+      for (let i = 0; i < 10; i++) {
+        await vi.advanceTimersByTimeAsync(300000);
+      }
+
+      watcher.stop();
+    });
+
+    it('should snap back to base interval when work is detected (count > 0)', async () => {
+      const mockEmbedder = {
+        embed: vi.fn().mockResolvedValue({ embedding: new Array(768).fill(0.1), model: 'test-model' }),
+      };
+
+      vi.mocked(mockStore.getHashesNeedingEmbedding)
+        .mockReturnValueOnce([])
+        .mockReturnValueOnce([])
+        .mockReturnValueOnce([])
+        .mockReturnValueOnce([{ hash: 'abc123', body: 'Content', path: '/test.md' }])
+        .mockReturnValue([]);
+      vi.mocked(mockStore.getNextHashNeedingEmbedding)
+        .mockReturnValueOnce(null)
+        .mockReturnValueOnce(null)
+        .mockReturnValueOnce(null)
+        .mockReturnValueOnce({ hash: 'abc123', body: 'Content', path: '/test.md' })
+        .mockReturnValue(null);
+
+      const watcher = startWatcher({
+        store: mockStore,
+        collections,
+        embedder: mockEmbedder,
+        embedIntervalMs: 1000,
+      });
+
+      await vi.advanceTimersByTimeAsync(5000);
+      await vi.advanceTimersByTimeAsync(1000);
+      await vi.advanceTimersByTimeAsync(1000);
+      await vi.advanceTimersByTimeAsync(1000);
+      await vi.advanceTimersByTimeAsync(1500);
+      await vi.advanceTimersByTimeAsync(1000);
+
+      watcher.stop();
+    });
+
+    it('should reset consecutiveEmptyCycles when work is detected', async () => {
+      const mockEmbedder = {
+        embed: vi.fn().mockResolvedValue({ embedding: new Array(768).fill(0.1), model: 'test-model' }),
+      };
+
+      vi.mocked(mockStore.getHashesNeedingEmbedding)
+        .mockReturnValueOnce([])
+        .mockReturnValueOnce([])
+        .mockReturnValueOnce([{ hash: 'abc123', body: 'Content', path: '/test.md' }])
+        .mockReturnValue([]);
+      vi.mocked(mockStore.getNextHashNeedingEmbedding)
+        .mockReturnValueOnce(null)
+        .mockReturnValueOnce(null)
+        .mockReturnValueOnce({ hash: 'abc123', body: 'Content', path: '/test.md' })
+        .mockReturnValue(null);
+
+      const watcher = startWatcher({
+        store: mockStore,
+        collections,
+        embedder: mockEmbedder,
+        embedIntervalMs: 1000,
+      });
+
+      await vi.advanceTimersByTimeAsync(5000);
+      await vi.advanceTimersByTimeAsync(1000);
+      await vi.advanceTimersByTimeAsync(1000);
+      await vi.advanceTimersByTimeAsync(1000);
+      await vi.advanceTimersByTimeAsync(1000);
+      await vi.advanceTimersByTimeAsync(1000);
+
+      watcher.stop();
+    });
+
+    it('should increment consecutiveFailures on error', async () => {
+      const mockEmbedder = {
+        embed: vi.fn().mockRejectedValue(new Error('Embedding failed')),
+      };
+
+      vi.mocked(mockStore.getHashesNeedingEmbedding).mockReturnValue([
+        { hash: 'abc123', body: 'Content', path: '/test.md' },
+      ]);
+      vi.mocked(mockStore.getNextHashNeedingEmbedding).mockReturnValue({
+        hash: 'abc123',
+        body: 'Content',
+        path: '/test.md',
+      });
+
+      const consoleWarnSpy = vi.spyOn(console, 'warn').mockImplementation(() => {});
+
+      const watcher = startWatcher({
+        store: mockStore,
+        collections,
+        embedder: mockEmbedder,
+        embedIntervalMs: 1000,
+      });
+
+      await vi.advanceTimersByTimeAsync(5000);
+      await vi.advanceTimersByTimeAsync(1000);
+
+      expect(consoleWarnSpy).toHaveBeenCalledWith(
+        expect.stringContaining('[embed]'),
+        expect.any(Error)
+      );
+
+      watcher.stop();
+      consoleWarnSpy.mockRestore();
+    });
+
+    it('should log warning after 5 consecutive failures', async () => {
+      const mockEmbedder = {
+        embed: vi.fn().mockResolvedValue({ embedding: new Array(768).fill(0.1), model: 'test-model' }),
+      };
+
+      vi.mocked(mockStore.getHashesNeedingEmbedding).mockImplementation(() => {
+        throw new Error('Database connection failed');
+      });
+
+      const consoleWarnSpy = vi.spyOn(console, 'warn').mockImplementation(() => {});
+
+      const watcher = startWatcher({
+        store: mockStore,
+        collections,
+        embedder: mockEmbedder,
+        embedIntervalMs: 10,
+      });
+
+      for (let i = 0; i < 60; i++) {
+        await vi.advanceTimersByTimeAsync(10);
+      }
+
+      const warningCalls = consoleWarnSpy.mock.calls.filter(
+        call => typeof call[0] === 'string' && call[0].includes('WARNING') && call[0].includes('consecutive embedding failures')
+      );
+      expect(warningCalls.length).toBeGreaterThan(0);
+
+      watcher.stop();
+      consoleWarnSpy.mockRestore();
+    });
+  });
+
+  describe('embedIntervalMs validation behavior', () => {
+    beforeEach(() => {
+      vi.useFakeTimers();
+    });
+
+    afterEach(() => {
+      vi.useRealTimers();
+    });
+
+    it('should use provided embedIntervalMs when valid', async () => {
+      const mockEmbedder = {
+        embed: vi.fn().mockResolvedValue({ embedding: new Array(768).fill(0.1), model: 'test-model' }),
+      };
+
+      vi.mocked(mockStore.getHashesNeedingEmbedding).mockReturnValue([]);
+      vi.mocked(mockStore.getNextHashNeedingEmbedding).mockReturnValue(null);
+
+      const watcher = startWatcher({
+        store: mockStore,
+        collections,
+        embedder: mockEmbedder,
+        embedIntervalMs: 2000,
+      });
+
+      await vi.advanceTimersByTimeAsync(5000);
+      await vi.advanceTimersByTimeAsync(2000);
+
+      watcher.stop();
+    });
+
+    it('should use default embedIntervalMs (60000) when not provided', async () => {
+      const mockEmbedder = {
+        embed: vi.fn().mockResolvedValue({ embedding: new Array(768).fill(0.1), model: 'test-model' }),
+      };
+
+      vi.mocked(mockStore.getHashesNeedingEmbedding).mockReturnValue([]);
+      vi.mocked(mockStore.getNextHashNeedingEmbedding).mockReturnValue(null);
+
+      const watcher = startWatcher({
+        store: mockStore,
+        collections,
+        embedder: mockEmbedder,
+      });
+
+      await vi.advanceTimersByTimeAsync(5000);
+      await vi.advanceTimersByTimeAsync(60000);
+
+      watcher.stop();
+    });
+
+    it('should handle very small embedIntervalMs values', async () => {
+      const mockEmbedder = {
+        embed: vi.fn().mockResolvedValue({ embedding: new Array(768).fill(0.1), model: 'test-model' }),
+      };
+
+      vi.mocked(mockStore.getHashesNeedingEmbedding).mockReturnValue([]);
+      vi.mocked(mockStore.getNextHashNeedingEmbedding).mockReturnValue(null);
+
+      const watcher = startWatcher({
+        store: mockStore,
+        collections,
+        embedder: mockEmbedder,
+        embedIntervalMs: 100,
+      });
+
+      await vi.advanceTimersByTimeAsync(5000);
+      await vi.advanceTimersByTimeAsync(100);
+      await vi.advanceTimersByTimeAsync(100);
+      await vi.advanceTimersByTimeAsync(100);
+
+      watcher.stop();
+    });
+
+    it('should handle large embedIntervalMs values', async () => {
+      const mockEmbedder = {
+        embed: vi.fn().mockResolvedValue({ embedding: new Array(768).fill(0.1), model: 'test-model' }),
+      };
+
+      vi.mocked(mockStore.getHashesNeedingEmbedding).mockReturnValue([]);
+      vi.mocked(mockStore.getNextHashNeedingEmbedding).mockReturnValue(null);
+
+      const watcher = startWatcher({
+        store: mockStore,
+        collections,
+        embedder: mockEmbedder,
+        embedIntervalMs: 300000,
+      });
+
+      await vi.advanceTimersByTimeAsync(5000);
+      await vi.advanceTimersByTimeAsync(300000);
+
+      watcher.stop();
+    });
+  });
 });