om-memory-system 5.9.1 → 5.10.1

package/dist/services/memory-replace.js

@@ -0,0 +1,26 @@
+import { tursoConnectionManager } from "./turso/connection-manager.js";
+import { tursoShardManager } from "./turso/shard-manager.js";
+import { tursoVectorSearch } from "./turso/vector-search.js";
+/**
+ * Swaps the stored row that has `record.id` for `record`, in the shard that
+ * holds it, in one transaction: a failed insert rolls the delete back, so the
+ * old row survives. Returns false when no row has that ID. The caller embeds
+ * first, so an embedding failure never reaches this point.
+ */
+export async function replaceMemoryRow(record) {
+    const shards = [
+        ...(await tursoShardManager.getAllShards("user", "")),
+        ...(await tursoShardManager.getAllShards("project", "")),
+    ];
+    for (const shard of shards) {
+        const db = await tursoConnectionManager.getConnection(shard.dbPath);
+        if (!(await tursoVectorSearch.getMemoryById(db, record.id)))
+            continue;
+        await db.transaction("write", async (tx) => {
+            await tx.execute({ sql: `DELETE FROM memories WHERE id = ?`, args: [record.id] });
+            await tursoVectorSearch.insertVectorInTransaction(tx, record);
+        });
+        return true;
+    }
+    return false;
+}

package/dist/services/retrieval-rerank.d.ts

@@ -10,8 +10,9 @@
  */
 import type { SearchResult, ShardInfo } from "./turso/types.js";
 import { type RerankerSettings } from "./reranker.js";
+import type { MemoryKind } from "./memory-kind.js";
 /** The shape of tursoVectorSearch.searchAcrossShards, injectable for tests. */
-export type SearchAcrossShards = (shards: ShardInfo[], queryVector: Float32Array, containerTag: string, limit: number, similarityThreshold: number, queryText?: string) => Promise<{
+export type SearchAcrossShards = (shards: ShardInfo[], queryVector: Float32Array, containerTag: string, limit: number, similarityThreshold: number, queryText?: string, kind?: MemoryKind) => Promise<{
     results: SearchResult[];
     warnings: string[];
 }>;
@@ -22,6 +23,7 @@ export interface RerankedSearchOptions {
     queryText: string;
     maxMemories: number;
     similarityThreshold: number;
+    kind?: MemoryKind;
 }
 export interface RerankedSearchDeps {
     search: SearchAcrossShards;

package/dist/services/retrieval-rerank.js

@@ -9,7 +9,7 @@ import { rerankDocuments } from "./reranker.js";
  */
 export async function rerankedSearch(options, settings, deps) {
     const { search } = deps;
-    const { results: candidates, warnings } = await search(options.shards, options.queryVector, options.containerTag, Math.max(options.maxMemories, RERANKER_POOL_SIZE), 0, options.queryText);
+    const { results: candidates, warnings } = await search(options.shards, options.queryVector, options.containerTag, Math.max(options.maxMemories, RERANKER_POOL_SIZE), 0, options.queryText, options.kind ?? "normal");
     // Nothing to reorder: skip the server round trip for an empty search.
     if (candidates.length === 0)
         return { results: [], warnings, reranked: false };

package/dist/services/settings-snapshot.js

@@ -42,6 +42,9 @@ const editable = [
     "openingContextQuery",
     "subagentMemory",
     "compaction.enabled",
+    "memorisationRepeat",
+    "memorisationMaxSize",
+    "memorisationSizeUnit",
     ...MEMORY_LIMIT_SETTINGS,
 ];
 /**
@@ -73,6 +76,9 @@ const globalOnly = [
     "rerankerTimeoutMs",
     "skillLearningRedact",
     "skillFolders",
+    "memorisationRepeat",
+    "memorisationMaxSize",
+    "memorisationSizeUnit",
 ];
 function readSettingsFile(path) {
     if (!path)

package/dist/services/turso/exact-scan.d.ts

@@ -1,6 +1,7 @@
 import type { TursoDb } from "./turso-db.js";
+import { type MemoryKind } from "../memory-kind.js";
 /** Exact (non-indexed) nearest-neighbour scan, used when `vector_top_k` fails. */
-export declare function exactScanKind(db: TursoDb, queryJson: string, k: number, containerTag: string, columnName: string): Promise<Array<{
+export declare function exactScanKind(db: TursoDb, queryJson: string, k: number, containerTag: string, columnName: string, kind?: MemoryKind): Promise<Array<{
     id: string;
     similarity: number;
 }>>;

package/dist/services/turso/exact-scan.js

@@ -1,18 +1,19 @@
 import { distanceToSimilarity } from "./vector-utils.js";
+import { memoryKindPredicate } from "../memory-kind.js";
 /** Exact (non-indexed) nearest-neighbour scan, used when `vector_top_k` fails. */
-export async function exactScanKind(db, queryJson, k, containerTag, columnName) {
+export async function exactScanKind(db, queryJson, k, containerTag, columnName, kind = "normal") {
     const rows = await db.all(containerTag === ""
         ? `
       SELECT m.id AS id, vector_distance_cos(m.${columnName}, vector32(?)) AS dist
       FROM memories m
-      WHERE m.${columnName} IS NOT NULL
+      WHERE m.${columnName} IS NOT NULL AND ${memoryKindPredicate("m.type", kind)}
       ORDER BY dist ASC
       LIMIT ?
     `
         : `
       SELECT m.id AS id, vector_distance_cos(m.${columnName}, vector32(?)) AS dist
       FROM memories m
-      WHERE m.${columnName} IS NOT NULL AND m.container_tag = ?
+      WHERE m.${columnName} IS NOT NULL AND m.container_tag = ? AND ${memoryKindPredicate("m.type", kind)}
       ORDER BY dist ASC
       LIMIT ?
     `, containerTag === "" ? [queryJson, k] : [queryJson, containerTag, k]);

package/dist/services/turso/keyword-search.d.ts

@@ -1,5 +1,6 @@
 import type { KeywordMode } from "../../utils/keyword-boost.js";
 import type { TursoDb } from "./turso-db.js";
+import { type MemoryKind } from "../memory-kind.js";
 /**
  * FTS5 query for the words of a prompt: lower-case terms from letters and
  * digits only ("ADR-023" gives `adr` and `023`), each in quotes, joined by OR.
@@ -27,7 +28,7 @@ export interface KeywordHits {
  * continues with vector and tag results. The log holds a code and an error
  * name only, never the prompt or memory text.
  */
-export declare function searchKeywords(db: TursoDb, queryText: string | undefined, containerTag: string, limit: number): Promise<KeywordHits | null>;
+export declare function searchKeywords(db: TursoDb, queryText: string | undefined, containerTag: string, limit: number, kind?: MemoryKind): Promise<KeywordHits | null>;
 /**
  * `base` with the boost for memory `id`; `base` itself when it has no keyword hit
  * or the mode is `rrf` (rank fusion keeps each memory's own similarity).

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

@@ -4,6 +4,7 @@
  * arguments: do not import CONFIG here, many tests stub src/config.js.
  */
 import { log } from "../logger.js";
+import { memoryKindPredicate } from "../memory-kind.js";
 const MAX_TERMS = 24;
 // Words that carry no search value. With the OR query below, one of them
 // would pull most of a shard in as candidates.
@@ -121,7 +122,7 @@ export async function ensureKeywordIndex(db) {
  * continues with vector and tag results. The log holds a code and an error
  * name only, never the prompt or memory text.
  */
-export async function searchKeywords(db, queryText, containerTag, limit) {
+export async function searchKeywords(db, queryText, containerTag, limit, kind = "normal") {
     const match = buildKeywordQuery(queryText);
     if (!match)
         return null;
@@ -129,7 +130,7 @@ export async function searchKeywords(db, queryText, containerTag, limit) {
         await ensureKeywordIndex(db);
         const rows = await db.all(`SELECT m.id AS id, -bm25(memories_fts) AS score
        FROM memories_fts JOIN memories m ON m.rowid = memories_fts.rowid
-       WHERE memories_fts MATCH ?${containerTag === "" ? "" : " AND m.container_tag = ?"}
+       WHERE memories_fts MATCH ? AND ${memoryKindPredicate("m.type", kind)}${containerTag === "" ? "" : " AND m.container_tag = ?"}
        ORDER BY score DESC LIMIT ?`, containerTag === "" ? [match, limit] : [match, containerTag, limit]);
         const scores = new Map(rows.map((row) => [String(row.id), Number(row.score)]));
         return { scores, best: Math.max(0, ...scores.values()) };

package/dist/services/turso/vector-search.d.ts

@@ -1,29 +1,30 @@
-import type { MemoryRecord, SearchResult, ShardInfo } from "./types.js";
+import type { SearchResult, ShardInfo } from "./types.js";
 import type { KeywordMode } from "../../utils/keyword-boost.js";
 import type { TursoDb } from "./turso-db.js";
-import type { Transaction } from "@libsql/client";
+import { type MemoryKind } from "../memory-kind.js";
 export declare class TursoVectorSearch {
-    insertVectorInTransaction(tx: Transaction, record: MemoryRecord): Promise<void>;
-    insertVector(db: TursoDb, record: MemoryRecord): Promise<void>;
+    insertVectorInTransaction: (tx: import("@libsql/client").Transaction, record: import("./types.js").MemoryRecord) => Promise<void>;
+    insertVector: (db: TursoDb, record: import("./types.js").MemoryRecord) => Promise<void>;
     searchInShard(shard: ShardInfo, queryVector: Float32Array, containerTag: string, limit: number, queryText?: string, keywordBoost?: number, keywordMode?: KeywordMode, 
     /** Opens the shard database; linked-space searches pass a read-only opener. */
-    openDb?: (dbPath: string) => Promise<TursoDb>): Promise<SearchResult[]>;
+    openDb?: (dbPath: string) => Promise<TursoDb>, kind?: MemoryKind): Promise<SearchResult[]>;
     private searchKind;
     searchAcrossShards(shards: ShardInfo[], queryVector: Float32Array, containerTag: string, limit: number, similarityThreshold: number, queryText?: string, keywordBoost?: number, keywordMode?: KeywordMode, 
     /** Opens each shard database; linked-space searches pass a read-only opener. */
-    openDb?: (dbPath: string) => Promise<TursoDb>): Promise<{
+    openDb?: (dbPath: string) => Promise<TursoDb>, kind?: MemoryKind): Promise<{
         results: SearchResult[];
         warnings: string[];
     }>;
     deleteVector(db: TursoDb, memoryId: string): Promise<void>;
     updateVector(db: TursoDb, memoryId: string, vector: Float32Array, tagsVector?: Float32Array, tags?: string): Promise<void>;
-    listMemories(db: TursoDb, containerTag: string, limit: number): Promise<Record<string, unknown>[]>;
-    getAllMemories(db: TursoDb): Promise<Record<string, unknown>[]>;
+    listMemories(db: TursoDb, containerTag: string, limit: number, kind?: MemoryKind): Promise<Record<string, unknown>[]>;
+    /** Every row of one kind. Pass "all" only for kind-neutral readers such as export. */
+    getAllMemories(db: TursoDb, kind?: MemoryKind | "all"): Promise<Record<string, unknown>[]>;
     getAllMemoriesWithExtractedVectors(db: TursoDb): Promise<Array<Record<string, unknown> & {
         vector_json: string | null;
     }>>;
     getMemoryById(db: TursoDb, memoryId: string): Promise<Record<string, unknown> | null>;
-    getMemoriesBySessionID(db: TursoDb, sessionID: string): Promise<Record<string, unknown>[]>;
+    getMemoriesBySessionID(db: TursoDb, sessionID: string, kind?: MemoryKind): Promise<Record<string, unknown>[]>;
     countVectors(db: TursoDb, containerTag: string): Promise<number>;
     countAllVectors(db: TursoDb): Promise<number>;
     getDistinctTags(db: TursoDb): Promise<Record<string, unknown>[]>;

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

@@ -5,6 +5,8 @@ import { tagMatchBoost } from "./tag-match.js";
 import { exactScanKind } from "./exact-scan.js";
 import { boostedSimilarity, searchKeywords } from "./keyword-search.js";
 import { fuseShardResults } from "./rank-fusion.js";
+import { tursoVectorWrites } from "./vector-writes.js";
+import { memoryKindPredicate } from "../memory-kind.js";
 function parseMetadata(value) {
     if (!value || typeof value !== "string")
         return undefined;
@@ -16,99 +18,25 @@ function parseMetadata(value) {
     }
 }
 export class TursoVectorSearch {
-    async insertVectorInTransaction(tx, record) {
-        const contentVector = vectorToJson(record.vector);
-        const commonArgs = [
-            record.containerTag,
-            record.tags || null,
-            record.type || null,
-            record.createdAt,
-            record.updatedAt,
-            record.metadata || null,
-            record.displayName || null,
-            record.userName || null,
-            record.userEmail || null,
-            record.projectPath || null,
-            record.projectName || null,
-            record.gitRepoUrl || null,
-        ];
-        if (record.tagsVector) {
-            await tx.execute({
-                sql: `
-        INSERT INTO memories (
-          id, content, vector, tags_vector, container_tag, tags, type, created_at, updated_at,
-          metadata, display_name, user_name, user_email, project_path, project_name, git_repo_url
-        ) VALUES (?, ?, vector32(?), vector32(?), ?, ?, ?, ?, ?, ?, ?, ?, ?, ?, ?, ?)
-      `,
-                args: [
-                    record.id,
-                    record.content,
-                    contentVector,
-                    vectorToJson(record.tagsVector),
-                    ...commonArgs,
-                ],
-            });
-            return;
-        }
-        await tx.execute({
-            sql: `
-      INSERT INTO memories (
-        id, content, vector, tags_vector, container_tag, tags, type, created_at, updated_at,
-        metadata, display_name, user_name, user_email, project_path, project_name, git_repo_url
-      ) VALUES (?, ?, vector32(?), NULL, ?, ?, ?, ?, ?, ?, ?, ?, ?, ?, ?, ?)
-    `,
-            args: [record.id, record.content, contentVector, ...commonArgs],
-        });
-    }
-    async insertVector(db, record) {
-        const contentVector = vectorToJson(record.vector);
-        const commonArgs = [
-            record.containerTag,
-            record.tags || null,
-            record.type || null,
-            record.createdAt,
-            record.updatedAt,
-            record.metadata || null,
-            record.displayName || null,
-            record.userName || null,
-            record.userEmail || null,
-            record.projectPath || null,
-            record.projectName || null,
-            record.gitRepoUrl || null,
-        ];
-        if (record.tagsVector) {
-            await db.execute(`
-        INSERT INTO memories (
-          id, content, vector, tags_vector, container_tag, tags, type, created_at, updated_at,
-          metadata, display_name, user_name, user_email, project_path, project_name, git_repo_url
-        ) VALUES (?, ?, vector32(?), vector32(?), ?, ?, ?, ?, ?, ?, ?, ?, ?, ?, ?, ?)
-      `, [record.id, record.content, contentVector, vectorToJson(record.tagsVector), ...commonArgs]);
-            return;
-        }
-        await db.execute(`
-      INSERT INTO memories (
-        id, content, vector, tags_vector, container_tag, tags, type, created_at, updated_at,
-        metadata, display_name, user_name, user_email, project_path, project_name, git_repo_url
-      ) VALUES (?, ?, vector32(?), NULL, ?, ?, ?, ?, ?, ?, ?, ?, ?, ?, ?, ?)
-    `, [record.id, record.content, contentVector, ...commonArgs]);
-    }
+    insertVectorInTransaction = tursoVectorWrites.insertVectorInTransaction.bind(tursoVectorWrites);
+    insertVector = tursoVectorWrites.insertVector.bind(tursoVectorWrites);
     async searchInShard(shard, queryVector, containerTag, limit, queryText, keywordBoost = 0, keywordMode = "boost", 
     /** Opens the shard database; linked-space searches pass a read-only opener. */
-    openDb = (dbPath) => tursoConnectionManager.getConnection(dbPath)) {
+    openDb = (dbPath) => tursoConnectionManager.getConnection(dbPath), kind = "normal") {
         const db = await openDb(shard.dbPath);
         const queryJson = vectorToJson(queryVector);
         // Over-fetch aggressively when filtering by container_tag after ANN,
         // because post-filtering can discard many DiskANN neighbors.
         const k = containerTag === "" ? Math.max(limit * 4, 32) : Math.max(limit * 16, 128);
-        const contentResults = await this.searchKind(db, queryJson, k, containerTag, "memories_vec_idx", "vector");
-        const tagsResults = await this.searchKind(db, queryJson, k, containerTag, "memories_tags_vec_idx", "tags_vector");
+        const contentResults = await this.searchKind(db, queryJson, k, containerTag, "memories_vec_idx", "vector", kind, limit);
+        const tagsResults = await this.searchKind(db, queryJson, k, containerTag, "memories_tags_vec_idx", "tags_vector", kind, limit);
         const candidateIds = new Set();
         for (const result of contentResults)
             candidateIds.add(result.id);
         for (const result of tagsResults)
             candidateIds.add(result.id);
         const kwHits = keywordBoost > 0
-            ? await searchKeywords(db, queryText, containerTag, Math.max(limit * 4, 32))
+            ? await searchKeywords(db, queryText, containerTag, Math.max(limit * 4, 32), kind)
             : null;
         for (const id of kwHits?.scores.keys() ?? [])
             candidateIds.add(id);
@@ -128,7 +56,7 @@ export class TursoVectorSearch {
                THEN vector_distance_cos(tags_vector, vector32(?))
                ELSE NULL END AS tags_dist
       FROM memories
-      WHERE id IN (${placeholders})
+      WHERE id IN (${placeholders}) AND ${memoryKindPredicate("type", kind)}
     `
             : `
       SELECT id, content, tags, type, created_at, metadata, container_tag,
@@ -139,7 +67,7 @@ export class TursoVectorSearch {
                THEN vector_distance_cos(tags_vector, vector32(?))
                ELSE NULL END AS tags_dist
       FROM memories
-      WHERE id IN (${placeholders}) AND container_tag = ?
+      WHERE id IN (${placeholders}) AND container_tag = ? AND ${memoryKindPredicate("type", kind)}
     `, containerTag === ""
             ? [queryJson, queryJson, ...ids]
             : [queryJson, queryJson, ...ids, containerTag]);
@@ -151,7 +79,9 @@ export class TursoVectorSearch {
             const memoryTagsStr = String(row.tags || "");
             const exactMatchBoost = tagMatchBoost(queryText, memoryTagsStr);
             const finalTagsSim = Math.max(tagsSim, exactMatchBoost);
-            const base = contentSim * 0.6 + finalTagsSim * 0.4;
+            // 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;
             const similarity = boostedSimilarity(base, kwHits, String(row.id), keywordBoost, keywordMode);
             return {
                 id: String(row.id),
@@ -177,21 +107,32 @@ export class TursoVectorSearch {
         const fusing = keywordMode === "rrf" && keywordBoost > 0;
         return fusing ? hydratedResults : hydratedResults.slice(0, Math.max(0, limit));
     }
-    async searchKind(db, queryJson, k, containerTag, indexName, columnName) {
+    async searchKind(db, queryJson, k, containerTag, indexName, columnName, kind = "normal", wanted = 0) {
+        // The ANN index covers every row, and the kind filter runs after it. Normal rows
+        // can fill all k candidates and hide the few memorisations. Memorisations are few,
+        // so scan them exactly; the exact scan filters by kind in SQL.
+        if (kind === "memorisation") {
+            return exactScanKind(db, queryJson, k, containerTag, columnName, kind);
+        }
         try {
             const rows = await db.all(containerTag === ""
                 ? `
           SELECT m.id AS id, vector_distance_cos(m.${columnName}, vector32(?)) AS dist
           FROM vector_top_k('${indexName}', vector32(?), ?) AS v
           CROSS JOIN memories m ON m.rowid = v.id
-          WHERE m.${columnName} IS NOT NULL
+          WHERE m.${columnName} IS NOT NULL AND ${memoryKindPredicate("m.type", kind)}
         `
                 : `
           SELECT m.id AS id, vector_distance_cos(m.${columnName}, vector32(?)) AS dist
           FROM vector_top_k('${indexName}', vector32(?), ?) AS v
           CROSS JOIN memories m ON m.rowid = v.id
-          WHERE m.${columnName} IS NOT NULL AND m.container_tag = ?
+          WHERE m.${columnName} IS NOT NULL AND m.container_tag = ? AND ${memoryKindPredicate("m.type", kind)}
         `, containerTag === "" ? [queryJson, queryJson, k] : [queryJson, queryJson, k, containerTag]);
+            // Memorisations or other projects can fill the k candidates and the filters then
+            // drop them all. A short result is rare, so only then pay for the exact scan.
+            if (rows.length < wanted) {
+                return exactScanKind(db, queryJson, k, containerTag, columnName, kind);
+            }
             return rows.map((row) => ({
                 id: String(row.id),
                 similarity: distanceToSimilarity(Number(row.dist)),
@@ -202,16 +143,16 @@ export class TursoVectorSearch {
                 indexName,
                 error: String(error),
             }, "warn");
-            return exactScanKind(db, queryJson, k, containerTag, columnName);
+            return exactScanKind(db, queryJson, k, containerTag, columnName, kind);
         }
     }
     async searchAcrossShards(shards, queryVector, containerTag, limit, similarityThreshold, queryText, keywordBoost = 0, keywordMode = "boost", 
     /** Opens each shard database; linked-space searches pass a read-only opener. */
-    openDb) {
+    openDb, kind = "normal") {
         const shardErrors = [];
         const shardPromises = shards.map(async (shard) => {
             try {
-                return await this.searchInShard(shard, queryVector, containerTag, limit, queryText, keywordBoost, keywordMode, openDb);
+                return await this.searchInShard(shard, queryVector, containerTag, limit, queryText, keywordBoost, keywordMode, openDb, kind);
             }
             catch (error) {
                 const message = error instanceof Error ? error.message : String(error);
@@ -264,22 +205,24 @@ export class TursoVectorSearch {
             await db.execute(`UPDATE memories SET vector = vector32(?), tags_vector = NULL WHERE id = ?`, [contentVector, memoryId]);
         }
     }
-    async listMemories(db, containerTag, limit) {
+    async listMemories(db, containerTag, limit, kind = "normal") {
         return containerTag === ""
             ? db.all(`
       SELECT * FROM memories
+      WHERE ${memoryKindPredicate("type", kind)}
       ORDER BY created_at DESC
       LIMIT ?
     `, [limit])
             : db.all(`
       SELECT * FROM memories
-      WHERE container_tag = ?
+      WHERE container_tag = ? AND ${memoryKindPredicate("type", kind)}
       ORDER BY created_at DESC
       LIMIT ?
     `, [containerTag, limit]);
     }
-    async getAllMemories(db) {
-        return db.all(`SELECT * FROM memories ORDER BY created_at DESC`);
+    /** Every row of one kind. Pass "all" only for kind-neutral readers such as export. */
+    async getAllMemories(db, kind = "normal") {
+        return db.all(`SELECT * FROM memories WHERE ${kind === "all" ? "1 = 1" : memoryKindPredicate("type", kind)} ORDER BY created_at DESC`);
     }
     async getAllMemoriesWithExtractedVectors(db) {
         return db.all(`
@@ -296,10 +239,10 @@ export class TursoVectorSearch {
     async getMemoryById(db, memoryId) {
         return db.get(`SELECT * FROM memories WHERE id = ?`, [memoryId]);
     }
-    async getMemoriesBySessionID(db, sessionID) {
+    async getMemoriesBySessionID(db, sessionID, kind = "normal") {
         const rows = await db.all(`
       SELECT * FROM memories
-      WHERE metadata LIKE ?
+      WHERE metadata LIKE ? AND ${memoryKindPredicate("type", kind)}
       ORDER BY created_at DESC
     `, [`%"sessionID":"${sessionID}"%`]);
         return rows.map((row) => ({

package/dist/services/turso/vector-writes.d.ts

@@ -0,0 +1,8 @@
+import type { MemoryRecord } from "./types.js";
+import type { TursoDb } from "./turso-db.js";
+import type { Transaction } from "@libsql/client";
+export declare class TursoVectorWrites {
+    insertVectorInTransaction(tx: Transaction, record: MemoryRecord): Promise<void>;
+    insertVector(db: TursoDb, record: MemoryRecord): Promise<void>;
+}
+export declare const tursoVectorWrites: TursoVectorWrites;

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

@@ -0,0 +1,80 @@
+import { vectorToJson } from "./vector-utils.js";
+export class TursoVectorWrites {
+    async insertVectorInTransaction(tx, record) {
+        const contentVector = vectorToJson(record.vector);
+        const commonArgs = [
+            record.containerTag,
+            record.tags || null,
+            record.type || null,
+            record.createdAt,
+            record.updatedAt,
+            record.metadata || null,
+            record.displayName || null,
+            record.userName || null,
+            record.userEmail || null,
+            record.projectPath || null,
+            record.projectName || null,
+            record.gitRepoUrl || null,
+        ];
+        if (record.tagsVector) {
+            await tx.execute({
+                sql: `
+        INSERT INTO memories (
+          id, content, vector, tags_vector, container_tag, tags, type, created_at, updated_at,
+          metadata, display_name, user_name, user_email, project_path, project_name, git_repo_url
+        ) VALUES (?, ?, vector32(?), vector32(?), ?, ?, ?, ?, ?, ?, ?, ?, ?, ?, ?, ?)
+      `,
+                args: [
+                    record.id,
+                    record.content,
+                    contentVector,
+                    vectorToJson(record.tagsVector),
+                    ...commonArgs,
+                ],
+            });
+            return;
+        }
+        await tx.execute({
+            sql: `
+      INSERT INTO memories (
+        id, content, vector, tags_vector, container_tag, tags, type, created_at, updated_at,
+        metadata, display_name, user_name, user_email, project_path, project_name, git_repo_url
+      ) VALUES (?, ?, vector32(?), NULL, ?, ?, ?, ?, ?, ?, ?, ?, ?, ?, ?, ?)
+    `,
+            args: [record.id, record.content, contentVector, ...commonArgs],
+        });
+    }
+    async insertVector(db, record) {
+        const contentVector = vectorToJson(record.vector);
+        const commonArgs = [
+            record.containerTag,
+            record.tags || null,
+            record.type || null,
+            record.createdAt,
+            record.updatedAt,
+            record.metadata || null,
+            record.displayName || null,
+            record.userName || null,
+            record.userEmail || null,
+            record.projectPath || null,
+            record.projectName || null,
+            record.gitRepoUrl || null,
+        ];
+        if (record.tagsVector) {
+            await db.execute(`
+        INSERT INTO memories (
+          id, content, vector, tags_vector, container_tag, tags, type, created_at, updated_at,
+          metadata, display_name, user_name, user_email, project_path, project_name, git_repo_url
+        ) VALUES (?, ?, vector32(?), vector32(?), ?, ?, ?, ?, ?, ?, ?, ?, ?, ?, ?, ?)
+      `, [record.id, record.content, contentVector, vectorToJson(record.tagsVector), ...commonArgs]);
+            return;
+        }
+        await db.execute(`
+      INSERT INTO memories (
+        id, content, vector, tags_vector, container_tag, tags, type, created_at, updated_at,
+        metadata, display_name, user_name, user_email, project_path, project_name, git_repo_url
+      ) VALUES (?, ?, vector32(?), NULL, ?, ?, ?, ?, ?, ?, ?, ?, ?, ?, ?, ?)
+    `, [record.id, record.content, contentVector, ...commonArgs]);
+    }
+}
+export const tursoVectorWrites = new TursoVectorWrites();

package/dist/services/web-ensure.d.ts

@@ -79,6 +79,7 @@ export declare function replaceRetrying(path: string, text: string, deps?: {
     mkdir?: (dir: string) => void;
     write?: (path: string, text: string) => void;
     rename?: (from: string, to: string) => void;
+    remove?: (path: string) => void;
     rewrites?: number;
 }, rewrites?: number): void;
 /** `renameSync` that retries while Windows reports the target busy. */

package/dist/services/web-ensure.js

@@ -95,9 +95,12 @@ export function replaceRetrying(path, text, deps = {}, rewrites = deps.rewrites
     const mkdir = deps.mkdir ?? ((dir) => mkdirSync(dir, { recursive: true, mode: 0o700 }));
     const write = deps.write ?? ((file, body) => writeFileSync(file, body, { mode: 0o600 }));
     const rename = deps.rename ?? ((from, to) => renameRetrying(from, to));
+    const remove = deps.remove ?? ((file) => rmSync(file, { force: true }));
     mkdir(dirname(path));
-    const temp = `${path}.${process.pid}.tmp`;
     for (let attempt = 0;; attempt++) {
+        // A new name for each attempt: the Bun rename fault can stick to one
+        // temp path, so a retry with the same name fails again (TDR-030).
+        const temp = `${path}.${process.pid}.${attempt}.tmp`;
         write(temp, text);
         try {
             rename(temp, path);
@@ -106,6 +109,7 @@ export function replaceRetrying(path, text, deps = {}, rewrites = deps.rewrites
         catch (error) {
             if (error.code !== "ENOENT" || attempt >= rewrites)
                 throw error;
+            remove(temp);
         }
     }
 }

package/dist/services/web-memory-rows.d.ts

@@ -0,0 +1,12 @@
+/** Why the Memories page cannot edit a memorisation. */
+export declare const MEMORISATION_EDIT_REFUSAL = "A memorisation cannot be edited or bulk deleted from the Memories page. Delete it on the Memorisation page, or replace it by memorising again.";
+/** Why the Memories page cannot create a memorisation. */
+export declare const MEMORISATION_TYPE_REFUSAL = "The memorisation type is reserved. Save a memorisation with the memorise operation, not from the Memories page.";
+/** Reads stored normal memory rows for one project tag, or for every project and user shard. */
+export declare function loadMemoryRows(tag?: string): Promise<any[]>;
+/** The IDs among `ids` whose stored row is a memorisation, across every project and user shard. */
+export declare function memorisationIdsAmong(ids: string[]): Promise<string[]>;
+/** The refusal for a web edit of memory `id` with `data`, or undefined when the edit is allowed. */
+export declare function webUpdateRefusal(id: string, data: {
+    type?: string;
+}): Promise<string | undefined>;

package/dist/services/web-memory-rows.js

@@ -0,0 +1,58 @@
+import { tursoShardManager } from "./turso/shard-manager.js";
+import { tursoVectorSearch } from "./turso/vector-search.js";
+import { tursoConnectionManager } from "./turso/connection-manager.js";
+import { ensureTursoReady } from "./turso/ready.js";
+import { extractScopeFromContainerTag } from "./memory-scope.js";
+/** Why the Memories page cannot edit a memorisation. */
+export const MEMORISATION_EDIT_REFUSAL = "A memorisation cannot be edited or bulk deleted from the Memories page. Delete it on the Memorisation page, or replace it by memorising again.";
+/** Why the Memories page cannot create a memorisation. */
+export const MEMORISATION_TYPE_REFUSAL = "The memorisation type is reserved. Save a memorisation with the memorise operation, not from the Memories page.";
+/** Reads stored normal memory rows for one project tag, or for every project and user shard. */
+export async function loadMemoryRows(tag) {
+    const allMemories = [];
+    if (tag) {
+        const { scope: tagScope, hash } = extractScopeFromContainerTag(tag);
+        const shards = await tursoShardManager.getAllShards(tagScope, hash);
+        for (const shard of shards) {
+            const db = await tursoConnectionManager.getConnection(shard.dbPath);
+            const memories = await tursoVectorSearch.listMemories(db, tag, 10000);
+            allMemories.push(...memories);
+        }
+    }
+    else {
+        // Walk both project and user shards, so user-scope memories are listed too.
+        // The container_tag check stays as defence in depth. Memorisations are not
+        // listed here: getAllMemories returns normal memories unless told otherwise.
+        const projectShards = await tursoShardManager.getAllShards("project", "");
+        const userShards = await tursoShardManager.getAllShards("user", "");
+        for (const shard of [...projectShards, ...userShards]) {
+            const db = await tursoConnectionManager.getConnection(shard.dbPath);
+            const memories = await tursoVectorSearch.getAllMemories(db);
+            allMemories.push(...memories.filter((m) => m.container_tag?.includes("_project_") || m.container_tag?.includes("_user_")));
+        }
+    }
+    return allMemories;
+}
+/** The IDs among `ids` whose stored row is a memorisation, across every project and user shard. */
+export async function memorisationIdsAmong(ids) {
+    if (ids.length === 0)
+        return [];
+    await ensureTursoReady();
+    const shards = [
+        ...(await tursoShardManager.getAllShards("project", "")),
+        ...(await tursoShardManager.getAllShards("user", "")),
+    ];
+    const found = [];
+    for (const shard of shards) {
+        const db = await tursoConnectionManager.getConnection(shard.dbPath);
+        const rows = await db.all(`SELECT id FROM memories WHERE type = 'memorisation' AND id IN (${ids.map(() => "?").join(",")})`, ids);
+        found.push(...rows.map((row) => String(row.id)));
+    }
+    return found;
+}
+/** The refusal for a web edit of memory `id` with `data`, or undefined when the edit is allowed. */
+export async function webUpdateRefusal(id, data) {
+    if (data.type === "memorisation")
+        return MEMORISATION_TYPE_REFUSAL;
+    return (await memorisationIdsAmong([id])).length > 0 ? MEMORISATION_EDIT_REFUSAL : undefined;
+}

package/dist/services/web-route-modules.js

@@ -1,4 +1,6 @@
 import { routeChat } from "./chat/chat-routes.js";
+import { linkedSettingsFrom } from "./linked-search.js";
+import { routeMemorisations } from "./memorisation-routes.js";
 import { routeMemoryHosts } from "./memory-host-routes.js";
 import { routeProfileCleanup } from "./profile-cleanup-routes.js";
 import { routeSpaceTransfers } from "./space-transfer-routes.js";
@@ -31,5 +33,8 @@ export async function routeModules(path, method, url, req, ctx) {
     });
     if (spaces !== undefined)
         return spaces;
+    const memorisations = await routeMemorisations(path, method, url, ctx.cwd, { defaultScope: config.memory.defaultScope, linked: linkedSettingsFrom(config) }, readBody);
+    if (memorisations !== undefined)
+        return memorisations;
     return routeChat(path, method, readBody, config);
 }