akm-cli 0.9.7 → 0.9.8-beta.2

package/dist/setup/setup.js

@@ -24,7 +24,7 @@ import { deriveBundleIds } from "../core/bundle-id.js";
 import { bundleEntryToSourceEntry, DEFAULT_CONFIG, loadUserConfig, mutateConfigWithPrecommit, parseAndValidateConfigText, primaryBundlePath, validateCompleteConfig, } from "../core/config/config.js";
 import { readConfigText } from "../core/config/config-io.js";
 import { listTopLevelConfigKeys } from "../core/config/config-schema.js";
-import { deepMergeConfig } from "../core/config/deep-merge.js";
+import { deepMergeConfig, isPlainObject } from "../core/config/deep-merge.js";
 import { ConfigError, UsageError } from "../core/errors.js";
 import { getConfigPath, getDefaultStashDir, isTransientStashPath } from "../core/paths.js";
 import { warn } from "../core/warn.js";
@@ -131,17 +131,11 @@ export function assertSetupConfigPreflight() {
             `(e.g. \`mv ${configPath} ${configPath}.bak\`) and re-run \`akm setup\`.`);
     }
 }
-function isPlainRecord(value) {
-    if (!value || typeof value !== "object" || Array.isArray(value))
-        return false;
-    const prototype = Object.getPrototypeOf(value);
-    return prototype === Object.prototype || prototype === null;
-}
 function sameConfigValue(left, right) {
     return isDeepStrictEqual(left, right);
 }
 function configArrayItemKey(value) {
-    if (!isPlainRecord(value))
+    if (!isPlainObject(value))
         return `value:${JSON.stringify(value)}`;
     if (typeof value.id === "string")
         return `id:${value.id}`;
@@ -199,14 +193,14 @@ export function rebaseSetupChanges(original, desired, latest, pathParts = []) {
         }
         return result;
     }
-    if (!isPlainRecord(original) || !isPlainRecord(desired)) {
+    if (!isPlainObject(original) || !isPlainObject(desired)) {
         if (!sameConfigValue(latest, original) && !sameConfigValue(latest, desired))
             setupConflict(pathParts);
         return desired;
     }
-    if (latest !== undefined && !isPlainRecord(latest))
+    if (latest !== undefined && !isPlainObject(latest))
         setupConflict(pathParts);
-    const result = isPlainRecord(latest) ? { ...latest } : {};
+    const result = isPlainObject(latest) ? { ...latest } : {};
     for (const key of new Set([...Object.keys(original), ...Object.keys(desired)])) {
         if (!Object.hasOwn(desired, key)) {
             if (Object.hasOwn(result, key) && !sameConfigValue(result[key], original[key]))
@@ -855,7 +849,7 @@ export async function runSetupFromConfig(opts) {
     catch (e) {
         throw new UsageError(`Invalid JSON in --config: ${e.message}`, "INVALID_FLAG_VALUE");
     }
-    if (!isPlainRecord(parsed)) {
+    if (!isPlainObject(parsed)) {
         throw new ConfigError("Setup config must contain a top-level object.", "INVALID_CONFIG_FILE");
     }
     const incoming = parsed;

package/dist/sources/providers/git-install.js

@@ -48,8 +48,13 @@ export function inspectGitUpstream(repoDir) {
  * commit SHA peels to itself.
  */
 export function verifyClonedRevision(cloneDir, url, expectedRevision) {
-    if (!expectedRevision)
-        return;
+    if (!expectedRevision) {
+        // `resolveGitArtifact` (registry/resolve.ts) throws when it cannot resolve
+        // a revision via `git ls-remote`, so a plain git install never reaches
+        // this call with `undefined` — treat it as a bug, not a silently-skipped
+        // check that would defeat the R-011 post-clone integrity verification.
+        throw new UsageError(`No revision was resolved from ${url}; refusing to install without a verifiable checkout.`);
+    }
     const head = runGit(["-C", cloneDir, "rev-parse", "HEAD"]);
     if (head.status !== 0 || !head.stdout.trim()) {
         throw new UsageError(`Failed to read cloned HEAD at ${cloneDir}: ${head.stderr.trim() || "rev-parse failed"}`);

package/dist/sources/providers/tar-utils.js

@@ -91,13 +91,7 @@ export function extractTarGzSecure(archivePath, destinationDir) {
     scanExtractedFiles(destinationDir, destinationDir);
 }
 function scanExtractedFiles(dir, root) {
-    let entries;
-    try {
-        entries = fs.readdirSync(dir, { withFileTypes: true });
-    }
-    catch {
-        return;
-    }
+    const entries = fs.readdirSync(dir, { withFileTypes: true });
     for (const entry of entries) {
         const fullPath = path.join(dir, entry.name);
         // Reject only entries whose name is exactly the parent-traversal segment

package/dist/sources/snapshot-fetchers/content-extract.js

@@ -609,20 +609,3 @@ export function htmlToMarkdownAndLinks(html, pageUrl) {
     const markdown = root ? markdownFromRoot(root, html, pageUrl) : plainTextFallback(html);
     return { markdown: finalizeMarkdown(markdown), links };
 }
-/**
- * Collect links from the WHOLE document, not the extracted content region.
- *
- * Deliberate and load-bearing: nav/header/footer links are how a crawl
- * discovers pages. Narrowing this to the content region would silently shrink
- * every crawl to whatever the first page happens to link inline.
- */
-export function extractDocumentLinks(html, pageUrl) {
-    let root;
-    try {
-        root = parse(scrubDangerousMarkup(html), { comment: false });
-    }
-    catch {
-        return [];
-    }
-    return collectLinksFromRoot(root, pageUrl);
-}

package/dist/storage/managed-db.js

@@ -61,13 +61,19 @@ export function openManagedDatabase(spec) {
         // Initializers may open a transaction (source update does so before index
         // schema work). Never strand that transaction/handle when later setup
         // fails; closing rolls it back and releases its writer lock.
-        if (db.inTransaction) {
-            try {
+        //
+        // `db.inTransaction` is INSIDE the try: reading it on an already-closed
+        // handle throws "Database has closed", and it used to sit outside, so that
+        // throw escaped and replaced `error` — masking the real initializer failure
+        // this whole block exists to preserve. Every other step here was already
+        // guarded for exactly that reason; this one was not, and a concurrent
+        // close (WAL contention between two writers) reached it.
+        try {
+            if (db.inTransaction)
                 db.exec("ROLLBACK");
-            }
-            catch {
-                // Closing remains the final rollback backstop.
-            }
+        }
+        catch {
+            // Closing remains the final rollback backstop.
         }
         try {
             db.close();
@@ -99,6 +105,13 @@ export function withManagedDb(open, fn, opts) {
         return fn(db);
     }
     finally {
-        db.close();
+        try {
+            db.close();
+        }
+        catch {
+            // A close() throw here would REPLACE fn's in-flight exception — the same
+            // masking openManagedDatabase above was hardened against. The handle is
+            // being discarded either way; fn's error is the one that matters.
+        }
     }
 }

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

@@ -147,84 +147,3 @@ export function purgeOldEvents(db, retentionDays = 90) {
     const changes = result.changes ?? 0;
     return typeof changes === "bigint" ? Number(changes) : changes;
 }
-/**
- * Import all events from an `events.jsonl` file into the `events` table.
- *
- * The old byte-offset `id` is NOT preserved — the database assigns new
- * monotonic integer ids. Callers that persisted a byte-offset cursor must
- * discard it after migration and use the returned `maxId` as the new cursor.
- *
- * **Idempotency**: each line is pre-checked against the `events` table using
- * `(event_type, ts, ref, metadata_json)` as the duplicate key. Lines whose
- * exact tuple is already present are skipped and reported as `skipped` in the
- * return value. This makes the migration safe to re-run (the v0.7→v0.8
- * migration guide recommends re-running the script as a recovery path; without
- * this guard, every re-run would double-import the entire event log).
- *
- * Duplicate detection is per-import-tuple, not a table-wide UNIQUE constraint:
- * the events table has no UNIQUE constraint at runtime so that
- * `appendEvent` can write multiple events with the same ts (sub-millisecond
- * bursts produce identical `(event_type, ts, ref)` triples in practice). The
- * SELECT-first check is scoped to the import path only.
- *
- * The import is wrapped in a single transaction for atomicity.
- *
- * @param db       - Open state.db connection.
- * @param jsonlPath - Absolute path to the events.jsonl file to import.
- * @returns         Number of rows inserted, the max id assigned, and the
- *                  count of rows skipped because an identical event already
- *                  existed in the table.
- */
-export async function importEventsJsonl(db, jsonlPath) {
-    const { readFileSync, existsSync } = await import("node:fs");
-    if (!existsSync(jsonlPath)) {
-        return { imported: 0, maxId: 0, skipped: 0 };
-    }
-    const text = readFileSync(jsonlPath, "utf8");
-    const lines = text.split("\n").filter((l) => l.trim().length > 0);
-    let imported = 0;
-    let maxId = 0;
-    let skipped = 0;
-    const insertStmt = db.prepare(`INSERT INTO events (event_type, ts, ref, metadata_json)
-     VALUES (?, ?, ?, ?)
-     RETURNING id`);
-    // Dedup pre-check: matches by the full tuple including metadata_json so an
-    // import is idempotent over identical rows but does not collide with two
-    // genuinely different events that happen to share (event_type, ts, ref).
-    //
-    // Uses IS for ref so two NULL refs compare equal (a plain `=` would treat
-    // NULL = NULL as NULL and the row would be re-inserted on every run).
-    const existsStmt = db.prepare(`SELECT 1 FROM events
-     WHERE event_type = ?
-       AND ts = ?
-       AND ref IS ?
-       AND metadata_json = ?
-     LIMIT 1`);
-    db.transaction(() => {
-        for (const line of lines) {
-            let parsed;
-            try {
-                parsed = JSON.parse(line);
-            }
-            catch {
-                continue; // skip malformed lines — same behaviour as readEvents()
-            }
-            const eventType = typeof parsed.eventType === "string" ? parsed.eventType : "unknown";
-            const ts = typeof parsed.ts === "string" ? parsed.ts : new Date().toISOString();
-            const ref = typeof parsed.ref === "string" ? parsed.ref : null;
-            const metadata = parsed.metadata !== undefined && typeof parsed.metadata === "object" ? JSON.stringify(parsed.metadata) : "{}";
-            const duplicate = existsStmt.get(eventType, ts, ref, metadata);
-            if (duplicate) {
-                skipped++;
-                continue;
-            }
-            const result = insertStmt.get(eventType, ts, ref, metadata);
-            if (result) {
-                imported++;
-                if (result.id > maxId)
-                    maxId = result.id;
-            }
-        }
-    })();
-    return { imported, maxId, skipped };
-}

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

@@ -336,12 +336,28 @@ export function getPositiveFeedbackCountsByIds(ids) {
     }, "positive feedback counts are best-effort");
     return result;
 }
-function rowsInDirectory(db, dirPath, bundleId) {
-    const rows = db
-        .prepare(`SELECT id, item_ref, file_path FROM entries${bundleId ? " WHERE bundle_id = ?" : ""}`)
-        .all(...(bundleId ? [bundleId] : []));
+/**
+ * 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
+ * into an index seek; the range is exact for "starts with `dir/`" but also
+ * admits nested subdirectories (`/a/b/c/x.md` for `/a/b`), so the dirname
+ * post-filter stays.
+ */
+function selectRowsInDirectory(db, dirPath, columns, bundleId) {
     const resolvedDir = path.resolve(dirPath);
-    return rows.filter((row) => path.dirname(path.resolve(row.file_path)) === resolvedDir);
+    const prefix = resolvedDir + path.sep;
+    const upperBound = resolvedDir + String.fromCharCode(path.sep.charCodeAt(0) + 1);
+    const params = [prefix, upperBound];
+    let sql = `SELECT ${columns} FROM entries WHERE file_path >= ? AND file_path < ?`;
+    if (bundleId) {
+        sql += " AND bundle_id = ?";
+        params.push(bundleId);
+    }
+    const rows = db.prepare(sql).all(...params);
+    return rows.filter((row) => path.dirname(row.file_path) === resolvedDir);
+}
+function rowsInDirectory(db, dirPath, bundleId) {
+    return selectRowsInDirectory(db, dirPath, "id, item_ref, file_path", bundleId);
 }
 function deleteEntryRows(db, rows, options = {}) {
     if (rows.length === 0)
@@ -629,9 +645,7 @@ export function getEntryById(db, id) {
     };
 }
 export function getEntriesByDir(db, dirPath) {
-    const ids = new Set(rowsInDirectory(db, dirPath).map((row) => row.id));
-    const rows = db.prepare(`SELECT ${ENTRY_COLUMNS} FROM entries`).all().filter((row) => ids.has(row.id));
-    return parseEntryRows(rows, "getEntriesByDir");
+    return parseEntryRows(selectRowsInDirectory(db, dirPath, ENTRY_COLUMNS), "getEntriesByDir");
 }
 /** Return every directory previously indexed for one canonical bundle. */
 export function getIndexedDirPathsByBundleId(db, bundleId) {
@@ -640,9 +654,8 @@ export function getIndexedDirPathsByBundleId(db, bundleId) {
 }
 /** Return every persisted bundle owner for one physical directory. */
 export function getIndexedBundleIdsByDir(db, dirPath) {
-    const ids = new Set(rowsInDirectory(db, dirPath).map((row) => row.id));
-    const rows = db.prepare("SELECT id, bundle_id FROM entries").all();
-    return [...new Set(rows.filter((row) => ids.has(row.id)).map((row) => row.bundle_id))];
+    const rows = selectRowsInDirectory(db, dirPath, "bundle_id, file_path");
+    return [...new Set(rows.map((row) => row.bundle_id))];
 }
 /**
  * Resolve a single `entries.id` by exact `file_path` (the canonical on-disk
@@ -683,23 +696,6 @@ export function getEntryFilePathById(db, id) {
     const row = db.prepare("SELECT file_path FROM entries WHERE id = ?").get(id);
     return row?.file_path;
 }
-/**
- * Fetch every `(file_path, document_json)` row whose path is under a source
- * root. The path containment filter is applied in JS so SQLite LIKE wildcard
- * characters in filesystem paths cannot widen ownership.
- *
- * Lifted verbatim (WS5) from the inline query in commands/graph.ts'
- * `buildRefByPath`. The full result set is materialised with `.all()` before
- * return so callers can iterate it after the connection closes (WS5
- * connection-lifetime rule). JSON parsing stays with the caller, unchanged.
- */
-export function getEntryRefRowsForStashRoot(db, stashRoot) {
-    const root = path.resolve(stashRoot);
-    return db.prepare("SELECT file_path, document_json FROM entries").all().filter((row) => {
-        const file = path.resolve(row.file_path);
-        return file === root || file.startsWith(`${root}${path.sep}`);
-    });
-}
 // ── Indexer-phase helpers (moved from indexer.ts) ────────────────────────────
 /**
  * Return distinct zero-result search queries from the `usage_events` table

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

@@ -91,38 +91,32 @@ function runFtsQuery(db, ftsQuery, lexicalMatch, limit, entryType, excludeTypes)
     ORDER BY bm25Score, e.id ASC
     LIMIT ?
   `;
-    try {
-        const rows = db.prepare(sql).all(...params);
-        // Guard against corrupt JSON — skip the row rather than crashing
-        const results = [];
-        for (const row of rows) {
-            let entry;
-            try {
-                entry = JSON.parse(row.documentJson);
-            }
-            catch {
-                warn(`[db] searchFts: skipping entry id=${row.id} — corrupt document_json`);
-                continue;
-            }
-            results.push({
-                id: row.id,
-                filePath: row.filePath,
-                entry,
-                searchText: row.searchText,
-                bm25Score: row.bm25Score,
-                itemRef: row.itemRef,
-                bundleId: row.bundleId,
-                conceptId: row.conceptId,
-                adapterId: row.adapterId,
-                lexicalMatch,
-            });
+    const rows = db.prepare(sql).all(...params);
+    // Guard against corrupt JSON — skip the row rather than crashing
+    const results = [];
+    for (const row of rows) {
+        let entry;
+        try {
+            entry = JSON.parse(row.documentJson);
         }
-        return results;
-    }
-    catch (err) {
-        warn("[db] runFtsQuery failed:", err instanceof Error ? err.message : String(err));
-        return [];
+        catch {
+            warn(`[db] searchFts: skipping entry id=${row.id} — corrupt document_json`);
+            continue;
+        }
+        results.push({
+            id: row.id,
+            filePath: row.filePath,
+            entry,
+            searchText: row.searchText,
+            bm25Score: row.bm25Score,
+            itemRef: row.itemRef,
+            bundleId: row.bundleId,
+            conceptId: row.conceptId,
+            adapterId: row.adapterId,
+            lexicalMatch,
+        });
     }
+    return results;
 }
 /**
  * Explicitly rebuild the complete FTS5 projection from canonical entries.

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

@@ -23,7 +23,7 @@ export function deleteMeta(db, key) {
 // ── Per-directory index state ───────────────────────────────────────────────
 export function getIndexDirState(db, dirPath) {
     const row = db
-        .prepare("SELECT dir_path, file_set_hash, file_mtime_max_ms, reason, updated_at FROM index_dir_state WHERE dir_path = ?")
+        .prepare("SELECT dir_path, file_set_hash, file_mtime_max_ms, reason, updated_at, row_count FROM index_dir_state WHERE dir_path = ?")
         .get(dirPath);
     if (!row)
         return undefined;
@@ -33,16 +33,18 @@ export function getIndexDirState(db, dirPath) {
         fileMtimeMaxMs: row.file_mtime_max_ms,
         reason: row.reason,
         updatedAt: row.updated_at,
+        rowCount: row.row_count ?? undefined,
     };
 }
 export function upsertIndexDirState(db, state) {
-    db.prepare(`INSERT INTO index_dir_state (dir_path, file_set_hash, file_mtime_max_ms, reason, updated_at)
-     VALUES (?, ?, ?, ?, ?)
+    db.prepare(`INSERT INTO index_dir_state (dir_path, file_set_hash, file_mtime_max_ms, reason, updated_at, row_count)
+     VALUES (?, ?, ?, ?, ?, ?)
      ON CONFLICT(dir_path) DO UPDATE SET
        file_set_hash = excluded.file_set_hash,
        file_mtime_max_ms = excluded.file_mtime_max_ms,
        reason = excluded.reason,
-       updated_at = excluded.updated_at`).run(state.dirPath, state.fileSetHash, state.fileMtimeMaxMs, state.reason, new Date().toISOString());
+       updated_at = excluded.updated_at,
+       row_count = excluded.row_count`).run(state.dirPath, state.fileSetHash, state.fileMtimeMaxMs, state.reason, new Date().toISOString(), state.rowCount ?? null);
 }
 export function deleteIndexDirState(db, dirPath) {
     db.prepare("DELETE FROM index_dir_state WHERE dir_path = ?").run(dirPath);

package/dist/storage/repositories/index-schema.js

@@ -268,9 +268,11 @@ export function ensureSchema(db, embeddingDim) {
       file_set_hash     TEXT NOT NULL,
       file_mtime_max_ms REAL NOT NULL,
       reason            TEXT NOT NULL,
-      updated_at        TEXT NOT NULL
+      updated_at        TEXT NOT NULL,
+      row_count         INTEGER
     );
   `);
+    ensureIndexDirStateRowCountColumn(db);
     // LLM enrichment result cache. Stores a SHA-256 body hash and the JSON
     // result for each asset so that subsequent `akm index --enrich` runs can
     // skip the LLM call when the body hasn't changed. The cache is keyed by
@@ -379,3 +381,16 @@ function tableExists(db, name) {
     const row = db.prepare("SELECT 1 FROM sqlite_master WHERE type='table' AND name=? LIMIT 1").get(name);
     return row !== undefined && row !== null;
 }
+/**
+ * #900: `row_count` was added after the table's first release, so a database
+ * created before it needs an `ALTER TABLE` (`CREATE TABLE IF NOT EXISTS` only
+ * shapes a fresh table). Idempotent. Pre-existing rows keep NULL until their
+ * directory is next drained; index.db is a regenerable cache, so nothing is
+ * backfilled.
+ */
+function ensureIndexDirStateRowCountColumn(db) {
+    const columns = db.prepare("PRAGMA table_info(index_dir_state)").all();
+    if (!columns.some((column) => column.name === "row_count")) {
+        db.exec("ALTER TABLE index_dir_state ADD COLUMN row_count INTEGER");
+    }
+}

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

@@ -263,63 +263,6 @@ function getSourceScopedRetrievalCounts(indexDb, stateDb, refs, options) {
     }
     return result;
 }
-/**
- * Apply a MemRL reward signal to a batch of entries via exponential moving
- * average (EMA): next = clamp(current + lr * (reward - current), 0, 1).
- *
- * Wrapped in a single transaction so all bumps succeed or fail together.
- * The indexer (`akm index`) will overwrite these values at next reindex run;
- * bumps are intentionally temporary hints between index runs, not permanent
- * overrides.
- *
- * When `scopeKey` is provided, also writes a scoped bump to
- * `utility_scores_scoped` so per-project usage signals accumulate alongside
- * the global ones. The global table is always updated regardless.
- */
-export function bumpUtilityScoresBatch(db, entryIds, reward, lr = 0.1, scopeKey) {
-    if (entryIds.length === 0)
-        return;
-    db.transaction(() => {
-        const { global: scoreMap } = getUtilityScoresByIds(db, entryIds);
-        const now = new Date().toISOString();
-        const nowMs = Date.now();
-        const stmt = db.prepare(`INSERT INTO utility_scores (entry_id, utility, show_count, search_count, select_rate, last_used_at, updated_at)
-       VALUES (?, ?, 0, 0, 0, ?, ?)
-       ON CONFLICT(entry_id) DO UPDATE SET
-         utility = excluded.utility,
-         updated_at = excluded.updated_at`);
-        // Prepare scoped upsert once outside the loop when scopeKey is present.
-        const scopedStmt = scopeKey
-            ? db.prepare(`INSERT INTO utility_scores_scoped (entry_id, scope_key, utility, last_used_at)
-           VALUES (?, ?, ?, ?)
-           ON CONFLICT(entry_id, scope_key) DO UPDATE SET
-             utility = excluded.utility,
-             last_used_at = excluded.last_used_at`)
-            : null;
-        for (const entryId of entryIds) {
-            const existing = scoreMap.get(entryId);
-            const current = existing?.utility ?? 0;
-            const next = Math.max(0, Math.min(1, current + lr * (reward - current)));
-            stmt.run(entryId, next, now, now);
-            if (scopedStmt && scopeKey) {
-                // Retrieve the current scoped utility so we can apply the same EMA.
-                const scopedCurrent = getScopedUtility(db, entryId, scopeKey);
-                const scopedNext = Math.max(0, Math.min(1, scopedCurrent + lr * (reward - scopedCurrent)));
-                scopedStmt.run(entryId, scopeKey, scopedNext, nowMs);
-            }
-        }
-    })();
-}
-/**
- * Return the current utility value for a single (entry_id, scope_key) pair.
- * Returns 0 when no row exists yet.
- */
-function getScopedUtility(db, entryId, scopeKey) {
-    const row = db
-        .prepare("SELECT utility FROM utility_scores_scoped WHERE entry_id = ? AND scope_key = ?")
-        .get(entryId, scopeKey);
-    return row?.utility ?? 0;
-}
 /**
  * Apply accumulated feedback counts to the utility score of an entry, persisting
  * the result. The bounded-step EMA policy itself (MemRL, F-5 / #386,

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

@@ -229,9 +229,14 @@ export function searchVec(db, queryEmbedding, k) {
                 .all(buf, k);
         }
         catch (err) {
-            // Log the failure so it's visible in diagnostics
-            warn("[db] searchVec (sqlite-vec path) failed:", err instanceof Error ? err.message : String(err));
-            return [];
+            // 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
@@ -281,32 +286,25 @@ function bufferToFloat32(buf, expectedDim) {
     return Array.from(f32);
 }
 function searchBlobVec(db, queryEmbedding, k) {
-    try {
-        const rows = db.prepare("SELECT id, embedding FROM embeddings").all();
-        if (rows.length === 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)),
-        }));
-    }
-    catch (err) {
-        // MD-5: Log the failure so it's visible in diagnostics
-        warn("[db] searchBlobVec (JS fallback) failed:", err instanceof Error ? err.message : String(err));
+    const rows = db.prepare("SELECT id, embedding FROM embeddings").all();
+    if (rows.length === 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 all entries that do not yet have an embedding row.

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

@@ -12,6 +12,7 @@
 import path from "node:path";
 import { stashDirFor } from "../../core/asset/asset-placement.js";
 import { bundleRefToString, isBundleSlug, parseBundleRef } from "../../core/asset/asset-ref.js";
+import { warnOnce } from "../../core/warn.js";
 /** Serialize `Proposal.changes` for `metadata_json` (see {@link StoredFileChange}). */
 function changesToStored(changes) {
     return changes.map((c, i) => ({
@@ -361,8 +362,10 @@ export function listStateProposals(db, options = {}) {
             proposals.push(proposalRowToProposal(row));
         }
         catch (error) {
+            // Once per row per process (#898): health alone reads this table several
+            // times per invocation.
             const message = error instanceof Error ? error.message : String(error);
-            console.warn(`[akm] Skipping unparseable proposal row (id=${row.id}, ref=${row.ref}): ${message}`);
+            warnOnce(`unparseable-proposal-row:${row.id}`, `[akm] Skipping unparseable proposal row (id=${row.id}, ref=${row.ref}): ${message}`);
         }
     }
     return proposals;

package/dist/storage/repositories/task-history-repository.js

@@ -1,12 +1,18 @@
 // 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/.
+/**
+ * Repository for the state.db `task_history` table (per-task run ledger,
+ * replaces the old per-task JSONL files). Extracted verbatim from
+ * core/state-db.ts — queries unchanged, only relocated behind the repository
+ * boundary. Re-exported by core/state-db.ts so existing importers resolve.
+ *
+ * @module task-history-repository
+ */
+import { isRecord } from "../../core/common.js";
 function metadataError(message) {
     throw new Error(`invalid task_history metadata_json: ${message}`);
 }
-function isRecord(value) {
-    return typeof value === "object" && value !== null && !Array.isArray(value);
-}
 function validateDetail(value) {
     if (value === undefined || value === null)
         return;