akm-cli 0.9.16 → 0.9.17-alpha.10

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

@@ -18,20 +18,30 @@ import { getStateDbPath, withStateDb } from "../../core/state-db.js";
 import { warn } from "../../core/warn.js";
 import { getMarkdownFragmentContent, hasMarkdownFragmentContent, } from "../../indexer/passes/metadata.js";
 import { buildSearchText } from "../../indexer/search/search-fields.js";
+import { sha256Hex } from "../../runtime.js";
 import { ENTRY_COLUMNS, rowToIndexedEntry } from "./index-entry-mapper.js";
 import { deleteFtsEntries, replaceFtsEntry } from "./index-fts-repository.js";
+import { deleteEntryLinks, replaceEntryLinks } from "./index-links-repository.js";
 import { SQLITE_CHUNK_SIZE } from "./index-sql.js";
-import { deleteEntryVectors, isVecAvailable } from "./index-vec-repository.js";
+import { deleteEntryVectors } from "./index-vec-repository.js";
 // ── Entry operations ────────────────────────────────────────────────────────
+/**
+ * Hash of the text an entry's vector is embedded from (`buildSearchText`),
+ * stored as `entries.embed_hash`: a change deletes the entry's vector, and the
+ * next embedding pass re-embeds it.
+ */
+function embedHash(entry) {
+    return sha256Hex(buildSearchText(entry));
+}
 /**
  * Insert or update one canonical entry and all synchronously derived search
  * state. Returns the stable row id.
  *
- * The entries row, FTS projection, and stale-vector invalidation commit as one
- * SQLite transaction. Callers therefore cannot publish an entry and forget a
- * second FTS maintenance step.
+ * The entries row, FTS projection, declared links, and stale-vector
+ * invalidation commit as one SQLite transaction. Callers therefore cannot
+ * publish an entry and forget a second FTS or links maintenance step.
  */
-export function upsertEntry(db, filePath, entry, searchText, provenance, contentHash) {
+export function upsertEntry(db, filePath, entry, provenance, contentHash) {
     // Hot path during indexing — cache prepared statements per database
     // connection so we don't pay the SQL parse/compile cost on every call.
     const stmts = getUpsertStmts(db);
@@ -39,16 +49,18 @@ export function upsertEntry(db, filePath, entry, searchText, provenance, content
     // dedicated `derived_from` column so retrieval-time lookup (parent→child)
     // does not have to scan + JSON-decode every memory row.
     const derivedFrom = typeof entry.derivedFrom === "string" && entry.derivedFrom.trim() ? entry.derivedFrom.trim() : null;
-    // `content_hash` is optional on the LLM-enrichment re-upsert; a missing hash
-    // preserves the scan writer's current value.
+    const hash = embedHash(entry);
+    // `content_hash` is optional; an upsert that omits it preserves the scan
+    // writer's current value.
     const apply = () => {
         const previous = stmts.findByItemRef.get(provenance.itemRef);
-        const result = stmts.upsert.get(provenance.itemRef, provenance.bundleId, provenance.componentId, provenance.conceptId, provenance.adapterId, entry.type, filePath, contentHash ?? null, JSON.stringify(entry), searchText, derivedFrom);
+        const result = stmts.upsert.get(provenance.itemRef, provenance.bundleId, provenance.componentId, provenance.conceptId, provenance.adapterId, entry.type, filePath, contentHash ?? null, JSON.stringify(entry), derivedFrom, hash);
         if (!result)
             throw new Error("upsertEntry: item_ref not found after upsert");
-        if (previous?.id === result.id && previous.search_text !== searchText)
+        if (previous?.id === result.id && previous.embed_hash !== hash)
             deleteEntryVectors(db, result.id);
         replaceFtsEntry(db, result.id, entry, hasMarkdownFragmentContent(entry) ? (getMarkdownFragmentContent(entry) ?? null) : undefined);
+        replaceEntryLinks(db, result.id, entry, provenance);
         return result.id;
     };
     // Always enter the driver's transaction wrapper. Both supported SQLite
@@ -58,8 +70,8 @@ export function upsertEntry(db, filePath, entry, searchText, provenance, content
     return db.transaction(apply)();
 }
 const upsertStmtsByDb = new WeakMap();
-// item_ref is the sole durable conflict target. `content_hash` COALESCEs so a
-// metadata-only enrichment pass cannot wipe a scan hash.
+// item_ref is the sole durable conflict target. `content_hash` COALESCEs so
+// an upsert that omits it (`contentHash` is optional) cannot wipe a scan hash.
 const UPSERT_SET_CLAUSE = `SET
         bundle_id = excluded.bundle_id,
         component_id = excluded.component_id,
@@ -68,8 +80,8 @@ const UPSERT_SET_CLAUSE = `SET
         type = excluded.type,
         file_path = excluded.file_path,
         document_json = excluded.document_json,
-        search_text = excluded.search_text,
         derived_from = excluded.derived_from,
+        embed_hash = excluded.embed_hash,
         content_hash = COALESCE(excluded.content_hash, content_hash)`;
 function getUpsertStmts(db) {
     const existing = upsertStmtsByDb.get(db);
@@ -82,13 +94,13 @@ function getUpsertStmts(db) {
         upsert: db.prepare(`
       INSERT INTO entries (
         item_ref, bundle_id, component_id, concept_id, adapter_id, type,
-        file_path, content_hash, document_json, search_text, derived_from
+        file_path, content_hash, document_json, derived_from, embed_hash
       )
       VALUES (?, ?, ?, ?, ?, ?, ?, ?, ?, ?, ?)
       ON CONFLICT(item_ref) DO UPDATE ${UPSERT_SET_CLAUSE}
       RETURNING id
     `),
-        findByItemRef: db.prepare("SELECT id, search_text FROM entries WHERE item_ref = ?"),
+        findByItemRef: db.prepare("SELECT id, embed_hash FROM entries WHERE item_ref = ?"),
     };
     upsertStmtsByDb.set(db, stmts);
     return stmts;
@@ -164,14 +176,13 @@ export function getBaseBeliefStatesForDerivedTwins(db, twinIds) {
 /**
  * Re-key an entries row in place for the opt-in source-maintenance script.
  *
- * The row id is preserved on purpose — `utility_scores`,
- * `utility_scores_scoped`, and `embeddings` are keyed by `entry_id`, so an
- * UPDATE (rather than a delete + insert under the new `item_ref`) is what
- * keeps the asset's accumulated usage-ranking history attached across a
- * rename. (`asset_salience` / `asset_outcome` live in state.db keyed by
- * `asset_ref` TEXT and are re-keyed separately by `akm mv` — see
+ * The row id is preserved on purpose — `utility_scores` and `embeddings` are
+ * keyed by `entry_id`, so an UPDATE (rather than a delete + insert under the
+ * new `item_ref`) is what keeps the asset's accumulated usage-ranking history
+ * attached across a rename. (`asset_salience` / `asset_outcome` live in
+ * state.db keyed by `asset_ref` TEXT and are re-keyed separately by `akm mv` — see
  * the state rekey helper.) `document_json.name` (and `filename`, when
- * present) is patched and `search_text` rebuilt so search reflects the new
+ * present) is patched and `embed_hash` recomputed so search reflects the new
  * name. Its FTS projection and stale vector are updated in the same
  * transaction as the canonical identity.
  *
@@ -187,7 +198,7 @@ export function getBaseBeliefStatesForDerivedTwins(db, twinIds) {
  * A stale row already occupying the new item ref (the caller has verified no
  * FILE exists at the target, so such a row can only be a leftover for a
  * deleted file) is evicted first — through {@link deleteRelatedRows}, so its
- * child rows (embeddings, entries_vec, utility scores, usage events) go with
+ * child rows (embeddings, utility scores, usage events) go with
  * it. A bare `DELETE FROM entries` would trip the non-CASCADE `embeddings`
  * FK under `PRAGMA foreign_keys = ON` and roll back the whole re-key.
  * The moved row keeps its id.
@@ -199,7 +210,7 @@ export function getBaseBeliefStatesForDerivedTwins(db, twinIds) {
 export function rekeyEntryInPlace(db, opts) {
     const oldItemRef = `${opts.sourceName}//${opts.oldRef}`;
     const row = db
-        .prepare("SELECT id, file_path, document_json, search_text, type FROM entries WHERE item_ref = ?")
+        .prepare("SELECT id, file_path, document_json, embed_hash, type FROM entries WHERE item_ref = ?")
         .get(oldItemRef);
     if (!row)
         return null;
@@ -211,7 +222,7 @@ export function rekeyEntryInPlace(db, opts) {
     // Patch the JSON payload. On corrupt document_json still re-key identity/path so
     // the utility history survives; the next full index heals the JSON.
     let documentJson = row.document_json;
-    let searchText = row.search_text;
+    let hash = row.embed_hash;
     let document;
     try {
         const entry = JSON.parse(row.document_json);
@@ -221,7 +232,7 @@ export function rekeyEntryInPlace(db, opts) {
         if (opts.newDerivedFrom !== undefined)
             entry.derivedFrom = opts.newDerivedFrom;
         documentJson = JSON.stringify(entry);
-        searchText = buildSearchText(entry);
+        hash = embedHash(entry);
         document = entry;
     }
     catch {
@@ -235,7 +246,7 @@ export function rekeyEntryInPlace(db, opts) {
     db.transaction(() => {
         const stale = db.prepare("SELECT id FROM entries WHERE item_ref = ?").get(newItemRef);
         if (stale && stale.id !== row.id) {
-            // Full child-row cleanup (embeddings, entries_vec, utility scores,
+            // Full child-row cleanup (embeddings, utility scores,
             // usage events, FTS + dirty marks) BEFORE the entries delete: the
             // `embeddings` FK is non-CASCADE and `foreign_keys = ON`, so a bare
             // entries delete would throw and roll back the entire re-key; and
@@ -243,14 +254,16 @@ export function rekeyEntryInPlace(db, opts) {
             deleteRelatedRows(db, [{ id: stale.id }]);
             db.prepare("DELETE FROM entries WHERE id = ?").run(stale.id);
         }
-        db.prepare("UPDATE entries SET file_path = ?, document_json = ?, search_text = ?, item_ref = ?, concept_id = ? WHERE id = ?").run(opts.newFilePath, documentJson, searchText, newItemRef, opts.newRef, row.id);
+        db.prepare("UPDATE entries SET file_path = ?, document_json = ?, embed_hash = ?, item_ref = ?, concept_id = ? WHERE id = ?").run(opts.newFilePath, documentJson, hash, newItemRef, opts.newRef, row.id);
         if (opts.newDerivedFrom !== undefined) {
             db.prepare("UPDATE entries SET derived_from = ? WHERE id = ?").run(opts.newDerivedFrom, row.id);
         }
-        if (row.search_text !== searchText)
+        if (row.embed_hash !== hash)
             deleteEntryVectors(db, row.id);
-        if (document)
+        if (document) {
             replaceFtsEntry(db, row.id, document, hasMarkdownFragmentContent(document) ? (getMarkdownFragmentContent(document) ?? null) : undefined);
+            replaceEntryLinks(db, row.id, document, { bundleId: opts.sourceName, conceptId: opts.newRef });
+        }
         else
             deleteFtsEntries(db, [row.id]);
     })();
@@ -293,50 +306,6 @@ function rewriteUsageEventRefForMove(opts) {
         throw new Error(`Failed to rewrite usage events for move: ${message}`, { cause: error });
     }
 }
-/**
- * Phase 2A / Rec 5: bulk-load positive feedback event counts for the given
- * entry ids. Used by the utility-decay forgetting curve to stabilize
- * (extend the half-life of) memories that have repeatedly proven useful.
- *
- * Returns a `Map<entryId, count>` containing only entries with at least one
- * positive feedback event — missing ids implicitly map to `0`. Chunks at
- * `SQLITE_CHUNK_SIZE` (500) to respect `SQLITE_MAX_VARIABLE_NUMBER`.
- *
- * Cheap when called with zero ids, and silently empty when state.db (or its
- * `usage_events` table) is absent.
- *
- * Chunk-8 WI-8.3: usage_events lives in state.db — this reads it there (no
- * entries join needed; the ids are supplied by the caller). Gated by the caller
- * (`shouldQueryPositiveFeedbackCounts`) so the state.db open is not on the
- * default search hot path.
- */
-export function getPositiveFeedbackCountsByIds(ids) {
-    const result = new Map();
-    if (ids.length === 0 || !fs.existsSync(getStateDbPath()))
-        return result;
-    bestEffort(() => {
-        withStateDb((stateDb) => {
-            for (let i = 0; i < ids.length; i += SQLITE_CHUNK_SIZE) {
-                const chunk = ids.slice(i, i + SQLITE_CHUNK_SIZE);
-                const placeholders = chunk.map(() => "?").join(",");
-                const rows = stateDb
-                    .prepare(`SELECT entry_id, COUNT(*) AS cnt
-               FROM usage_events
-               WHERE event_type = 'feedback'
-                 AND signal = 'positive'
-                 AND entry_id IN (${placeholders})
-               GROUP BY entry_id`)
-                    .all(...chunk);
-                for (const row of rows) {
-                    if (row.entry_id !== null && row.cnt > 0) {
-                        result.set(row.entry_id, row.cnt);
-                    }
-                }
-            }
-        });
-    }, "positive feedback counts are best-effort");
-    return result;
-}
 /**
  * Rows whose `file_path` sits directly in `dirPath`. A half-open byte range
  * over `idx_entries_file_path` (`[dir + sep, dir + sep + 1)`) turns the lookup
@@ -382,14 +351,30 @@ export function deleteEntriesByBundle(db, bundleId) {
     })();
 }
 /**
- * Delete the complete regenerable entry generation through the same child-row
- * authority used by targeted deletes. The caller may retain cross-database
- * usage events so the finalize pass can relink them to the new row ids.
+ * The `file_path` of every entry indexed under one bundle — used by
+ * `akm bundle rename` (D6) to find bundle CONTENT that still spells the old
+ * `<bundle>//` prefix (xrefs, `supersededBy`, task `uses:`), which the rename
+ * reports rather than rewrites.
+ */
+export function getFilePathsByBundle(db, bundleId) {
+    const rows = db.prepare("SELECT DISTINCT file_path FROM entries WHERE bundle_id = ?").all(bundleId);
+    return rows.map((row) => row.file_path);
+}
+/**
+ * Re-key every entry row's `bundle_id`/`item_ref` from `oldBundleId` to
+ * `newBundleId` in place (`akm bundle rename`, D6). Unlike
+ * {@link rekeyEntryInPlace} (one asset, `akm mv`), this is a bulk identity
+ * change with no content move: `concept_id`/`file_path`/`document_json` are
+ * untouched, so no FTS/vector rebuild is needed (FTS and `embeddings` key on
+ * the entry's row `id`, which this preserves, not on `item_ref`). Returns the
+ * number of rows renamed.
  */
-export function deleteAllEntries(db, options = {}) {
+export function renameEntriesBundleId(db, oldBundleId, newBundleId) {
     return db.transaction(() => {
-        const rows = db.prepare("SELECT id FROM entries").all();
-        return deleteEntryRows(db, rows, options);
+        const result = db
+            .prepare("UPDATE entries SET bundle_id = ?, item_ref = ? || '//' || concept_id WHERE bundle_id = ?")
+            .run(newBundleId, newBundleId, oldBundleId);
+        return Number(result.changes);
     })();
 }
 /**
@@ -415,56 +400,24 @@ function deleteRelatedRows(db, ids, options = {}) {
     if (ids.length === 0)
         return;
     const numericIds = ids.map((r) => r.id);
-    const vecAvail = isVecAvailable(db);
-    // FTS is part of the canonical mutation boundary, not a caller-maintained
-    // dirty queue. Delete it before the parent row inside this transaction.
+    // FTS and declared links are part of the canonical mutation boundary, not a
+    // caller-maintained dirty queue. Delete them before the parent row inside
+    // this transaction.
     deleteFtsEntries(db, numericIds);
+    deleteEntryLinks(db, numericIds);
     // Process in chunks to stay within SQLITE_MAX_VARIABLE_NUMBER
     for (let i = 0; i < numericIds.length; i += SQLITE_CHUNK_SIZE) {
         const chunk = numericIds.slice(i, i + SQLITE_CHUNK_SIZE);
         const placeholders = chunk.map(() => "?").join(",");
         bestEffort(() => db.prepare(`DELETE FROM embeddings WHERE id IN (${placeholders})`).run(...chunk), "delete embeddings for entries");
-        if (vecAvail) {
-            bestEffort(() => db.prepare(`DELETE FROM entries_vec WHERE id IN (${placeholders})`).run(...chunk), "delete entries_vec for entries");
-        }
         // Clean up utility scores before deleting entries
         bestEffort(() => db.prepare(`DELETE FROM utility_scores WHERE entry_id IN (${placeholders})`).run(...chunk), "delete utility_scores for entries");
-        bestEffort(() => db.prepare(`DELETE FROM utility_scores_scoped WHERE entry_id IN (${placeholders})`).run(...chunk), "delete utility_scores_scoped for entries");
-    }
-    // Graph rows are independently keyed and intentionally survive entry
-    // deletion. Resolve their owning roots through the canonical physical path
-    // before entries disappear, then refresh the derived summary counts.
-    const affectedGraphRoots = new Set();
-    for (let i = 0; i < numericIds.length; i += SQLITE_CHUNK_SIZE) {
-        const chunk = numericIds.slice(i, i + SQLITE_CHUNK_SIZE);
-        const placeholders = chunk.map(() => "?").join(",");
-        bestEffort(() => {
-            const rows = db
-                .prepare(`SELECT DISTINCT gf.stash_root
-             FROM graph_files gf
-             JOIN entries e ON e.file_path = gf.file_path
-            WHERE e.id IN (${placeholders})`)
-                .all(...chunk);
-            for (const row of rows)
-                affectedGraphRoots.add(row.stash_root);
-        }, "resolve graph roots for graph_meta recompute");
-    }
-    for (const stashRoot of affectedGraphRoots) {
-        bestEffort(() => db
-            .prepare(`UPDATE graph_meta
-                SET extracted_files = (SELECT COUNT(*) FROM graph_files WHERE stash_root = ?),
-                    entity_count    = (SELECT COUNT(*) FROM graph_file_entities WHERE stash_root = ?),
-                    relation_count  = (SELECT COUNT(*) FROM graph_file_relations WHERE stash_root = ?)
-              WHERE stash_root = ?`)
-            .run(stashRoot, stashRoot, stashRoot, stashRoot), "sync graph_meta counts after entries delete");
     }
     // usage_events lives in state.db, outside this transaction. Index persistence
     // disables this cleanup and runs it only after its index.db transaction
     // commits; standalone delete callers retain the immediate behavior.
     if (options.cleanupUsageEvents !== false)
         deleteUsageEventsByEntryIds(numericIds);
-    // graph_files is keyed by its own stash_root/file_path/body_hash identity,
-    // so deleting an entry row intentionally leaves extracted graph data intact.
 }
 export function deleteUsageEventsByEntryIds(entryIds) {
     if (entryIds.length === 0 || !fs.existsSync(getStateDbPath()))
@@ -481,7 +434,7 @@ export function deleteUsageEventsByEntryIds(entryIds) {
 }
 /**
  * Delete entries by their primary key IDs, along with all related rows
- * (embeddings, entries_vec, entries_fts, utility scores, usage_events).
+ * (embeddings, entries_fts, utility scores, usage_events).
  *
  * Used by explicit `--clean` reconciliation before embeddings and final
  * verification to remove stale entries whose source files no longer exist.
@@ -645,6 +598,20 @@ export function getEntryById(db, id) {
         adapterId: row.adapter_id,
     };
 }
+/** The `item_ref` and `type` of every id that has an entry row. */
+export function getEntryRefsAndTypes(db, ids) {
+    const out = new Map();
+    for (let i = 0; i < ids.length; i += SQLITE_CHUNK_SIZE) {
+        const chunk = ids.slice(i, i + SQLITE_CHUNK_SIZE);
+        const placeholders = chunk.map(() => "?").join(",");
+        const rows = db
+            .prepare(`SELECT id, item_ref, type FROM entries WHERE id IN (${placeholders})`)
+            .all(...chunk);
+        for (const row of rows)
+            out.set(row.id, { itemRef: row.item_ref, type: row.type });
+    }
+    return out;
+}
 export function getEntriesByDir(db, dirPath) {
     return parseEntryRows(selectRowsInDirectory(db, dirPath, ENTRY_COLUMNS), "getEntriesByDir");
 }
@@ -684,6 +651,22 @@ export function getIndexedFilePaths(db) {
         .all();
     return new Set(rows.map((r) => r.file_path));
 }
+/**
+ * `entries.file_path -> content_hash` for every currently-indexed file that
+ * carries a stored hash. Used by per-file staleness detection
+ * (`hasNewerIndexableFiles`, R6) to tell "edited after the last build" apart
+ * from "already re-indexed with this exact content after the last build" —
+ * `indexWrittenAssets` upserts a fresh row (and its `content_hash`) without
+ * bumping `builtAt`, so mtime alone cannot distinguish the two cases.
+ */
+export function getIndexedFileHashes(db) {
+    const rows = db
+        .prepare(`SELECT file_path, content_hash FROM entries
+        WHERE file_path IS NOT NULL AND file_path <> ''
+          AND content_hash IS NOT NULL`)
+        .all();
+    return new Map(rows.map((r) => [r.file_path, r.content_hash]));
+}
 /**
  * Resolve a single `entries.file_path` by primary key, or `undefined` if no
  * row matches.
@@ -732,6 +715,33 @@ export function getEntryByRef(db, ref) {
     const id = findEntryIdByRef(db, ref);
     return id === undefined ? null : { id };
 }
+/** Build a {@link LiveRefSnapshot} from the current `entries` table. */
+export function getLiveRefSnapshot(db) {
+    const rows = db.prepare("SELECT item_ref FROM entries").all();
+    const itemRefs = new Set();
+    const conceptIds = new Set();
+    for (const { item_ref } of rows) {
+        itemRefs.add(item_ref);
+        const boundary = item_ref.indexOf("//");
+        if (boundary >= 0)
+            conceptIds.add(item_ref.slice(boundary + 2));
+    }
+    return { itemRefs, conceptIds };
+}
+/**
+ * `getEntryByRef`'s liveness check (bundle-qualified exact match, or bare
+ * `//conceptId` suffix match across bundles, each tried with the `.md`
+ * toggle {@link withMdVariants} applies) against a prebuilt
+ * {@link LiveRefSnapshot} instead of the database — no query per call.
+ */
+export function isRefLiveInSnapshot(snapshot, ref) {
+    const parsed = parseBundleRef(ref);
+    const conceptVariants = withMdVariants(parsed.conceptId);
+    if (parsed.bundle !== undefined) {
+        return conceptVariants.some((conceptId) => snapshot.itemRefs.has(`${parsed.bundle}//${conceptId}`));
+    }
+    return conceptVariants.some((conceptId) => snapshot.conceptIds.has(conceptId));
+}
 /**
  * The fully-qualified `item_ref` (`<bundle>//<conceptId>`, the durable stored
  * spelling — spec §11.1 D-R3) for an entry `id`, or `null` when the row is gone
@@ -766,15 +776,7 @@ function resolveUsageEventEntryId(db, ref) {
  * distinct linked entry_ids in usage_events is small — and the re-resolution
  * reads `entries` from `indexDb`.
  */
-function qualifiedUsageEventsTable(stateSchema) {
-    if (stateSchema === undefined)
-        return "usage_events";
-    if (!/^[A-Za-z_][A-Za-z0-9_]*$/.test(stateSchema))
-        throw new Error("Invalid attached state schema name.");
-    return `"${stateSchema}".usage_events`;
-}
-export function relinkUsageEvents(indexDb, stateDb, options = {}) {
-    const usageEvents = qualifiedUsageEventsTable(options.stateSchema);
+export function relinkUsageEvents(indexDb, stateDb) {
     bestEffort(() => {
         // Step 1: null out stale entry_ids (entry was deleted, re-keyed, etc).
         // Leaving them in place would let `recomputeUtilityScores` aggregate by an
@@ -783,7 +785,7 @@ export function relinkUsageEvents(indexDb, stateDb, options = {}) {
         // transaction. Nulled rows can be re-resolved by step 2 below; events whose
         // entry is permanently gone simply stay null and age out via retention.
         const linkedRows = stateDb
-            .prepare(`SELECT DISTINCT entry_id AS id, entry_ref AS ref FROM ${usageEvents} WHERE entry_id IS NOT NULL`)
+            .prepare("SELECT DISTINCT entry_id AS id, entry_ref AS ref FROM usage_events WHERE entry_id IS NOT NULL")
             .all();
         const entryIdentity = indexDb.prepare("SELECT item_ref AS itemRef FROM entries WHERE id = ?");
         const staleLinks = linkedRows.filter(({ id, ref }) => {
@@ -791,7 +793,7 @@ export function relinkUsageEvents(indexDb, stateDb, options = {}) {
             return live == null || (ref !== null && live.itemRef !== ref);
         });
         if (staleLinks.length > 0) {
-            const nullOut = stateDb.prepare(`UPDATE ${usageEvents} SET entry_id = NULL WHERE entry_id = ? AND entry_ref IS ?`);
+            const nullOut = stateDb.prepare("UPDATE usage_events SET entry_id = NULL WHERE entry_id = ? AND entry_ref IS ?");
             const nullTx = stateDb.transaction(() => {
                 for (const { id, ref } of staleLinks)
                     nullOut.run(id, ref);
@@ -801,9 +803,9 @@ export function relinkUsageEvents(indexDb, stateDb, options = {}) {
         // Step 2: re-resolve each fully-qualified ref. Bare rows are not current
         // durable identities and remain detached.
         const refs = stateDb
-            .prepare(`SELECT DISTINCT entry_ref AS ref FROM ${usageEvents} WHERE entry_id IS NULL AND entry_ref IS NOT NULL`)
+            .prepare("SELECT DISTINCT entry_ref AS ref FROM usage_events WHERE entry_id IS NULL AND entry_ref IS NOT NULL")
             .all();
-        const update = stateDb.prepare(`UPDATE ${usageEvents} SET entry_id = ? WHERE entry_ref = ? AND entry_id IS NULL`);
+        const update = stateDb.prepare("UPDATE usage_events SET entry_id = ? WHERE entry_ref = ? AND entry_id IS NULL");
         const relinkTx = stateDb.transaction(() => {
             for (const { ref } of refs) {
                 let id;

package/dist/storage/repositories/index-entry-mapper.js

@@ -23,7 +23,7 @@ import { warn } from "../../core/warn.js";
  * Durable identity columns are surfaced here so every mapped entry carries
  * current indexed provenance.
  */
-export const ENTRY_COLUMNS = "id, item_ref, bundle_id, component_id, concept_id, adapter_id, type, file_path, content_hash, document_json, search_text";
+export const ENTRY_COLUMNS = "id, item_ref, bundle_id, component_id, concept_id, adapter_id, type, file_path, content_hash, document_json";
 /**
  * Map one raw `entries` row to a {@link DbIndexedEntry}, parsing `document_json`.
  * Returns `null` (and warns, tagged with `context`) when the JSON is corrupt so
@@ -42,7 +42,6 @@ export function rowToIndexedEntry(row, context) {
         id: row.id,
         filePath: row.file_path,
         entry,
-        searchText: row.search_text,
         itemRef: row.item_ref,
         conceptId: row.concept_id,
         bundleId: row.bundle_id,