akm-cli 0.9.17-alpha.2 → 0.9.17-alpha.4

package/dist/storage/repositories/index-vec-repository.js

@@ -1,465 +1,184 @@
 // This Source Code Form is subject to the terms of the Mozilla Public
 // License, v. 2.0. If a copy of the MPL was not distributed with this
 // file, You can obtain one at https://mozilla.org/MPL/2.0/.
-/**
- * `index.db` vector + embedding repository.
- *
- * Owns the sqlite-vec extension load/availability probe, the BLOB `embeddings`
- * table, the `entries_vec` virtual table, and the JS-cosine fallback path.
- */
-import { createRequire } from "node:module";
-import { bestEffort } from "../../core/best-effort.js";
-import { warn } from "../../core/warn.js";
-import { cosineSimilarity } from "../../llm/embedders/types.js";
+import { buildSearchText } from "../../indexer/search/search-fields.js";
 import { getMeta, setMeta } from "./index-meta-repository.js";
 import { SQLITE_CHUNK_SIZE } from "./index-sql.js";
-// ── sqlite-vec extension ────────────────────────────────────────────────────
-const vecStatus = new WeakMap();
-/**
- * Attempt to load the sqlite-vec extension into `db`, recording availability.
- * Exported so the connection lifecycle can arm it at open time.
- */
-export function loadVecExtension(db) {
-    try {
-        const esmRequire = createRequire(import.meta.url);
-        const sqliteVec = esmRequire("sqlite-vec");
-        // `db` is the storage boundary's handle. On Bun that IS the bun:sqlite
-        // handle; on Node it is a wrapper, which must forward `loadExtension` for
-        // this call to work at all (see openNodeDatabase in storage/database.ts —
-        // it did not, so vec could never load on the entire npm distribution).
-        sqliteVec.load(db);
-        vecStatus.set(db, true);
-    }
-    catch {
-        vecStatus.set(db, false);
-    }
-}
-export function isVecAvailable(db) {
-    return vecStatus.get(db) ?? false;
-}
 /**
- * Meta key persisting whether the sqlite-vec fast-path table (`entries_vec`) is
- * fully populated and trustworthy for this index. Set to "0" by the embedding
- * phase when one or more vec inserts FAILED (e.g. a vec0 dimension mismatch)
- * while their BLOB rows still wrote — so semantic search reads the complete
- * BLOB table via the JS-cosine fallback instead of a partial/mismatched vec
- * table. Absent (legacy indexes) and "1" both mean the fast path is trusted.
+ * The embedding model whose vectors this index currently serves: the provider
+ * fingerprint the last embedding pass targeted (`index_meta.embeddingFingerprint`).
+ * `undefined` on an index that has never run an embedding pass.
  */
-const VEC_FAST_PATH_READY_META = "vecFastPathReady";
-/** Persist whether the sqlite-vec fast path is trustworthy (see the meta doc). */
-export function setVecFastPathReady(db, ready) {
-    setMeta(db, VEC_FAST_PATH_READY_META, ready ? "1" : "0");
+function currentEmbeddingModel(db) {
+    return getMeta(db, "embeddingFingerprint");
 }
+const modelColumnPresent = new WeakMap();
 /**
- * True unless the embedding phase recorded a vec insert failure. Reflects the
- * ACTUAL insert outcomes recorded at index time — not an inference from how many
- * BLOB rows exist — so a degraded vec table routes search to the JS fallback
- * rather than silently returning partial fast-path results.
+ * Whether `embeddings` carries the per-row `model` column. A read-only open of
+ * an index the writable opener has not migrated yet does not; its rows are
+ * then all served as the current model. Only a positive answer is memoized:
+ * the column can appear on a live connection (`ensureSchema`), never vanish.
  */
-export function isVecFastPathReady(db) {
-    if (getMeta(db, VEC_FAST_PATH_READY_META) === "0")
-        return false;
-    // The meta flag alone is not sufficient. An index built while sqlite-vec was
-    // unavailable wrote only BLOB rows, and because "unavailable" outcomes were
-    // not counted as failures the flag was still set to "1" against a table that
-    // is empty or absent. If sqlite-vec later becomes loadable — the user installs
-    // it, or the same index is opened under the other runtime — the fast path
-    // would then be trusted and return zero neighbours while the BLOB table holds
-    // every embedding. Indexes written by earlier versions still carry that stale
-    // flag, so the read path has to verify the table really exists.
-    return hasVecTable(db);
-}
-/**
- * Verify that the vec fast-path table mirrors the complete durable BLOB set.
- *
- * A targeted embedding write preserves the prior readiness decision because
- * its subset cannot prove an older degraded generation is healed. Global
- * materialization uses this aggregate check before promoting the persisted
- * flag; search itself still reads the cheap flag and does not repeat the check
- * per query.
- */
-export function isVecFastPathComplete(db) {
-    if (!isVecAvailable(db) || !hasVecTable(db))
-        return false;
-    try {
-        const missingVecRows = db
-            .prepare(`
-        SELECT id FROM embeddings
-        EXCEPT
-        SELECT id FROM entries_vec
-        LIMIT 1
-      `)
-            .all();
-        if (missingVecRows.length > 0)
-            return false;
-        const orphanVecRows = db
-            .prepare(`
-        SELECT id FROM entries_vec
-        EXCEPT
-        SELECT id FROM embeddings
-        LIMIT 1
-      `)
-            .all();
-        return orphanVecRows.length === 0;
-    }
-    catch {
-        return false;
-    }
-}
-/**
- * Reconcile sqlite-vec's derived mirror from the durable BLOB embeddings.
- *
- * This never calls an embedding provider and never mutates the BLOB table.
- * The readiness flag is lowered before the first mutation and is promoted only
- * after a bidirectional aggregate check proves both ID sets match exactly.
- */
-export function repairVecFastPath(db, embeddingDim) {
-    let repaired = 0;
-    let removedOrphans = 0;
-    let rejected = 0;
-    setVecFastPathReady(db, false);
-    if (!isVecAvailable(db) || !hasVecTable(db)) {
-        return { available: false, repaired, removedOrphans, rejected, complete: false };
-    }
-    if (!Number.isInteger(embeddingDim) || embeddingDim <= 0) {
-        return {
-            available: true,
-            repaired,
-            removedOrphans,
-            rejected,
-            complete: false,
-            error: `Invalid embedding dimension ${embeddingDim}.`,
-        };
-    }
-    try {
-        while (true) {
-            const orphanIds = db
-                .prepare(`
-          SELECT id FROM entries_vec
-          EXCEPT
-          SELECT id FROM embeddings
-          ORDER BY id
-          LIMIT ?
-        `)
-                .all(SQLITE_CHUNK_SIZE);
-            if (orphanIds.length === 0)
-                break;
-            db.transaction(() => {
-                const remove = db.prepare("DELETE FROM entries_vec WHERE id = ?");
-                for (const { id } of orphanIds) {
-                    remove.run(id);
-                    removedOrphans++;
-                }
-            })();
-        }
-        let afterId = -1;
-        while (true) {
-            const missingIds = db
-                .prepare(`
-          SELECT id FROM (
-            SELECT id FROM embeddings
-            EXCEPT
-            SELECT id FROM entries_vec
-          ) AS missing
-          WHERE id > ?
-          ORDER BY id
-          LIMIT ?
-        `)
-                .all(afterId, SQLITE_CHUNK_SIZE);
-            if (missingIds.length === 0)
-                break;
-            afterId = missingIds[missingIds.length - 1].id;
-            const placeholders = missingIds.map(() => "?").join(",");
-            const rows = db
-                .prepare(`SELECT id, embedding FROM embeddings WHERE id IN (${placeholders}) ORDER BY id`)
-                .all(...missingIds.map(({ id }) => id));
-            db.transaction(() => {
-                const insert = db.prepare("INSERT INTO entries_vec (id, embedding) VALUES (?, ?)");
-                for (const row of rows) {
-                    if (row.embedding.byteLength !== embeddingDim * 4) {
-                        rejected++;
-                        continue;
-                    }
-                    try {
-                        insert.run(row.id, Buffer.from(row.embedding));
-                        repaired++;
-                    }
-                    catch {
-                        rejected++;
-                    }
-                }
-            })();
-        }
-        const complete = rejected === 0 && isVecFastPathComplete(db);
-        setVecFastPathReady(db, complete);
-        return { available: true, repaired, removedOrphans, rejected, complete };
-    }
-    catch (error) {
-        setVecFastPathReady(db, false);
-        return {
-            available: true,
-            repaired,
-            removedOrphans,
-            rejected,
-            complete: false,
-            error: error instanceof Error ? error.message : String(error),
-        };
-    }
-}
-const vecTablePresent = new WeakMap();
-/**
- * Whether `entries_vec` exists on this connection, memoized per handle.
- *
- * openExistingDatabase loads the vec extension but deliberately does not run
- * ensureSchema, so the table is not created on read paths — its absence is a
- * normal state, not an error.
- */
-function hasVecTable(db) {
-    // Only a POSITIVE result is memoized. The table cannot vanish from a live
-    // connection, but it CAN appear — ensureSchema creates it partway through an
-    // index run — so caching "absent" would pin a stale answer for the rest of
-    // the handle's life.
-    if (vecTablePresent.get(db) === true)
+function hasModelColumn(db) {
+    if (modelColumnPresent.get(db) === true)
         return true;
     let present = false;
     try {
-        present =
-            db.prepare("SELECT 1 FROM sqlite_master WHERE type IN ('table','view') AND name = 'entries_vec'").get() !==
-                undefined;
+        present = db.prepare("PRAGMA table_info(embeddings)").all().some((column) => column.name === "model");
     }
     catch {
         present = false;
     }
     if (present)
-        vecTablePresent.set(db, true);
+        modelColumnPresent.set(db, true);
     return present;
 }
-/** Remove both vector representations for an entry whose embedding input changed. */
+/**
+ * SQL predicate selecting `embeddings` rows usable for `model`. A NULL model
+ * predates per-row model tracking and is trusted as the current model; when
+ * no model is known at all, or the index predates the column, every row
+ * qualifies.
+ */
+function modelPredicate(db, model, alias = "embeddings") {
+    if (model === undefined || !hasModelColumn(db))
+        return { sql: "1", params: [] };
+    return { sql: `(${alias}.model IS NULL OR ${alias}.model = ?)`, params: [model] };
+}
+/** Remove the vector of an entry whose embedding input changed. */
 export function deleteEntryVectors(db, id) {
     db.prepare("DELETE FROM embeddings WHERE id = ?").run(id);
-    if (isVecAvailable(db))
-        db.prepare("DELETE FROM entries_vec WHERE id = ?").run(id);
 }
-const VEC_DOCS_URL = "https://github.com/itlackey/akm/blob/main/docs/reference/configuration.md#sqlite-vec-extension";
-const VEC_FALLBACK_THRESHOLD = 10_000;
-// Per-database warning state: tracks which databases have already emitted the
-// vec-missing warning so we don't spam on every openDatabase() call.
-const vecInitWarnedDbs = new WeakSet();
 /**
- * Warn if sqlite-vec is unavailable and embedding count exceeds threshold.
- * Called from openDatabase (once at init) and from indexer (each run).
+ * Purge every stored vector and mark the index as embedding-free. Only the
+ * explicit `akm index --reembed` override calls this: a model or dimension
+ * change keeps every stored row (each carries its own model) and re-embeds
+ * incrementally.
  */
-export function warnIfVecMissing(db, { once } = { once: false }) {
-    if (isVecAvailable(db))
-        return;
-    if (once && vecInitWarnedDbs.has(db))
-        return;
-    bestEffort(() => {
-        const row = db.prepare("SELECT COUNT(*) AS cnt FROM embeddings").get();
-        const count = row?.cnt ?? 0;
-        if (count >= VEC_FALLBACK_THRESHOLD) {
-            warn("Semantic search is using JS fallback for %d entries. Install sqlite-vec for faster performance.\n  See: %s", count, VEC_DOCS_URL);
-            if (once)
-                vecInitWarnedDbs.add(db);
-        }
-    }, "embeddings table may not exist yet during init");
+export function purgeEmbeddings(db) {
+    db.exec("DELETE FROM embeddings");
+    setMeta(db, "hasEmbeddings", "0");
 }
 /**
- * Purge stored embeddings (BLOB rows in `embeddings`, plus the `entries_vec`
- * virtual table) and mark the index as embedding-free. The single place that
- * invalidates embeddings — used on a dimension change, a model/provider change,
- * and a full rebuild.
- *
- * No backup: embeddings are a derived cache, fully regenerable from the markdown
- * by the next `akm index`. (Recovery model decided 2026-06-25.)
- *
- * `dropVecTable: true` DROPs `entries_vec` — used on a DIMENSION change, where
- * the vec0 table must be recreated at the new width by the caller. The default
- * clears its rows in place (same dimension, stale vectors).
+ * Store one entry's vector. `model` is the provider fingerprint it was
+ * generated under (`deriveSemanticProviderFingerprint`); a row written without
+ * one is trusted as the current model. Returns false, writing nothing, when
+ * the entry no longer exists.
  */
-export function purgeEmbeddings(db, opts) {
-    bestEffort(() => db.exec("DELETE FROM embeddings"), "purge embeddings");
-    if (isVecAvailable(db)) {
-        bestEffort(() => db.exec(opts?.dropVecTable ? "DROP TABLE IF EXISTS entries_vec" : "DELETE FROM entries_vec"), "purge entries_vec");
-    }
-    setMeta(db, "hasEmbeddings", "0");
-}
-export function upsertEmbedding(db, entryId, embedding) {
+export function upsertEmbedding(db, entryId, embedding, model) {
     // Pre-flight FK guard: when an entry is deleted between when its id is queued
     // for embedding and when this INSERT runs (e.g. consolidation deletes during
     // a concurrent improve cycle), the INSERT throws "FOREIGN KEY constraint failed"
     // and rolls back the entire batch transaction in the caller, losing every
     // embedding for that run. A cheap SELECT here turns the race into a clean skip.
-    const exists = db.prepare("SELECT 1 FROM entries WHERE id = ?").get(entryId);
-    if (!exists)
-        return { stored: false, vec: "unavailable" };
-    const buf = float32Buffer(embedding);
-    // Always write to BLOB table (works without sqlite-vec; the JS-cosine fallback
-    // reads it, so semantic search survives a vec fast-path failure).
-    db.prepare("INSERT OR REPLACE INTO embeddings (id, embedding) VALUES (?, ?)").run(entryId, buf);
-    if (!isVecAvailable(db))
-        return { stored: true, vec: "unavailable" };
-    // Fast path: mirror into the sqlite-vec table. Wrapped in a transaction so a
-    // crash between DELETE and INSERT does not leave the entry missing. A THROW
-    // here — previously swallowed silently by bestEffort — is now surfaced to the
-    // caller so the embedding phase can count it, warn, and route search to the
-    // (complete) BLOB table rather than a partial/mismatched vec table.
-    try {
-        db.transaction(() => {
-            db.prepare("DELETE FROM entries_vec WHERE id = ?").run(entryId);
-            db.prepare("INSERT INTO entries_vec (id, embedding) VALUES (?, ?)").run(entryId, buf);
-        })();
-        return { stored: true, vec: "ok" };
-    }
-    catch {
-        return { stored: true, vec: "failed" };
-    }
-}
-export function searchVec(db, queryEmbedding, k) {
-    // Fast path: sqlite-vec, but ONLY when the extension is loaded AND the
-    // embedding phase did not record a vec insert failure. A degraded fast-path
-    // table (partial or dimension-mismatched) would return wrong or missing
-    // neighbours, so we honestly fall back to the JS-cosine scan over the
-    // complete BLOB table instead.
-    if (isVecAvailable(db) && isVecFastPathReady(db)) {
-        const buf = float32Buffer(queryEmbedding);
-        try {
-            return db
-                .prepare("SELECT id, distance FROM entries_vec WHERE embedding MATCH ? AND k = ?")
-                .all(buf, k);
-        }
-        catch (err) {
-            // A dimension mismatch (e.g. the embedding provider/model changed since
-            // the fast-path table was built) is a real, expected reason this query
-            // specifically cannot use the vec table — the complete BLOB table below
-            // is unaffected, so fall back to it rather than either silently
-            // returning [] (masking a genuinely corrupt index) or failing the whole
-            // search over one degraded index.
-            warn("[db] searchVec (sqlite-vec path) failed, falling back to JS-cosine scan:", err instanceof Error ? err.message : String(err));
-            return searchBlobVec(db, queryEmbedding, k);
-        }
-    }
-    // Fallback: JS-based cosine similarity over BLOB table
-    return searchBlobVec(db, queryEmbedding, k);
+    if (!db.prepare("SELECT 1 FROM entries WHERE id = ?").get(entryId))
+        return false;
+    db.prepare("INSERT OR REPLACE INTO embeddings (id, embedding, model) VALUES (?, ?, ?)").run(entryId, Buffer.from(new Float32Array(embedding).buffer), model ?? null);
+    return true;
 }
 /**
- * Return the k nearest neighbours of an already-indexed entry using its
- * persisted embedding — no re-embedding, no network. Decodes the stored BLOB by
- * byte length (dim = bytes / 4) and reuses searchVec (sqlite-vec fast path or
- * JS-cosine fallback). Returns [] when the entry has no stored embedding or the
- * BLOB is corrupt. The query entry itself is typically returned with distance
- * ~0 — callers should filter it out by id.
+ * The `k` stored vectors nearest to `query` by cosine similarity, best first
+ * (ties by id): an exact scan of the current model's rows. `distance` is
+ * `sqrt(2 * (1 - cosine))`, the L2 distance between the unit-normalised
+ * vectors. Rows of another width, left by a model that is no longer current,
+ * never match.
  */
-export function getNeighborsByEntryId(db, id, k) {
-    const row = db.prepare("SELECT embedding FROM embeddings WHERE id = ?").get(id);
-    if (!row)
-        return [];
-    const queryEmbedding = bufferToFloat32(row.embedding, Math.floor(row.embedding.byteLength / 4));
-    if (!queryEmbedding)
+export function searchVec(db, query, k) {
+    const dim = query.length;
+    const q = Float64Array.from(query);
+    let queryNorm = 0;
+    for (let i = 0; i < dim; i++)
+        queryNorm += q[i] * q[i];
+    if (k <= 0 || queryNorm === 0)
         return [];
-    return searchVec(db, queryEmbedding, k);
-}
-function float32Buffer(vec) {
-    const f32 = new Float32Array(vec);
-    return Buffer.from(f32.buffer);
+    queryNorm = Math.sqrt(queryNorm);
+    const current = modelPredicate(db, currentEmbeddingModel(db));
+    const ids = [];
+    const similarities = [];
+    const rows = db
+        .prepare(`SELECT id, embedding FROM embeddings WHERE ${current.sql}`)
+        .iterate(...current.params);
+    for (const { id, embedding } of rows) {
+        if (embedding.byteLength !== dim * 4)
+            continue;
+        // A Float32Array view needs 4-byte alignment; copy the rare row that lacks it.
+        const vector = embedding.byteOffset % 4 === 0
+            ? new Float32Array(embedding.buffer, embedding.byteOffset, dim)
+            : new Float32Array(embedding.slice().buffer);
+        let dot = 0;
+        let norm = 0;
+        for (let i = 0; i < dim; i++) {
+            const x = vector[i];
+            dot += x * q[i];
+            norm += x * x;
+        }
+        if (norm === 0)
+            continue;
+        ids.push(id);
+        similarities.push(dot / (Math.sqrt(norm) * queryNorm));
+    }
+    const order = ids.map((_, index) => index);
+    order.sort((a, b) => similarities[b] - similarities[a] || ids[a] - ids[b]);
+    return order.slice(0, k).map((index) => ({
+        id: ids[index],
+        distance: Math.sqrt(2 * Math.max(0, 1 - similarities[index])),
+    }));
 }
 /**
- * Decode a stored embedding BLOB into a Float32 array of `expectedDim`
- * dimensions. Returns `null` (and emits a warning) when the byte length does
- * not exactly match `expectedDim * 4`, including the legacy partial-trailing
- * float case the previous truncating-divide silently swallowed.
- *
- * BUG-M2: the previous `buf.byteLength / 4` divide would truncate any
- * trailing partial float and a misaligned `byteOffset` would throw — both
- * surfaced as opaque generic errors caught upstream.
+ * The k nearest neighbours of an already-indexed entry, by its stored vector —
+ * no re-embedding, no network. Returns [] when the entry has no stored
+ * vector. The entry itself is typically returned with distance ~0; callers
+ * filter it out by id.
  */
-function bufferToFloat32(buf, expectedDim) {
-    if (buf.byteLength !== expectedDim * 4) {
-        warn("[db] bufferToFloat32: skipping embedding row — expected %d bytes (%d dim x 4), got %d", expectedDim * 4, expectedDim, buf.byteLength);
-        return null;
-    }
-    // Copy into a fresh ArrayBuffer to sidestep any byteOffset alignment
-    // requirements imposed by Float32Array's typed-array view contract.
-    const aligned = new ArrayBuffer(buf.byteLength);
-    new Uint8Array(aligned).set(buf);
-    const f32 = new Float32Array(aligned);
-    return Array.from(f32);
-}
-function searchBlobVec(db, queryEmbedding, k) {
-    const rows = db.prepare("SELECT id, embedding FROM embeddings").all();
-    if (rows.length === 0)
+export function getNeighborsByEntryId(db, id, k) {
+    const row = db.prepare("SELECT embedding FROM embeddings WHERE id = ?").get(id);
+    if (!row || row.embedding.byteLength % 4 !== 0)
         return [];
-    const expectedDim = queryEmbedding.length;
-    const scored = [];
-    for (const row of rows) {
-        const embedding = bufferToFloat32(row.embedding, expectedDim);
-        if (embedding === null)
-            continue;
-        const similarity = cosineSimilarity(queryEmbedding, embedding);
-        scored.push({ id: row.id, similarity });
-    }
-    scored.sort((a, b) => b.similarity - a.similarity);
-    // Convert cosine similarity to L2 distance for compatibility with sqlite-vec interface
-    // For normalized vectors: L2² = 2(1 - cos_sim)
-    return scored.slice(0, k).map(({ id, similarity }) => ({
-        id,
-        distance: Math.sqrt(2 * Math.max(0, 1 - similarity)),
-    }));
+    return searchVec(db, new Float32Array(row.embedding.slice().buffer), k);
 }
 /**
- * Return all entries that do not yet have an embedding row.
- * Used by the embedding phase to determine which entries need vectors generated.
+ * Every entry that has no embedding row for `model` (any row when no model is
+ * given), with its embedding input derived from the stored document
+ * (`buildSearchText`, whose hash `upsertEntry` keeps in `entries.embed_hash`).
+ * This is the embedding pass's cursor: a row generated under another model
+ * counts as missing and is replaced when the entry is re-embedded, so a model
+ * change re-embeds incrementally and an interrupted pass resumes where it
+ * stopped. A row whose `document_json` does not parse has no text to embed
+ * and is left out.
  */
-export function getAllEntriesForEmbedding(db, entryIds) {
-    const select = `
-      SELECT e.id, e.search_text AS searchText, e.item_ref AS itemRef, e.file_path AS filePath FROM entries e
-    `;
-    const missing = "NOT EXISTS (SELECT 1 FROM embeddings b WHERE b.id = e.id)";
+export function getAllEntriesForEmbedding(db, entryIds, model) {
+    const select = "SELECT e.id, e.document_json AS documentJson, e.item_ref AS itemRef, e.file_path AS filePath FROM entries e";
+    const current = modelPredicate(db, model, "b");
+    const missing = `NOT EXISTS (SELECT 1 FROM embeddings b WHERE b.id = e.id AND ${current.sql})`;
+    const rows = [];
     if (entryIds === undefined) {
-        return db.prepare(`${select} WHERE ${missing} ORDER BY e.id`).all();
+        rows.push(...db.prepare(`${select} WHERE ${missing} ORDER BY e.id`).all(...current.params));
+    }
+    else {
+        const targets = [...new Set(entryIds)].sort((left, right) => left - right);
+        for (let offset = 0; offset < targets.length; offset += SQLITE_CHUNK_SIZE) {
+            const chunk = targets.slice(offset, offset + SQLITE_CHUNK_SIZE);
+            const placeholders = chunk.map(() => "?").join(",");
+            rows.push(...db
+                .prepare(`${select} WHERE e.id IN (${placeholders}) AND ${missing} ORDER BY e.id`)
+                .all(...chunk, ...current.params));
+        }
     }
-    const targets = [...new Set(entryIds)].sort((left, right) => left - right);
-    const rows = [];
-    for (let offset = 0; offset < targets.length; offset += SQLITE_CHUNK_SIZE) {
-        const chunk = targets.slice(offset, offset + SQLITE_CHUNK_SIZE);
-        if (chunk.length === 0)
+    const entries = [];
+    for (const { documentJson, ...row } of rows) {
+        let document;
+        try {
+            document = JSON.parse(documentJson);
+        }
+        catch {
             continue;
-        const placeholders = chunk.map(() => "?").join(",");
-        rows.push(...db.prepare(`${select} WHERE e.id IN (${placeholders}) AND ${missing} ORDER BY e.id`).all(...chunk));
+        }
+        entries.push({ ...row, searchText: buildSearchText(document) });
     }
-    return rows;
+    return entries;
 }
-export function getEmbeddingCount(db) {
-    const row = db.prepare("SELECT COUNT(*) AS cnt FROM embeddings").get();
+/** Stored embedding rows — for `model` when given, otherwise every row. */
+export function getEmbeddingCount(db, model) {
+    const current = modelPredicate(db, model);
+    const row = db.prepare(`SELECT COUNT(*) AS cnt FROM embeddings WHERE ${current.sql}`).get(...current.params);
     return row.cnt;
 }
-/**
- * Sample up to `limit` already-embedded entries (id, search text, and the
- * stored vector) for the embedding-fingerprint canary check: re-embedding
- * these texts with the CURRENT config and comparing against `vector` is how
- * a model-string rename is told apart from a genuine model/dimension change
- * (#955), without trusting the config string alone.
- *
- * Ordered by `id` for a deterministic, cheap sample (no `ORDER BY RANDOM()`)
- * — the canary only needs "some" already-verified vectors, not a
- * statistically representative one. A corrupt stored BLOB (see
- * `bufferToFloat32`) is skipped rather than failing the whole sample.
- */
-export function sampleEmbeddedEntriesForCanary(db, limit) {
-    const rows = db
-        .prepare(`
-      SELECT e.id, e.search_text AS searchText, em.embedding AS embedding
-      FROM entries e
-      JOIN embeddings em ON em.id = e.id
-      ORDER BY e.id
-      LIMIT ?
-    `)
-        .all(limit);
-    const samples = [];
-    for (const row of rows) {
-        const vector = bufferToFloat32(row.embedding, Math.floor(row.embedding.byteLength / 4));
-        if (vector)
-            samples.push({ id: row.id, searchText: row.searchText, vector });
-    }
-    return samples;
-}

package/dist/storage/repositories/outcome-repository.js

@@ -40,7 +40,8 @@ export function getAssetOutcome(db, ref) {
     return row == null ? undefined : row;
 }
 /**
- * Load ALL asset_outcome rows. Used for the proxy-adequacy tripwire computation.
+ * Load ALL asset_outcome rows. Used for the stash-wide outcome-score
+ * normalisation in improve preparation.
  */
 export function getAllAssetOutcomes(db) {
     return db

package/dist/storage/repositories/proposals-repository.js

@@ -402,3 +402,38 @@ export function listStateProposalIdsByPrefix(db, stashDir, idPrefix) {
         .all(stashDir, `${escaped}%`);
     return rows.map((r) => r.id);
 }
+/**
+ * Preview counterpart of {@link renameProposalsBundleRef} for `akm bundle
+ * rename --dry-run`: the same two `WHERE` predicates, read-only.
+ */
+export function countProposalsForBundleRename(db, oldBundleId) {
+    const prefix = `${escapeLikePattern(oldBundleId)}//`;
+    const refs = db.prepare(`SELECT COUNT(*) AS n FROM proposals WHERE ref LIKE ? ESCAPE '\\'`).get(`${prefix}%`).n;
+    const targets = db
+        .prepare(`SELECT COUNT(*) AS n FROM proposals WHERE json_extract(metadata_json, '$.proposedTarget.source') = ?`)
+        .get(oldBundleId).n;
+    return { refs, targets };
+}
+/**
+ * Rewrite every proposal that names `oldBundleId` from `akm bundle rename`
+ * (D6): the fully-qualified `ref` column (`<bundle>//conceptId` — an
+ * unqualified legacy `ref` resolves against `defaultBundle` at use time and
+ * never names a bundle explicitly, so it is left alone), and
+ * `metadata_json.proposedTarget.source`, which names the write-target bundle
+ * a still-pending proposal would apply to (`resolveRecordedProposalTarget`,
+ * `commands/proposal/repository.ts`). Returns how many rows of each were
+ * rewritten.
+ */
+export function renameProposalsBundleRef(db, oldBundleId, newBundleId) {
+    const prefix = `${escapeLikePattern(oldBundleId)}//`;
+    return db.transaction(() => {
+        const refs = Number(db
+            .prepare(`UPDATE proposals SET ref = ? || substr(ref, ?) WHERE ref LIKE ? ESCAPE '\\'`)
+            .run(newBundleId, oldBundleId.length + 1, `${prefix}%`).changes);
+        const targets = Number(db
+            .prepare(`UPDATE proposals SET metadata_json = json_set(metadata_json, '$.proposedTarget.source', ?)
+           WHERE json_extract(metadata_json, '$.proposedTarget.source') = ?`)
+            .run(newBundleId, oldBundleId).changes);
+        return { refs, targets };
+    })();
+}