alvin-bot 4.20.2 → 4.22.0

package/dist/services/embeddings/vector-base.js

@@ -0,0 +1,113 @@
+/**
+ * Shared base for vector-based providers (Gemini, OpenAI, Ollama).
+ *
+ * Owns the `entries` table schema, vector BLOB encoding, cosine-similarity
+ * search, and transactional indexing. Subclasses implement only the embedding
+ * API calls (embed for documents, embedQuery for the search query).
+ *
+ * Vectors are stored as Float32 BLOBs (4 bytes per dim). For a 1536-dim model
+ * that's 6 KB per chunk; 3072-dim is 12 KB. Reading is mmap-cheap; cosine sim
+ * runs in JS over the in-memory result set — fast enough for tens of thousands
+ * of chunks.
+ */
+function vectorToBlob(v) {
+    const f32 = new Float32Array(v);
+    return Buffer.from(f32.buffer, f32.byteOffset, f32.byteLength);
+}
+function blobToVector(b) {
+    // better-sqlite3 buffers may be unaligned; copy via DataView guarantees alignment.
+    const f32 = new Float32Array(b.byteLength / 4);
+    const dv = new DataView(b.buffer, b.byteOffset, b.byteLength);
+    for (let i = 0; i < f32.length; i++) {
+        f32[i] = dv.getFloat32(i * 4, true);
+    }
+    return f32;
+}
+function cosineSimilarity(a, b) {
+    if (a.length !== b.length)
+        return 0;
+    let dot = 0;
+    let na = 0;
+    let nb = 0;
+    for (let i = 0; i < a.length; i++) {
+        dot += a[i] * b[i];
+        na += a[i] * a[i];
+        nb += b[i] * b[i];
+    }
+    const denom = Math.sqrt(na) * Math.sqrt(nb);
+    return denom === 0 ? 0 : dot / denom;
+}
+export class VectorProviderBase {
+    initSchema(db) {
+        db.exec(`
+      CREATE TABLE IF NOT EXISTS entries (
+        id         TEXT PRIMARY KEY,
+        source     TEXT NOT NULL,
+        text       TEXT NOT NULL,
+        vector     BLOB NOT NULL,
+        indexed_at INTEGER NOT NULL
+      );
+      CREATE INDEX IF NOT EXISTS idx_entries_source ON entries(source);
+    `);
+    }
+    dropSchema(db) {
+        db.exec(`DROP TABLE IF EXISTS entries;`);
+    }
+    async indexChunks(db, chunks) {
+        if (chunks.length === 0)
+            return;
+        const vectors = await this.embed(chunks.map(c => c.text));
+        if (vectors.length !== chunks.length) {
+            throw new Error(`Embedding count mismatch: requested ${chunks.length}, got ${vectors.length}`);
+        }
+        const insertStmt = db.prepare("INSERT INTO entries (id, source, text, vector, indexed_at) VALUES (?, ?, ?, ?, ?) " +
+            "ON CONFLICT(id) DO UPDATE SET source=excluded.source, text=excluded.text, " +
+            "vector=excluded.vector, indexed_at=excluded.indexed_at");
+        const now = Date.now();
+        const writeAll = db.transaction((rows) => {
+            for (const r of rows)
+                insertStmt.run(r.id, r.source, r.text, r.vector, now);
+        });
+        writeAll(chunks.map((c, i) => ({
+            id: c.id,
+            source: c.source,
+            text: c.text,
+            vector: vectorToBlob(vectors[i]),
+        })));
+    }
+    dropEntriesForSources(db, sources) {
+        if (sources.length === 0)
+            return;
+        const del = db.prepare("DELETE FROM entries WHERE source = ?");
+        const dropAll = db.transaction((srcs) => {
+            for (const s of srcs)
+                del.run(s);
+        });
+        dropAll(sources);
+    }
+    async search(db, query, topK, minScore) {
+        const qv = Float32Array.from(await this.embedQuery(query));
+        const rows = db
+            .prepare("SELECT source, text, vector FROM entries")
+            .all();
+        const scored = [];
+        for (const row of rows) {
+            const v = blobToVector(row.vector);
+            const score = cosineSimilarity(qv, v);
+            if (score >= minScore) {
+                scored.push({ text: row.text, source: row.source, score });
+            }
+        }
+        scored.sort((a, b) => b.score - a.score);
+        return scored.slice(0, topK);
+    }
+    countEntries(db) {
+        try {
+            const row = db.prepare("SELECT COUNT(*) AS c FROM entries").get();
+            return row?.c ?? 0;
+        }
+        catch {
+            return 0;
+        }
+    }
+}

package/dist/services/embeddings.js

@@ -1,505 +1,9 @@
 /**
- * Embeddings Service — Vector-based semantic memory search.
+ * Embeddings Service — public API shim.
  *
- * Uses Google's gemini-embedding-001 model for generating embeddings.
- * Stores embeddings in a SQLite database (.embeddings.db) — replaces the
- * older .embeddings.json index since v4.20. The migration runs once
- * automatically on startup (see src/migrate.ts).
- *
- * Architecture:
- * - Each memory entry (paragraph/section) gets a 3072-dim Float32 vector.
- * - Vectors are stored as raw BLOB (4 bytes × 3072 = 12 KB each) instead of
- *   JSON-encoded Float64 arrays (~24 KB each) — halves disk footprint.
- * - Cosine similarity runs in-memory: SQLite has no native vector ops, but
- *   reading the BLOBs is mmap-cheap and JS does the dot product fast enough
- *   for the current corpus (a few thousand entries).
- * - Reindexing is per-chunk INSERT/UPDATE — no full-file rewrite.
- */
-import fs from "fs";
-import path from "path";
-import { resolve } from "path";
-import os from "os";
-import { createRequire } from "module";
-import { config } from "../config.js";
-import { MEMORY_DIR, MEMORY_FILE, EMBEDDINGS_DB } from "../paths.js";
-import { ASSETS_DIR, ASSETS_INDEX_MD } from "../paths.js";
-let SqliteClass = null;
-let sqliteLoadAttempted = false;
-let sqliteLoadError = null;
-const cjsRequire = createRequire(import.meta.url);
-function loadSqlite() {
-    if (sqliteLoadAttempted)
-        return SqliteClass;
-    sqliteLoadAttempted = true;
-    try {
-        SqliteClass = cjsRequire("better-sqlite3");
-        return SqliteClass;
-    }
-    catch (err) {
-        sqliteLoadError = err instanceof Error ? err : new Error(String(err));
-        console.warn("⚠️ better-sqlite3 native binary unavailable — embeddings disabled. " +
-            "Bot continues without semantic memory search. Fix: rebuild deps with " +
-            "`cd $(npm root -g)/alvin-bot && npm rebuild better-sqlite3` or reinstall " +
-            "alvin-bot. Underlying error: " +
-            sqliteLoadError.message);
-        return null;
-    }
-}
-export function getEmbeddingsBackendStatus() {
-    loadSqlite();
-    return { available: SqliteClass !== null, error: sqliteLoadError?.message ?? null };
-}
-// Hub memory directory (Claude Hub — read-only, additional context)
-const HUB_MEMORY_DIR = resolve(os.homedir(), ".claude", "hub", "MEMORY");
-// ── Constants ───────────────────────────────────────────
-const EMBEDDING_MODEL = "gemini-embedding-001";
-const EMBEDDING_DIMENSION = 3072;
-const SCHEMA_VERSION = "1";
-// ── Vector encoding (Float32Array ↔ Buffer) ─────────────
-function vectorToBlob(v) {
-    const f32 = new Float32Array(v);
-    // Buffer.from(arrayBuffer, byteOffset, length) preserves the underlying memory.
-    return Buffer.from(f32.buffer, f32.byteOffset, f32.byteLength);
-}
-function blobToVector(b) {
-    // Buffers from better-sqlite3 own their memory and may not be aligned to 4 bytes.
-    // Copying into a fresh Float32Array guarantees alignment.
-    const f32 = new Float32Array(b.byteLength / 4);
-    const dv = new DataView(b.buffer, b.byteOffset, b.byteLength);
-    for (let i = 0; i < f32.length; i++) {
-        f32[i] = dv.getFloat32(i * 4, true /* little-endian */);
-    }
-    return f32;
-}
-// ── DB lifecycle ────────────────────────────────────────
-let dbInstance = null;
-/**
- * Returns the live DB handle, or null when better-sqlite3 isn't loadable.
- * Callers must handle the null case (treat as "search unavailable").
+ * v4.22.0 refactor: the implementation moved to src/services/embeddings/ with
+ * pluggable providers (Gemini, OpenAI, Ollama, FTS5). This file re-exports the
+ * facade so existing callers (memory.ts, personality.ts, self-search.ts,
+ * commands.ts, index.ts) keep working without import changes.
  */
-function db() {
-    if (dbInstance)
-        return dbInstance;
-    const Database = loadSqlite();
-    if (!Database)
-        return null;
-    // Ensure directory exists (handles fresh installs).
-    fs.mkdirSync(path.dirname(EMBEDDINGS_DB), { recursive: true });
-    dbInstance = new Database(EMBEDDINGS_DB);
-    dbInstance.pragma("journal_mode = WAL");
-    dbInstance.pragma("synchronous = NORMAL");
-    dbInstance.pragma("temp_store = MEMORY");
-    dbInstance.pragma("mmap_size = 268435456"); // 256 MB
-    dbInstance.exec(`
-    CREATE TABLE IF NOT EXISTS meta (
-      key   TEXT PRIMARY KEY,
-      value TEXT NOT NULL
-    );
-    CREATE TABLE IF NOT EXISTS file_mtimes (
-      source   TEXT PRIMARY KEY,
-      mtime_ms REAL NOT NULL
-    );
-    CREATE TABLE IF NOT EXISTS entries (
-      id         TEXT PRIMARY KEY,
-      source     TEXT NOT NULL,
-      text       TEXT NOT NULL,
-      vector     BLOB NOT NULL,
-      indexed_at INTEGER NOT NULL
-    );
-    CREATE INDEX IF NOT EXISTS idx_entries_source ON entries(source);
-  `);
-    // Initialise meta if absent.
-    const set = dbInstance.prepare("INSERT INTO meta (key, value) VALUES (?, ?) ON CONFLICT(key) DO NOTHING");
-    set.run("model", EMBEDDING_MODEL);
-    set.run("schemaVersion", SCHEMA_VERSION);
-    return dbInstance;
-}
-/** Close handle (used by tests / shutdown). */
-export function closeEmbeddingsDb() {
-    if (dbInstance) {
-        dbInstance.close();
-        dbInstance = null;
-    }
-}
-/** Sharper assertion for use inside helpers that require an open DB. */
-function dbOrThrow() {
-    const d = db();
-    if (!d) {
-        throw new Error("Embeddings DB unavailable — better-sqlite3 native module not loaded");
-    }
-    return d;
-}
-// ── Meta helpers ────────────────────────────────────────
-function getMeta(key) {
-    const row = dbOrThrow().prepare("SELECT value FROM meta WHERE key = ?").get(key);
-    return row?.value ?? null;
-}
-function setMeta(key, value) {
-    dbOrThrow()
-        .prepare("INSERT INTO meta (key, value) VALUES (?, ?) ON CONFLICT(key) DO UPDATE SET value = excluded.value")
-        .run(key, value);
-}
-function getFileMtimes() {
-    const rows = dbOrThrow()
-        .prepare("SELECT source, mtime_ms FROM file_mtimes")
-        .all();
-    const out = {};
-    for (const r of rows)
-        out[r.source] = r.mtime_ms;
-    return out;
-}
-function setFileMtime(source, mtimeMs) {
-    dbOrThrow()
-        .prepare("INSERT INTO file_mtimes (source, mtime_ms) VALUES (?, ?) ON CONFLICT(source) DO UPDATE SET mtime_ms = excluded.mtime_ms")
-        .run(source, mtimeMs);
-}
-// ── Google Embeddings API ───────────────────────────────
-async function getEmbeddings(texts) {
-    const apiKey = config.apiKeys.google;
-    if (!apiKey) {
-        throw new Error("Google API key not configured. Set GOOGLE_API_KEY in .env");
-    }
-    const results = [];
-    const batchSize = 100;
-    for (let i = 0; i < texts.length; i += batchSize) {
-        const batch = texts.slice(i, i + batchSize);
-        const response = await fetch(`https://generativelanguage.googleapis.com/v1beta/models/${EMBEDDING_MODEL}:batchEmbedContents?key=${apiKey}`, {
-            method: "POST",
-            headers: { "Content-Type": "application/json" },
-            body: JSON.stringify({
-                requests: batch.map(text => ({
-                    model: `models/${EMBEDDING_MODEL}`,
-                    content: { parts: [{ text }] },
-                    taskType: "RETRIEVAL_DOCUMENT",
-                })),
-            }),
-        });
-        if (!response.ok) {
-            const err = await response.text();
-            throw new Error(`Embedding API error: ${response.status} — ${err}`);
-        }
-        const data = (await response.json());
-        for (const emb of data.embeddings) {
-            results.push(emb.values);
-        }
-    }
-    return results;
-}
-async function getQueryEmbedding(text) {
-    const apiKey = config.apiKeys.google;
-    if (!apiKey) {
-        throw new Error("Google API key not configured");
-    }
-    const response = await fetch(`https://generativelanguage.googleapis.com/v1beta/models/${EMBEDDING_MODEL}:embedContent?key=${apiKey}`, {
-        method: "POST",
-        headers: { "Content-Type": "application/json" },
-        body: JSON.stringify({
-            model: `models/${EMBEDDING_MODEL}`,
-            content: { parts: [{ text }] },
-            taskType: "RETRIEVAL_QUERY",
-        }),
-    });
-    if (!response.ok) {
-        const err = await response.text();
-        throw new Error(`Embedding API error: ${response.status} — ${err}`);
-    }
-    const data = (await response.json());
-    return data.embedding.values;
-}
-// ── Vector Math ─────────────────────────────────────────
-function cosineSimilarityF32(a, b) {
-    if (a.length !== b.length)
-        return 0;
-    let dotProduct = 0;
-    let normA = 0;
-    let normB = 0;
-    for (let i = 0; i < a.length; i++) {
-        dotProduct += a[i] * b[i];
-        normA += a[i] * a[i];
-        normB += b[i] * b[i];
-    }
-    const denom = Math.sqrt(normA) * Math.sqrt(normB);
-    return denom === 0 ? 0 : dotProduct / denom;
-}
-// ── Text Chunking ───────────────────────────────────────
-function chunkMarkdown(content, source) {
-    const chunks = [];
-    const sections = content.split(/^(?=## )/gm);
-    for (let i = 0; i < sections.length; i++) {
-        const section = sections[i].trim();
-        if (!section || section.length < 20)
-            continue;
-        if (section.length > 1000) {
-            const paragraphs = section.split(/\n\n+/);
-            let currentChunk = "";
-            let chunkIdx = 0;
-            for (const para of paragraphs) {
-                if (currentChunk.length + para.length > 800 && currentChunk.length > 100) {
-                    chunks.push({
-                        id: `${source}:${i}:${chunkIdx}`,
-                        text: currentChunk.trim(),
-                    });
-                    currentChunk = "";
-                    chunkIdx++;
-                }
-                currentChunk += para + "\n\n";
-            }
-            if (currentChunk.trim().length > 20) {
-                chunks.push({
-                    id: `${source}:${i}:${chunkIdx}`,
-                    text: currentChunk.trim(),
-                });
-            }
-        }
-        else {
-            chunks.push({
-                id: `${source}:${i}`,
-                text: section,
-            });
-        }
-    }
-    return chunks;
-}
-// ── Indexable file discovery ────────────────────────────
-function walkAssetDir(dir) {
-    const results = [];
-    function walk(currentDir) {
-        let entries;
-        try {
-            entries = fs.readdirSync(currentDir, { withFileTypes: true });
-        }
-        catch {
-            return;
-        }
-        for (const entry of entries) {
-            const fullPath = resolve(currentDir, entry.name);
-            if (entry.isDirectory()) {
-                walk(fullPath);
-            }
-            else if (entry.isFile()) {
-                if (currentDir === dir && (entry.name === "INDEX.json" || entry.name === "INDEX.md"))
-                    continue;
-                results.push({ name: entry.name, path: fullPath });
-            }
-        }
-    }
-    walk(dir);
-    return results;
-}
-const TEXT_EXTENSIONS = new Set([".md", ".html", ".txt", ".css", ".ts"]);
-function getIndexableFiles() {
-    const files = [];
-    if (fs.existsSync(MEMORY_FILE)) {
-        files.push({ path: MEMORY_FILE, relativePath: "MEMORY.md" });
-    }
-    if (fs.existsSync(MEMORY_DIR)) {
-        const entries = fs.readdirSync(MEMORY_DIR);
-        for (const entry of entries) {
-            if (entry.endsWith(".md") && !entry.startsWith(".")) {
-                files.push({
-                    path: resolve(MEMORY_DIR, entry),
-                    relativePath: `memory/${entry}`,
-                });
-            }
-        }
-    }
-    if (fs.existsSync(HUB_MEMORY_DIR)) {
-        try {
-            const entries = fs.readdirSync(HUB_MEMORY_DIR);
-            for (const entry of entries) {
-                if (entry.endsWith(".md") && !entry.startsWith(".")) {
-                    files.push({
-                        path: resolve(HUB_MEMORY_DIR, entry),
-                        relativePath: `hub/${entry}`,
-                    });
-                }
-            }
-        }
-        catch {
-            /* Hub not available — skip */
-        }
-    }
-    if (fs.existsSync(ASSETS_INDEX_MD)) {
-        files.push({ path: ASSETS_INDEX_MD, relativePath: "assets/INDEX.md" });
-    }
-    if (fs.existsSync(ASSETS_DIR)) {
-        for (const entry of walkAssetDir(ASSETS_DIR)) {
-            if (TEXT_EXTENSIONS.has(path.extname(entry.name))) {
-                files.push({
-                    path: entry.path,
-                    relativePath: `assets/${path.relative(ASSETS_DIR, entry.path)}`,
-                });
-            }
-        }
-    }
-    return files;
-}
-function getStaleFiles() {
-    const allFiles = getIndexableFiles();
-    const known = getFileMtimes();
-    const stale = [];
-    for (const file of allFiles) {
-        try {
-            const mtime = fs.statSync(file.path).mtimeMs;
-            if (!known[file.relativePath] || known[file.relativePath] < mtime) {
-                stale.push(file);
-            }
-        }
-        catch {
-            /* file disappeared */
-        }
-    }
-    return stale;
-}
-// ── Public API ──────────────────────────────────────────
-export async function reindexMemory(force = false) {
-    if (!loadSqlite()) {
-        return { indexed: 0, total: 0 };
-    }
-    const filesToIndex = force ? getIndexableFiles() : getStaleFiles();
-    if (filesToIndex.length === 0) {
-        const total = dbOrThrow().prepare("SELECT COUNT(*) AS c FROM entries").get().c;
-        return { indexed: 0, total };
-    }
-    // Drop existing entries for files being reindexed (per-source DELETE is O(log n) thanks to idx).
-    const delStmt = dbOrThrow().prepare("DELETE FROM entries WHERE source = ?");
-    const dropOld = dbOrThrow().transaction((sources) => {
-        for (const s of sources)
-            delStmt.run(s);
-    });
-    dropOld(filesToIndex.map(f => f.relativePath));
-    // Chunk all files.
-    const allChunks = [];
-    for (const file of filesToIndex) {
-        try {
-            const content = fs.readFileSync(file.path, "utf-8");
-            const chunks = chunkMarkdown(content, file.relativePath);
-            const mtime = fs.statSync(file.path).mtimeMs;
-            for (const chunk of chunks) {
-                allChunks.push({ ...chunk, source: file.relativePath, mtime });
-            }
-        }
-        catch (err) {
-            console.error(`Failed to chunk ${file.relativePath}:`, err);
-        }
-    }
-    if (allChunks.length === 0) {
-        // Even with zero chunks, keep mtimes in sync so we don't re-walk on next run.
-        const updMtime = dbOrThrow().transaction((files) => {
-            for (const f of files) {
-                try {
-                    setFileMtime(f.relativePath, fs.statSync(f.path).mtimeMs);
-                }
-                catch {
-                    /* file disappeared */
-                }
-            }
-        });
-        updMtime(filesToIndex);
-        const total = dbOrThrow().prepare("SELECT COUNT(*) AS c FROM entries").get().c;
-        return { indexed: 0, total };
-    }
-    // Get embeddings for all chunks (network).
-    const texts = allChunks.map(c => c.text);
-    const vectors = await getEmbeddings(texts);
-    // Single transaction for all writes.
-    const insertStmt = dbOrThrow().prepare("INSERT INTO entries (id, source, text, vector, indexed_at) VALUES (?, ?, ?, ?, ?) " +
-        "ON CONFLICT(id) DO UPDATE SET source=excluded.source, text=excluded.text, vector=excluded.vector, indexed_at=excluded.indexed_at");
-    const writeAll = dbOrThrow().transaction((rows) => {
-        for (const r of rows) {
-            insertStmt.run(r.id, r.source, r.text, r.vector, r.indexedAt);
-        }
-    });
-    const now = Date.now();
-    writeAll(allChunks.map((c, i) => ({
-        id: c.id,
-        source: c.source,
-        text: c.text,
-        vector: vectorToBlob(vectors[i]),
-        indexedAt: now,
-    })));
-    // Update mtimes for the files we just (re-)indexed.
-    const updMtime = dbOrThrow().transaction((files) => {
-        for (const f of files) {
-            try {
-                setFileMtime(f.relativePath, fs.statSync(f.path).mtimeMs);
-            }
-            catch {
-                /* file disappeared */
-            }
-        }
-    });
-    updMtime(filesToIndex);
-    setMeta("lastReindex", String(now));
-    const total = dbOrThrow().prepare("SELECT COUNT(*) AS c FROM entries").get().c;
-    return { indexed: allChunks.length, total };
-}
-export async function searchMemory(query, topK = 5, minScore = 0.3) {
-    if (!loadSqlite()) {
-        return [];
-    }
-    // Auto-index if empty.
-    const total = dbOrThrow().prepare("SELECT COUNT(*) AS c FROM entries").get().c;
-    if (total === 0) {
-        await reindexMemory();
-        const after = dbOrThrow().prepare("SELECT COUNT(*) AS c FROM entries").get().c;
-        if (after === 0)
-            return [];
-    }
-    const queryVector = Float32Array.from(await getQueryEmbedding(query));
-    const rows = dbOrThrow().prepare("SELECT id, source, text, vector FROM entries").all();
-    const scored = [];
-    for (const row of rows) {
-        const v = blobToVector(row.vector);
-        const score = cosineSimilarityF32(queryVector, v);
-        if (score >= minScore) {
-            scored.push({ text: row.text, source: row.source, score });
-        }
-    }
-    scored.sort((a, b) => b.score - a.score);
-    return scored.slice(0, topK);
-}
-export async function initEmbeddings() {
-    if (!loadSqlite()) {
-        return; // already warned via loadSqlite
-    }
-    try {
-        db(); // Open & migrate schema.
-        const stale = getStaleFiles();
-        if (stale.length === 0) {
-            const total = dbOrThrow().prepare("SELECT COUNT(*) AS c FROM entries").get().c;
-            if (total > 0)
-                return;
-        }
-        const result = await reindexMemory();
-        if (result.indexed > 0) {
-            console.log(`🔍 Embeddings: indexed ${result.indexed} chunks (${result.total} total)`);
-        }
-    }
-    catch (err) {
-        console.warn("⚠️ Embeddings init failed:", err instanceof Error ? err.message : err);
-    }
-}
-export function getIndexStats() {
-    let entries = 0;
-    let files = 0;
-    let lastReindex = 0;
-    let sizeBytes = 0;
-    if (!loadSqlite()) {
-        return { entries, files, lastReindex, sizeBytes };
-    }
-    try {
-        entries = dbOrThrow().prepare("SELECT COUNT(*) AS c FROM entries").get().c;
-        files = dbOrThrow().prepare("SELECT COUNT(*) AS c FROM file_mtimes").get().c;
-        const meta = getMeta("lastReindex");
-        if (meta)
-            lastReindex = Number(meta);
-        sizeBytes = fs.statSync(EMBEDDINGS_DB).size;
-    }
-    catch {
-        /* DB not yet initialised */
-    }
-    return { entries, files, lastReindex, sizeBytes };
-}
-// ── Re-export embedding dim for tests / debugging ──────
-export { EMBEDDING_DIMENSION, EMBEDDING_MODEL };
+export { initEmbeddings, searchMemory, reindexMemory, getIndexStats, getEmbeddingsBackendStatus, closeEmbeddingsDb, isSqliteMemoryReady, } from "./embeddings/index.js";

package/dist/services/memory-inject-mode.js

@@ -0,0 +1,43 @@
+/**
+ * Memory inject-mode resolver.
+ *
+ * v4.22 introduces three modes for how curated long-term memory is added to
+ * the system prompt:
+ *
+ *   legacy  — inject MEMORY.md + daily logs as plain text on every turn.
+ *             Pre-v4.22 behaviour. Tokens-heavy but works without any API key
+ *             or SQLite. The fallback when nothing else is configured.
+ *
+ *   sqlite  — DON'T bulk-inject MEMORY.md or daily logs. Trust the SQLite
+ *             memory store (vector or FTS5) + searchMemory() to surface
+ *             relevant chunks on demand. identity.md and preferences.md are
+ *             still always plain-text injected because they're tiny and
+ *             always-on by design.
+ *
+ *   auto    — (default) sqlite if the SQLite store has at least one indexed
+ *             entry, otherwise legacy. This is the seamless-upgrade path:
+ *             public users keep the legacy behaviour until they've actually
+ *             populated the SQLite store, then automatically benefit from
+ *             smaller prompts + targeted retrieval.
+ *
+ * Override via MEMORY_INJECT_MODE=auto|legacy|sqlite. The bot logs the
+ * resolved mode at startup.
+ */
+import { isSqliteMemoryReady } from "./embeddings.js";
+export function getInjectModeRaw() {
+    const v = (process.env.MEMORY_INJECT_MODE || "auto").trim().toLowerCase();
+    if (v === "legacy" || v === "sqlite" || v === "auto")
+        return v;
+    return "auto";
+}
+/**
+ * Resolve the effective mode. In auto, defer to whether the SQLite store
+ * actually has indexed entries — falls back to legacy on a fresh install or
+ * when reindex hasn't run yet.
+ */
+export function getEffectiveInjectMode() {
+    const raw = getInjectModeRaw();
+    if (raw === "legacy" || raw === "sqlite")
+        return raw;
+    return isSqliteMemoryReady() ? "sqlite" : "legacy";
+}