om-memory-system 5.10.1 → 6.1.0-next.237

package/dist/importer/handled-lookup.js

@@ -0,0 +1,13 @@
+const exactKeyLookup = (ledger, { key, readOnly }) => readOnly ? ledger.peek(key) : ledger.get(key);
+const HANDLED_LOOKUPS = {
+    opencode: async (ledger, query) => {
+        const exact = await exactKeyLookup(ledger, query);
+        if (exact?.status === "imported" || exact?.status === "skipped")
+            return exact;
+        return ((await ledger.findHandledByPrefix(query.sessionId, `opencode:${query.sessionId}:${query.window.userEntryId}:`, { readOnly: query.readOnly })) ?? exact);
+    },
+};
+/** The lookup for a host, chosen once per import run. */
+export function handledLookupFor(host) {
+    return HANDLED_LOOKUPS[host] ?? exactKeyLookup;
+}

package/dist/importer/importer.js

@@ -8,6 +8,7 @@ import { tursoConnectionManager } from "../services/turso/connection-manager.js"
 import { tursoShardManager } from "../services/turso/shard-manager.js";
 import { extractPiConversationWindows, } from "./pi-conversation.js";
 import { discoverPiSessions } from "./discovery.js";
+import { handledLookupFor } from "./handled-lookup.js";
 import { importDirectory } from "./import-project.js";
 import { importSkillTurnOutput, importSkillTurnsOn, importWorkUnit, skillTurnsOnly, } from "./import-turn-outputs.js";
 import { PiImportLedger, importLedgerDbPath } from "./ledger.js";
@@ -112,6 +113,7 @@ export async function importHistorySource(source, host, deps, filters, report) {
     const ledger = deps.ledger ?? new PiImportLedger();
     const ledgerFileExists = existsSync(importLedgerDbPath());
     const ledgerAccessible = !dryRun || ledgerFileExists;
+    const lookupHandled = handledLookupFor(host);
     if (!dryRun && memories) {
         // A dry run only reads the ledger (peek), so it never writes its schema.
         await ledger.get("__warmup__");
@@ -166,9 +168,7 @@ export async function importHistorySource(source, host, deps, filters, report) {
             continue;
         const existing = !ledgerAccessible
             ? null
-            : dryRun
-                ? await ledger.peek(key)
-                : await ledger.get(key);
+            : await lookupHandled(ledger, { key, sessionId, window, readOnly: dryRun });
         const terminalHandled = existing &&
             (existing.status === "imported" || existing.status === "skipped") &&
             !filters.force;

package/dist/importer/ledger.d.ts

@@ -32,6 +32,15 @@ export declare class ImportLedger {
      * A ledger file without the table reads as empty.
      */
     peek(key: string): Promise<ImportLedgerRow | null>;
+    /**
+     * An imported or skipped memory row of one session whose key starts with `prefix`.
+     * Rows are found through the `session_id` index, then prefix-checked. Profile rows
+     * (`#profile` keys) share the prefix but do not show that a memory was imported.
+     * With `readOnly` it never creates the table, like `peek`.
+     */
+    findHandledByPrefix(sessionId: string, prefix: string, options?: {
+        readOnly?: boolean;
+    }): Promise<ImportLedgerRow | null>;
     /**
      * Sessions whose ledger rows are all finished for every ticked output.
      * Memory rows and profile rows (`project_hash = 'profile'`) are judged apart.

package/dist/importer/ledger.js

@@ -88,6 +88,27 @@ export class ImportLedger {
         const row = await db.get(`SELECT * FROM import_ledger WHERE key = ?`, [key]);
         return row ? rowToEntry(row) : null;
     }
+    /**
+     * An imported or skipped memory row of one session whose key starts with `prefix`.
+     * Rows are found through the `session_id` index, then prefix-checked. Profile rows
+     * (`#profile` keys) share the prefix but do not show that a memory was imported.
+     * With `readOnly` it never creates the table, like `peek`.
+     */
+    async findHandledByPrefix(sessionId, prefix, options = {}) {
+        const db = options.readOnly
+            ? await tursoConnectionManager.getConnection(importLedgerDbPath())
+            : await this.db();
+        if (options.readOnly) {
+            const table = await db.get(`SELECT name FROM sqlite_master WHERE type = 'table' AND name = 'import_ledger'`);
+            if (!table)
+                return null;
+        }
+        const row = await db.get(`SELECT * FROM import_ledger
+       WHERE session_id = ? AND status IN ('imported', 'skipped') AND substr(key, 1, ?) = ?
+         AND project_hash <> 'profile'
+       LIMIT 1`, [sessionId, prefix.length, prefix]);
+        return row ? rowToEntry(row) : null;
+    }
     /**
      * Sessions whose ledger rows are all finished for every ticked output.
      * Memory rows and profile rows (`project_hash = 'profile'`) are judged apart.

package/dist/importer/opencode-reader.d.ts

@@ -35,5 +35,5 @@ export interface OpencodeOpenOptions {
     };
     signal?: AbortSignal;
 }
-/** Read V1 OpenCode history without changing its database or WAL sidecars. */
+/** Read OpenCode history without changing its database or WAL sidecars. */
 export declare function openOpencodeHistory(dbPath: string, filters?: OpencodeReaderFilters, options?: OpencodeOpenOptions): Promise<OpencodeHistory>;

package/dist/importer/opencode-reader.js

@@ -6,27 +6,59 @@ import { DatabaseSync } from "node:sqlite";
 import { boundToolInput, readToolPath } from "../core/tool-input.js";
 import { opencodeMemorise, opencodeToolOutcome } from "../core/tool-outcome.js";
 import { INTERNAL_CAPTURE_SESSION_TITLES } from "./opencode-internal-sessions.js";
+import { buildV2Windows } from "./opencode-v2-units.js";
 import { acquirePrivateSnapshot, opencodeSnapshots, OpencodeSnapshotError, } from "./opencode-snapshot.js";
 export const DEFAULT_OPENCODE_DB = join(homedir(), ".local/share/opencode/opencode.db");
-function validateSchema(db) {
-    const required = {
-        session: ["id", "directory", "project_id", "parent_id", "time_created"],
-        project: ["id", "worktree"],
-        message: ["id", "session_id", "time_created", "data"],
-        part: ["id", "message_id", "session_id", "time_created", "data"],
-    };
-    for (const [table, columns] of Object.entries(required)) {
-        const found = db
-            .prepare("SELECT name FROM sqlite_master WHERE type = 'table' AND name = ?")
-            .get(table);
-        if (!found)
-            throw new Error(`Unsupported OpenCode V1 database: missing ${table} table`);
-        const names = new Set(db.prepare(`PRAGMA table_info(${table})`).all().map((column) => column.name));
+function columnsOf(db, table) {
+    const found = db
+        .prepare("SELECT name FROM sqlite_master WHERE type = 'table' AND name = ?")
+        .get(table);
+    if (!found)
+        return null;
+    return new Set(db.prepare(`PRAGMA table_info(${table})`).all().map((column) => column.name));
+}
+function requireColumns(db, required) {
+    return Object.entries(required).map(([table, columns]) => {
+        const names = columnsOf(db, table);
+        if (!names)
+            throw new Error(`Unsupported OpenCode database: missing ${table} table`);
         for (const column of columns) {
             if (!names.has(column))
-                throw new Error(`Unsupported OpenCode V1 database: missing ${table}.${column}`);
+                throw new Error(`Unsupported OpenCode database: missing ${table}.${column}`);
         }
+        return names;
+    });
+}
+/**
+ * OpenCode 2.x keeps sessions in `session_v2` and `session_message`; older
+ * copies have `session`, `message` and `part`. A set counts as present when
+ * its session table exists, and is then checked in full.
+ */
+function detectTableSets(db) {
+    const v2 = columnsOf(db, "session_v2") !== null;
+    const v1 = columnsOf(db, "session") !== null;
+    if (!v2 && !v1) {
+        throw new Error("Unsupported OpenCode database: missing session_v2 and session_message tables, " +
+            "and missing session and message tables");
+    }
+    const titled = { v2: false, v1: false };
+    if (v2) {
+        const [sessions] = requireColumns(db, {
+            session_v2: ["id", "directory", "project_id", "parent_id", "time_created"],
+            session_message: ["id", "session_id", "type", "time_created", "data"],
+        });
+        titled.v2 = sessions.has("title");
+    }
+    if (v1) {
+        const [sessions] = requireColumns(db, {
+            session: ["id", "directory", "project_id", "parent_id", "time_created"],
+            message: ["id", "session_id", "time_created", "data"],
+            part: ["id", "message_id", "session_id", "time_created", "data"],
+        });
+        titled.v1 = sessions.has("title");
     }
+    requireColumns(db, { project: ["id", "worktree"] });
+    return { v2, v1, titled };
 }
 function parseData(json) {
     try {
@@ -153,19 +185,34 @@ function changedSinceOpen(dbPath, source) {
         return false;
     return existsSync(`${dbPath}-wal`) || fileStamp(dbPath) !== source.stamp;
 }
+/**
+ * Every session once: `session_v2` rows, plus `session` rows whose id has no
+ * `session_v2` row. A session therefore comes from one table set only.
+ */
+function sessionSourcesSql(sets) {
+    const parts = [];
+    if (sets.v2) {
+        parts.push(`SELECT s.id, s.parent_id, ${sets.titled.v2 ? "s.title" : "NULL"} AS title,
+      s.directory, s.project_id, s.time_created, 'v2' AS source FROM session_v2 s`);
+    }
+    if (sets.v1) {
+        parts.push(`SELECT s.id, s.parent_id, ${sets.titled.v1 ? "s.title" : "NULL"} AS title,
+      s.directory, s.project_id, s.time_created, 'v1' AS source FROM session s
+      ${sets.v2 ? "WHERE NOT EXISTS (SELECT 1 FROM session_v2 v WHERE v.id = s.id)" : ""}`);
+    }
+    return parts.join(" UNION ALL ");
+}
 function readSessions(db, filters) {
-    validateSchema(db);
+    const sets = detectTableSets(db);
     // omms's own capture/profile calls run in OpenCode sessions; never import them as history.
-    const hasTitle = db.prepare("PRAGMA table_info(session)").all().some((column) => column.name === "title");
-    const notInternal = hasTitle
-        ? `AND (s.title IS NULL OR s.title NOT IN (${INTERNAL_CAPTURE_SESSION_TITLES.map(() => "?").join(", ")}))`
-        : "";
-    const internalArgs = hasTitle ? [...INTERNAL_CAPTURE_SESSION_TITLES] : [];
+    const notInternal = `AND (s.title IS NULL OR s.title NOT IN (${INTERNAL_CAPTURE_SESSION_TITLES.map(() => "?").join(", ")}))`;
+    const internalArgs = [...INTERNAL_CAPTURE_SESSION_TITLES];
+    const sources = sessionSourcesSql(sets);
     const count = (where) => Number(db
-        .prepare(`SELECT COUNT(*) AS count FROM session s WHERE ${where} ${notInternal}`)
+        .prepare(`SELECT COUNT(*) AS count FROM (${sources}) s WHERE ${where} ${notInternal}`)
         .get(...internalArgs).count);
-    const query = `SELECT s.id, s.directory, p.worktree AS project_worktree, s.time_created
-    FROM session s LEFT JOIN project p ON p.id = s.project_id
+    const query = `SELECT s.id, s.directory, p.worktree AS project_worktree, s.time_created, s.source
+    FROM (${sources}) s LEFT JOIN project p ON p.id = s.project_id
     WHERE s.parent_id IS NULL ${notInternal} ${filters.session ? "AND s.id = ?" : ""}
     ${filters.sessionIds ? "AND s.id IN (SELECT value FROM json_each(?))" : ""}
     ORDER BY s.time_created, s.id ${filters.maxSessions ? "LIMIT ?" : ""}`;
@@ -176,19 +223,20 @@ function readSessions(db, filters) {
         args.push(JSON.stringify(filters.sessionIds));
     if (filters.maxSessions)
         args.push(filters.maxSessions);
-    const sessions = db.prepare(query).all(...args).map((row) => ({
-        sessionId: row.id,
-        recordedDirectory: row.directory,
-        projectWorktree: row.project_worktree,
-        timeCreated: Number(row.time_created),
-    }));
+    const rows = db.prepare(query).all(...args);
     return {
         childSessions: count("s.parent_id IS NOT NULL"),
         topLevelSessions: count("s.parent_id IS NULL"),
-        sessions,
+        sessions: rows.map((row) => ({
+            sessionId: row.id,
+            recordedDirectory: row.directory,
+            projectWorktree: row.project_worktree,
+            timeCreated: Number(row.time_created),
+        })),
+        origin: new Map(rows.map((row) => [row.id, row.source === "v2" ? "v2" : "v1"])),
     };
 }
-/** Read V1 OpenCode history without changing its database or WAL sidecars. */
+/** Read OpenCode history without changing its database or WAL sidecars. */
 export async function openOpencodeHistory(dbPath, filters = {}, options = {}) {
     if (!existsSync(dbPath))
         throw new Error("OpenCode database not found");
@@ -211,10 +259,16 @@ export async function openOpencodeHistory(dbPath, filters = {}, options = {}) {
         throw error;
     }
     const opened = source;
+    const { origin, ...summary } = listed;
     let closed = false;
     return {
-        ...listed,
-        loadUnits: (sessionId) => buildWindows(opened.db, sessionId, filters),
+        ...summary,
+        loadUnits: (sessionId) => {
+            const from = origin.get(sessionId);
+            if (from === "v2")
+                return buildV2Windows(opened.db, sessionId, filters);
+            return from === "v1" ? buildWindows(opened.db, sessionId, filters) : [];
+        },
         close: async () => {
             if (closed)
                 return;

package/dist/importer/opencode-v2-units.d.ts

@@ -0,0 +1,16 @@
+import type { DatabaseSync } from "node:sqlite";
+import type { ImportWindow } from "./importer.js";
+/** The part of the reader filters that decides which user messages start a unit. */
+interface V2UnitFilters {
+    since?: number;
+    until?: number;
+}
+/**
+ * A `user` message starts a unit. A `synthetic` or `compaction` message ends
+ * the current unit and starts none, so OMMS context and compaction summaries
+ * never become prompts and later assistant messages do not join the old unit.
+ * `assistant` messages add `text` replies and `tool` calls; every other
+ * message type is ignored.
+ */
+export declare function buildV2Windows(db: DatabaseSync, sessionId: string, filters: V2UnitFilters): ImportWindow[];
+export {};

package/dist/importer/opencode-v2-units.js

@@ -0,0 +1,93 @@
+import { boundToolInput, readToolPath } from "../core/tool-input.js";
+import { opencodeMemorise, opencodeToolOutcome } from "../core/tool-outcome.js";
+function parseRecord(json) {
+    try {
+        const parsed = JSON.parse(json);
+        return parsed && typeof parsed === "object" && !Array.isArray(parsed)
+            ? parsed
+            : {};
+    }
+    catch {
+        return {};
+    }
+}
+function formatInput(value) {
+    return typeof value === "string" ? value : JSON.stringify(value ?? "");
+}
+function toolCall(item) {
+    const state = item.state && typeof item.state === "object" ? item.state : {};
+    const name = String(item.name ?? item.type);
+    const args = state.input ?? "";
+    const path = readToolPath(name, args);
+    return {
+        name,
+        input: boundToolInput(formatInput(args)),
+        ...opencodeToolOutcome(state),
+        ...opencodeMemorise(name, args, state),
+        ...(path === undefined ? {} : { path }),
+    };
+}
+/**
+ * A `user` message starts a unit. A `synthetic` or `compaction` message ends
+ * the current unit and starts none, so OMMS context and compaction summaries
+ * never become prompts and later assistant messages do not join the old unit.
+ * `assistant` messages add `text` replies and `tool` calls; every other
+ * message type is ignored.
+ */
+export function buildV2Windows(db, sessionId, filters) {
+    const messages = db
+        .prepare("SELECT id, type, time_created, data FROM session_message WHERE session_id = ? ORDER BY time_created, id")
+        .all(sessionId);
+    const units = [];
+    let current = null;
+    const finish = () => {
+        if (current?.sourceEntryIds?.length)
+            units.push(current);
+        current = null;
+    };
+    for (const message of messages) {
+        if (message.type === "user") {
+            finish();
+            const text = parseRecord(message.data).text;
+            const prompt = typeof text === "string" ? text.trim() : "";
+            const timestamp = Number(message.time_created);
+            if (prompt &&
+                (filters.since === undefined || timestamp >= filters.since) &&
+                (filters.until === undefined || timestamp <= filters.until)) {
+                current = {
+                    userEntryId: message.id,
+                    userPrompt: prompt,
+                    userTimestamp: timestamp,
+                    sourceTimestamp: timestamp,
+                    textResponses: [],
+                    toolCalls: [],
+                    sourceEntryIds: [],
+                };
+            }
+            continue;
+        }
+        if (message.type === "synthetic" || message.type === "compaction") {
+            finish();
+            continue;
+        }
+        if (message.type !== "assistant" || !current)
+            continue;
+        current.sourceEntryIds.push(message.id);
+        const content = parseRecord(message.data).content;
+        if (!Array.isArray(content))
+            continue;
+        for (const item of content) {
+            if (!item || typeof item !== "object")
+                continue;
+            const entry = item;
+            if (entry.type === "text" && typeof entry.text === "string") {
+                current.textResponses.push(entry.text);
+            }
+            else if (entry.type === "tool") {
+                current.toolCalls.push(toolCall(entry));
+            }
+        }
+    }
+    finish();
+    return units;
+}

package/dist/importer/settings-models.d.ts

@@ -1,4 +1,3 @@
-import type { OpencodeClient } from "@opencode-ai/sdk/v2/client";
 import type { SettingsModel } from "./backfill-controls.js";
 import type { StandaloneResult } from "./opencode-standalone-models.js";
 export declare const OPENCODE_LIST_UNAVAILABLE = "OpenCode model list unavailable";
@@ -18,16 +17,22 @@ type ProviderList = {
         }>;
     }>;
 };
-/** The models of each connected provider in an OpenCode v1 provider list. */
+/** The models of each connected provider in an OpenCode server provider list. */
 export declare function connectedProviderModels(list: ProviderList): SettingsModel[];
-/** Connected models from an OpenCode client; null when the client returns no list. */
-export declare function listOpencodeClientModels(client: Pick<OpencodeClient, "provider">): Promise<SettingsModel[] | null>;
+/** One model a running host lists, with its provider and display name. */
+export type ListedModel = {
+    readonly providerID: string;
+    readonly id: string;
+    readonly name: string;
+};
+/** Settings rows for the models a running OpenCode plugin lists, grouped by provider. */
+export declare function listOpencodeClientModels(listModels: () => Promise<readonly ListedModel[]>): Promise<SettingsModel[]>;
 /**
- * The OpenCode models for the Settings page. Without a client or a registered
+ * The OpenCode models for the Settings page. Without `listModels` or a registered
  * OpenCode host, this starts a private OpenCode server through `readStandalone`.
  * Pass `null` to skip that, for callers that need a live session.
  */
-export declare function listOpencodeSettingsModels(client?: Pick<OpencodeClient, "provider">, readStandalone?: (() => Promise<StandaloneResult>) | null): Promise<{
+export declare function listOpencodeSettingsModels(listModels?: () => Promise<readonly ListedModel[]>, readStandalone?: (() => Promise<StandaloneResult>) | null): Promise<{
     available: boolean;
     models?: SettingsModel[];
     reason?: string;

package/dist/importer/settings-models.js

@@ -22,7 +22,7 @@ const STANDALONE_REASONS = {
     empty: OPENCODE_NO_MODELS,
     unreadable: OPENCODE_UNREADABLE,
 };
-/** The models of each connected provider in an OpenCode v1 provider list. */
+/** The models of each connected provider in an OpenCode server provider list. */
 export function connectedProviderModels(list) {
     const connected = new Set(list.connected);
     return list.all
@@ -33,28 +33,32 @@ export function connectedProviderModels(list) {
         name: info.name,
     })));
 }
-/** Connected models from an OpenCode client; null when the client returns no list. */
-export async function listOpencodeClientModels(client) {
-    const result = await client.provider.list();
-    if (!result.data)
-        return null;
-    return connectedProviderModels(result.data);
+/** Settings rows for the models a running OpenCode plugin lists, grouped by provider. */
+export async function listOpencodeClientModels(listModels) {
+    // Providers keep the order they first appear in; models keep their order inside each.
+    const byProvider = new Map();
+    for (const model of await listModels()) {
+        const rows = byProvider.get(model.providerID) ?? [];
+        rows.push({ provider: model.providerID, model: model.id, name: model.name });
+        byProvider.set(model.providerID, rows);
+    }
+    return [...byProvider.values()].flat();
 }
 async function readStandaloneModels() {
     const { readStandaloneOpencodeModels } = await import("./opencode-standalone-models.js");
     return readStandaloneOpencodeModels();
 }
 /**
- * The OpenCode models for the Settings page. Without a client or a registered
+ * The OpenCode models for the Settings page. Without `listModels` or a registered
  * OpenCode host, this starts a private OpenCode server through `readStandalone`.
  * Pass `null` to skip that, for callers that need a live session.
  */
-export async function listOpencodeSettingsModels(client, readStandalone = readStandaloneModels) {
+export async function listOpencodeSettingsModels(listModels, readStandalone = readStandaloneModels) {
     const unavailable = (reason) => ({ available: false, reason });
     try {
         let models;
-        if (client) {
-            models = await listOpencodeClientModels(client);
+        if (listModels) {
+            models = await listOpencodeClientModels(listModels);
         }
         else {
             const { getOpencodeHostModels } = await import("./backfill-controls.js");

package/dist/plugin.d.ts

@@ -1,9 +1,6 @@
-declare const OmmsPlugin: import("@opencode-ai/plugin").Plugin;
 export declare const id = "omms";
-export { OmmsPlugin };
 declare const _default: {
     id: string;
-    server: import("@opencode-ai/plugin").Plugin;
     setup: (context: import("@opencode/plugin/promise/plugin").Context) => Promise<import("@opencode/plugin/promise/plugin").Cleanup | void> | import("@opencode/plugin/promise/plugin").Cleanup | void;
 };
 export default _default;

package/dist/plugin.js

@@ -1,11 +1,5 @@
-const { OmmsPlugin } = await import("./index.js");
 const { default: OmmsPluginV2 } = await import("./v2/plugin.js");
 // Stable plugin id: OpenCode scopes plugin storage and enable/disable rules by it,
 // so it stays "omms" independent of the npm package name.
 export const id = "omms";
-export { OmmsPlugin };
-export default {
-    ...OmmsPluginV2,
-    id,
-    server: OmmsPlugin,
-};
+export default { ...OmmsPluginV2, id };

package/dist/services/global-config-writer.js

@@ -35,7 +35,6 @@ const keys = new Set([
     "claudeConfigDir",
     "autoCaptureLanguage",
     "maxMemories",
-    "chatMessage.maxMemories",
     "autoCaptureMaxContextBytes",
     "userProfileMaxContextBytes",
     "retrievalMaxTokens",
@@ -285,8 +284,8 @@ options = {}) {
         }
         checkMemorisationSettingsEdits(edits, memorisationSettingsFrom(current));
         for (const [key, value] of Object.entries(edits)) {
-            // A nested identifier maps to its JSONC leaf path, so chatMessage.maxMemories
-            // and compaction.enabled write the leaf, never a literal dotted key.
+            // A nested identifier maps to its JSONC leaf path, so compaction.enabled
+            // writes the leaf, never a literal dotted key.
             const jsoncPath = (getMemoryLimitRule(key)?.path ?? key.split("."));
             // null is the wire form of "reset to default": remove the key so the
             // value follows the default again (undefined removes in jsonc modify).

package/dist/services/settings-snapshot.js

@@ -96,10 +96,10 @@ function projectFile(directory) {
         .find((path) => existsSync(path));
 }
 /**
- * Snapshot entry for a nested setting (chatMessage.maxMemories, compaction.*).
- * The runtime merge is shallow, so a project chatMessage object replaces the
- * global one: a missing count means the default even when the global file sets
- * a value, and the source must not be inferred from dotted-key presence alone.
+ * Snapshot entry for a nested setting (compaction.enabled).
+ * The runtime merge is shallow, so a project object replaces the global one:
+ * a missing leaf means the default even when the global file sets a value, and
+ * the source must not be inferred from dotted-key presence alone.
  */
 function nestedSetting(path, defaultValue, global, project) {
     const parent = path[0];
@@ -127,8 +127,8 @@ function nestedSetting(path, defaultValue, global, project) {
 export function getSettingsSnapshot(directory) {
     const global = readSettingsFile(getGlobalConfigSourcePath());
     const project = readSettingsFile(projectFile(directory));
-    // Dotted limit identifiers (chatMessage.maxMemories) are resolved by the
-    // nested rule above, so the runtime lookup only handles flat keys.
+    // Dotted identifiers (compaction.enabled) are resolved by the nested rule
+    // above, so the runtime lookup only handles flat keys.
     const runtime = CONFIG;
     const injection = injectionOptionsFromFile(global);
     const injectionDefaults = injectionOptionsFromFile({});

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

@@ -80,8 +80,10 @@ export class TursoVectorSearch {
             const exactMatchBoost = tagMatchBoost(queryText, memoryTagsStr);
             const finalTagsSim = Math.max(tagsSim, exactMatchBoost);
             // Every memorisation carries the same tag, so the tags half is near constant and
-            // pulls a close match down. Score memorisations by content alone.
-            const base = kind === "memorisation" ? contentSim : contentSim * 0.6 + finalTagsSim * 0.4;
+            // pulls a close match down. An untagged memory has no tags half at all, and the
+            // blend would cap it at 0.6 of its content match. Score both by content alone.
+            const untagged = row.tags_dist == null && !memoryTagsStr.trim();
+            const base = kind === "memorisation" || untagged ? contentSim : contentSim * 0.6 + finalTagsSim * 0.4;
             const similarity = boostedSimilarity(base, kwHits, String(row.id), keywordBoost, keywordMode);
             return {
                 id: String(row.id),

package/dist/shared/api/schemas.d.ts

@@ -265,8 +265,8 @@ export declare const UpdateProfileItemRequestSchema: z.ZodObject<{
     }>;
     index: z.ZodNumber;
     action: z.ZodEnum<{
-        delete: "delete";
         edit: "edit";
+        delete: "delete";
     }>;
     category: z.ZodOptional<z.ZodString>;
     description: z.ZodOptional<z.ZodString>;

package/dist/utils/memory-limits.d.ts

@@ -16,7 +16,6 @@ export interface MemoryLimitRule {
 }
 export declare const MEMORY_LIMITS: {
     readonly maxMemories: MemoryLimitRule;
-    readonly "chatMessage.maxMemories": MemoryLimitRule;
     readonly autoCaptureMaxContextBytes: MemoryLimitRule;
     readonly userProfileMaxContextBytes: MemoryLimitRule;
     readonly retrievalMaxTokens: MemoryLimitRule;

package/dist/utils/memory-limits.js

@@ -23,7 +23,6 @@ function rule(setting, path, defaultValue, unit, accepted, isValid, defaultFor)
 }
 export const MEMORY_LIMITS = {
     maxMemories: rule("maxMemories", ["maxMemories"], 10, "results", "positive safe integers", isPositiveSafeInteger),
-    "chatMessage.maxMemories": rule("chatMessage.maxMemories", ["chatMessage", "maxMemories"], 3, "memories", "positive safe integers", isPositiveSafeInteger),
     autoCaptureMaxContextBytes: rule("autoCaptureMaxContextBytes", ["autoCaptureMaxContextBytes"], 131072, "UTF-8 bytes", "integers from 16384 to 16777216", integerInRange(16384, 16777216)),
     userProfileMaxContextBytes: rule("userProfileMaxContextBytes", ["userProfileMaxContextBytes"], 32768, "UTF-8 bytes", "integers from 1024 to 16777216", integerInRange(1024, 16777216)),
     retrievalMaxTokens: rule("retrievalMaxTokens", ["retrievalMaxTokens"], 2000, "approximate tokens", "integers from 256 to 65536", integerInRange(256, 65536)),