om-memory-system 4.25.1 → 4.26.1

package/dist/services/cleanup-service.js

@@ -72,7 +72,7 @@ export class CleanupService {
                         }
                     }
                     catch (error) {
-                        log("Cleanup: delete error", { memoryId: memory.id, error: String(error) });
+                        log("Cleanup: delete error", { memoryId: memory.id, error: String(error) }, "error");
                     }
                 }
             }
@@ -84,7 +84,7 @@ export class CleanupService {
             catch (error) {
                 log("Capture attempt cleanup failed", {
                     code: error instanceof Error ? error.name : "unknown",
-                });
+                }, "error");
             }
             try {
                 const { pruneCaptureRetries } = await import("./capture-retry-queue.js");
@@ -93,7 +93,7 @@ export class CleanupService {
             catch (error) {
                 log("Capture retry cleanup failed", {
                     code: error instanceof Error ? error.name : "unknown",
-                });
+                }, "error");
             }
             try {
                 const { pruneAutoCleanupRecords } = await import("./user-profile/auto-cleanup-store.js");
@@ -102,14 +102,14 @@ export class CleanupService {
             catch (error) {
                 log("Automatic cleanup record cleanup failed", {
                     code: error instanceof Error ? error.name : "unknown",
-                });
+                }, "error");
             }
             try {
                 await userPromptManager.vacuum();
                 log("Cleanup: VACUUM done", { db: "user-prompts.db" });
             }
             catch (err) {
-                log("Cleanup: VACUUM skipped (DB busy)", { error: String(err) });
+                log("Cleanup: VACUUM skipped (DB busy)", { error: String(err) }, "warn");
             }
             return {
                 deletedCount: totalDeleted,

package/dist/services/client.js

@@ -54,7 +54,7 @@ export class LocalMemoryClient {
             }
             catch (error) {
                 this.initPromise = null;
-                log("Turso initialization failed", { error: String(error) });
+                log("Turso initialization failed", { error: String(error) }, "error");
                 throw error;
             }
         })();
@@ -142,7 +142,7 @@ export class LocalMemoryClient {
         }
         catch (error) {
             const errorMessage = error instanceof Error ? error.message : String(error);
-            log("searchMemories: error", { error: errorMessage });
+            log("searchMemories: error", { error: errorMessage }, "error");
             return { success: false, error: errorMessage, results: [], total: 0, timing: 0 };
         }
     }
@@ -192,7 +192,7 @@ export class LocalMemoryClient {
         }
         catch (error) {
             const errorMessage = error instanceof Error ? error.message : String(error);
-            log("addMemory: error", { error: errorMessage });
+            log("addMemory: error", { error: errorMessage }, "error");
             return { success: false, error: errorMessage };
         }
     }
@@ -215,7 +215,7 @@ export class LocalMemoryClient {
         }
         catch (error) {
             const errorMessage = error instanceof Error ? error.message : String(error);
-            log("deleteMemory: error", { memoryId, error: errorMessage });
+            log("deleteMemory: error", { memoryId, error: errorMessage }, "error");
             return { success: false, error: errorMessage };
         }
     }
@@ -259,7 +259,7 @@ export class LocalMemoryClient {
         }
         catch (error) {
             const errorMessage = error instanceof Error ? error.message : String(error);
-            log("listMemories: error", { error: errorMessage });
+            log("listMemories: error", { error: errorMessage }, "error");
             return {
                 success: false,
                 error: errorMessage,
@@ -279,7 +279,7 @@ export class LocalMemoryClient {
         }
         catch (error) {
             const errorMessage = error instanceof Error ? error.message : String(error);
-            log("listShards: error", { error: errorMessage });
+            log("listShards: error", { error: errorMessage }, "error");
             return { success: false, error: errorMessage };
         }
     }
@@ -291,7 +291,7 @@ export class LocalMemoryClient {
         }
         catch (error) {
             const errorMessage = error instanceof Error ? error.message : String(error);
-            log("migrateProjectPath: error", { error: errorMessage });
+            log("migrateProjectPath: error", { error: errorMessage }, "error");
             return { success: false, dryRun: Boolean(options.dryRun), error: errorMessage };
         }
     }
@@ -303,7 +303,7 @@ export class LocalMemoryClient {
         }
         catch (error) {
             const errorMessage = error instanceof Error ? error.message : String(error);
-            log("exportMemories: error", { error: errorMessage });
+            log("exportMemories: error", { error: errorMessage }, "error");
             return { success: false, error: errorMessage };
         }
     }
@@ -319,7 +319,7 @@ export class LocalMemoryClient {
         }
         catch (error) {
             const errorMessage = error instanceof Error ? error.message : String(error);
-            log("importMemories: error", { error: errorMessage });
+            log("importMemories: error", { error: errorMessage }, "error");
             return { success: false, dryRun: Boolean(dryRun), error: errorMessage };
         }
     }
@@ -357,7 +357,7 @@ export class LocalMemoryClient {
         }
         catch (error) {
             const errorMessage = error instanceof Error ? error.message : String(error);
-            log("searchMemoriesBySessionID: error", { error: errorMessage });
+            log("searchMemoriesBySessionID: error", { error: errorMessage }, "error");
             return { success: false, error: errorMessage, results: [], total: 0, timing: 0 };
         }
     }

package/dist/services/deduplication-service.js

@@ -48,7 +48,7 @@ export class DeduplicationService {
                                 log("Deduplication: delete error", {
                                     memoryId: dup.id,
                                     error: String(error),
-                                });
+                                }, "error");
                             }
                         }
                     }

package/dist/services/embedding.js

@@ -62,7 +62,7 @@ async function ensureTransformersLoaded() {
         mod.env.backends.onnx.wasm.numThreads = 1;
     }
     catch (e) {
-        log("Failed to set wasm.numThreads", { error: String(e) });
+        log("Failed to set wasm.numThreads", { error: String(e) }, "warn");
     }
     _transformers = mod;
     return _transformers;
@@ -183,7 +183,7 @@ export class EmbeddingService {
             const rewritten = formatOnnxruntimeInitError(error);
             this.initPromise = null;
             this.initError = rewritten.message;
-            log("Failed to initialize embedding model", { error: rewritten.message });
+            log("Failed to initialize embedding model", { error: rewritten.message }, "error");
             throw rewritten;
         }
     }

package/dist/services/host-appearance.d.ts

@@ -0,0 +1,28 @@
+export declare const APPEARANCE_HOSTS: readonly ["pi", "opencode", "claude-code"];
+export type AppearanceHost = (typeof APPEARANCE_HOSTS)[number];
+export type HostLook = {
+    kind: "default";
+} | {
+    kind: "icon";
+    icon: string;
+} | {
+    kind: "image";
+    image: string;
+};
+export type HostLooks = Record<AppearanceHost, HostLook>;
+/** A refused change; `status` is the HTTP status. */
+export declare class HostAppearanceError extends Error {
+    readonly status = 400;
+    constructor(message: string);
+}
+/**
+ * Per-host avatar choices in one global folder. `appearance.json` holds the
+ * choices and `<host>.png` holds an uploaded image. Files are written to a
+ * temporary name and renamed, so a crash leaves the previous avatar.
+ */
+export declare function createHostAppearance(directory: string): {
+    read(): Promise<HostLooks>;
+    setIcon(host: string, icon: unknown): Promise<void>;
+    setImage(host: string, encoded: unknown): Promise<void>;
+    reset(host: string): Promise<void>;
+};

package/dist/services/host-appearance.js

@@ -0,0 +1,117 @@
+import { mkdir, readFile, rename, rm, writeFile } from "node:fs/promises";
+import { join } from "node:path";
+export const APPEARANCE_HOSTS = ["pi", "opencode", "claude-code"];
+/** A refused change; `status` is the HTTP status. */
+export class HostAppearanceError extends Error {
+    status = 400;
+    constructor(message) {
+        super(message);
+        this.name = "HostAppearanceError";
+    }
+}
+const PNG_SIGNATURE = Buffer.from([0x89, 0x50, 0x4e, 0x47, 0x0d, 0x0a, 0x1a, 0x0a]);
+const IEND = Buffer.from([0x49, 0x45, 0x4e, 0x44, 0xae, 0x42, 0x60, 0x82]);
+const SIZE = 128;
+const MAX_BYTES = 256 * 1024;
+const ICON_NAME = /^[a-z0-9]+(?:-[a-z0-9]+)*$/;
+function assertHost(host) {
+    if (!APPEARANCE_HOSTS.includes(host)) {
+        throw new HostAppearanceError("Unknown host");
+    }
+}
+/** Decode and check a host image: a 128 by 128 PNG of at most 256 KB. Nothing else is stored. */
+function decodeImage(encoded) {
+    if (typeof encoded !== "string" || encoded.length === 0 || encoded.length > MAX_BYTES * 2) {
+        throw new HostAppearanceError("The image must be a 128 by 128 PNG of at most 256 KB");
+    }
+    if (!/^[A-Za-z0-9+/]+={0,2}$/.test(encoded))
+        throw new HostAppearanceError("Invalid image data");
+    const bytes = Buffer.from(encoded, "base64");
+    const isPng = bytes.length >= 45 &&
+        bytes.length <= MAX_BYTES &&
+        bytes.subarray(0, 8).equals(PNG_SIGNATURE) &&
+        bytes.readUInt32BE(8) === 13 &&
+        bytes.subarray(12, 16).toString("ascii") === "IHDR" &&
+        bytes.subarray(bytes.length - 8).equals(IEND);
+    if (!isPng || bytes.readUInt32BE(16) !== SIZE || bytes.readUInt32BE(20) !== SIZE) {
+        throw new HostAppearanceError("The image must be a 128 by 128 PNG of at most 256 KB");
+    }
+    return bytes;
+}
+/**
+ * Per-host avatar choices in one global folder. `appearance.json` holds the
+ * choices and `<host>.png` holds an uploaded image. Files are written to a
+ * temporary name and renamed, so a crash leaves the previous avatar.
+ */
+export function createHostAppearance(directory) {
+    const settingsPath = join(directory, "appearance.json");
+    const imagePath = (host) => join(directory, `${host}.png`);
+    async function readSaved() {
+        try {
+            const parsed = JSON.parse(await readFile(settingsPath, "utf8"));
+            return parsed && typeof parsed === "object" ? parsed : {};
+        }
+        catch {
+            return {};
+        }
+    }
+    async function atomicWrite(path, data) {
+        await mkdir(directory, { recursive: true });
+        const temporary = `${path}.${process.pid}.tmp`;
+        await writeFile(temporary, data);
+        await rename(temporary, path);
+    }
+    async function save(host, value) {
+        const saved = await readSaved();
+        if (value)
+            saved[host] = value;
+        else
+            delete saved[host];
+        await atomicWrite(settingsPath, JSON.stringify(saved));
+    }
+    return {
+        async read() {
+            const saved = await readSaved();
+            const looks = {};
+            for (const host of APPEARANCE_HOSTS) {
+                const entry = saved[host];
+                looks[host] = { kind: "default" };
+                if (entry?.kind === "icon" && ICON_NAME.test(String(entry.icon))) {
+                    looks[host] = { kind: "icon", icon: entry.icon };
+                }
+                else if (entry?.kind === "image") {
+                    try {
+                        const bytes = await readFile(imagePath(host));
+                        looks[host] = {
+                            kind: "image",
+                            image: `data:image/png;base64,${bytes.toString("base64")}`,
+                        };
+                    }
+                    catch {
+                        // A missing image file shows the default mark.
+                    }
+                }
+            }
+            return looks;
+        },
+        async setIcon(host, icon) {
+            assertHost(host);
+            if (typeof icon !== "string" || icon.length > 40 || !ICON_NAME.test(icon)) {
+                throw new HostAppearanceError("Invalid icon name");
+            }
+            await save(host, { kind: "icon", icon });
+            await rm(imagePath(host), { force: true });
+        },
+        async setImage(host, encoded) {
+            assertHost(host);
+            const bytes = decodeImage(encoded);
+            await atomicWrite(imagePath(host), bytes);
+            await save(host, { kind: "image" });
+        },
+        async reset(host) {
+            assertHost(host);
+            await save(host, undefined);
+            await rm(imagePath(host), { force: true });
+        },
+    };
+}

package/dist/services/logger.d.ts

@@ -1 +1,7 @@
-export declare function log(message: string, data?: unknown): void;
+export type LogLevel = "warn" | "error";
+/**
+ * Writes one line: `[time] LEVEL message: {data}`. No level means INFO. The
+ * level is an extra argument, not a method, because many tests stub this module
+ * with a bare `log`.
+ */
+export declare function log(message: string, data?: unknown, level?: LogLevel): void;

package/dist/services/logger.js

@@ -92,7 +92,12 @@ function ensureLoggerInitialized() {
     });
     globalThis[GLOBAL_LOGGER_KEY] = true;
 }
-export function log(message, data) {
+/**
+ * Writes one line: `[time] LEVEL message: {data}`. No level means INFO. The
+ * level is an extra argument, not a method, because many tests stub this module
+ * with a bare `log`.
+ */
+export function log(message, data, level) {
     ensureLoggerInitialized();
     const today = formatDate(new Date());
     if (globalThis[LAST_ROTATE_DATE_KEY] !== today) {
@@ -101,8 +106,9 @@ export function log(message, data) {
     }
     const logFile = getLogFilePath();
     const timestamp = formatTimestamp(new Date());
+    const token = level ? level.toUpperCase() : "INFO";
     const line = data
-        ? `[${timestamp}] ${message}: ${JSON.stringify(data)}\n`
-        : `[${timestamp}] ${message}\n`;
+        ? `[${timestamp}] ${token} ${message}: ${JSON.stringify(data)}\n`
+        : `[${timestamp}] ${token} ${message}\n`;
     appendFileSync(logFile, line);
 }

package/dist/services/memory-host-routes.d.ts

@@ -0,0 +1,11 @@
+/**
+ * Routes for the Memory page: whether memories can be saved, and each host's
+ * avatar. Returns undefined for paths it does not own. The web token check
+ * runs before this, for every `/api/` path.
+ */
+export declare function routeMemoryHosts(path: string, method: string, url: URL, readBody: () => Promise<any>, config: {
+    storagePath: string;
+}): Promise<{
+    status: number;
+    body: unknown;
+} | undefined>;

package/dist/services/memory-host-routes.js

@@ -0,0 +1,56 @@
+import { join } from "node:path";
+import { HostAppearanceError, createHostAppearance } from "./host-appearance.js";
+const instances = new Map();
+function appearanceFor(storagePath) {
+    const directory = join(storagePath, "host-appearance");
+    let appearance = instances.get(directory);
+    if (!appearance) {
+        appearance = createHostAppearance(directory);
+        instances.set(directory, appearance);
+    }
+    return appearance;
+}
+const refused = (error) => {
+    if (error instanceof HostAppearanceError) {
+        return { status: error.status, body: { success: false, error: error.message } };
+    }
+    throw error;
+};
+/**
+ * Routes for the Memory page: whether memories can be saved, and each host's
+ * avatar. Returns undefined for paths it does not own. The web token check
+ * runs before this, for every `/api/` path.
+ */
+export async function routeMemoryHosts(path, method, url, readBody, config) {
+    if (path === "/api/memory/write-health" && method === "GET") {
+        const { checkWriteHealth } = await import("./write-health-checks.js");
+        return { status: 200, body: await checkWriteHealth(url.searchParams.get("fresh") === "1") };
+    }
+    if (path === "/api/host-appearance" && method === "GET") {
+        return { status: 200, body: { hosts: await appearanceFor(config.storagePath).read() } };
+    }
+    const host = /^\/api\/host-appearance\/([^/]+)$/.exec(path)?.[1];
+    if (!host)
+        return undefined;
+    const appearance = appearanceFor(config.storagePath);
+    try {
+        if (method === "PUT") {
+            const body = await readBody();
+            if (body?.kind === "icon")
+                await appearance.setIcon(host, body.icon);
+            else if (body?.kind === "image")
+                await appearance.setImage(host, body.png);
+            else
+                throw new HostAppearanceError("Choose an icon or an image");
+            return { status: 200, body: { hosts: await appearance.read() } };
+        }
+        if (method === "DELETE") {
+            await appearance.reset(host);
+            return { status: 200, body: { hosts: await appearance.read() } };
+        }
+    }
+    catch (error) {
+        return refused(error);
+    }
+    return undefined;
+}

package/dist/services/memory-portability-service.js

@@ -321,7 +321,7 @@ export class MemoryPortabilityService {
                     }
                 }
                 catch (cleanupError) {
-                    log("Memory import cleanup failed", { error: String(cleanupError) });
+                    log("Memory import cleanup failed", { error: String(cleanupError) }, "error");
                 }
             }
             return {

package/dist/services/migration-service.js

@@ -46,7 +46,7 @@ export class MigrationService {
                 log("Migration: error checking shard", {
                     shardId: shard.id,
                     error: String(error),
-                });
+                }, "error");
             }
         }
         return {
@@ -82,7 +82,7 @@ export class MigrationService {
             return await this.reEmbedMigration(mismatch, startTime);
         }
         catch (error) {
-            log("Migration: failed", { error: String(error) });
+            log("Migration: failed", { error: String(error) }, "error");
             return {
                 success: false,
                 strategy,

package/dist/services/settings-log.d.ts

@@ -1,5 +1,26 @@
+export type LogRecordLevel = "info" | "warn" | "error";
+export interface LogRecord {
+    /** Line number of the record's first line within the tail that was read. */
+    seq: number;
+    time: string;
+    level: LogRecordLevel;
+    /** True when the level was guessed from the message, as for lines written before levels. */
+    guessed: boolean;
+    message: string;
+    /** The JSON text after the message, or null when the line has none. */
+    data: string | null;
+}
+export interface SettingsLogQuery {
+    lines?: number | string;
+    /** `capture` keeps only `Capture attempt` records. */
+    filter?: string;
+    /** `warn` keeps warn and error records, `error` keeps error records. */
+    level?: string;
+}
+/** Guess the level of a line written before levels, from its message text only. */
+export declare function guessLevel(message: string): LogRecordLevel;
 /** Read the bounded tail of OMMS's own log. The request cannot choose a path. */
-export declare function readSettingsLog(lines?: number, captureOnly?: boolean): Promise<{
+export declare function readSettingsLog(query?: SettingsLogQuery): Promise<{
     path: string;
-    lines: string[];
+    records: LogRecord[];
 }>;

package/dist/services/settings-log.js

@@ -1,16 +1,75 @@
 import { open, stat } from "node:fs/promises";
 import { getLogFilePath } from "./log-path.js";
+const LEVEL_RANK = { info: 0, warn: 1, error: 2 };
+const RECORD_LINE = /^\[([^\]]+)\] (?:(INFO|WARN|ERROR) )?(.*)$/;
+const SESSION_LINE = /^--- Session started: (.+) ---$/;
+/** Guess the level of a line written before levels, from its message text only. */
+export function guessLevel(message) {
+    if (/fail|error|exception/i.test(message))
+        return "error";
+    if (/warn|fallback|falling back|unavailable|skip|retry/i.test(message))
+        return "warn";
+    return "info";
+}
+function splitData(text) {
+    const at = [text.indexOf(": {"), text.indexOf(": [")].filter((i) => i >= 0);
+    if (at.length === 0)
+        return { message: text, data: null };
+    const i = Math.min(...at);
+    return { message: text.slice(0, i), data: text.slice(i + 2) };
+}
+function parseRecords(rows) {
+    const records = [];
+    rows.forEach((row, seq) => {
+        if (row === "")
+            return;
+        const session = SESSION_LINE.exec(row);
+        if (session) {
+            records.push({
+                seq,
+                time: session[1],
+                level: "info",
+                guessed: false,
+                message: "Session started",
+                data: null,
+            });
+            return;
+        }
+        const match = RECORD_LINE.exec(row);
+        if (!match) {
+            const last = records.at(-1);
+            if (last)
+                last.message += `\n${row}`;
+            else
+                records.push({ seq, time: "", level: "info", guessed: true, message: row, data: null });
+            return;
+        }
+        const { message, data } = splitData(match[3]);
+        const token = match[2];
+        records.push({
+            seq,
+            time: match[1],
+            level: token ? token.toLowerCase() : guessLevel(message),
+            guessed: !token,
+            message,
+            data,
+        });
+    });
+    return records;
+}
 /** Read the bounded tail of OMMS's own log. The request cannot choose a path. */
-export async function readSettingsLog(lines = 200, captureOnly = false) {
+export async function readSettingsLog(query = {}) {
     const path = getLogFilePath();
+    const lines = Number(query.lines ?? 200);
     const count = Number.isFinite(lines) ? Math.max(1, Math.min(2000, Math.floor(lines))) : 200;
+    const minimum = query.level === "warn" || query.level === "error" ? query.level : "info";
     let size;
     try {
         size = (await stat(path)).size;
     }
     catch (error) {
         if (error.code === "ENOENT")
-            return { path, lines: [] };
+            return { path, records: [] };
         throw error;
     }
     const start = Math.max(0, size - 256 * 1024);
@@ -21,14 +80,13 @@ export async function readSettingsLog(lines = 200, captureOnly = false) {
         const text = buffer.subarray(0, bytesRead).toString("utf8");
         const whole = start === 0 ? text : text.slice(text.indexOf("\n") + 1);
         if (start > 0 && !text.includes("\n"))
-            return { path, lines: [] };
+            return { path, records: [] };
         const rows = whole.split(/\r?\n/);
         if (rows.at(-1) === "")
             rows.pop();
-        return {
-            path,
-            lines: rows.filter((line) => !captureOnly || line.includes("Capture attempt")).slice(-count),
-        };
+        const records = parseRecords(rows).filter((record) => LEVEL_RANK[record.level] >= LEVEL_RANK[minimum] &&
+            (query.filter !== "capture" || record.message.includes("Capture attempt")));
+        return { path, records: records.slice(-count) };
     }
     finally {
         await file.close();

package/dist/services/shard-path-migration-service.js

@@ -240,7 +240,7 @@ export class ShardPathMigrationService {
                     await userPromptManager.updateProjectPath(source.group.projectPath, target.projectPath);
                 }
                 catch (error) {
-                    log("Path migration prompt metadata update failed", { error: String(error) });
+                    log("Path migration prompt metadata update failed", { error: String(error) }, "error");
                 }
             }
             log("Path migration completed", {
@@ -289,7 +289,7 @@ export class ShardPathMigrationService {
             }
             catch (error) {
                 rollbackFailed = true;
-                log("Path migration source rollback failed", { move, error: String(error) });
+                log("Path migration source rollback failed", { move, error: String(error) }, "error");
             }
         }
         for (const archived of state.archivedTargets) {
@@ -302,7 +302,7 @@ export class ShardPathMigrationService {
             }
             catch (error) {
                 rollbackFailed = true;
-                log("Path migration target rollback failed", { archived, error: String(error) });
+                log("Path migration target rollback failed", { archived, error: String(error) }, "error");
             }
         }
         // Startup reconciliation may have registered a newly renamed shard before
@@ -317,7 +317,7 @@ export class ShardPathMigrationService {
         }
         catch (error) {
             rollbackFailed = true;
-            log("Path migration stale target cleanup failed", { error: String(error) });
+            log("Path migration stale target cleanup failed", { error: String(error) }, "error");
         }
         if (!rollbackFailed && existsSync(statePath)) {
             unlinkSync(statePath);

package/dist/services/tag-prefix-migration.js

@@ -434,6 +434,6 @@ export async function runStartupTagPrefixGate() {
     }
     const warning = explicitOpencodePrefixWarning(getExplicitContainerTagPrefix());
     if (warning) {
-        log(warning);
+        log(warning, undefined, "warn");
     }
 }

package/dist/services/turso/connection-manager.js

@@ -111,7 +111,7 @@ export class TursoConnectionManager {
                     await db.close();
                 }
                 catch (error) {
-                    log("Error closing Turso database", { path: dbPath, error: String(error) });
+                    log("Error closing Turso database", { path: dbPath, error: String(error) }, "error");
                 }
                 this.connections.delete(dbPath);
             }
@@ -133,7 +133,7 @@ export class TursoConnectionManager {
                     await db.close();
                 }
                 catch (error) {
-                    log("Error closing Turso database", { path, error: String(error) });
+                    log("Error closing Turso database", { path, error: String(error) }, "error");
                 }
             }
             this.connections.clear();
@@ -153,7 +153,7 @@ export class TursoConnectionManager {
                 db.getClient().close();
             }
             catch (error) {
-                log("Error closing Turso database (sync)", { path, error: String(error) });
+                log("Error closing Turso database (sync)", { path, error: String(error) }, "error");
             }
         }
         this.connections.clear();

package/dist/services/turso/keyword-search.js

@@ -138,7 +138,7 @@ export async function searchKeywords(db, queryText, containerTag, limit) {
         log("Keyword search failed; using vector results", {
             code: "keyword_index_failed",
             error: error instanceof Error ? error.name : "unknown",
-        });
+        }, "warn");
         return null;
     }
 }

package/dist/services/turso/legacy-migrator.js

@@ -303,7 +303,7 @@ async function migrateMemoryShard(dbPath) {
         const record = rowToRecord(row);
         if (!record) {
             skippedIds.push(String(row.id));
-            log("Legacy migration skipped memory without vector", { memoryId: row.id, dbPath });
+            log("Legacy migration skipped memory without vector", { memoryId: row.id, dbPath }, "warn");
             continue;
         }
         records.push(record);