@cleocode/cleo 2026.9.7 → 2026.9.10

package/studio-dist/server/chunks/brain-search2-CwI2cXgg.js

@@ -1,716 +0,0 @@
-import { g as getBrainAccessor } from './memory-accessor2-B981tHDR.js';
-import { t as typedAll } from './typed-query-l1D_QElt.js';
-import { Q as QUALITY_SCORE_THRESHOLD } from './quality-scoring-CCPuRQmJ.js';
-import { s as searchSimilar } from './brain-similarity-DI4yzm9e.js';
-
-//#region ../core/dist/memory/brain-search.js
-/**
-* Full-text search across BRAIN memory using SQLite FTS5.
-* Uses raw SQL via nativeDb because drizzle doesn't support FTS5 virtual tables.
-*
-* Falls back to LIKE queries if FTS5 is not available (some SQLite builds lack it).
-*
-* @task T5130
-* @epic T5149
-*/
-/** Track whether FTS5 is available in the current SQLite build. */
-var _fts5Available = null;
-/**
-* Track WHICH brain database has had its FTS tables created and index rebuilt
-* this session — keyed by the resolved `cleo.db` file PATH, NOT a process-wide
-* boolean (and deliberately not by `DatabaseSync` handle identity: a cached
-* handle reference is exactly the per-domain DB singleton the T12041 DB Open
-* Guard exists to prevent).
-*
-* The dual-scope cache guarantees one `DatabaseSync` per `cleo.db` path, so a
-* different path means a different database whose FTS index may not yet
-* contain rows inserted before the content-sync triggers existed. The old
-* process-wide boolean skipped the rebuild for every database after the
-* first: in a multi-project process — and in vitest `--retry` re-attempts,
-* which mint a fresh temp DB per attempt while module state survives —
-* `memory find` then returned zero hits for committed rows (T12101, macOS CI
-* shard 1 flake on PRs #1188/#1191/#1202).
-*
-* Same-path file recreation (close + delete + recreate one `cleo.db` in a
-* single process) is the one case path-keying cannot distinguish; tests that
-* do this already call {@link resetFts5Cache} explicitly.
-*
-* Naming note: the identifier must NOT contain `Db`/`Database`/`Connection`/
-* `Handle` — the T12041 gate regexes module-level `let … = null` declarations
-* for exactly those tokens (scripts/lint-no-domain-db-singleton.mjs).
-*
-* @task T12101
-*/
-var _fts5RebuiltForPath = null;
-/**
-* Check if FTS5 is available in the current SQLite build.
-*/
-function checkFts5Available(nativeDb) {
-	if (_fts5Available !== null) return _fts5Available;
-	try {
-		nativeDb.prepare("CREATE VIRTUAL TABLE IF NOT EXISTS _fts5_check USING fts5(test)").run();
-		nativeDb.prepare("DROP TABLE IF EXISTS _fts5_check").run();
-		_fts5Available = true;
-	} catch {
-		_fts5Available = false;
-	}
-	return _fts5Available;
-}
-/**
-* Execute a DDL statement using the native database.
-* Wraps nativeDb.prepare().run() for consistent usage.
-*/
-function execDDL(nativeDb, sql) {
-	nativeDb.prepare(sql).run();
-}
-/**
-* Create FTS5 virtual tables and content-sync triggers if they don't exist.
-*
-* Uses content= to sync from main tables, so inserts to main tables
-* auto-populate FTS. UPDATE/DELETE require triggers.
-*
-* @task T5130
-*/
-function ensureFts5Tables(nativeDb) {
-	if (!checkFts5Available(nativeDb)) return false;
-	execDDL(nativeDb, `
-    CREATE VIRTUAL TABLE IF NOT EXISTS brain_decisions_fts
-    USING fts5(id, decision, rationale, content=brain_decisions, content_rowid=rowid)
-  `);
-	execDDL(nativeDb, `
-    CREATE VIRTUAL TABLE IF NOT EXISTS brain_patterns_fts
-    USING fts5(id, pattern, context, content=brain_patterns, content_rowid=rowid)
-  `);
-	execDDL(nativeDb, `
-    CREATE VIRTUAL TABLE IF NOT EXISTS brain_learnings_fts
-    USING fts5(id, insight, source, content=brain_learnings, content_rowid=rowid)
-  `);
-	execDDL(nativeDb, `
-    CREATE TRIGGER IF NOT EXISTS brain_decisions_ai AFTER INSERT ON brain_decisions BEGIN
-      INSERT INTO brain_decisions_fts(rowid, id, decision, rationale)
-      VALUES (new.rowid, new.id, new.decision, new.rationale);
-    END
-  `);
-	execDDL(nativeDb, `
-    CREATE TRIGGER IF NOT EXISTS brain_decisions_ad AFTER DELETE ON brain_decisions BEGIN
-      INSERT INTO brain_decisions_fts(brain_decisions_fts, rowid, id, decision, rationale)
-      VALUES('delete', old.rowid, old.id, old.decision, old.rationale);
-    END
-  `);
-	execDDL(nativeDb, `
-    CREATE TRIGGER IF NOT EXISTS brain_decisions_au AFTER UPDATE ON brain_decisions BEGIN
-      INSERT INTO brain_decisions_fts(brain_decisions_fts, rowid, id, decision, rationale)
-      VALUES('delete', old.rowid, old.id, old.decision, old.rationale);
-      INSERT INTO brain_decisions_fts(rowid, id, decision, rationale)
-      VALUES (new.rowid, new.id, new.decision, new.rationale);
-    END
-  `);
-	execDDL(nativeDb, `
-    CREATE TRIGGER IF NOT EXISTS brain_patterns_ai AFTER INSERT ON brain_patterns BEGIN
-      INSERT INTO brain_patterns_fts(rowid, id, pattern, context)
-      VALUES (new.rowid, new.id, new.pattern, new.context);
-    END
-  `);
-	execDDL(nativeDb, `
-    CREATE TRIGGER IF NOT EXISTS brain_patterns_ad AFTER DELETE ON brain_patterns BEGIN
-      INSERT INTO brain_patterns_fts(brain_patterns_fts, rowid, id, pattern, context)
-      VALUES('delete', old.rowid, old.id, old.pattern, old.context);
-    END
-  `);
-	execDDL(nativeDb, `
-    CREATE TRIGGER IF NOT EXISTS brain_patterns_au AFTER UPDATE ON brain_patterns BEGIN
-      INSERT INTO brain_patterns_fts(brain_patterns_fts, rowid, id, pattern, context)
-      VALUES('delete', old.rowid, old.id, old.pattern, old.context);
-      INSERT INTO brain_patterns_fts(rowid, id, pattern, context)
-      VALUES (new.rowid, new.id, new.pattern, new.context);
-    END
-  `);
-	execDDL(nativeDb, `
-    CREATE TRIGGER IF NOT EXISTS brain_learnings_ai AFTER INSERT ON brain_learnings BEGIN
-      INSERT INTO brain_learnings_fts(rowid, id, insight, source)
-      VALUES (new.rowid, new.id, new.insight, new.source);
-    END
-  `);
-	execDDL(nativeDb, `
-    CREATE TRIGGER IF NOT EXISTS brain_learnings_ad AFTER DELETE ON brain_learnings BEGIN
-      INSERT INTO brain_learnings_fts(brain_learnings_fts, rowid, id, insight, source)
-      VALUES('delete', old.rowid, old.id, old.insight, old.source);
-    END
-  `);
-	execDDL(nativeDb, `
-    CREATE TRIGGER IF NOT EXISTS brain_learnings_au AFTER UPDATE ON brain_learnings BEGIN
-      INSERT INTO brain_learnings_fts(brain_learnings_fts, rowid, id, insight, source)
-      VALUES('delete', old.rowid, old.id, old.insight, old.source);
-      INSERT INTO brain_learnings_fts(rowid, id, insight, source)
-      VALUES (new.rowid, new.id, new.insight, new.source);
-    END
-  `);
-	execDDL(nativeDb, `
-    CREATE VIRTUAL TABLE IF NOT EXISTS brain_observations_fts
-    USING fts5(id, title, narrative, content=brain_observations, content_rowid=rowid)
-  `);
-	execDDL(nativeDb, `
-    CREATE TRIGGER IF NOT EXISTS brain_observations_ai AFTER INSERT ON brain_observations BEGIN
-      INSERT INTO brain_observations_fts(rowid, id, title, narrative)
-      VALUES (new.rowid, new.id, new.title, new.narrative);
-    END
-  `);
-	execDDL(nativeDb, `
-    CREATE TRIGGER IF NOT EXISTS brain_observations_ad AFTER DELETE ON brain_observations BEGIN
-      INSERT INTO brain_observations_fts(brain_observations_fts, rowid, id, title, narrative)
-      VALUES('delete', old.rowid, old.id, old.title, old.narrative);
-    END
-  `);
-	execDDL(nativeDb, `
-    CREATE TRIGGER IF NOT EXISTS brain_observations_au AFTER UPDATE ON brain_observations BEGIN
-      INSERT INTO brain_observations_fts(brain_observations_fts, rowid, id, title, narrative)
-      VALUES('delete', old.rowid, old.id, old.title, old.narrative);
-      INSERT INTO brain_observations_fts(rowid, id, title, narrative)
-      VALUES (new.rowid, new.id, new.title, new.narrative);
-    END
-  `);
-	return true;
-}
-/**
-* Rebuild FTS5 indexes from the content tables.
-* Useful after bulk inserts that bypass triggers.
-*
-* @task T5130
-*/
-function rebuildFts5Index(nativeDb) {
-	if (!checkFts5Available(nativeDb)) return;
-	nativeDb.prepare("INSERT INTO brain_decisions_fts(brain_decisions_fts) VALUES('rebuild')").run();
-	nativeDb.prepare("INSERT INTO brain_patterns_fts(brain_patterns_fts) VALUES('rebuild')").run();
-	nativeDb.prepare("INSERT INTO brain_learnings_fts(brain_learnings_fts) VALUES('rebuild')").run();
-	try {
-		nativeDb.prepare("INSERT INTO brain_observations_fts(brain_observations_fts) VALUES('rebuild')").run();
-	} catch {}
-}
-/**
-* Unified search across all BRAIN memory tables.
-*
-* Uses FTS5 MATCH for full-text search with BM25 ranking when available,
-* falls back to LIKE queries otherwise.
-*
-* @task T5130
-*/
-async function searchBrain(projectRoot, query, options) {
-	if (!query?.trim()) return {
-		decisions: [],
-		patterns: [],
-		learnings: [],
-		observations: []
-	};
-	const { getBrainDb, getBrainDbPath, getBrainNativeDb } = await import('./memory-sqlite2-B7dq8doO.js');
-	await getBrainDb(projectRoot);
-	const nativeDb = getBrainNativeDb(projectRoot);
-	if (!nativeDb) return {
-		decisions: [],
-		patterns: [],
-		learnings: [],
-		observations: []
-	};
-	const limit = options?.limit ?? 10;
-	const tables = options?.tables ?? [
-		"decisions",
-		"patterns",
-		"learnings",
-		"observations"
-	];
-	const peerId = options?.peerId;
-	const includeGlobal = options?.includeGlobal ?? true;
-	if (ensureFts5Tables(nativeDb)) {
-		if (_fts5RebuiltForPath !== getBrainDbPath(projectRoot)) {
-			_fts5RebuiltForPath = getBrainDbPath(projectRoot);
-			rebuildFts5Index(nativeDb);
-		}
-		return searchWithFts5(nativeDb, query, tables, limit, peerId, includeGlobal);
-	}
-	return searchWithLike(nativeDb, query, tables, limit, peerId, includeGlobal);
-}
-/**
-* Build a SQL peer isolation clause and the corresponding bind parameters.
-*
-* When `peerId` is undefined the clause is empty string (no filter applied).
-* When `peerId` is provided and `includeGlobal` is true (default), the clause
-* is `AND (t.peer_id = ? OR t.peer_id = 'global')`.
-* When `includeGlobal` is false, the clause is `AND t.peer_id = ?`.
-*
-* The `tableAlias` must match the alias used for the main table in the query.
-*
-* @internal
-*/
-function buildPeerClause(tableAlias, peerId, includeGlobal) {
-	if (!peerId) return {
-		clause: "",
-		params: []
-	};
-	if (includeGlobal) return {
-		clause: ` AND (${tableAlias}.peer_id = ? OR ${tableAlias}.peer_id = 'global')`,
-		params: [peerId]
-	};
-	return {
-		clause: ` AND ${tableAlias}.peer_id = ?`,
-		params: [peerId]
-	};
-}
-/**
-* Search using FTS5 MATCH with BM25 ranking.
-*/
-function searchWithFts5(nativeDb, query, tables, limit, peerId, includeGlobal = true) {
-	const result = {
-		decisions: [],
-		patterns: [],
-		learnings: [],
-		observations: []
-	};
-	const fts5Queries = buildFts5Queries(query);
-	if (tables.includes("decisions")) {
-		const { clause, params } = buildPeerClause("d", peerId, includeGlobal);
-		try {
-			const stmt = nativeDb.prepare(`
-        SELECT d.*
-        FROM brain_decisions_fts fts
-        JOIN brain_decisions d ON d.rowid = fts.rowid
-        WHERE brain_decisions_fts MATCH ?
-          AND (d.quality_score IS NULL OR d.quality_score >= ?)
-          ${clause}
-        ORDER BY bm25(brain_decisions_fts)
-        LIMIT ?
-      `);
-			result.decisions = matchConjunctiveFirst((matchExpr) => typedAll(stmt, matchExpr, QUALITY_SCORE_THRESHOLD, ...params, limit), fts5Queries);
-		} catch {
-			result.decisions = likeSearchDecisions(nativeDb, query, limit, peerId, includeGlobal);
-		}
-	}
-	if (tables.includes("patterns")) {
-		const { clause, params } = buildPeerClause("p", peerId, includeGlobal);
-		try {
-			const stmt = nativeDb.prepare(`
-        SELECT p.*
-        FROM brain_patterns_fts fts
-        JOIN brain_patterns p ON p.rowid = fts.rowid
-        WHERE brain_patterns_fts MATCH ?
-          AND (p.quality_score IS NULL OR p.quality_score >= ?)
-          ${clause}
-        ORDER BY bm25(brain_patterns_fts)
-        LIMIT ?
-      `);
-			result.patterns = matchConjunctiveFirst((matchExpr) => typedAll(stmt, matchExpr, QUALITY_SCORE_THRESHOLD, ...params, limit), fts5Queries);
-		} catch {
-			result.patterns = likeSearchPatterns(nativeDb, query, limit, peerId, includeGlobal);
-		}
-	}
-	if (tables.includes("learnings")) {
-		const { clause, params } = buildPeerClause("l", peerId, includeGlobal);
-		try {
-			const stmt = nativeDb.prepare(`
-        SELECT l.*
-        FROM brain_learnings_fts fts
-        JOIN brain_learnings l ON l.rowid = fts.rowid
-        WHERE brain_learnings_fts MATCH ?
-          AND (l.quality_score IS NULL OR l.quality_score >= ?)
-          ${clause}
-        ORDER BY bm25(brain_learnings_fts)
-        LIMIT ?
-      `);
-			result.learnings = matchConjunctiveFirst((matchExpr) => typedAll(stmt, matchExpr, QUALITY_SCORE_THRESHOLD, ...params, limit), fts5Queries);
-		} catch {
-			result.learnings = likeSearchLearnings(nativeDb, query, limit, peerId, includeGlobal);
-		}
-	}
-	if (tables.includes("observations")) {
-		const { clause, params } = buildPeerClause("o", peerId, includeGlobal);
-		try {
-			const stmt = nativeDb.prepare(`
-        SELECT o.*
-        FROM brain_observations_fts fts
-        JOIN brain_observations o ON o.rowid = fts.rowid
-        WHERE brain_observations_fts MATCH ?
-          AND (o.quality_score IS NULL OR o.quality_score >= ?)
-          ${clause}
-        ORDER BY bm25(brain_observations_fts)
-        LIMIT ?
-      `);
-			result.observations = matchConjunctiveFirst((matchExpr) => typedAll(stmt, matchExpr, QUALITY_SCORE_THRESHOLD, ...params, limit), fts5Queries);
-		} catch {
-			result.observations = likeSearchObservations(nativeDb, query, limit, peerId, includeGlobal);
-		}
-	}
-	return result;
-}
-/**
-* Search using LIKE queries as fallback when FTS5 is unavailable.
-*/
-function searchWithLike(nativeDb, query, tables, limit, peerId, includeGlobal = true) {
-	const result = {
-		decisions: [],
-		patterns: [],
-		learnings: [],
-		observations: []
-	};
-	if (tables.includes("decisions")) result.decisions = likeSearchDecisions(nativeDb, query, limit, peerId, includeGlobal);
-	if (tables.includes("patterns")) result.patterns = likeSearchPatterns(nativeDb, query, limit, peerId, includeGlobal);
-	if (tables.includes("learnings")) result.learnings = likeSearchLearnings(nativeDb, query, limit, peerId, includeGlobal);
-	if (tables.includes("observations")) result.observations = likeSearchObservations(nativeDb, query, limit, peerId, includeGlobal);
-	return result;
-}
-function likeSearchDecisions(nativeDb, query, limit, peerId, includeGlobal = true) {
-	const likePattern = `%${query}%`;
-	const { clause, params } = buildPeerClause("brain_decisions", peerId, includeGlobal);
-	return typedAll(nativeDb.prepare(`
-    SELECT * FROM brain_decisions
-    WHERE (decision LIKE ? OR rationale LIKE ?)
-      AND (quality_score IS NULL OR quality_score >= ?)
-      ${clause}
-    ORDER BY created_at DESC
-    LIMIT ?
-  `), likePattern, likePattern, QUALITY_SCORE_THRESHOLD, ...params, limit);
-}
-function likeSearchPatterns(nativeDb, query, limit, peerId, includeGlobal = true) {
-	const likePattern = `%${query}%`;
-	const { clause, params } = buildPeerClause("brain_patterns", peerId, includeGlobal);
-	return typedAll(nativeDb.prepare(`
-    SELECT * FROM brain_patterns
-    WHERE (pattern LIKE ? OR context LIKE ?)
-      AND (quality_score IS NULL OR quality_score >= ?)
-      ${clause}
-    ORDER BY frequency DESC
-    LIMIT ?
-  `), likePattern, likePattern, QUALITY_SCORE_THRESHOLD, ...params, limit);
-}
-function likeSearchLearnings(nativeDb, query, limit, peerId, includeGlobal = true) {
-	const likePattern = `%${query}%`;
-	const { clause, params } = buildPeerClause("brain_learnings", peerId, includeGlobal);
-	return typedAll(nativeDb.prepare(`
-    SELECT * FROM brain_learnings
-    WHERE (insight LIKE ? OR source LIKE ?)
-      AND (quality_score IS NULL OR quality_score >= ?)
-      ${clause}
-    ORDER BY confidence DESC
-    LIMIT ?
-  `), likePattern, likePattern, QUALITY_SCORE_THRESHOLD, ...params, limit);
-}
-function likeSearchObservations(nativeDb, query, limit, peerId, includeGlobal = true) {
-	const likePattern = `%${query}%`;
-	const { clause, params } = buildPeerClause("brain_observations", peerId, includeGlobal);
-	return typedAll(nativeDb.prepare(`
-    SELECT * FROM brain_observations
-    WHERE (title LIKE ? OR narrative LIKE ?)
-      AND (quality_score IS NULL OR quality_score >= ?)
-      ${clause}
-    ORDER BY created_at DESC
-    LIMIT ?
-  `), likePattern, likePattern, QUALITY_SCORE_THRESHOLD, ...params, limit);
-}
-/**
-* Build the AND and OR MATCH expressions for a natural-language query.
-*
-* ## Why both, and why prefixes (T12073)
-*
-* The previous builder emitted `"tok1" OR "tok2"` — quoted terms joined by OR.
-* Measured against the live 6,985-observation corpus, that has two failure
-* modes that together make recall useless for anything but an exact rare token:
-*
-* **Quoted terms are exact, so morphological variants are invisible.** A search
-* for `orphan` matched 113 documents; `orphan*` matched 189. Seventy-six
-* documents saying "orphaned" or "orphans" could not be found by searching for
-* "orphan". SQLite FTS5 has no stemmer on the `unicode61` tokenizer, so a
-* prefix wildcard is the available substitute — and it is a good one, because
-* it costs nothing on a prefix-indexed b-tree.
-*
-* **Pure OR plus BM25 ranks by term rarity, not by term coverage.** A short
-* document matching ONE query term outranks a long one matching ALL of them,
-* because BM25 normalises for length. On this corpus that is catastrophic:
-* 30% of observations are sub-60-character auto-capture stubs, so the
-* shortest, emptiest records win. Searching `nexus_symbols_fts orphan` under
-* the old builder returned *"Consolidated: change observations (5 entries)"*
-* as the top hit — a record with no content at all — while the conjunctive
-* form returns only documents about orphans in nexus.
-*
-* So: require all terms first, and fall back to ANY only when the conjunction
-* finds nothing. That preserves the recall the OR form was introduced for
-* (T553: non-word tokens like em dashes zeroing out an implicit-AND query)
-* without letting it dominate the common case.
-*
-* @param query - the raw user query.
-* @returns AND/OR MATCH expressions and the usable term count.
-*
-* @example
-* ```ts
-* const q = buildFts5Queries('nexus_symbols_fts orphan');
-* // q.and === 'nexus_symbols_fts* AND orphan*'
-* // q.or  === 'nexus_symbols_fts* OR orphan*'
-* ```
-*
-* @task T553
-* @task T12073
-*/
-function buildFts5Queries(query) {
-	const rawTokens = query.trim().split(/\s+/).filter(Boolean);
-	const seen = /* @__PURE__ */ new Set();
-	const terms = [];
-	for (const t of rawTokens) {
-		const stripped = t.replace(/^\W+|\W+$/g, "");
-		if (stripped.length < 2) continue;
-		if (!/\w/.test(stripped)) continue;
-		const lower = stripped.toLowerCase();
-		if (seen.has(lower)) continue;
-		seen.add(lower);
-		terms.push(`"${stripped.replace(/"/g, "\"\"")}"*`);
-	}
-	if (terms.length === 0) return {
-		and: "\"\"",
-		or: "\"\"",
-		termCount: 0
-	};
-	return {
-		and: terms.join(" AND "),
-		or: terms.join(" OR "),
-		termCount: terms.length
-	};
-}
-/**
-* Run an FTS5-backed query conjunctively, falling back to disjunctive.
-*
-* Single-term queries skip the fallback entirely (AND and OR are identical).
-*
-* @param run - executes one MATCH expression and returns its rows.
-* @param queries - the pair from {@link buildFts5Queries}.
-* @returns conjunctive rows when non-empty, else disjunctive rows.
-*
-* @task T12073
-*/
-function matchConjunctiveFirst(run, queries) {
-	const conjunctive = run(queries.and);
-	if (conjunctive.length > 0 || queries.termCount < 2) return conjunctive;
-	return run(queries.or);
-}
-/**
-* Round-robin interleave several independently-ranked lists.
-*
-* Takes rank 1 from every list, then rank 2 from every list, and so on, so a
-* downstream consumer that scores by array position does not systematically
-* favour whichever list happened to be concatenated first.
-*
-* @param lists - per-source lists, each already ordered best-first.
-* @returns a single list preserving each source's internal order.
-*
-* @example
-* ```ts
-* interleaveRanked([['a1', 'a2'], ['b1'], ['c1', 'c2', 'c3']]);
-* // ['a1', 'b1', 'c1', 'a2', 'c2', 'c3']
-* ```
-*
-* @task T12073
-*/
-function interleaveRanked(lists) {
-	const out = [];
-	const longest = lists.reduce((max, l) => Math.max(max, l.length), 0);
-	for (let i = 0; i < longest; i++) for (const list of lists) {
-		const item = list[i];
-		if (item !== void 0) out.push(item);
-	}
-	return out;
-}
-/**
-* Fuse ranked lists from multiple retrieval sources using Reciprocal Rank Fusion.
-*
-* Implements the RRF algorithm from Cormack, Clarke & Buettcher (SIGIR 2009):
-*
-*   score(d) = Σ 1 / (k + rank(d, list))  for each list containing d
-*
-* where k=60 is the research-proven smoothing constant.
-*
-* Properties:
-* - Rank-based: actual scores from each source are ignored (only rank matters).
-* - Additive: items appearing in multiple lists accumulate higher scores.
-* - Robust: the +60 constant prevents rank-1 items from dominating.
-*
-* @param sources - Named arrays of ranked hits (order = rank, index 0 = best)
-* @param k - RRF smoothing constant (default: RRF_K = 60)
-* @returns Array of fused results sorted by rrfScore descending
-*
-* @example
-* ```ts
-* const fused = reciprocalRankFusion([
-*   { source: 'fts', hits: ftsHits },
-*   { source: 'vec', hits: vecHits },
-* ]);
-* ```
-*/
-function reciprocalRankFusion(sources, k = 60) {
-	const accum = /* @__PURE__ */ new Map();
-	for (const { source, hits } of sources) for (let rank = 0; rank < hits.length; rank++) {
-		const hit = hits[rank];
-		const contribution = 1 / (k + rank);
-		const existing = accum.get(hit.id);
-		if (existing) {
-			existing.rrfScore += contribution;
-			existing.sources.add(source);
-			if (source === "fts") existing.ftsRank = rank;
-			if (source === "vec") existing.vecRank = rank;
-		} else accum.set(hit.id, {
-			rrfScore: contribution,
-			type: hit.type,
-			title: hit.title,
-			text: hit.text,
-			sources: new Set([source]),
-			ftsRank: source === "fts" ? rank : void 0,
-			vecRank: source === "vec" ? rank : void 0
-		});
-	}
-	return [...accum.entries()].map(([id, data]) => ({
-		id,
-		rrfScore: data.rrfScore,
-		type: data.type,
-		title: data.title,
-		text: data.text,
-		sources: [...data.sources],
-		ftsRank: data.ftsRank,
-		vecRank: data.vecRank
-	})).sort((a, b) => b.rrfScore - a.rrfScore);
-}
-/**
-* Hybrid search across FTS5, vector similarity, graph neighbors, and optionally code symbols.
-* Uses Reciprocal Rank Fusion (RRF) for result combination.
-*
-* Algorithm:
-* 1. Run FTS5 search, vector similarity search, and optionally code symbol search in parallel.
-* 2. Optionally expand via graph neighbors (best-effort).
-* 3. Fuse all ranked lists with RRF: score = Σ 1/(rank+rrfK).
-* 4. Return top-N sorted by fused RRF score.
-*
-* Graceful degradation: vector, graph, and code sources are silently skipped when
-* unavailable — RRF naturally handles partial source lists.
-*
-* @param query - Search query text
-* @param projectRoot - Project root directory
-* @param options - Limit, RRF tuning, and includeCode flag for code symbol search
-* @returns Array of hybrid results ranked by RRF score descending
-*
-* @task T5130 (hybrid search), T1058 (code symbol integration)
-*/
-async function hybridSearch(query, projectRoot, options) {
-	if (!query?.trim()) return [];
-	const maxResults = options?.limit ?? 10;
-	const rrfK = options?.rrfK ?? 60;
-	const includeCode = options?.includeCode ?? false;
-	const searches = [searchBrain(projectRoot, query, { limit: maxResults * 3 }).catch(() => ({
-		decisions: [],
-		patterns: [],
-		learnings: [],
-		observations: []
-	})), searchSimilar(query, projectRoot, maxResults * 3).catch(() => [])];
-	let codeSearchPromise = null;
-	if (includeCode) {
-		codeSearchPromise = (async () => {
-			try {
-				const { smartSearch } = await import('./src4-DNleK_t_.js');
-				return smartSearch(query, {
-					maxResults: maxResults * 2,
-					rootDir: projectRoot
-				}).map((r) => ({
-					id: `code:${r.symbol.filePath}:${r.symbol.name}:${r.symbol.startLine}`,
-					title: r.symbol.name,
-					kind: r.symbol.kind,
-					score: r.score
-				}));
-			} catch {
-				return [];
-			}
-		})();
-		searches.push(codeSearchPromise);
-	}
-	const allResults = await Promise.all(searches);
-	const ftsResults = allResults[0];
-	const vecResults = allResults[1];
-	const codeResults = includeCode ? allResults[2] ?? [] : [];
-	const ftsHits = interleaveRanked([
-		ftsResults.decisions.map((d) => ({
-			id: d.id,
-			type: "decision",
-			title: d.decision,
-			text: `${d.decision} — ${d.rationale}`
-		})),
-		ftsResults.patterns.map((p) => ({
-			id: p.id,
-			type: "pattern",
-			title: p.pattern,
-			text: `${p.pattern} — ${p.context}`
-		})),
-		ftsResults.learnings.map((l) => ({
-			id: l.id,
-			type: "learning",
-			title: l.insight,
-			text: `${l.insight} (source: ${l.source})`
-		})),
-		ftsResults.observations.map((o) => ({
-			id: o.id,
-			type: "observation",
-			title: o.title,
-			text: o.narrative ?? o.title
-		}))
-	]);
-	const vecHits = vecResults.map((r) => ({
-		id: r.id,
-		type: r.type,
-		title: r.title,
-		text: r.text
-	}));
-	const codeHits = codeResults.map((r) => ({
-		id: r.id,
-		type: "code-symbol",
-		title: r.title,
-		text: `${r.title} (${r.kind})`
-	}));
-	const rrfSources = [];
-	if (ftsHits.length > 0) rrfSources.push({
-		source: "fts",
-		hits: ftsHits
-	});
-	if (vecHits.length > 0) rrfSources.push({
-		source: "vec",
-		hits: vecHits
-	});
-	if (codeHits.length > 0) rrfSources.push({
-		source: "code",
-		hits: codeHits
-	});
-	try {
-		const accessor = await getBrainAccessor(projectRoot);
-		const possibleNodeIds = [
-			`concept:${query.toLowerCase().replace(/\s+/g, "-")}`,
-			`task:${query}`,
-			`doc:${query}`
-		];
-		const graphHits = [];
-		for (const nodeId of possibleNodeIds) {
-			if (!await accessor.getPageNode(nodeId)) continue;
-			const neighbors = await accessor.getNeighbors(nodeId);
-			for (const neighbor of neighbors) graphHits.push({
-				id: neighbor.id,
-				type: neighbor.nodeType,
-				title: neighbor.label,
-				text: neighbor.label
-			});
-		}
-		if (graphHits.length > 0) rrfSources.push({
-			source: "graph",
-			hits: graphHits
-		});
-	} catch {}
-	return reciprocalRankFusion(rrfSources, rrfK).slice(0, maxResults).map((r) => ({
-		id: r.id,
-		score: r.rrfScore,
-		type: r.type,
-		title: r.title,
-		text: r.text,
-		sources: r.sources,
-		ftsRank: r.ftsRank,
-		vecRank: r.vecRank
-	}));
-}
-
-export { buildFts5Queries as b, ensureFts5Tables as e, hybridSearch as h, matchConjunctiveFirst as m, searchBrain as s };
-//# sourceMappingURL=brain-search2-CwI2cXgg.js.map