moflo 4.8.21 → 4.8.23

package/bin/index-tests.mjs

@@ -1,710 +1,710 @@
 #!/usr/bin/env node
-/**
- * Index test files into claude-flow memory under the `tests` namespace
- *
- * Extracts from each test file:
- * - File path
- * - Describe/it/test block names (regex-based, no AST)
- * - Import targets (what modules the test imports — key for reverse mapping)
- * - Test framework detected (vitest, jest, mocha, etc.)
- *
- * Chunk types:
- *   test-file:{path}       — Per-file entry with describe blocks, imports, test names
- *   test-map:{source-file}  — Reverse mapping: source file → test files that import it
- *   test-dir:{path}         — Directory summary of test coverage
- *
- * Usage:
- *   node node_modules/moflo/bin/index-tests.mjs                # Incremental
- *   node node_modules/moflo/bin/index-tests.mjs --force        # Full reindex
- *   node node_modules/moflo/bin/index-tests.mjs --verbose      # Detailed logging
- *   node node_modules/moflo/bin/index-tests.mjs --no-embeddings  # Skip embeddings
- *   node node_modules/moflo/bin/index-tests.mjs --stats        # Print stats and exit
- *   npx flo-testmap                                            # Via npx
- */
-
-import { existsSync, readFileSync, writeFileSync, mkdirSync, readdirSync, statSync } from 'fs';
-import { resolve, dirname, relative, basename, extname, join } from 'path';
-import { fileURLToPath } from 'url';
-import { createHash } from 'crypto';
-import { execSync, spawn } from 'child_process';
-import { mofloResolveURL } from './lib/moflo-resolve.mjs';
-const initSqlJs = (await import(mofloResolveURL('sql.js'))).default;
-
-const __dirname = dirname(fileURLToPath(import.meta.url));
-
-function findProjectRoot() {
-  let dir = process.cwd();
-  const root = resolve(dir, '/');
-  while (dir !== root) {
-    if (existsSync(resolve(dir, 'package.json'))) return dir;
-    dir = dirname(dir);
-  }
-  return process.cwd();
-}
-
-const projectRoot = findProjectRoot();
-const NAMESPACE = 'tests';
-const DB_PATH = resolve(projectRoot, '.swarm/memory.db');
-const HASH_CACHE_PATH = resolve(projectRoot, '.swarm/tests-hash.txt');
-
-// Parse args
-const args = process.argv.slice(2);
-const force = args.includes('--force');
-const verbose = args.includes('--verbose') || args.includes('-v');
-const skipEmbeddings = args.includes('--no-embeddings');
-const statsOnly = args.includes('--stats');
-
-function log(msg) { console.log(`[index-tests] ${msg}`); }
-function debug(msg) { if (verbose) console.log(`[index-tests]   ${msg}`); }
-
-// ---------------------------------------------------------------------------
-// Test file patterns
-// ---------------------------------------------------------------------------
-
-const TEST_FILE_PATTERNS = [
-  /\.test\.\w+$/,
-  /\.spec\.\w+$/,
-  /\.test-\w+\.\w+$/,
-];
-
-const TEST_EXTENSIONS = new Set(['.ts', '.tsx', '.js', '.jsx', '.mjs']);
-
-const EXCLUDE_DIRS = new Set([
-  'node_modules', 'dist', 'build', '.next', 'coverage',
-  '.claude', '.swarm', '.claude-flow', '.git',
-]);
-
-// ---------------------------------------------------------------------------
-// Database helpers (same pattern as index-guidance.mjs / generate-code-map.mjs)
-// ---------------------------------------------------------------------------
-
-function ensureDbDir() {
-  const dir = dirname(DB_PATH);
-  if (!existsSync(dir)) mkdirSync(dir, { recursive: true });
-}
-
-async function getDb() {
-  ensureDbDir();
-  const SQL = await initSqlJs();
-  let db;
-  if (existsSync(DB_PATH)) {
-    const buffer = readFileSync(DB_PATH);
-    db = new SQL.Database(buffer);
-  } else {
-    db = new SQL.Database();
-  }
-
-  db.run(`
-    CREATE TABLE IF NOT EXISTS memory_entries (
-      id TEXT PRIMARY KEY,
-      key TEXT NOT NULL,
-      namespace TEXT DEFAULT 'default',
-      content TEXT NOT NULL,
-      type TEXT DEFAULT 'semantic',
-      embedding TEXT,
-      embedding_model TEXT DEFAULT 'local',
-      embedding_dimensions INTEGER,
-      tags TEXT,
-      metadata TEXT,
-      owner_id TEXT,
-      created_at INTEGER NOT NULL DEFAULT (strftime('%s', 'now') * 1000),
-      updated_at INTEGER NOT NULL DEFAULT (strftime('%s', 'now') * 1000),
-      expires_at INTEGER,
-      last_accessed_at INTEGER,
-      access_count INTEGER DEFAULT 0,
-      status TEXT DEFAULT 'active',
-      UNIQUE(namespace, key)
-    )
-  `);
-  db.run(`CREATE INDEX IF NOT EXISTS idx_memory_key_ns ON memory_entries(key, namespace)`);
-  db.run(`CREATE INDEX IF NOT EXISTS idx_memory_namespace ON memory_entries(namespace)`);
-  return db;
-}
-
-function saveDb(db) {
-  const data = db.export();
-  writeFileSync(DB_PATH, Buffer.from(data));
-}
-
-function generateId() {
-  return `mem_${Date.now()}_${Math.random().toString(36).substr(2, 9)}`;
-}
-
-function storeEntry(db, key, content, metadata = {}, tags = []) {
-  const now = Date.now();
-  const id = generateId();
-  db.run(`
-    INSERT OR REPLACE INTO memory_entries
-    (id, key, namespace, content, metadata, tags, created_at, updated_at, status)
-    VALUES (?, ?, ?, ?, ?, ?, ?, ?, 'active')
-  `, [id, key, NAMESPACE, content, JSON.stringify(metadata), JSON.stringify(tags), now, now]);
-}
-
-function deleteNamespace(db) {
-  db.run(`DELETE FROM memory_entries WHERE namespace = ?`, [NAMESPACE]);
-}
-
-function countNamespace(db) {
-  const stmt = db.prepare(`SELECT COUNT(*) as cnt FROM memory_entries WHERE namespace = ?`);
-  stmt.bind([NAMESPACE]);
-  let count = 0;
-  if (stmt.step()) count = stmt.getAsObject().cnt;
-  stmt.free();
-  return count;
-}
-
-// ---------------------------------------------------------------------------
-// Test directory discovery
-// ---------------------------------------------------------------------------
-
-/**
- * Load test directories from moflo.yaml or discover automatically.
- */
-function loadTestDirs() {
-  const yamlPath = resolve(projectRoot, 'moflo.yaml');
-  const jsonPath = resolve(projectRoot, 'moflo.config.json');
-
-  // Try moflo.yaml first
-  if (existsSync(yamlPath)) {
-    try {
-      const content = readFileSync(yamlPath, 'utf-8');
-      const testsBlock = content.match(/tests:\s*\n\s+directories:\s*\n((?:\s+-\s+.+\n?)+)/);
-      if (testsBlock) {
-        const items = testsBlock[1].match(/-\s+(.+)/g);
-        if (items && items.length > 0) {
-          return items.map(item => item.replace(/^-\s+/, '').trim());
-        }
-      }
-    } catch { /* ignore */ }
-  }
-
-  // Try moflo.config.json
-  if (existsSync(jsonPath)) {
-    try {
-      const raw = JSON.parse(readFileSync(jsonPath, 'utf-8'));
-      if (raw.tests?.directories && Array.isArray(raw.tests.directories)) {
-        return raw.tests.directories;
-      }
-    } catch { /* ignore */ }
-  }
-
-  // Auto-discover common test directories
-  return discoverTestDirs();
-}
-
-/**
- * Discover test directories by checking common locations.
- */
-function discoverTestDirs() {
-  const candidates = ['tests', 'test', '__tests__', 'spec', 'e2e'];
-  const found = [];
-
-  for (const dir of candidates) {
-    if (existsSync(resolve(projectRoot, dir))) {
-      found.push(dir);
-    }
-  }
-
-  return found;
-}
-
-// ---------------------------------------------------------------------------
-// Test file enumeration
-// ---------------------------------------------------------------------------
-
-/**
- * Find all test files using git ls-files + pattern matching.
- */
-function getTestFiles() {
-  // Strategy 1: git ls-files for tracked test files
-  let gitFiles = [];
-  try {
-    const raw = execSync(
-      `git ls-files -- "*.test.*" "*.spec.*" "*.test-*"`,
-      { cwd: projectRoot, encoding: 'utf-8', maxBuffer: 10 * 1024 * 1024 }
-    ).trim();
-
-    if (raw) {
-      gitFiles = raw.split('\n').filter(f => {
-        // Skip excluded dirs
-        for (const ex of EXCLUDE_DIRS) {
-          if (f.startsWith(ex + '/') || f.startsWith(ex + '\\')) return false;
-        }
-        // Only include recognized extensions
-        const ext = extname(f);
-        return TEST_EXTENSIONS.has(ext);
-      });
-    }
-  } catch { /* git not available or not a repo */ }
-
-  // Strategy 2: Walk configured test directories for any files
-  const testDirs = loadTestDirs();
-  const walkedFiles = new Set(gitFiles);
-
-  for (const dir of testDirs) {
-    const fullDir = resolve(projectRoot, dir);
-    if (!existsSync(fullDir)) continue;
-    walkTestFiles(fullDir, walkedFiles);
-  }
-
-  return [...walkedFiles].sort();
-}
-
-/**
- * Walk a directory for test files (*.test.*, *.spec.*, or any source file in test dirs).
- */
-function walkTestFiles(dir, results) {
-  if (!existsSync(dir)) return;
-
-  try {
-    for (const entry of readdirSync(dir, { withFileTypes: true })) {
-      if (entry.isDirectory()) {
-        if (!EXCLUDE_DIRS.has(entry.name)) {
-          walkTestFiles(resolve(dir, entry.name), results);
-        }
-      } else if (entry.isFile()) {
-        const ext = extname(entry.name);
-        if (!TEST_EXTENSIONS.has(ext)) continue;
-
-        // Include if it matches test patterns OR if it's inside a test directory
-        const isTestFile = TEST_FILE_PATTERNS.some(p => p.test(entry.name));
-        const isInTestDir = true; // already walking a test dir
-
-        if (isTestFile || isInTestDir) {
-          const relPath = relative(projectRoot, resolve(dir, entry.name)).replace(/\\/g, '/');
-          results.add(relPath);
-        }
-      }
-    }
-  } catch { /* skip unreadable dirs */ }
-}
-
-function computeFileListHash(files) {
-  const sorted = [...files].sort();
-  return createHash('sha256').update(sorted.join('\n')).digest('hex');
-}
-
-function isUnchanged(currentHash) {
-  if (force) return false;
-  if (!existsSync(HASH_CACHE_PATH)) return false;
-  const cached = readFileSync(HASH_CACHE_PATH, 'utf-8').trim();
-  return cached === currentHash;
-}
-
-// ---------------------------------------------------------------------------
-// Test file analysis (regex-based, no AST)
-// ---------------------------------------------------------------------------
-
-/**
- * Detect test framework from import statements.
- */
-function detectFramework(content) {
-  if (/from\s+['"]vitest['"]/.test(content) || /import.*vitest/.test(content)) return 'vitest';
-  if (/from\s+['"]@jest/.test(content) || /from\s+['"]jest['"]/.test(content)) return 'jest';
-  if (/require\s*\(\s*['"]mocha['"]/.test(content)) return 'mocha';
-  if (/from\s+['"]@playwright/.test(content)) return 'playwright';
-  if (/from\s+['"]cypress['"]/.test(content)) return 'cypress';
-  if (/from\s+['"]ava['"]/.test(content)) return 'ava';
-  if (/describe\s*\(/.test(content) || /it\s*\(/.test(content) || /test\s*\(/.test(content)) return 'generic';
-  return 'unknown';
-}
-
-/**
- * Extract describe/it/test block names from test file content.
- */
-function extractTestBlocks(content) {
-  const blocks = [];
-
-  // Match: describe("name", ...) / describe('name', ...) / describe(`name`, ...)
-  const describePattern = /(?:describe|suite)\s*\(\s*(['"`])(.+?)\1/g;
-  let m;
-  while ((m = describePattern.exec(content)) !== null) {
-    blocks.push({ type: 'describe', name: m[2] });
-  }
-
-  // Match: it("name", ...) / test("name", ...) / specify("name", ...)
-  const testPattern = /(?:it|test|specify)\s*\(\s*(['"`])(.+?)\1/g;
-  while ((m = testPattern.exec(content)) !== null) {
-    blocks.push({ type: 'test', name: m[2] });
-  }
-
-  // Match: it.each / test.each (parameterized)
-  const eachPattern = /(?:it|test)\.each[^(]*\(\s*[^)]*\)\s*\(\s*(['"`])(.+?)\1/g;
-  while ((m = eachPattern.exec(content)) !== null) {
-    blocks.push({ type: 'test', name: m[2] + ' (parameterized)' });
-  }
-
-  return blocks;
-}
-
-/**
- * Extract import targets — the source files that this test imports.
- * This is the KEY mechanism for mapping tests to functionality.
- */
-function extractImportTargets(content, filePath) {
-  const imports = [];
-  const fileDir = dirname(filePath);
-
-  // ES module imports: import { X } from '../path'
-  const esImportPattern = /import\s+(?:{[^}]*}|[\w*]+(?:\s*,\s*{[^}]*})?)\s+from\s+['"]([^'"]+)['"]/g;
-  let m;
-  while ((m = esImportPattern.exec(content)) !== null) {
-    const target = m[1];
-    // Only track relative imports (not packages)
-    if (target.startsWith('.') || target.startsWith('/')) {
-      imports.push(resolveImportPath(target, fileDir));
-    }
-  }
-
-  // CJS requires: const X = require('../path')
-  const cjsPattern = /require\s*\(\s*['"]([^'"]+)['"]\s*\)/g;
-  while ((m = cjsPattern.exec(content)) !== null) {
-    const target = m[1];
-    if (target.startsWith('.') || target.startsWith('/')) {
-      imports.push(resolveImportPath(target, fileDir));
-    }
-  }
-
-  // Dynamic imports: await import('../path')
-  const dynamicPattern = /import\s*\(\s*['"]([^'"]+)['"]\s*\)/g;
-  while ((m = dynamicPattern.exec(content)) !== null) {
-    const target = m[1];
-    if (target.startsWith('.') || target.startsWith('/')) {
-      imports.push(resolveImportPath(target, fileDir));
-    }
-  }
-
-  return [...new Set(imports)];
-}
-
-/**
- * Resolve a relative import path to a project-relative path.
- * Strips extensions if present, normalizes to forward slashes.
- */
-function resolveImportPath(importPath, fromDir) {
-  // Resolve relative to the importing file's directory
-  const resolved = resolve(projectRoot, fromDir, importPath).replace(/\\/g, '/');
-  const rel = relative(projectRoot, resolved).replace(/\\/g, '/');
-
-  // Normalize: strip common source extensions (the import may omit them)
-  return rel.replace(/\.(ts|tsx|js|jsx|mjs)$/, '');
-}
-
-// ---------------------------------------------------------------------------
-// Chunk generators
-// ---------------------------------------------------------------------------
-
-/**
- * Generate per-file test entries.
- */
-function generateTestFileEntries(testFiles, analyses) {
-  const chunks = [];
-
-  for (const filePath of testFiles) {
-    const analysis = analyses[filePath];
-    if (!analysis) continue;
-
-    const fileName = basename(filePath);
-    const dir = dirname(filePath);
-
-    let content = `# ${fileName} (${filePath})\n`;
-    content += `Framework: ${analysis.framework}\n`;
-    if (analysis.importTargets.length > 0) {
-      content += `Tests: ${analysis.importTargets.map(t => t + '.*').join(', ')}\n`;
-    }
-    content += '\n';
-
-    // Describe blocks
-    const describes = analysis.blocks.filter(b => b.type === 'describe');
-    if (describes.length > 0) {
-      content += 'Describe blocks:\n';
-      for (const d of describes) {
-        content += `  - ${d.name}\n`;
-      }
-      content += '\n';
-    }
-
-    // Test names
-    const tests = analysis.blocks.filter(b => b.type === 'test');
-    if (tests.length > 0) {
-      content += `Test cases (${tests.length}):\n`;
-      for (const t of tests.slice(0, 30)) { // Cap at 30 to avoid huge entries
-        content += `  - ${t.name}\n`;
-      }
-      if (tests.length > 30) {
-        content += `  ... and ${tests.length - 30} more\n`;
-      }
-      content += '\n';
-    }
-
-    // Import targets
-    if (analysis.importTargets.length > 0) {
-      content += 'Source files under test:\n';
-      for (const imp of analysis.importTargets) {
-        content += `  - ${imp}\n`;
-      }
-    }
-
-    const tags = ['test-file', analysis.framework];
-    if (filePath.includes('e2e') || filePath.includes('E2E')) tags.push('e2e');
-    if (filePath.includes('integration')) tags.push('integration');
-    if (filePath.includes('unit')) tags.push('unit');
-
-    chunks.push({
-      key: `test-file:${filePath}`,
-      content: content.trim(),
-      metadata: {
-        kind: 'test-file',
-        filePath,
-        directory: dir,
-        framework: analysis.framework,
-        describeCount: describes.length,
-        testCount: tests.length,
-        importTargets: analysis.importTargets,
-        describeNames: describes.map(d => d.name),
-      },
-      tags,
-    });
-  }
-
-  return chunks;
-}
-
-/**
- * Generate reverse mapping: source file → test files that import it.
- * This is the primary value — enables "find tests for this file" queries.
- */
-function generateTestMaps(testFiles, analyses) {
-  const chunks = [];
-
-  // Build reverse map: source file → [test files]
-  const reverseMap = {};
-  for (const filePath of testFiles) {
-    const analysis = analyses[filePath];
-    if (!analysis) continue;
-
-    for (const target of analysis.importTargets) {
-      if (!reverseMap[target]) reverseMap[target] = [];
-      reverseMap[target].push({
-        testFile: filePath,
-        framework: analysis.framework,
-        testCount: analysis.blocks.filter(b => b.type === 'test').length,
-      });
-    }
-  }
-
-  // Generate a chunk for each source file that has tests
-  for (const [sourceFile, testEntries] of Object.entries(reverseMap)) {
-    let content = `# Tests for: ${sourceFile}\n\n`;
-    content += `${testEntries.length} test file(s) cover this module:\n\n`;
-
-    for (const entry of testEntries) {
-      content += `  ${entry.testFile} [${entry.framework}, ${entry.testCount} tests]\n`;
-    }
-
-    chunks.push({
-      key: `test-map:${sourceFile}`,
-      content: content.trim(),
-      metadata: {
-        kind: 'test-map',
-        sourceFile,
-        testFiles: testEntries.map(e => e.testFile),
-        totalTests: testEntries.reduce((sum, e) => sum + e.testCount, 0),
-      },
-      tags: ['test-map'],
-    });
-  }
-
-  return chunks;
-}
-
-/**
- * Generate directory summaries showing test coverage per directory.
- */
-function generateTestDirSummaries(testFiles, analyses) {
-  const chunks = [];
-
-  // Group by directory
-  const dirMap = {};
-  for (const filePath of testFiles) {
-    const dir = dirname(filePath);
-    if (!dirMap[dir]) dirMap[dir] = [];
-    dirMap[dir].push(filePath);
-  }
-
-  for (const [dir, files] of Object.entries(dirMap)) {
-    if (files.length < 1) continue;
-
-    const frameworks = new Set();
-    let totalTests = 0;
-    let totalDescribes = 0;
-    const allImports = new Set();
-
-    for (const f of files) {
-      const analysis = analyses[f];
-      if (!analysis) continue;
-      frameworks.add(analysis.framework);
-      totalTests += analysis.blocks.filter(b => b.type === 'test').length;
-      totalDescribes += analysis.blocks.filter(b => b.type === 'describe').length;
-      for (const imp of analysis.importTargets) allImports.add(imp);
-    }
-
-    let content = `# ${dir}/ (${files.length} test files)\n`;
-    content += `Frameworks: ${[...frameworks].join(', ')}\n`;
-    content += `Total: ${totalDescribes} suites, ${totalTests} tests\n\n`;
-    content += 'Files:\n';
-    for (const f of files) {
-      content += `  ${basename(f)}\n`;
-    }
-    if (allImports.size > 0) {
-      content += '\nModules under test:\n';
-      for (const imp of [...allImports].sort().slice(0, 20)) {
-        content += `  ${imp}\n`;
-      }
-      if (allImports.size > 20) {
-        content += `  ... and ${allImports.size - 20} more\n`;
-      }
-    }
-
-    chunks.push({
-      key: `test-dir:${dir}`,
-      content: content.trim(),
-      metadata: {
-        kind: 'test-dir',
-        directory: dir,
-        fileCount: files.length,
-        frameworks: [...frameworks],
-        totalTests,
-        totalDescribes,
-      },
-      tags: ['test-dir'],
-    });
-  }
-
-  return chunks;
-}
-
-// ---------------------------------------------------------------------------
-// Main
-// ---------------------------------------------------------------------------
-
-async function main() {
-  const startTime = Date.now();
-
-  log(`Project root: ${projectRoot}`);
-
-  // 1. Find test files
-  log('Discovering test files...');
-  const testFiles = getTestFiles();
-  log(`Found ${testFiles.length} test files`);
-
-  if (testFiles.length === 0) {
-    log('No test files found — nothing to index');
-    return;
-  }
-
-  // 2. Check hash for incremental skip
-  const currentHash = computeFileListHash(testFiles);
-
-  if (statsOnly) {
-    const db = await getDb();
-    const count = countNamespace(db);
-    db.close();
-    log(`Stats: ${testFiles.length} test files, ${count} chunks in tests namespace`);
-    log(`File list hash: ${currentHash.slice(0, 12)}...`);
-    return;
-  }
-
-  if (isUnchanged(currentHash)) {
-    const db = await getDb();
-    const count = countNamespace(db);
-    db.close();
-    if (count > 0) {
-      log(`Skipping — file list unchanged (${count} chunks in DB, hash ${currentHash.slice(0, 12)}...)`);
-      return;
-    }
-    log('File list unchanged but no chunks in DB — forcing regeneration');
-  }
-
-  // 3. Analyze all test files
-  log('Analyzing test files...');
-  const analyses = {};
-
-  for (const filePath of testFiles) {
-    const fullPath = resolve(projectRoot, filePath);
-    if (!existsSync(fullPath)) continue;
-
-    try {
-      const content = readFileSync(fullPath, 'utf-8');
-      analyses[filePath] = {
-        framework: detectFramework(content),
-        blocks: extractTestBlocks(content),
-        importTargets: extractImportTargets(content, filePath),
-      };
-      debug(`  ${filePath}: ${analyses[filePath].framework}, ${analyses[filePath].blocks.length} blocks, ${analyses[filePath].importTargets.length} imports`);
-    } catch (err) {
-      debug(`  ${filePath}: ERROR - ${err.message}`);
-    }
-  }
-
-  const analyzedCount = Object.keys(analyses).length;
-  log(`Analyzed ${analyzedCount} test files`);
-
-  // 4. Generate all chunk types
-  log('Generating chunks...');
-  const fileChunks = generateTestFileEntries(testFiles, analyses);
-  const mapChunks = generateTestMaps(testFiles, analyses);
-  const dirChunks = generateTestDirSummaries(testFiles, analyses);
-
-  const allChunks = [...fileChunks, ...mapChunks, ...dirChunks];
-
-  log(`Generated ${allChunks.length} chunks:`);
-  log(`  Test file entries:   ${fileChunks.length}`);
-  log(`  Reverse maps:        ${mapChunks.length} (source → test files)`);
-  log(`  Directory summaries: ${dirChunks.length}`);
-
-  // 5. Write to database
-  log('Writing to memory database...');
-  const db = await getDb();
-  deleteNamespace(db);
-
-  for (const chunk of allChunks) {
-    storeEntry(db, chunk.key, chunk.content, chunk.metadata, chunk.tags);
-  }
-
-  saveDb(db);
-  db.close();
-
-  // 6. Save hash for incremental caching
-  writeFileSync(HASH_CACHE_PATH, currentHash, 'utf-8');
-
-  const elapsed = ((Date.now() - startTime) / 1000).toFixed(1);
-  log(`Done in ${elapsed}s — ${allChunks.length} chunks written to tests namespace`);
-
-  // 7. Generate embeddings (inline, like code-map)
-  if (!skipEmbeddings && allChunks.length > 0) {
-    const embedCandidates = [
-      resolve(dirname(fileURLToPath(import.meta.url)), 'build-embeddings.mjs'),
-      resolve(projectRoot, '.claude/scripts/build-embeddings.mjs'),
-    ];
-    const embedScript = embedCandidates.find(p => existsSync(p));
-    if (embedScript) {
-      log('Generating embeddings for tests...');
-      try {
-        execSync(`node "${embedScript}" --namespace tests`, {
-          cwd: projectRoot,
-          stdio: 'inherit',
-          timeout: 120000,
-          windowsHide: true,
-        });
-      } catch (err) {
-        log(`Warning: embedding generation failed: ${err.message?.split('\n')[0]}`);
-      }
-    }
-  }
-}
-
-main().catch(err => {
-  console.error('[index-tests] Fatal error:', err);
-  process.exit(1);
-});
+/**
+ * Index test files into claude-flow memory under the `tests` namespace
+ *
+ * Extracts from each test file:
+ * - File path
+ * - Describe/it/test block names (regex-based, no AST)
+ * - Import targets (what modules the test imports — key for reverse mapping)
+ * - Test framework detected (vitest, jest, mocha, etc.)
+ *
+ * Chunk types:
+ *   test-file:{path}       — Per-file entry with describe blocks, imports, test names
+ *   test-map:{source-file}  — Reverse mapping: source file → test files that import it
+ *   test-dir:{path}         — Directory summary of test coverage
+ *
+ * Usage:
+ *   node node_modules/moflo/bin/index-tests.mjs                # Incremental
+ *   node node_modules/moflo/bin/index-tests.mjs --force        # Full reindex
+ *   node node_modules/moflo/bin/index-tests.mjs --verbose      # Detailed logging
+ *   node node_modules/moflo/bin/index-tests.mjs --no-embeddings  # Skip embeddings
+ *   node node_modules/moflo/bin/index-tests.mjs --stats        # Print stats and exit
+ *   npx flo-testmap                                            # Via npx
+ */
+
+import { existsSync, readFileSync, writeFileSync, mkdirSync, readdirSync, statSync } from 'fs';
+import { resolve, dirname, relative, basename, extname, join } from 'path';
+import { fileURLToPath } from 'url';
+import { createHash } from 'crypto';
+import { execSync, spawn } from 'child_process';
+import { mofloResolveURL } from './lib/moflo-resolve.mjs';
+const initSqlJs = (await import(mofloResolveURL('sql.js'))).default;
+
+const __dirname = dirname(fileURLToPath(import.meta.url));
+
+function findProjectRoot() {
+  let dir = process.cwd();
+  const root = resolve(dir, '/');
+  while (dir !== root) {
+    if (existsSync(resolve(dir, 'package.json'))) return dir;
+    dir = dirname(dir);
+  }
+  return process.cwd();
+}
+
+const projectRoot = findProjectRoot();
+const NAMESPACE = 'tests';
+const DB_PATH = resolve(projectRoot, '.swarm/memory.db');
+const HASH_CACHE_PATH = resolve(projectRoot, '.swarm/tests-hash.txt');
+
+// Parse args
+const args = process.argv.slice(2);
+const force = args.includes('--force');
+const verbose = args.includes('--verbose') || args.includes('-v');
+const skipEmbeddings = args.includes('--no-embeddings');
+const statsOnly = args.includes('--stats');
+
+function log(msg) { console.log(`[index-tests] ${msg}`); }
+function debug(msg) { if (verbose) console.log(`[index-tests]   ${msg}`); }
+
+// ---------------------------------------------------------------------------
+// Test file patterns
+// ---------------------------------------------------------------------------
+
+const TEST_FILE_PATTERNS = [
+  /\.test\.\w+$/,
+  /\.spec\.\w+$/,
+  /\.test-\w+\.\w+$/,
+];
+
+const TEST_EXTENSIONS = new Set(['.ts', '.tsx', '.js', '.jsx', '.mjs']);
+
+const EXCLUDE_DIRS = new Set([
+  'node_modules', 'dist', 'build', '.next', 'coverage',
+  '.claude', '.swarm', '.claude-flow', '.git',
+]);
+
+// ---------------------------------------------------------------------------
+// Database helpers (same pattern as index-guidance.mjs / generate-code-map.mjs)
+// ---------------------------------------------------------------------------
+
+function ensureDbDir() {
+  const dir = dirname(DB_PATH);
+  if (!existsSync(dir)) mkdirSync(dir, { recursive: true });
+}
+
+async function getDb() {
+  ensureDbDir();
+  const SQL = await initSqlJs();
+  let db;
+  if (existsSync(DB_PATH)) {
+    const buffer = readFileSync(DB_PATH);
+    db = new SQL.Database(buffer);
+  } else {
+    db = new SQL.Database();
+  }
+
+  db.run(`
+    CREATE TABLE IF NOT EXISTS memory_entries (
+      id TEXT PRIMARY KEY,
+      key TEXT NOT NULL,
+      namespace TEXT DEFAULT 'default',
+      content TEXT NOT NULL,
+      type TEXT DEFAULT 'semantic',
+      embedding TEXT,
+      embedding_model TEXT DEFAULT 'local',
+      embedding_dimensions INTEGER,
+      tags TEXT,
+      metadata TEXT,
+      owner_id TEXT,
+      created_at INTEGER NOT NULL DEFAULT (strftime('%s', 'now') * 1000),
+      updated_at INTEGER NOT NULL DEFAULT (strftime('%s', 'now') * 1000),
+      expires_at INTEGER,
+      last_accessed_at INTEGER,
+      access_count INTEGER DEFAULT 0,
+      status TEXT DEFAULT 'active',
+      UNIQUE(namespace, key)
+    )
+  `);
+  db.run(`CREATE INDEX IF NOT EXISTS idx_memory_key_ns ON memory_entries(key, namespace)`);
+  db.run(`CREATE INDEX IF NOT EXISTS idx_memory_namespace ON memory_entries(namespace)`);
+  return db;
+}
+
+function saveDb(db) {
+  const data = db.export();
+  writeFileSync(DB_PATH, Buffer.from(data));
+}
+
+function generateId() {
+  return `mem_${Date.now()}_${Math.random().toString(36).substr(2, 9)}`;
+}
+
+function storeEntry(db, key, content, metadata = {}, tags = []) {
+  const now = Date.now();
+  const id = generateId();
+  db.run(`
+    INSERT OR REPLACE INTO memory_entries
+    (id, key, namespace, content, metadata, tags, created_at, updated_at, status)
+    VALUES (?, ?, ?, ?, ?, ?, ?, ?, 'active')
+  `, [id, key, NAMESPACE, content, JSON.stringify(metadata), JSON.stringify(tags), now, now]);
+}
+
+function deleteNamespace(db) {
+  db.run(`DELETE FROM memory_entries WHERE namespace = ?`, [NAMESPACE]);
+}
+
+function countNamespace(db) {
+  const stmt = db.prepare(`SELECT COUNT(*) as cnt FROM memory_entries WHERE namespace = ?`);
+  stmt.bind([NAMESPACE]);
+  let count = 0;
+  if (stmt.step()) count = stmt.getAsObject().cnt;
+  stmt.free();
+  return count;
+}
+
+// ---------------------------------------------------------------------------
+// Test directory discovery
+// ---------------------------------------------------------------------------
+
+/**
+ * Load test directories from moflo.yaml or discover automatically.
+ */
+function loadTestDirs() {
+  const yamlPath = resolve(projectRoot, 'moflo.yaml');
+  const jsonPath = resolve(projectRoot, 'moflo.config.json');
+
+  // Try moflo.yaml first
+  if (existsSync(yamlPath)) {
+    try {
+      const content = readFileSync(yamlPath, 'utf-8');
+      const testsBlock = content.match(/tests:\s*\n\s+directories:\s*\n((?:\s+-\s+.+\n?)+)/);
+      if (testsBlock) {
+        const items = testsBlock[1].match(/-\s+(.+)/g);
+        if (items && items.length > 0) {
+          return items.map(item => item.replace(/^-\s+/, '').trim());
+        }
+      }
+    } catch { /* ignore */ }
+  }
+
+  // Try moflo.config.json
+  if (existsSync(jsonPath)) {
+    try {
+      const raw = JSON.parse(readFileSync(jsonPath, 'utf-8'));
+      if (raw.tests?.directories && Array.isArray(raw.tests.directories)) {
+        return raw.tests.directories;
+      }
+    } catch { /* ignore */ }
+  }
+
+  // Auto-discover common test directories
+  return discoverTestDirs();
+}
+
+/**
+ * Discover test directories by checking common locations.
+ */
+function discoverTestDirs() {
+  const candidates = ['tests', 'test', '__tests__', 'spec', 'e2e'];
+  const found = [];
+
+  for (const dir of candidates) {
+    if (existsSync(resolve(projectRoot, dir))) {
+      found.push(dir);
+    }
+  }
+
+  return found;
+}
+
+// ---------------------------------------------------------------------------
+// Test file enumeration
+// ---------------------------------------------------------------------------
+
+/**
+ * Find all test files using git ls-files + pattern matching.
+ */
+function getTestFiles() {
+  // Strategy 1: git ls-files for tracked test files
+  let gitFiles = [];
+  try {
+    const raw = execSync(
+      `git ls-files -- "*.test.*" "*.spec.*" "*.test-*"`,
+      { cwd: projectRoot, encoding: 'utf-8', maxBuffer: 10 * 1024 * 1024 }
+    ).trim();
+
+    if (raw) {
+      gitFiles = raw.split('\n').filter(f => {
+        // Skip excluded dirs
+        for (const ex of EXCLUDE_DIRS) {
+          if (f.startsWith(ex + '/') || f.startsWith(ex + '\\')) return false;
+        }
+        // Only include recognized extensions
+        const ext = extname(f);
+        return TEST_EXTENSIONS.has(ext);
+      });
+    }
+  } catch { /* git not available or not a repo */ }
+
+  // Strategy 2: Walk configured test directories for any files
+  const testDirs = loadTestDirs();
+  const walkedFiles = new Set(gitFiles);
+
+  for (const dir of testDirs) {
+    const fullDir = resolve(projectRoot, dir);
+    if (!existsSync(fullDir)) continue;
+    walkTestFiles(fullDir, walkedFiles);
+  }
+
+  return [...walkedFiles].sort();
+}
+
+/**
+ * Walk a directory for test files (*.test.*, *.spec.*, or any source file in test dirs).
+ */
+function walkTestFiles(dir, results) {
+  if (!existsSync(dir)) return;
+
+  try {
+    for (const entry of readdirSync(dir, { withFileTypes: true })) {
+      if (entry.isDirectory()) {
+        if (!EXCLUDE_DIRS.has(entry.name)) {
+          walkTestFiles(resolve(dir, entry.name), results);
+        }
+      } else if (entry.isFile()) {
+        const ext = extname(entry.name);
+        if (!TEST_EXTENSIONS.has(ext)) continue;
+
+        // Include if it matches test patterns OR if it's inside a test directory
+        const isTestFile = TEST_FILE_PATTERNS.some(p => p.test(entry.name));
+        const isInTestDir = true; // already walking a test dir
+
+        if (isTestFile || isInTestDir) {
+          const relPath = relative(projectRoot, resolve(dir, entry.name)).replace(/\\/g, '/');
+          results.add(relPath);
+        }
+      }
+    }
+  } catch { /* skip unreadable dirs */ }
+}
+
+function computeFileListHash(files) {
+  const sorted = [...files].sort();
+  return createHash('sha256').update(sorted.join('\n')).digest('hex');
+}
+
+function isUnchanged(currentHash) {
+  if (force) return false;
+  if (!existsSync(HASH_CACHE_PATH)) return false;
+  const cached = readFileSync(HASH_CACHE_PATH, 'utf-8').trim();
+  return cached === currentHash;
+}
+
+// ---------------------------------------------------------------------------
+// Test file analysis (regex-based, no AST)
+// ---------------------------------------------------------------------------
+
+/**
+ * Detect test framework from import statements.
+ */
+function detectFramework(content) {
+  if (/from\s+['"]vitest['"]/.test(content) || /import.*vitest/.test(content)) return 'vitest';
+  if (/from\s+['"]@jest/.test(content) || /from\s+['"]jest['"]/.test(content)) return 'jest';
+  if (/require\s*\(\s*['"]mocha['"]/.test(content)) return 'mocha';
+  if (/from\s+['"]@playwright/.test(content)) return 'playwright';
+  if (/from\s+['"]cypress['"]/.test(content)) return 'cypress';
+  if (/from\s+['"]ava['"]/.test(content)) return 'ava';
+  if (/describe\s*\(/.test(content) || /it\s*\(/.test(content) || /test\s*\(/.test(content)) return 'generic';
+  return 'unknown';
+}
+
+/**
+ * Extract describe/it/test block names from test file content.
+ */
+function extractTestBlocks(content) {
+  const blocks = [];
+
+  // Match: describe("name", ...) / describe('name', ...) / describe(`name`, ...)
+  const describePattern = /(?:describe|suite)\s*\(\s*(['"`])(.+?)\1/g;
+  let m;
+  while ((m = describePattern.exec(content)) !== null) {
+    blocks.push({ type: 'describe', name: m[2] });
+  }
+
+  // Match: it("name", ...) / test("name", ...) / specify("name", ...)
+  const testPattern = /(?:it|test|specify)\s*\(\s*(['"`])(.+?)\1/g;
+  while ((m = testPattern.exec(content)) !== null) {
+    blocks.push({ type: 'test', name: m[2] });
+  }
+
+  // Match: it.each / test.each (parameterized)
+  const eachPattern = /(?:it|test)\.each[^(]*\(\s*[^)]*\)\s*\(\s*(['"`])(.+?)\1/g;
+  while ((m = eachPattern.exec(content)) !== null) {
+    blocks.push({ type: 'test', name: m[2] + ' (parameterized)' });
+  }
+
+  return blocks;
+}
+
+/**
+ * Extract import targets — the source files that this test imports.
+ * This is the KEY mechanism for mapping tests to functionality.
+ */
+function extractImportTargets(content, filePath) {
+  const imports = [];
+  const fileDir = dirname(filePath);
+
+  // ES module imports: import { X } from '../path'
+  const esImportPattern = /import\s+(?:{[^}]*}|[\w*]+(?:\s*,\s*{[^}]*})?)\s+from\s+['"]([^'"]+)['"]/g;
+  let m;
+  while ((m = esImportPattern.exec(content)) !== null) {
+    const target = m[1];
+    // Only track relative imports (not packages)
+    if (target.startsWith('.') || target.startsWith('/')) {
+      imports.push(resolveImportPath(target, fileDir));
+    }
+  }
+
+  // CJS requires: const X = require('../path')
+  const cjsPattern = /require\s*\(\s*['"]([^'"]+)['"]\s*\)/g;
+  while ((m = cjsPattern.exec(content)) !== null) {
+    const target = m[1];
+    if (target.startsWith('.') || target.startsWith('/')) {
+      imports.push(resolveImportPath(target, fileDir));
+    }
+  }
+
+  // Dynamic imports: await import('../path')
+  const dynamicPattern = /import\s*\(\s*['"]([^'"]+)['"]\s*\)/g;
+  while ((m = dynamicPattern.exec(content)) !== null) {
+    const target = m[1];
+    if (target.startsWith('.') || target.startsWith('/')) {
+      imports.push(resolveImportPath(target, fileDir));
+    }
+  }
+
+  return [...new Set(imports)];
+}
+
+/**
+ * Resolve a relative import path to a project-relative path.
+ * Strips extensions if present, normalizes to forward slashes.
+ */
+function resolveImportPath(importPath, fromDir) {
+  // Resolve relative to the importing file's directory
+  const resolved = resolve(projectRoot, fromDir, importPath).replace(/\\/g, '/');
+  const rel = relative(projectRoot, resolved).replace(/\\/g, '/');
+
+  // Normalize: strip common source extensions (the import may omit them)
+  return rel.replace(/\.(ts|tsx|js|jsx|mjs)$/, '');
+}
+
+// ---------------------------------------------------------------------------
+// Chunk generators
+// ---------------------------------------------------------------------------
+
+/**
+ * Generate per-file test entries.
+ */
+function generateTestFileEntries(testFiles, analyses) {
+  const chunks = [];
+
+  for (const filePath of testFiles) {
+    const analysis = analyses[filePath];
+    if (!analysis) continue;
+
+    const fileName = basename(filePath);
+    const dir = dirname(filePath);
+
+    let content = `# ${fileName} (${filePath})\n`;
+    content += `Framework: ${analysis.framework}\n`;
+    if (analysis.importTargets.length > 0) {
+      content += `Tests: ${analysis.importTargets.map(t => t + '.*').join(', ')}\n`;
+    }
+    content += '\n';
+
+    // Describe blocks
+    const describes = analysis.blocks.filter(b => b.type === 'describe');
+    if (describes.length > 0) {
+      content += 'Describe blocks:\n';
+      for (const d of describes) {
+        content += `  - ${d.name}\n`;
+      }
+      content += '\n';
+    }
+
+    // Test names
+    const tests = analysis.blocks.filter(b => b.type === 'test');
+    if (tests.length > 0) {
+      content += `Test cases (${tests.length}):\n`;
+      for (const t of tests.slice(0, 30)) { // Cap at 30 to avoid huge entries
+        content += `  - ${t.name}\n`;
+      }
+      if (tests.length > 30) {
+        content += `  ... and ${tests.length - 30} more\n`;
+      }
+      content += '\n';
+    }
+
+    // Import targets
+    if (analysis.importTargets.length > 0) {
+      content += 'Source files under test:\n';
+      for (const imp of analysis.importTargets) {
+        content += `  - ${imp}\n`;
+      }
+    }
+
+    const tags = ['test-file', analysis.framework];
+    if (filePath.includes('e2e') || filePath.includes('E2E')) tags.push('e2e');
+    if (filePath.includes('integration')) tags.push('integration');
+    if (filePath.includes('unit')) tags.push('unit');
+
+    chunks.push({
+      key: `test-file:${filePath}`,
+      content: content.trim(),
+      metadata: {
+        kind: 'test-file',
+        filePath,
+        directory: dir,
+        framework: analysis.framework,
+        describeCount: describes.length,
+        testCount: tests.length,
+        importTargets: analysis.importTargets,
+        describeNames: describes.map(d => d.name),
+      },
+      tags,
+    });
+  }
+
+  return chunks;
+}
+
+/**
+ * Generate reverse mapping: source file → test files that import it.
+ * This is the primary value — enables "find tests for this file" queries.
+ */
+function generateTestMaps(testFiles, analyses) {
+  const chunks = [];
+
+  // Build reverse map: source file → [test files]
+  const reverseMap = {};
+  for (const filePath of testFiles) {
+    const analysis = analyses[filePath];
+    if (!analysis) continue;
+
+    for (const target of analysis.importTargets) {
+      if (!reverseMap[target]) reverseMap[target] = [];
+      reverseMap[target].push({
+        testFile: filePath,
+        framework: analysis.framework,
+        testCount: analysis.blocks.filter(b => b.type === 'test').length,
+      });
+    }
+  }
+
+  // Generate a chunk for each source file that has tests
+  for (const [sourceFile, testEntries] of Object.entries(reverseMap)) {
+    let content = `# Tests for: ${sourceFile}\n\n`;
+    content += `${testEntries.length} test file(s) cover this module:\n\n`;
+
+    for (const entry of testEntries) {
+      content += `  ${entry.testFile} [${entry.framework}, ${entry.testCount} tests]\n`;
+    }
+
+    chunks.push({
+      key: `test-map:${sourceFile}`,
+      content: content.trim(),
+      metadata: {
+        kind: 'test-map',
+        sourceFile,
+        testFiles: testEntries.map(e => e.testFile),
+        totalTests: testEntries.reduce((sum, e) => sum + e.testCount, 0),
+      },
+      tags: ['test-map'],
+    });
+  }
+
+  return chunks;
+}
+
+/**
+ * Generate directory summaries showing test coverage per directory.
+ */
+function generateTestDirSummaries(testFiles, analyses) {
+  const chunks = [];
+
+  // Group by directory
+  const dirMap = {};
+  for (const filePath of testFiles) {
+    const dir = dirname(filePath);
+    if (!dirMap[dir]) dirMap[dir] = [];
+    dirMap[dir].push(filePath);
+  }
+
+  for (const [dir, files] of Object.entries(dirMap)) {
+    if (files.length < 1) continue;
+
+    const frameworks = new Set();
+    let totalTests = 0;
+    let totalDescribes = 0;
+    const allImports = new Set();
+
+    for (const f of files) {
+      const analysis = analyses[f];
+      if (!analysis) continue;
+      frameworks.add(analysis.framework);
+      totalTests += analysis.blocks.filter(b => b.type === 'test').length;
+      totalDescribes += analysis.blocks.filter(b => b.type === 'describe').length;
+      for (const imp of analysis.importTargets) allImports.add(imp);
+    }
+
+    let content = `# ${dir}/ (${files.length} test files)\n`;
+    content += `Frameworks: ${[...frameworks].join(', ')}\n`;
+    content += `Total: ${totalDescribes} suites, ${totalTests} tests\n\n`;
+    content += 'Files:\n';
+    for (const f of files) {
+      content += `  ${basename(f)}\n`;
+    }
+    if (allImports.size > 0) {
+      content += '\nModules under test:\n';
+      for (const imp of [...allImports].sort().slice(0, 20)) {
+        content += `  ${imp}\n`;
+      }
+      if (allImports.size > 20) {
+        content += `  ... and ${allImports.size - 20} more\n`;
+      }
+    }
+
+    chunks.push({
+      key: `test-dir:${dir}`,
+      content: content.trim(),
+      metadata: {
+        kind: 'test-dir',
+        directory: dir,
+        fileCount: files.length,
+        frameworks: [...frameworks],
+        totalTests,
+        totalDescribes,
+      },
+      tags: ['test-dir'],
+    });
+  }
+
+  return chunks;
+}
+
+// ---------------------------------------------------------------------------
+// Main
+// ---------------------------------------------------------------------------
+
+async function main() {
+  const startTime = Date.now();
+
+  log(`Project root: ${projectRoot}`);
+
+  // 1. Find test files
+  log('Discovering test files...');
+  const testFiles = getTestFiles();
+  log(`Found ${testFiles.length} test files`);
+
+  if (testFiles.length === 0) {
+    log('No test files found — nothing to index');
+    return;
+  }
+
+  // 2. Check hash for incremental skip
+  const currentHash = computeFileListHash(testFiles);
+
+  if (statsOnly) {
+    const db = await getDb();
+    const count = countNamespace(db);
+    db.close();
+    log(`Stats: ${testFiles.length} test files, ${count} chunks in tests namespace`);
+    log(`File list hash: ${currentHash.slice(0, 12)}...`);
+    return;
+  }
+
+  if (isUnchanged(currentHash)) {
+    const db = await getDb();
+    const count = countNamespace(db);
+    db.close();
+    if (count > 0) {
+      log(`Skipping — file list unchanged (${count} chunks in DB, hash ${currentHash.slice(0, 12)}...)`);
+      return;
+    }
+    log('File list unchanged but no chunks in DB — forcing regeneration');
+  }
+
+  // 3. Analyze all test files
+  log('Analyzing test files...');
+  const analyses = {};
+
+  for (const filePath of testFiles) {
+    const fullPath = resolve(projectRoot, filePath);
+    if (!existsSync(fullPath)) continue;
+
+    try {
+      const content = readFileSync(fullPath, 'utf-8');
+      analyses[filePath] = {
+        framework: detectFramework(content),
+        blocks: extractTestBlocks(content),
+        importTargets: extractImportTargets(content, filePath),
+      };
+      debug(`  ${filePath}: ${analyses[filePath].framework}, ${analyses[filePath].blocks.length} blocks, ${analyses[filePath].importTargets.length} imports`);
+    } catch (err) {
+      debug(`  ${filePath}: ERROR - ${err.message}`);
+    }
+  }
+
+  const analyzedCount = Object.keys(analyses).length;
+  log(`Analyzed ${analyzedCount} test files`);
+
+  // 4. Generate all chunk types
+  log('Generating chunks...');
+  const fileChunks = generateTestFileEntries(testFiles, analyses);
+  const mapChunks = generateTestMaps(testFiles, analyses);
+  const dirChunks = generateTestDirSummaries(testFiles, analyses);
+
+  const allChunks = [...fileChunks, ...mapChunks, ...dirChunks];
+
+  log(`Generated ${allChunks.length} chunks:`);
+  log(`  Test file entries:   ${fileChunks.length}`);
+  log(`  Reverse maps:        ${mapChunks.length} (source → test files)`);
+  log(`  Directory summaries: ${dirChunks.length}`);
+
+  // 5. Write to database
+  log('Writing to memory database...');
+  const db = await getDb();
+  deleteNamespace(db);
+
+  for (const chunk of allChunks) {
+    storeEntry(db, chunk.key, chunk.content, chunk.metadata, chunk.tags);
+  }
+
+  saveDb(db);
+  db.close();
+
+  // 6. Save hash for incremental caching
+  writeFileSync(HASH_CACHE_PATH, currentHash, 'utf-8');
+
+  const elapsed = ((Date.now() - startTime) / 1000).toFixed(1);
+  log(`Done in ${elapsed}s — ${allChunks.length} chunks written to tests namespace`);
+
+  // 7. Generate embeddings (inline, like code-map)
+  if (!skipEmbeddings && allChunks.length > 0) {
+    const embedCandidates = [
+      resolve(dirname(fileURLToPath(import.meta.url)), 'build-embeddings.mjs'),
+      resolve(projectRoot, '.claude/scripts/build-embeddings.mjs'),
+    ];
+    const embedScript = embedCandidates.find(p => existsSync(p));
+    if (embedScript) {
+      log('Generating embeddings for tests...');
+      try {
+        execSync(`node "${embedScript}" --namespace tests`, {
+          cwd: projectRoot,
+          stdio: 'inherit',
+          timeout: 120000,
+          windowsHide: true,
+        });
+      } catch (err) {
+        log(`Warning: embedding generation failed: ${err.message?.split('\n')[0]}`);
+      }
+    }
+  }
+}
+
+main().catch(err => {
+  console.error('[index-tests] Fatal error:', err);
+  process.exit(1);
+});