@geraldmaron/construct 1.0.0 → 1.0.1

package/lib/storage/embeddings-ollama.mjs

@@ -0,0 +1,78 @@
+/**
+ * lib/storage/embeddings-ollama.mjs — Ollama embedding adapter.
+ *
+ * Requires OLLAMA_BASE_URL (default: http://localhost:11434).
+ * Uses nomic-embed-text model (768d).
+ */
+
+const MODEL_ID = 'nomic-embed-text';
+const DIMENSIONS = 768;
+
+async function ollamaEmbed(baseUrl, text) {
+  const res = await fetch(`${baseUrl}/api/embeddings`, {
+    method: 'POST',
+    headers: { 'Content-Type': 'application/json' },
+    body: JSON.stringify({ model: MODEL_ID, prompt: text }),
+  });
+
+  if (!res.ok) {
+    const body = await res.text().catch(() => '');
+    throw new Error(`Ollama embedding error ${res.status}: ${body}`);
+  }
+
+  return res.json();
+}
+
+/**
+ * Embed a single text string.
+ * @param {string} text
+ * @param {{ env?: object }} opts
+ * @returns {Promise<{ embedding: Float32Array, model: string, dimensions: number }>}
+ */
+export async function embed(text, { env = process.env } = {}) {
+  const baseUrl = env.OLLAMA_BASE_URL || 'http://localhost:11434';
+
+  const data = await ollamaEmbed(baseUrl, text);
+  return {
+    embedding: new Float32Array(data.embedding),
+    model: `ollama/${MODEL_ID}`,
+    dimensions: DIMENSIONS,
+  };
+}
+
+/**
+ * Embed a batch of texts. Ollama doesn't support native batching,
+ * so we process sequentially with a small concurrency limit.
+ * @param {string[]} texts
+ * @param {{ env?: object }} opts
+ * @returns {Promise<{ embedding: Float32Array, model: string, dimensions: number }[]>}
+ */
+export async function embedBatch(texts, { env = process.env } = {}) {
+  const baseUrl = env.OLLAMA_BASE_URL || 'http://localhost:11434';
+  const results = [];
+
+  for (const text of texts) {
+    const data = await ollamaEmbed(baseUrl, text);
+    results.push({
+      embedding: new Float32Array(data.embedding),
+      model: `ollama/${MODEL_ID}`,
+      dimensions: DIMENSIONS,
+    });
+  }
+
+  return results;
+}
+
+/**
+ * Return metadata about this embedding model.
+ * @param {{ env?: object }} opts
+ * @returns {{ id: string, model: string, provider: string, dimensions: number }}
+ */
+export function getModelInfo({ env = process.env } = {}) {
+  return {
+    id: 'ollama',
+    model: `ollama/${MODEL_ID}`,
+    provider: 'ollama',
+    dimensions: DIMENSIONS,
+  };
+}

package/lib/storage/embeddings-openai.mjs

@@ -0,0 +1,85 @@
+/**
+ * lib/storage/embeddings-openai.mjs — OpenAI embedding adapter.
+ *
+ * Requires OPENAI_API_KEY. Uses text-embedding-3-small (1536d).
+ * Supports native batching for up to 2048 inputs per request.
+ */
+
+const MODEL_ID = 'text-embedding-3-small';
+const DIMENSIONS = 1536;
+const MAX_BATCH_SIZE = 2048;
+
+async function openaiEmbed(key, input) {
+  const res = await fetch('https://api.openai.com/v1/embeddings', {
+    method: 'POST',
+    headers: {
+      'Authorization': `Bearer ${key}`,
+      'Content-Type': 'application/json',
+    },
+    body: JSON.stringify({ model: MODEL_ID, input }),
+  });
+
+  if (!res.ok) {
+    const body = await res.text().catch(() => '');
+    throw new Error(`OpenAI embedding error ${res.status}: ${body}`);
+  }
+
+  return res.json();
+}
+
+/**
+ * Embed a single text string.
+ * @param {string} text
+ * @param {{ env?: object }} opts
+ * @returns {Promise<{ embedding: Float32Array, model: string, dimensions: number }>}
+ */
+export async function embed(text, { env = process.env } = {}) {
+  const key = env.OPENAI_API_KEY;
+  if (!key) throw new Error('OPENAI_API_KEY required for OpenAI embeddings');
+
+  const data = await openaiEmbed(key, text);
+  return {
+    embedding: new Float32Array(data.data[0].embedding),
+    model: `openai/${MODEL_ID}`,
+    dimensions: DIMENSIONS,
+  };
+}
+
+/**
+ * Embed a batch of texts using OpenAI's native batching.
+ * @param {string[]} texts
+ * @param {{ env?: object }} opts
+ * @returns {Promise<{ embedding: Float32Array, model: string, dimensions: number }[]>}
+ */
+export async function embedBatch(texts, { env = process.env } = {}) {
+  const key = env.OPENAI_API_KEY;
+  if (!key) throw new Error('OPENAI_API_KEY required for OpenAI embeddings');
+
+  const results = [];
+  for (let i = 0; i < texts.length; i += MAX_BATCH_SIZE) {
+    const batch = texts.slice(i, i + MAX_BATCH_SIZE);
+    const data = await openaiEmbed(key, batch);
+    for (const item of data.data) {
+      results.push({
+        embedding: new Float32Array(item.embedding),
+        model: `openai/${MODEL_ID}`,
+        dimensions: DIMENSIONS,
+      });
+    }
+  }
+  return results;
+}
+
+/**
+ * Return metadata about this embedding model.
+ * @param {{ env?: object }} opts
+ * @returns {{ id: string, model: string, provider: string, dimensions: number }}
+ */
+export function getModelInfo({ env = process.env } = {}) {
+  return {
+    id: 'openai',
+    model: `openai/${MODEL_ID}`,
+    provider: 'openai',
+    dimensions: DIMENSIONS,
+  };
+}

package/lib/storage/embeddings.mjs

@@ -1,42 +1,26 @@
 #!/usr/bin/env node
 /**
- * lib/storage/embeddings.mjs — deterministic local embeddings for hybrid retrieval.
+ * lib/storage/embeddings.mjs — Pure scoring & tokenization utilities.
+ *
+ * Holds the model-agnostic primitives only:
+ *   tokenize, cosineSimilarity, bm25Score, buildTermFrequencies,
+ *   buildIdf, rankByBm25, scoreByEmbedding.
+ *
+ * Embedding adapters live alongside the engine (lib/storage/embeddings-engine.mjs
+ * and per-model files like embeddings-local.mjs / embeddings-openai.mjs /
+ * embeddings-legacy.mjs). Callers obtain embeddings via the engine. Anything
+ * reaching for a hashing fallback should call `embeddings-legacy.mjs::embed`
+ * directly or set CONSTRUCT_EMBEDDING_MODEL=hashing.
  */
-import crypto from 'node:crypto';
 
-export const EMBEDDING_MODEL = 'hashing-bow-v1';
-export const EMBEDDING_DIMENSIONS = 256;
+const BM25_K1 = 1.5;
+const BM25_B = 0.75;
 
-function tokenize(text) {
+export function tokenize(text) {
   return String(text || '')
     .toLowerCase()
     .split(/[^a-z0-9]+/)
-    .filter((term) => term.length >= 3);
-}
-
-function bucketForToken(token, dimensions) {
-  const hash = crypto.createHash('sha256').update(token).digest();
-  return hash.readUInt32BE(0) % dimensions;
-}
-
-function signForToken(token) {
-  const hash = crypto.createHash('sha256').update(token).digest();
-  return (hash[4] & 1) === 0 ? 1 : -1;
-}
-
-export function embedText(text, dimensions = EMBEDDING_DIMENSIONS) {
-  const vector = new Array(dimensions).fill(0);
-  const tokens = tokenize(text);
-  if (tokens.length === 0) return vector;
-
-  for (const token of tokens) {
-    const bucket = bucketForToken(token, dimensions);
-    vector[bucket] += signForToken(token);
-  }
-
-  const norm = Math.sqrt(vector.reduce((sum, value) => sum + (value * value), 0));
-  if (norm === 0) return vector;
-  return vector.map((value) => Number((value / norm).toFixed(8)));
+    .filter((term) => term.length >= 2);
 }
 
 export function cosineSimilarity(left = [], right = []) {
@@ -56,8 +40,58 @@ export function cosineSimilarity(left = [], right = []) {
   return denom > 0 ? dot / denom : 0;
 }
 
-export function scoreEmbeddedDocuments(documents = [], query, { limit = 10 } = {}) {
-  const queryEmbedding = embedText(query);
+/**
+ * BM25 score for a single document against a query.
+ * documents — array of tokenized term-frequency maps built by buildTermFrequencies().
+ * avgDocLen — average document length across the corpus.
+ * idf — Map<term, number> built by buildIdf().
+ */
+export function bm25Score(queryTerms, docTerms, docLen, avgDocLen, idf) {
+  let score = 0;
+  for (const term of queryTerms) {
+    const tf = docTerms.get(term) || 0;
+    if (tf === 0) continue;
+    const idfVal = idf.get(term) || 0;
+    const tfNorm = (tf * (BM25_K1 + 1)) / (tf + BM25_K1 * (1 - BM25_B + BM25_B * docLen / Math.max(avgDocLen, 1)));
+    score += idfVal * tfNorm;
+  }
+  return score;
+}
+
+export function buildTermFrequencies(text) {
+  const tf = new Map();
+  for (const term of tokenize(text)) {
+    tf.set(term, (tf.get(term) || 0) + 1);
+  }
+  return tf;
+}
+
+/**
+ * Build IDF values for a corpus of term-frequency maps.
+ * Returns Map<term, idf_value> using the Robertson-Sparck Jones variant.
+ */
+export function buildIdf(corpus) {
+  const N = corpus.length;
+  const docFreq = new Map();
+  for (const tfMap of corpus) {
+    for (const term of tfMap.keys()) {
+      docFreq.set(term, (docFreq.get(term) || 0) + 1);
+    }
+  }
+  const idf = new Map();
+  for (const [term, df] of docFreq) {
+    idf.set(term, Math.log((N - df + 0.5) / (df + 0.5) + 1));
+  }
+  return idf;
+}
+
+/**
+ * Rank documents by cosine similarity against a pre-computed query embedding.
+ * Decouples scoring from the embedding model — callers obtain the query
+ * embedding via the configured engine, then pass it here to score documents
+ * that already carry an `embedding` field of the same dimension.
+ */
+export function scoreByEmbedding(documents = [], queryEmbedding = [], { limit = 10 } = {}) {
   return documents
     .map((document) => ({
       document,
@@ -68,3 +102,28 @@ export function scoreEmbeddedDocuments(documents = [], query, { limit = 10 } = {
     .slice(0, limit)
     .map(({ document, score }) => ({ ...document, score }));
 }
+
+export function rankByBm25(documents, query, { limit = 10 } = {}) {
+  if (!query || documents.length === 0) return [];
+  const queryTerms = tokenize(query);
+  if (queryTerms.length === 0) return [];
+
+  const tfMaps = documents.map((doc) => {
+    const text = [doc.text, doc.body, doc.summary, doc.content, doc.title].filter(Boolean).join(' ');
+    return buildTermFrequencies(text);
+  });
+
+  const totalLen = tfMaps.reduce((sum, tf) => sum + [...tf.values()].reduce((a, b) => a + b, 0), 0);
+  const avgDocLen = totalLen / Math.max(tfMaps.length, 1);
+  const idf = buildIdf(tfMaps);
+
+  return documents
+    .map((doc, i) => {
+      const docLen = [...tfMaps[i].values()].reduce((a, b) => a + b, 0);
+      const score = bm25Score(queryTerms, tfMaps[i], docLen, avgDocLen, idf);
+      return { ...doc, score };
+    })
+    .filter((d) => d.score > 0)
+    .sort((a, b) => b.score - a.score)
+    .slice(0, limit);
+}

package/lib/storage/file-lock.mjs

@@ -0,0 +1,130 @@
+/**
+ * lib/storage/file-lock.mjs — Cooperative per-file locking for shared JSON stores.
+ *
+ * The observation, entity, and session stores are read-modify-written by both
+ * CLI invocations and hook processes; concurrent writers can race and produce
+ * a corrupted JSON file. This helper provides a thin lock primitive that:
+ *
+ *   - Creates a `<file>.lock` sidecar with O_EXCL semantics (`flag: 'wx'`)
+ *   - Records the holder PID inside the lock so stale locks (from killed
+ *     processes) can be detected and stolen
+ *   - Spins with backoff for up to LOCK_TIMEOUT_MS before giving up
+ *   - Unlocks on release, on `process.exit`, and on uncaught exceptions
+ *
+ * Usage:
+ *
+ *   await withFileLock(filePath, async () => {
+ *     const data = JSON.parse(readFileSync(filePath, 'utf8'));
+ *     // ...mutate
+ *     writeFileSync(filePath, JSON.stringify(data));
+ *   });
+ *
+ * The lock is best-effort: if the OS, FS, or process is in a state that
+ * defeats O_EXCL, the helper falls through after the timeout and lets the
+ * caller proceed. Logged regressions are surfaced via construct doctor.
+ */
+
+import { writeFileSync, readFileSync, unlinkSync, mkdirSync, existsSync } from 'node:fs';
+import { dirname } from 'node:path';
+
+const LOCK_TIMEOUT_MS = 5_000;
+const POLL_INTERVAL_MS = 50;
+
+const heldLocks = new Set();
+
+function isHolderAlive(holderPid) {
+  if (!holderPid || !Number.isFinite(holderPid)) return false;
+  try {
+    process.kill(holderPid, 0);
+    return true;
+  } catch (err) {
+    return err.code === 'EPERM';
+  }
+}
+
+function tryAcquire(lockPath) {
+  try {
+    mkdirSync(dirname(lockPath), { recursive: true });
+    writeFileSync(lockPath, String(process.pid), { flag: 'wx' });
+    heldLocks.add(lockPath);
+    return true;
+  } catch (err) {
+    if (err.code !== 'EEXIST') throw err;
+    let holder = null;
+    try { holder = Number(readFileSync(lockPath, 'utf8').trim()); } catch { /* unreadable */ }
+    if (!isHolderAlive(holder)) {
+      try { unlinkSync(lockPath); } catch { /* race */ }
+      try {
+        writeFileSync(lockPath, String(process.pid), { flag: 'wx' });
+        heldLocks.add(lockPath);
+        return true;
+      } catch { return false; }
+    }
+    return false;
+  }
+}
+
+function release(lockPath) {
+  if (!heldLocks.has(lockPath)) return;
+  try { unlinkSync(lockPath); } catch { /* already gone */ }
+  heldLocks.delete(lockPath);
+}
+
+let exitHandlerInstalled = false;
+function installExitHandler() {
+  if (exitHandlerInstalled) return;
+  exitHandlerInstalled = true;
+  const cleanup = () => { for (const p of heldLocks) try { unlinkSync(p); } catch { /* ignore */ } };
+  process.on('exit', cleanup);
+  process.on('SIGTERM', () => { cleanup(); process.exit(0); });
+  process.on('SIGINT', () => { cleanup(); process.exit(0); });
+  process.on('uncaughtException', (err) => { cleanup(); throw err; });
+}
+
+/**
+ * Run `fn` while holding an exclusive lock on `<filePath>.lock`. Awaits the
+ * function's return value, releases the lock, and propagates any error.
+ *
+ * If the lock cannot be acquired within LOCK_TIMEOUT_MS, runs `fn` anyway —
+ * better to lose the lock guarantee than to deadlock the caller. This is
+ * cooperative locking; it relies on every writer using this helper.
+ */
+export async function withFileLock(filePath, fn) {
+  installExitHandler();
+  const lockPath = `${filePath}.lock`;
+  const deadline = Date.now() + LOCK_TIMEOUT_MS;
+
+  while (!tryAcquire(lockPath)) {
+    if (Date.now() >= deadline) break;
+    await new Promise((resolve) => setTimeout(resolve, POLL_INTERVAL_MS));
+  }
+
+  try {
+    return await fn();
+  } finally {
+    release(lockPath);
+  }
+}
+
+/**
+ * Synchronous variant. Same contract, but for callers that cannot be async.
+ * Uses a busy-wait loop; prefer `withFileLock` whenever possible.
+ */
+export function withFileLockSync(filePath, fn) {
+  installExitHandler();
+  const lockPath = `${filePath}.lock`;
+  const deadline = Date.now() + LOCK_TIMEOUT_MS;
+
+  while (!tryAcquire(lockPath)) {
+    if (Date.now() >= deadline) break;
+    // Crude sleep — node has no native sync sleep, so we busy-wait briefly.
+    const stop = Date.now() + POLL_INTERVAL_MS;
+    while (Date.now() < stop) { /* spin */ }
+  }
+
+  try {
+    return fn();
+  } finally {
+    release(lockPath);
+  }
+}

package/lib/storage/fusion.mjs

@@ -0,0 +1,95 @@
+/**
+ * lib/storage/fusion.mjs — score fusion for hybrid retrieval.
+ *
+ * Exposes two fusion strategies for combining ranked results from
+ * multiple retrieval signals (lexical, vector, metadata, recency):
+ *
+ *   fuseScores({ vector, lexical, metadata, recency }, weights)
+ *     — weighted linear combination, returns the final score and
+ *       component scores so callers can debug retrieval drift.
+ *
+ *   reciprocalRankFusion(rankedLists, { k })
+ *     — RRF: finalScore = Σ 1 / (k + rank_i) for each list a doc appears in.
+ *       Order-insensitive across lists; robust to score-scale mismatch
+ *       between lexical (BM25) and vector (cosine) backends.
+ *
+ * Default weights match the source plan: vector 0.45, lexical 0.35,
+ * metadata 0.15, recency 0.05. Callers override per-query when needed
+ * (e.g. weight metadata higher for filter-driven queries).
+ */
+
+export const DEFAULT_WEIGHTS = Object.freeze({
+  vector: 0.45,
+  lexical: 0.35,
+  metadata: 0.15,
+  recency: 0.05,
+});
+
+function clamp01(value) {
+  if (!Number.isFinite(value)) return 0;
+  if (value < 0) return 0;
+  if (value > 1) return 1;
+  return value;
+}
+
+/**
+ * Compute a fused score from component signals.
+ *
+ * @param {object} components
+ * @param {number} [components.vector]    cosine similarity in [0, 1]
+ * @param {number} [components.lexical]   normalized lexical score in [0, 1]
+ * @param {number} [components.metadata]  metadata-match score in [0, 1]
+ * @param {number} [components.recency]   freshness score in [0, 1]
+ * @param {object} [weights]
+ * @returns {{ vector, lexical, metadata, recency, finalScore, weights }}
+ */
+export function fuseScores(components = {}, weights = DEFAULT_WEIGHTS) {
+  const v = clamp01(components.vector);
+  const l = clamp01(components.lexical);
+  const m = clamp01(components.metadata);
+  const r = clamp01(components.recency);
+  const w = { ...DEFAULT_WEIGHTS, ...weights };
+  const finalScore = clamp01(v * w.vector + l * w.lexical + m * w.metadata + r * w.recency);
+  return { vector: v, lexical: l, metadata: m, recency: r, finalScore, weights: w };
+}
+
+/**
+ * Reciprocal Rank Fusion across N ranked lists. Each list is an array
+ * of `{ id, ... }` objects ordered by descending relevance.
+ *
+ * @param {Array<Array<object>>} rankedLists
+ * @param {object} [opts]
+ * @param {number} [opts.k=60]
+ * @returns {Array<{ id, rrfScore, appearsIn: number }>}
+ */
+export function reciprocalRankFusion(rankedLists, { k = 60 } = {}) {
+  if (!Array.isArray(rankedLists) || rankedLists.length === 0) return [];
+  const scores = new Map();
+  for (const list of rankedLists) {
+    if (!Array.isArray(list)) continue;
+    list.forEach((item, idx) => {
+      if (!item?.id) return;
+      const rrf = 1 / (k + idx + 1);
+      const prev = scores.get(item.id) || { id: item.id, rrfScore: 0, appearsIn: 0 };
+      prev.rrfScore += rrf;
+      prev.appearsIn += 1;
+      scores.set(item.id, prev);
+    });
+  }
+  return [...scores.values()].sort((a, b) => b.rrfScore - a.rrfScore);
+}
+
+/**
+ * Compute a normalized recency score in [0, 1] given a timestamp and
+ * a half-life in days. A doc updated today scores ~1, a doc older than
+ * 4× the half-life scores near 0.
+ */
+export function recencyScore(updatedAt, { halfLifeDays = 30, now = Date.now() } = {}) {
+  if (!updatedAt) return 0;
+  const ts = updatedAt instanceof Date ? updatedAt.getTime() : Date.parse(updatedAt);
+  if (!Number.isFinite(ts)) return 0;
+  const ageMs = Math.max(0, now - ts);
+  const halfLifeMs = halfLifeDays * 24 * 60 * 60 * 1000;
+  if (halfLifeMs <= 0) return 0;
+  return clamp01(Math.pow(0.5, ageMs / halfLifeMs));
+}

package/lib/storage/hybrid-query.mjs

@@ -4,9 +4,10 @@
  */
 import { loadStateSnapshot, summarizeStateSnapshot } from './state-source.mjs';
 import { describeSqlStore } from './sql-store.mjs';
-import { describeVectorStore, vectorSearchLocal } from './vector-store.mjs';
+import { describeVectorStore, searchLocalVectorIndex, vectorSearchLocal } from './vector-store.mjs';
 import { createSqlClient, closeSqlClient, readVectorConfig } from './backend.mjs';
-import { EMBEDDING_MODEL, embedText, scoreEmbeddedDocuments } from './embeddings.mjs';
+import { scoreByEmbedding } from './embeddings.mjs';
+import { embedText, getEmbeddingModelInfo } from './embeddings-engine.mjs';
 
 function collectFileCandidates(snapshot) {
   const docs = [];
@@ -22,20 +23,9 @@ function collectFileCandidates(snapshot) {
     });
   }
 
-  if (snapshot.workflow) {
-    docs.push({
-      id: '.cx/workflow.json',
-      kind: 'workflow',
-      title: snapshot.workflow.title || 'Workflow state',
-      summary: snapshot.workflow.summary || null,
-      body: JSON.stringify(snapshot.workflow, null, 2),
-      tags: ['workflow', 'state', 'cx'],
-    });
-  }
-
   if (snapshot.architecture) {
     docs.push({
-      id: 'docs/architecture.md',
+      id: 'docs/concepts/architecture.md',
       kind: 'architecture',
       title: 'Architecture docs',
       summary: snapshot.architecture.slice(0, 240),
@@ -60,14 +50,14 @@ function collectFileCandidates(snapshot) {
       ? 'prd'
       : doc.path.startsWith('docs/meta-prd/')
         ? 'meta-prd'
-        : 'product-intel';
+        : 'knowledge';
     docs.push({
       id: doc.path,
       kind,
       title: doc.title,
       summary: doc.body.slice(0, 240),
       body: doc.body,
-      tags: ['product-intel', kind],
+      tags: ['knowledge', kind],
     });
   }
 
@@ -77,10 +67,24 @@ function collectFileCandidates(snapshot) {
 export function buildHybridSearchResults(rootDir, query, { limit = 10, env = process.env } = {}) {
   const snapshot = loadStateSnapshot(rootDir);
   const fileCandidates = collectFileCandidates(snapshot);
-  const fileHits = vectorSearchLocal(fileCandidates, query, { limit });
-
   const sqlStore = describeSqlStore(env);
   const vectorStore = describeVectorStore(env);
+  const fileHits = vectorSearchLocal(fileCandidates, query, { limit });
+  const localVectorHits = vectorStore.mode === 'local' && vectorStore.indexPath
+    ? searchLocalVectorIndex(vectorStore.indexPath, query, { limit })
+    : [];
+  const merged = [...fileHits];
+  for (const hit of localVectorHits) {
+    if (merged.some((entry) => entry.id === hit.id)) continue;
+    merged.push({
+      id: hit.id,
+      kind: hit.kind,
+      title: hit.title,
+      summary: hit.summary,
+      score: hit.score,
+      source_path: hit.source_path,
+    });
+  }
 
   return {
     query,
@@ -90,7 +94,7 @@ export function buildHybridSearchResults(rootDir, query, { limit = 10, env = pro
       sql: sqlStore,
       vector: vectorStore,
     },
-    results: fileHits.map((hit) => ({
+    results: merged.slice(0, limit).map((hit) => ({
       id: hit.id,
       kind: hit.kind,
       title: hit.title,
@@ -105,20 +109,23 @@ export async function buildHybridSearchResultsAsync(rootDir, query, { limit = 10
   const client = createSqlClient(env);
   if (!client) return base;
 
+  // Resolve the active embedding model so the SQL filter and the query
+  // embedding agree on dimensionality and identity.
+  const modelInfo = await getEmbeddingModelInfo({ env });
+  const embeddingModel = modelInfo.model;
+
   try {
     const embeddingRows = await client`
       select d.id, d.kind, d.title, d.summary, d.body, d.source_path, d.tags, e.embedding
       from construct_documents d
       join construct_embeddings e on e.document_id = d.id
-      where d.project = 'construct' and e.model = ${EMBEDDING_MODEL}
+      where d.project = 'construct' and e.model = ${embeddingModel}
     `;
 
-    const embeddedHits = scoreEmbeddedDocuments(
-      embeddingRows.map((row) => ({
-        ...row,
-        embedding: row.embedding,
-      })),
-      query,
+    const queryEmbedding = (await embedText(query, { env })).embedding;
+    const embeddedHits = scoreByEmbedding(
+      embeddingRows.map((row) => ({ ...row, embedding: row.embedding })),
+      Array.from(queryEmbedding),
       { limit },
     );
 
@@ -163,7 +170,7 @@ export async function buildHybridSearchResultsAsync(rootDir, query, { limit = 10
         vector: {
           ...base.stores.vector,
           ...readVectorConfig(env),
-          model: EMBEDDING_MODEL,
+          model: embeddingModel,
         },
         sql: {
           ...base.stores.sql,