graph-indexer 2.1.1 → 3.0.1

package/search-sparse.mjs

@@ -1,183 +0,0 @@
-/**
- * @file search-sparse.mjs
- * @description B3 — opt-in LEARNED-SPARSE vocabulary-expansion channel. A learned-sparse retriever
- *              (SPLADE / uniCOIL family) expands a query into a WEIGHTED term set — original terms
- *              plus learned associates — and fuses that as an extra sparse channel, closing
- *              lexical-gap misses the Porter-stemming bridge structurally cannot (stemming only
- *              normalises morphology; it cannot connect "auth" → "credential"/"token").
- *
- *              THE AIR-GAPPED, ZERO-DEPENDENCY REALISATION: rather than require a neural MLM
- *              (which needs a downloaded model + @huggingface/transformers and cannot be measured
- *              air-gapped), the SHIPPED provider LEARNS the term associations FROM THE CORPUS at
- *              index time via positive pointwise mutual information (PMI) over chunk co-occurrence.
- *              It is genuine learned-sparse — learned per-term weights + vocabulary expansion — with
- *              ZERO new dependency, fully deterministic, and measurable on the honest `test:eval`.
- *              A neural SPLADE provider is a clean future drop-in behind the same `expandSparseQuery`
- *              seam (see docs/internals/IMPROVEMENT_LEARNED_SPARSE.md).
- *
- *              SOUNDNESS / SACRED DEFAULT: the model is built ONLY with --learned-sparse and
- *              serialized as an ISOLATED index artifact (like centrality/taint/scip_refs), so it
- *              cannot perturb the lexical postings or the default path. The channel is
- *              NL-ASYMMETRIC — it fires only for natural-language queries with a real expansion —
- *              so symbolic/exact lookups stay byte-identical. Scoring is delegated to a SHARED
- *              core (search-core.scoreSparseExpanded) that both backends call through their own
- *              postings accessors → parity by construction.
- * @author MaquinaTech <https://github.com/MaquinaTech>
- * @copyright (c) 2026 MaquinaTech. All rights reserved.
- * @license MIT
- */
-import { tokenize } from './search-core.mjs';
-
-// ── Model-build knobs (structural, not tuned to any query) ──────────────────────────────────
-const MIN_TOKEN_LEN = 3;          // ignore 1-2 char noise
-const MAX_TOKENS_PER_CHUNK = 40;  // cap co-occurrence fan-out per chunk (most-discriminative first)
-const MIN_DF = 2;                 // a term must occur in ≥2 chunks to carry association signal
-const MAX_DF_RATIO = 0.30;        // skip ultra-common terms (in >30% of chunks → no discriminative value)
-const MIN_COOC = 2;               // a pair must co-occur in ≥2 chunks (kills incidental pairs)
-const TOPK_ASSOC = 8;             // keep the strongest K associates per term
-const PMI_NORM = 6;               // PMI (log2) normaliser → stored weight = clamp(pmi/6, 0..1)
-
-// ── Query-expansion knobs ───────────────────────────────────────────────────────────────────
-const EXPANSION_SCALE = 0.35;     // an associate term contributes ≤0.35× a real query term
-const MAX_QUERY_EXPANSIONS = 12;  // total associate terms added across the whole query
-const MIN_EXPANSION_WEIGHT = 0.05;// drop near-zero associates (no point fusing them)
-
-/** Distinct, length-filtered RAW tokens of a text (no stems — associations are surface-form). */
-function distinctTokens(text) {
-    const out = new Set();
-    for (const t of tokenize(text, false)) if (t.length >= MIN_TOKEN_LEN) out.add(t);
-    return out;
-}
-
-/**
- * Learn the sparse association model from the corpus. Two passes:
- *   1. document frequency per token (over distinct per-chunk tokens);
- *   2. co-occurrence counts over each chunk's top-MAX_TOKENS_PER_CHUNK most-discriminative tokens
- *      (rarest first by df), then positive PMI per pair, keeping the top-K associates per term.
- *
- * Deterministic: every map is materialised through SORTED keys, and stored weights are rounded, so
- * the serialized model is byte-identical run to run and the two backends read identical bytes.
- *
- * @param {Iterable<{code_snippet?:string,name?:string,docstring?:string}>} chunks  the index chunks
- * @param {object} [opts]
- * @returns {{ assoc: Record<string, Array<[string, number]>>, meta: object } | null}  null if no signal
- */
-export function buildSparseModel(chunks, opts = {}) {
-    const minDf = opts.minDf ?? MIN_DF;
-    const maxDfRatio = opts.maxDfRatio ?? MAX_DF_RATIO;
-    const topK = opts.topKAssoc ?? TOPK_ASSOC;
-
-    // The text a chunk contributes its vocabulary from — name + docstring + the snippet.
-    const chunkText = (c) => `${c.name || ''} ${c.docstring || ''} ${c.summary || ''} ${c.code_snippet || ''}`;
-
-    // Pass 1: per-chunk distinct tokens + document frequency.
-    const perChunk = [];
-    const df = new Map();
-    for (const c of chunks) {
-        const toks = distinctTokens(chunkText(c));
-        if (toks.size < 2) { perChunk.push(null); continue; }
-        perChunk.push(toks);
-        for (const t of toks) df.set(t, (df.get(t) || 0) + 1);
-    }
-    const docCount = perChunk.length;
-    if (!docCount) return null;
-    const maxDf = Math.max(minDf, Math.floor(maxDfRatio * docCount));
-
-    // A token carries association signal only inside the df band [minDf, maxDf].
-    const eligible = (t) => { const d = df.get(t) || 0; return d >= minDf && d <= maxDf; };
-
-    // Pass 2: co-occurrence over each chunk's most-discriminative (rarest) eligible tokens.
-    const cooc = new Map();  // term → Map<term, count>
-    const bump = (a, b) => {
-        let m = cooc.get(a); if (!m) { m = new Map(); cooc.set(a, m); }
-        m.set(b, (m.get(b) || 0) + 1);
-    };
-    for (const toks of perChunk) {
-        if (!toks) continue;
-        const elig = [...toks].filter(eligible);
-        if (elig.length < 2) continue;
-        // rarest-first (df asc, then lexical) → cap fan-out deterministically
-        elig.sort((a, b) => (df.get(a) - df.get(b)) || (a < b ? -1 : a > b ? 1 : 0));
-        const top = elig.slice(0, MAX_TOKENS_PER_CHUNK);
-        for (let i = 0; i < top.length; i++) {
-            for (let j = i + 1; j < top.length; j++) {
-                bump(top[i], top[j]); bump(top[j], top[i]);   // symmetric
-            }
-        }
-    }
-
-    // Positive PMI per pair → top-K associates per term, weight = clamp(pmi / PMI_NORM, 0..1).
-    const log2 = (x) => Math.log(x) / Math.LN2;
-    const assoc = {};
-    let pairs = 0;
-    for (const term of [...cooc.keys()].sort()) {
-        const dfa = df.get(term);
-        const row = [];
-        for (const [other, c] of cooc.get(term)) {
-            if (c < MIN_COOC) continue;
-            const dfb = df.get(other);
-            // PMI = log2( P(a,b) / (P(a) P(b)) ) = log2( c·N / (dfa·dfb) )
-            const pmi = log2((c * docCount) / (dfa * dfb));
-            if (pmi <= 0) continue;
-            const w = Math.min(1, pmi / PMI_NORM);
-            if (w < MIN_EXPANSION_WEIGHT) continue;
-            row.push([other, Number(w.toFixed(4))]);
-        }
-        if (!row.length) continue;
-        // strongest first; lexical tie-break for determinism; keep top-K
-        row.sort((a, b) => (b[1] - a[1]) || (a[0] < b[0] ? -1 : 1));
-        assoc[term] = row.slice(0, topK);
-        pairs += assoc[term].length;
-    }
-    if (!pairs) return null;
-
-    return {
-        assoc,
-        meta: { terms: Object.keys(assoc).length, pairs, docs: docCount, metric: 'pmi', version: 1 },
-    };
-}
-
-/**
- * Expand a natural-language query into a WEIGHTED term set for the sparse channel: the learned
- * ASSOCIATE terms only (the original query terms already drive the lexical channel, so the sparse
- * channel is a pure vocabulary-EXPANSION view — it surfaces chunks that match the semantically
- * associated vocabulary the literal query never mentions). Deterministic insertion order (query-token
- * order, then per-token associate order) so both backends accumulate scores identically.
- *
- * Returns null when nothing fires (no model, no eligible token, no association) — the caller then
- * runs ZERO sparse channel and the result is byte-identical to the default path.
- *
- * @param {string} queryText
- * @param {{assoc:Record<string,Array<[string,number]>>}} model
- * @param {object} [opts]
- * @returns {Map<string, number> | null}  associate term → fusion weight, or null
- */
-export function expandSparseQuery(queryText, model, opts = {}) {
-    if (!model || !model.assoc) return null;
-    const scale = opts.scale ?? EXPANSION_SCALE;
-    const maxExp = opts.maxExpansions ?? MAX_QUERY_EXPANSIONS;
-    const assoc = model.assoc;
-
-    const qTokens = [...distinctTokens(queryText)];           // raw surface forms, query order via Set
-    const weights = new Map();                                // associate term → best weight seen
-    for (const qt of qTokens) {
-        const row = assoc[qt];
-        if (!row) continue;
-        for (const [term, w] of row) {
-            if (qTokens.includes(term)) continue;             // don't re-add a literal query term
-            const ew = scale * w;
-            if (ew < MIN_EXPANSION_WEIGHT) continue;
-            const prev = weights.get(term);
-            if (prev === undefined || ew > prev) weights.set(term, ew);
-        }
-    }
-    if (!weights.size) return null;
-
-    // Keep the strongest MAX_QUERY_EXPANSIONS, but REBUILD the map in deterministic order
-    // (weight desc, then term asc) so both backends iterate — and float-accumulate — identically.
-    const ranked = [...weights.entries()]
-        .sort((a, b) => (b[1] - a[1]) || (a[0] < b[0] ? -1 : 1))
-        .slice(0, maxExp);
-    if (!ranked.length) return null;
-    return new Map(ranked);
-}

package/storage.mjs

@@ -1,73 +0,0 @@
-/**
- * @file storage.mjs
- * @description Storage backend factory. Selects the in-memory engine (default,
- *              zero-dependency) or the disk-backed SQLite store based on config,
- *              and documents the single read contract that the MCP tools depend
- *              on so they remain backend-agnostic.
- * @author MaquinaTech <https://github.com/MaquinaTech>
- * @copyright (c) 2026 MaquinaTech. All rights reserved.
- * @license MIT
- *
- * ── Store contract (implemented by both MemoryGraphIndex and SqliteGraphStore) ──
- *   load()                                   Prepare for queries (open db / parse json).
- *   get backend()                            'memory' | 'sqlite'.
- *   get graph()                              { dependencies, importedBy } (file-level).
- *   searchHybrid(q, vec, topK, minScore, exactBoost) → [{ score, chunk }]
- *   getChunk(id)                             → chunk | null
- *   getChunksByFile(path)                    → chunk[]
- *   resolveSymbol(name)                      → chunk[]   (exact, case-insensitive)
- *   findCallers(funcName)                    → chunk[]
- *   findReferers(symbol)                     → chunk[]   (type_refs / extends matches)
- *   getEdges(chunkId, {kind?, direction})    → edge[]    (A4 resolved symbol graph; [] when off)
- *   hasSymbolGraph() / hasCentrality()       → boolean   (opt-in A4 / A5 layers present?)
- *   getCentrality(chunkId)                   → { score, rank, total } | null   (A5 symbol PageRank)
- *   topCentral(limit)                        → [{ chunk, score, rank }]         (A5, rank-ascending)
- *   hasTaint() / getTaintFlows()             → boolean / { flows, meta } | null (C2 serialized taint, --taint)
- *   findRoutes({method, pathPrefix})         → route[]   (HTTP route → handler chunk)
- *   iterateChunks()                          → Iterable<chunk>  (cursor on SQLite)
- *   getDependencies(path) / getImportedBy(path) → string[]
- *   chunkCount() / fileCount() / symbolCount() / vectorCount() → number
- *   stats()                                  → engine health facts
- *   close()                                  Release fds / db handles.
- */
-import fs from 'fs';
-import { MemoryGraphIndex } from './engine/memory.mjs';
-
-// 'auto' storage keeps the index in memory until a repo is large enough that the
-// disk-backed SQLite store earns its slightly higher per-query latency. The indexer
-// decides by the real chunk count it just built; readers decide by which artifact
-// exists on disk (see resolveBackend).
-export const AUTO_SQLITE_CHUNK_THRESHOLD = 15000;
-
-/**
- * Resolve the abstract storage setting ('auto'|'memory'|'sqlite') to a concrete
- * read backend. Explicit settings win; 'auto' picks SQLite when a SQLite artifact
- * is present (the indexer writes one only for large repos and removes the other
- * backend's artifact, so presence is unambiguous), else the in-memory JSON index.
- *
- * @param {object} config  Resolved config from config.mjs.
- * @returns {'memory'|'sqlite'}
- */
-export function resolveBackend(config) {
-    if (config.storage === 'sqlite') return 'sqlite';
-    if (config.storage === 'memory') return 'memory';
-    try { if (fs.existsSync(config.sqlitePath)) return 'sqlite'; } catch { /* fall through to memory */ }
-    return 'memory';
-}
-
-/**
- * Construct (but do not yet load) the configured store.
- *
- * @param {object}  config                 Resolved config from config.mjs.
- * @param {object}  [opts]
- * @param {boolean} [opts.cacheEmbeddings] Eager vector cache (in-memory backend only).
- * @returns {Promise<object>} a store implementing the contract above.
- */
-export async function createStore(config, { cacheEmbeddings = false } = {}) {
-    if (resolveBackend(config) === 'sqlite') {
-        // Imported lazily so the default path never loads node:sqlite.
-        const { SqliteGraphStore } = await import('./engine/sqlite.mjs');
-        return new SqliteGraphStore(config.sqlitePath, { embeddingPath: config.embeddingPath });
-    }
-    return new MemoryGraphIndex(config.indexPath, { cacheEmbeddings });
-}

package/watch-daemon.mjs

@@ -1,289 +0,0 @@
-#!/usr/bin/env node
-/**
- * @file watch-daemon.mjs
- * @description Native FileSystem Watcher Daemon that keeps the configured index
- *              backend fresh incrementally. Backend-agnostic: file changes are
- *              parsed once (Tree-sitter), optionally enriched (LLM cache-first)
- *              and embedded (Ollama), then handed to the store's applyFileUpdate
- *              — the in-memory engine persists a debounced JSON snapshot, the
- *              SQLite store commits a per-file WAL transaction that running MCP
- *              servers pick up live via PRAGMA data_version. No more "SQLite
- *              requires a full re-index on every change".
- * @author MaquinaTech <https://github.com/MaquinaTech>
- * @copyright (c) 2026 MaquinaTech. All rights reserved.
- * @license MIT
- * Copyright (c) 2026 MaquinaTech. All rights reserved.
- * Permission is hereby granted, free of charge, to any person obtaining a copy
- * of this software and associated documentation files (the "Software"), to deal
- * in the Software without restriction, including without limitation the rights
- * to use, copy, modify, merge, publish, distribute, sublicense, and/or sell
- * copies of the Software, and to permit persons to whom the Software is
- * furnished to do so, subject to the following conditions: The above copyright
- * notice and this permission notice shall be included in all copies or
- * substantial portions of the Software.
- */
-
-import fs from 'fs';
-import path from 'path';
-import chokidar from 'chokidar';
-import { resolveConfig } from './config.mjs';
-import { ensureDataDir, migrateLegacyLayout } from './layout.mjs';
-import { acquireLock, releaseLock, readPid } from './daemon-lock.mjs';
-import { createStore, resolveBackend } from './storage.mjs';
-import {
-    embeddingKeyFor, computePageRank, TEST_FILE_RE, EXAMPLE_DIR_RE,
-    summaryEmbeddingText, SUMMARY_VEC_SUFFIX, WINDOW_VEC_SUFFIX, embeddingWindows,
-} from './search-core.mjs';
-import { MAX_FILE_SIZE_BYTES, buildIgnoreFilter, extractImportsFromAST, extractSemanticChunks } from './parse/extractor.mjs';
-import { getParserForFile, ensureLanguagesReady } from './parse/languages.mjs';
-import { resolveLocalImports, buildEmbeddingPayload, fullBodyForEmbedding } from './parse/imports.mjs';
-import { createEmbedder, readEmbedMeta } from './embeddings.mjs';
-import {
-    loadEnrichmentCache, saveEnrichmentCache, attachEnrichment,
-    ollamaGenerate, parseEnrichResponse, buildEnrichPrompt, resolveEnrichModel,
-} from './enrichment.mjs';
-
-const config = resolveConfig();
-const PROJECT_ROOT = config.projectRoot;
-
-// Embed incremental updates with the SAME provider/model the index was built with
-// (stamped in the embeddings-bin sidecar), so live vectors match the bootstrap
-// ones. Built lazily and cached for the daemon's lifetime.
-let _embedder = null;
-async function getEmbedder() {
-    if (_embedder) return _embedder;
-    const m = readEmbedMeta(config.embeddingPath);
-    _embedder = await createEmbedder(config, m?.provider
-        ? { provider: m.provider, model: m.model }
-        : { provider: config.embeddingsEnabled ? 'ollama' : 'off', model: config.embedModel });
-    return _embedder;
-}
-
-// ─── Single-instance guard ──────────────────────────────────────────────────────
-// Exactly one daemon may run per project. Acquire the PID lock BEFORE doing any
-// work (loading the store, opening the db) so a redundant launch — via the MCP
-// server, `idx-daemon start`, or a stray `idx-watch` — exits immediately instead
-// of racing a second watcher onto the same index.
-ensureDataDir(PROJECT_ROOT);
-migrateLegacyLayout(PROJECT_ROOT);
-if (!acquireLock(config.pidFile)) {
-    process.stderr.write(
-        `✋ A graph-indexer daemon is already running for this project `
-        + `(PID ${readPid(config.pidFile)}). Exiting — only one runs per project.\n`
-    );
-    process.exit(0);
-}
-
-const ignoreFilter = buildIgnoreFilter(PROJECT_ROOT);
-const db = await createStore(config, { cacheEmbeddings: true });
-db.load();
-
-// ─── Enrichment (cache-first, live for core files) ──────────────────────────────
-// Cached entries re-attach for free on every change. When enrichment is enabled
-// and the changed file sits in the PageRank core, new/changed chunks are enriched
-// live (best-effort, low concurrency) so edits don't silently lose their semantic
-// metadata until the next full index run.
-const enrichCache = config.enrichment.enabled
-    ? loadEnrichmentCache(config.enrichmentCachePath)
-    : null;
-let enrichCacheDirty = false;
-let saveCacheTimer = null;
-function scheduleEnrichCacheSave() {
-    if (!enrichCacheDirty) return;
-    if (saveCacheTimer) clearTimeout(saveCacheTimer);
-    saveCacheTimer = setTimeout(() => {
-        saveCacheTimer = null;
-        try { saveEnrichmentCache(config.enrichmentCachePath, enrichCache); enrichCacheDirty = false; }
-        catch (err) { process.stderr.write(`[daemon] ⚠️ enrichment cache save failed: ${err.message}\n`); }
-    }, 3000);
-}
-
-// "auto" resolves to the strongest available local code model, same policy as the bootstrap indexer.
-let _enrichModel = null;
-async function getEnrichModel() {
-    if (_enrichModel) return _enrichModel;
-    _enrichModel = await resolveEnrichModel(config.enrichment.model, config.ollamaHost);
-    return _enrichModel;
-}
-
-let _coreFiles = null;
-function isEnrichableFile(filename) {
-    if (TEST_FILE_RE.test(filename) || EXAMPLE_DIR_RE.test(filename)) return false;
-    if (config.enrichment.coreRatio >= 1) return true; // all production files
-    if (!_coreFiles) {
-        const pr = computePageRank(db.graph);
-        const files = Array.from(pr.keys()).sort((a, b) => (pr.get(b) ?? 0) - (pr.get(a) ?? 0));
-        const coreCount = Math.max(1, Math.ceil(files.length * config.enrichment.coreRatio));
-        _coreFiles = new Set(files.slice(0, coreCount));
-    }
-    return _coreFiles.has(filename);
-}
-
-async function enrichChunks(filename, chunks) {
-    if (!enrichCache) return;
-    const pending = [];
-    for (const chunk of chunks) {
-        if (!chunk.content_hash) continue;
-        if (attachEnrichment(chunk, enrichCache.get(chunk.content_hash))) continue;
-        pending.push(chunk);
-    }
-    if (pending.length === 0 || !isEnrichableFile(filename)) return;
-    // Live enrichment of changed core chunks: sequential and best-effort — a file
-    // save touches a handful of chunks, so latency stays low and failures only
-    // mean "no enrichment until the next full index run".
-    const model = await getEnrichModel();
-    for (const chunk of pending) {
-        if ((chunk.end_line - chunk.start_line) < 4) continue; // trivial stubs
-        const raw = await ollamaGenerate(buildEnrichPrompt(chunk), {
-            model, ollamaHost: config.ollamaHost, timeoutMs: 20000,
-        });
-        const parsed = parseEnrichResponse(raw);
-        if (!parsed) break; // model unreachable — stop trying for this batch
-        chunk.summary  = parsed.summary;
-        chunk.concepts = parsed.concepts;
-        chunk.hyde     = parsed.hyde;
-        enrichCache.set(chunk.content_hash, {
-            summary: parsed.summary, concepts: parsed.concepts, model,
-        });
-        enrichCacheDirty = true;
-    }
-    scheduleEnrichCacheSave();
-}
-
-// ─── Incremental file sync ──────────────────────────────────────────────────────
-
-// Catch-up scan: chokidar fires 'add' for every existing file at startup. Files
-// not modified since the index artifact was last written are already indexed —
-// skipping them turns daemon start from O(repo) parse work into O(changed files),
-// while still picking up edits made while the daemon was down.
-const BACKEND = resolveBackend(config); // 'auto' → concrete backend by artifact presence.
-const ARTIFACT_PATH = BACKEND === 'sqlite' ? config.sqlitePath : config.indexPath;
-let indexBuiltAt = 0;
-try { indexBuiltAt = fs.statSync(ARTIFACT_PATH).mtimeMs; } catch { /* no index yet → full scan */ }
-let initialScan = true;
-
-async function processFileChange(absolutePath) {
-    const filename = path.relative(PROJECT_ROOT, absolutePath).replace(/\\/g, '/');
-    if (ignoreFilter.ignores(filename)) return;
-    if (filename.includes('.bundle.') || filename.includes('.min.')) return;
-    if (filename.startsWith('code-index.')) return; // never index our own artifacts
-
-    try {
-        if (initialScan && indexBuiltAt > 0 && fs.existsSync(absolutePath)
-            && fs.statSync(absolutePath).mtimeMs <= indexBuiltAt) {
-            return; // unchanged since the last index write
-        }
-
-        if (!fs.existsSync(absolutePath)) {
-            if (typeof db.removeFile === 'function') db.removeFile(filename);
-            else db.applyFileUpdate(filename, { chunks: [], imports: [] });
-            _coreFiles = null;
-            process.stderr.write(`[daemon] 🗑️  Purged: ${filename}\n`);
-            return;
-        }
-
-        const stats = fs.statSync(absolutePath);
-        if (stats.size > MAX_FILE_SIZE_BYTES) return;
-
-        const content = fs.readFileSync(absolutePath, 'utf-8');
-        if (!content.trim()) return;
-
-        const ext = path.extname(absolutePath);
-        const parser = getParserForFile(ext);
-        if (!parser) return;
-
-        const tree = parser.parse((offset) => offset < content.length ? content.slice(offset, offset + 4096) : null);
-        const imports = resolveLocalImports(extractImportsFromAST(tree.rootNode, ext), filename, PROJECT_ROOT);
-        const newChunks = extractSemanticChunks(tree.rootNode, filename, content, ext);
-        _coreFiles = null; // dependency graph may change → PageRank core set is stale
-
-        // Enrichment BEFORE embedding: summary rides the vector payload and
-        // embeddingKeyFor accounts for it, so cache lookups stay correct.
-        await enrichChunks(filename, newChunks);
-
-        // Identical embedding payloads to indexer.mjs (shared helpers) so incremental
-        // updates match the bootstrap index, including summary-only vectors for enriched chunks.
-        const chunksToEmbed = newChunks.filter(c => !db.hasEmbedding(embeddingKeyFor(c)));
-        const embeddings = new Map();
-        if (chunksToEmbed.length > 0) {
-            const entries = [];
-            for (const c of chunksToEmbed) {
-                const baseKey = embeddingKeyFor(c);
-                // Oversized definitions embed their full body (windowed) while the lexical path
-                // keeps the 3000-char snippet — parity with how indexer.mjs builds payloads.
-                const payload = buildEmbeddingPayload(c, imports, fullBodyForEmbedding(c, content));
-                entries.push({ key: baseKey, text: payload });
-                const windows = embeddingWindows(payload); // tail windows for oversized chunks
-                for (let i = 1; i < windows.length; i++) entries.push({ key: baseKey + WINDOW_VEC_SUFFIX + i, text: windows[i] });
-                const sText = summaryEmbeddingText(c);
-                if (sText) entries.push({ key: baseKey + SUMMARY_VEC_SUFFIX, text: sText });
-            }
-            const embedder = await getEmbedder();
-            const embeddingsMatrix = await embedder.embedDocuments(entries.map(e => e.text));
-            if (embeddingsMatrix && embeddingsMatrix.length === entries.length) {
-                entries.forEach((entry, j) => {
-                    if (embeddingsMatrix[j]) embeddings.set(entry.key, new Float32Array(embeddingsMatrix[j]));
-                });
-            }
-        }
-
-        db.applyFileUpdate(filename, { chunks: newChunks, imports, embeddings });
-        process.stderr.write(
-            `[daemon] 🔄 Synced: ${filename} (${newChunks.length} chunks, `
-            + `${newChunks.length - chunksToEmbed.length} cached vectors, ${BACKEND})\n`
-        );
-    } catch (err) {
-        process.stderr.write(`[daemon] ❌ Error in ${filename}: ${err.message}\n`);
-    }
-}
-
-// Serialize updates: chokidar can fire bursts (git checkout, format-on-save across
-// files); per-file work must not interleave inside the store.
-// Seeds the update chain: the daemon inherits its language set from whatever the
-// last `idx-index` run resolved, and won't autoInstall (grammars are provisioned
-// at index time, not silently mid-watch) — a language added after the daemon
-// started is picked up on the next full `idx-index`, same as other whole-program
-// passes (see interprocedural.mjs).
-let queue = ensureLanguagesReady({ projectRoot: PROJECT_ROOT, enabledLangs: config.languages, autoInstall: false, log: (msg) => process.stderr.write(msg + '\n') });
-function enqueue(absolutePath) {
-    queue = queue.then(() => processFileChange(absolutePath)).catch(() => {});
-}
-
-process.stderr.write(`🚀 Watcher Daemon started in: ${PROJECT_ROOT} (backend: ${BACKEND})\n`);
-
-// Only watch source files we can actually index. Critically, this prevents
-// chokidar from descending into node_modules / dist / .git / .gitignored dirs —
-// watching those would exhaust the OS file-watcher limit (ENOSPC on Linux) and
-// waste CPU/memory on large projects. The ignore decision happens at the watcher
-// level, not just in processFileChange, so ignored trees are never traversed.
-function shouldIgnore(absPath) {
-    const rel = path.relative(PROJECT_ROOT, absPath).replace(/\\/g, '/');
-    if (!rel) return false;                       // the project root itself
-    if (path.basename(absPath).startsWith('.')) return true; // dotfiles / dot-dirs
-    if (rel.startsWith('code-index.')) return true;          // our own artifacts (.db/-wal/.bin/.json)
-    try { return ignoreFilter.ignores(rel); }     // node_modules, dist, .gitignore, …
-    catch { return false; }
-}
-
-const watcher = chokidar.watch(PROJECT_ROOT, {
-    ignored: shouldIgnore,
-    persistent: true,
-    awaitWriteFinish: { stabilityThreshold: 300, pollInterval: 100 }
-});
-watcher.on('add', enqueue).on('change', enqueue).on('unlink', enqueue);
-watcher.on('ready', () => { queue = queue.then(() => { initialScan = false; }); });
-watcher.on('error', (err) => process.stderr.write(`[daemon] 💥 OS Watcher panic: ${err.message}\n`));
-
-function shutdown() {
-    watcher.close().catch(() => {});
-    if (enrichCache && enrichCacheDirty) {
-        try { saveEnrichmentCache(config.enrichmentCachePath, enrichCache); } catch { /* best effort */ }
-    }
-    if (typeof db.close === 'function') db.close();
-    process.exit(0);
-}
-process.on('SIGTERM', shutdown);
-process.on('SIGINT', shutdown);
-// Always relinquish the single-instance lock on the way out (covers shutdown(),
-// uncaught exits and normal termination) so the next launch can take over cleanly.
-process.on('exit', () => releaseLock(config.pidFile));