@hanhnd/agent-kit 1.0.36 → 1.0.38

package/dist/cli.js

@@ -15019,6 +15019,11 @@ import * as os from "os";
 import * as path3 from "path";
 
 // src/services/memory/constants.ts
+var EMBEDDING_MODEL_DIMENSIONS = {
+  ["tiny" /* TINY */]: 384,
+  ["base" /* BASE */]: 384,
+  ["large" /* LARGE */]: 768
+};
 var DEFAULT_MEMORY_CONFIG = {
   enabled: false,
   wikiDir: "",
@@ -15026,22 +15031,32 @@ var DEFAULT_MEMORY_CONFIG = {
   chunkSize: 1500,
   overlapLines: 2,
   embeddingModel: "base" /* BASE */,
-  vectorDimension: 384
+  vectorDimension: EMBEDDING_MODEL_DIMENSIONS["base" /* BASE */]
 };
 var LOCK_RETRY_MS = 50;
 var LOCK_TIMEOUT_MS = 500;
 var RRF_K = 60;
+var FETCH_MULTIPLIER = 4;
+var RECENCY_WEIGHT = 0.5;
+var DENSE_SCORE_FLOOR = 0.2;
 
 // src/core/config/index.ts
 function resolveMemoryConfig(settings, workspaceRoot) {
   const override = settings.memory ?? {};
+  const embeddingModel = isEmbeddingModelName(override.embeddingModel) ? override.embeddingModel : DEFAULT_MEMORY_CONFIG.embeddingModel;
+  const vectorDimension = typeof override.vectorDimension === "number" && Number.isFinite(override.vectorDimension) && override.vectorDimension > 0 ? override.vectorDimension : EMBEDDING_MODEL_DIMENSIONS[embeddingModel];
   return {
     ...DEFAULT_MEMORY_CONFIG,
     ...override,
     enabled: override.enabled ?? DEFAULT_MEMORY_CONFIG.enabled,
+    embeddingModel,
+    vectorDimension,
     wikiDir: typeof override.wikiDir === "string" && override.wikiDir.length > 0 ? override.wikiDir : path3.join(workspaceRoot, ".agent-kit", "wiki")
   };
 }
+function isEmbeddingModelName(value) {
+  return value === "tiny" /* TINY */ || value === "base" /* BASE */ || value === "large" /* LARGE */;
+}
 function getGlobalSettingsFile() {
   return path3.join(os.homedir(), ".agent-kit", "settings.json");
 }
@@ -15313,7 +15328,7 @@ var import_stopword = __toESM(require_stopword_cjs(), 1);
 import Database from "libsql";
 import * as fs5 from "fs";
 import * as path7 from "path";
-var SCHEMA_VERSION = 3;
+var SCHEMA_VERSION = 4;
 var LibsqlDatabase = Database;
 var StoreError = class extends Error {
   constructor(message, cause) {
@@ -15356,7 +15371,8 @@ var MemoryStore = class {
   createSchema(db) {
     try {
       const current = this.readUserVersion(db);
-      if (current < SCHEMA_VERSION) {
+      const currentVectorDimension = current >= SCHEMA_VERSION ? this.readEmbeddingColumnDimension(db) : void 0;
+      if (current < SCHEMA_VERSION || currentVectorDimension !== void 0 && currentVectorDimension !== this.config.vectorDimension) {
         db.exec(`
           DROP TRIGGER IF EXISTS memory_chunks_ai;
           DROP TRIGGER IF EXISTS memory_chunks_ad;
@@ -15413,6 +15429,22 @@ var MemoryStore = class {
       throw new StoreError("schema migration failed", err);
     }
   }
+  readEmbeddingColumnDimension(db) {
+    try {
+      const rows = db.pragma("table_info(memory_chunks)");
+      if (!Array.isArray(rows)) return void 0;
+      const embeddingColumn = rows.find((row) => {
+        if (!row || typeof row !== "object") return false;
+        const candidate = row;
+        return candidate.name === "embedding" && typeof candidate.type === "string";
+      });
+      const match = /^F32_BLOB\((\d+)\)$/i.exec(embeddingColumn?.type.trim() ?? "");
+      if (!match) return void 0;
+      return Number.parseInt(match[1], 10);
+    } catch {
+      return void 0;
+    }
+  }
   readUserVersion(db) {
     const value = db.pragma("user_version", { simple: true });
     if (typeof value === "number") return value;
@@ -15427,6 +15459,7 @@ var MemoryStore = class {
     return 0;
   }
   upsert(chunks, embeddings) {
+    const deleteChunk = this.db.prepare(`DELETE FROM memory_chunks WHERE id = ?`);
     const insertChunk = this.db.prepare(`
       INSERT OR REPLACE INTO memory_chunks
         (id, source, source_type, heading, heading_level, content, line_start, line_end, indexed_at, file_mtime_at, embedding)
@@ -15437,7 +15470,7 @@ var MemoryStore = class {
         const chunk = chunks[i];
         try {
           const vectorBinding = this.toVectorBinding(embeddings[i]);
-          this.db.prepare(`DELETE FROM memory_chunks WHERE id = ?`).run(chunk.id);
+          deleteChunk.run(chunk.id);
           insertChunk.run(
             chunk.id,
             chunk.source,
@@ -15466,11 +15499,10 @@ var MemoryStore = class {
     if (!embedding) throw new Error("missing embedding");
     if (!(embedding instanceof Float32Array)) throw new Error("missing embedding");
     if (embedding.length !== this.config.vectorDimension) throw new Error("embedding dimension mismatch");
-    const values = Array.from(embedding, (value) => {
-      if (!Number.isFinite(value)) throw new Error("embedding contains non-finite value");
-      return value;
-    });
-    return JSON.stringify(values);
+    for (let i = 0; i < embedding.length; i++) {
+      if (!Number.isFinite(embedding[i])) throw new Error("embedding contains non-finite value");
+    }
+    return Buffer.from(embedding.buffer, embedding.byteOffset, embedding.byteLength);
   }
   normalizeVectorDistance(distance) {
     if (distance <= 0) return 1;
@@ -15826,7 +15858,7 @@ var MemoryIndexer = class {
     return totals;
   }
   async search(query, topK) {
-    const fetchLimit = topK * 2;
+    const fetchLimit = topK * FETCH_MULTIPLIER;
     let denseResults = [];
     if (this.store.vecAvailable) {
       try {
@@ -15837,30 +15869,50 @@ var MemoryIndexer = class {
       }
     }
     const bm25Results = this.store.searchBm25(query, fetchLimit);
-    const bm25Ids = new Set(bm25Results.map((result) => result.id));
-    if (bm25Ids.size > 0) {
-      denseResults = denseResults.filter((result) => bm25Ids.has(result.id));
-    }
+    const denseIds = new Set(denseResults.map((r) => r.id));
+    const bm25Ids = new Set(bm25Results.map((r) => r.id));
+    const unionIds = /* @__PURE__ */ new Set([...denseIds, ...bm25Ids]);
+    const denseRetrievalScore = new Map(denseResults.map((r) => [r.id, r.score]));
+    const unionArray = [...unionIds];
+    const chunks = this.store.getChunksByIds(unionArray);
+    const chunkMap = new Map(chunks.map((c) => [c.id, c]));
+    const unionIndexOf = new Map(unionArray.map((id, idx) => [id, idx]));
+    const recencyOrdered = [...unionArray].sort((a, b) => {
+      const mtimeA = chunkMap.get(a)?.fileMtimeAt ?? 0;
+      const mtimeB = chunkMap.get(b)?.fileMtimeAt ?? 0;
+      if (mtimeB !== mtimeA) return mtimeB - mtimeA;
+      return (unionIndexOf.get(a) ?? 0) - (unionIndexOf.get(b) ?? 0);
+    });
     const scoreMap = /* @__PURE__ */ new Map();
     denseResults.forEach((r, rank) => {
-      scoreMap.set(r.id, { dense: 1 / (RRF_K + rank + 1), bm25: 0 });
+      scoreMap.set(r.id, { dense: 1 / (RRF_K + rank + 1), bm25: 0, recency: 0 });
     });
     bm25Results.forEach((r, rank) => {
-      const entry = scoreMap.get(r.id) ?? { dense: 0, bm25: 0 };
+      const entry = scoreMap.get(r.id) ?? { dense: 0, bm25: 0, recency: 0 };
       entry.bm25 = 1 / (RRF_K + rank + 1);
       scoreMap.set(r.id, entry);
     });
-    const hasDense = this.store.vecAvailable && denseResults.length > 0;
-    const numRetrievers = hasDense ? 2 : 1;
-    const maxScore = numRetrievers / (RRF_K + 1);
+    recencyOrdered.forEach((id, rank) => {
+      const entry = scoreMap.get(id);
+      if (!entry) return;
+      entry.recency = RECENCY_WEIGHT * (1 / (RRF_K + rank + 1));
+    });
+    const denseActive = denseResults.length > 0;
+    const bm25Active = bm25Results.length > 0;
+    const recencyActive = unionIds.size > 0;
+    const maxScore = ((denseActive ? 1 : 0) + (bm25Active ? 1 : 0) + (recencyActive ? RECENCY_WEIGHT : 0)) / (RRF_K + 1);
     const ranked = [...scoreMap.entries()].map(([id, scores]) => ({
       id,
-      totalScore: scores.dense + scores.bm25,
+      totalScore: scores.dense + scores.bm25 + scores.recency,
       hasDense: scores.dense > 0,
-      hasBm25: scores.bm25 > 0
-    })).sort((a, b) => b.totalScore - a.totalScore);
-    const chunks = this.store.getChunksByIds(ranked.map((r) => r.id));
-    const chunkMap = new Map(chunks.map((c) => [c.id, c]));
+      hasBm25: scores.bm25 > 0,
+      isDenseOnly: denseIds.has(id) && !bm25Ids.has(id)
+    })).filter((candidate) => {
+      if (!candidate.isDenseOnly) return true;
+      const retrieval = denseRetrievalScore.get(candidate.id);
+      if (retrieval === void 0) return true;
+      return retrieval >= DENSE_SCORE_FLOOR;
+    }).sort((a, b) => b.totalScore - a.totalScore);
     const results = [];
     const seenSources = /* @__PURE__ */ new Set();
     for (const r of ranked) {

package/dist/core/config/index.d.ts

@@ -2,7 +2,7 @@
  * Configuration utilities
  * Shared configuration constants and loaders
  */
-import type { MemoryConfig } from '../../services/memory/types.js';
+import { type MemoryConfig } from '../../services/memory/types.js';
 import type { ConversationDigestSettings } from '../../services/digest/types.js';
 /**
  * Default file extensions - expanded to support more languages

package/dist/core/config/index.js

@@ -5,7 +5,8 @@
 import * as fs from 'fs';
 import * as os from 'os';
 import * as path from 'path';
-import { DEFAULT_MEMORY_CONFIG } from '../../services/memory/constants.js';
+import { DEFAULT_MEMORY_CONFIG, EMBEDDING_MODEL_DIMENSIONS } from '../../services/memory/constants.js';
+import { EmbeddingModelName } from '../../services/memory/types.js';
 import { atomicWriteJsonFile } from '../../utils/files.js';
 /**
  * Default file extensions - expanded to support more languages
@@ -40,15 +41,28 @@ export const DEFAULT_EXTENSIONS = [
  */
 export function resolveMemoryConfig(settings, workspaceRoot) {
     const override = settings.memory ?? {};
+    const embeddingModel = isEmbeddingModelName(override.embeddingModel)
+        ? override.embeddingModel
+        : DEFAULT_MEMORY_CONFIG.embeddingModel;
+    const vectorDimension = typeof override.vectorDimension === 'number' &&
+        Number.isFinite(override.vectorDimension) &&
+        override.vectorDimension > 0
+        ? override.vectorDimension
+        : EMBEDDING_MODEL_DIMENSIONS[embeddingModel];
     return {
         ...DEFAULT_MEMORY_CONFIG,
         ...override,
         enabled: override.enabled ?? DEFAULT_MEMORY_CONFIG.enabled,
+        embeddingModel,
+        vectorDimension,
         wikiDir: typeof override.wikiDir === 'string' && override.wikiDir.length > 0
             ? override.wikiDir
             : path.join(workspaceRoot, '.agent-kit', 'wiki'),
     };
 }
+function isEmbeddingModelName(value) {
+    return value === EmbeddingModelName.TINY || value === EmbeddingModelName.BASE || value === EmbeddingModelName.LARGE;
+}
 export function loadProjectSettings(projectDir) {
     const settingsPath = path.join(projectDir, '.agent-kit', 'settings.json');
     if (fs.existsSync(settingsPath)) {

package/dist/server.js

@@ -35903,6 +35903,11 @@ import * as path2 from "path";
 var SOURCE_TYPES = ["digest", "concept", "entity", "preference", "wiki"];
 
 // src/services/memory/constants.ts
+var EMBEDDING_MODEL_DIMENSIONS = {
+  ["tiny" /* TINY */]: 384,
+  ["base" /* BASE */]: 384,
+  ["large" /* LARGE */]: 768
+};
 var DEFAULT_MEMORY_CONFIG = {
   enabled: false,
   wikiDir: "",
@@ -35910,11 +35915,14 @@ var DEFAULT_MEMORY_CONFIG = {
   chunkSize: 1500,
   overlapLines: 2,
   embeddingModel: "base" /* BASE */,
-  vectorDimension: 384
+  vectorDimension: EMBEDDING_MODEL_DIMENSIONS["base" /* BASE */]
 };
 var LOCK_RETRY_MS = 50;
 var LOCK_TIMEOUT_MS = 500;
 var RRF_K = 60;
+var FETCH_MULTIPLIER = 4;
+var RECENCY_WEIGHT = 0.5;
+var DENSE_SCORE_FLOOR = 0.2;
 
 // src/utils/files.ts
 import * as fs from "node:fs";
@@ -35985,13 +35993,20 @@ function tryAcquireProcessLock(lockPath) {
 // src/core/config/index.ts
 function resolveMemoryConfig(settings, workspaceRoot2) {
   const override = settings.memory ?? {};
+  const embeddingModel = isEmbeddingModelName(override.embeddingModel) ? override.embeddingModel : DEFAULT_MEMORY_CONFIG.embeddingModel;
+  const vectorDimension = typeof override.vectorDimension === "number" && Number.isFinite(override.vectorDimension) && override.vectorDimension > 0 ? override.vectorDimension : EMBEDDING_MODEL_DIMENSIONS[embeddingModel];
   return {
     ...DEFAULT_MEMORY_CONFIG,
     ...override,
     enabled: override.enabled ?? DEFAULT_MEMORY_CONFIG.enabled,
+    embeddingModel,
+    vectorDimension,
     wikiDir: typeof override.wikiDir === "string" && override.wikiDir.length > 0 ? override.wikiDir : path2.join(workspaceRoot2, ".agent-kit", "wiki")
   };
 }
+function isEmbeddingModelName(value) {
+  return value === "tiny" /* TINY */ || value === "base" /* BASE */ || value === "large" /* LARGE */;
+}
 function getGlobalSettingsFile() {
   return path2.join(os.homedir(), ".agent-kit", "settings.json");
 }
@@ -37081,7 +37096,7 @@ var MemoryIndexer = class {
     return totals;
   }
   async search(query, topK) {
-    const fetchLimit = topK * 2;
+    const fetchLimit = topK * FETCH_MULTIPLIER;
     let denseResults = [];
     if (this.store.vecAvailable) {
       try {
@@ -37092,30 +37107,50 @@ var MemoryIndexer = class {
       }
     }
     const bm25Results = this.store.searchBm25(query, fetchLimit);
-    const bm25Ids = new Set(bm25Results.map((result) => result.id));
-    if (bm25Ids.size > 0) {
-      denseResults = denseResults.filter((result) => bm25Ids.has(result.id));
-    }
+    const denseIds = new Set(denseResults.map((r) => r.id));
+    const bm25Ids = new Set(bm25Results.map((r) => r.id));
+    const unionIds = /* @__PURE__ */ new Set([...denseIds, ...bm25Ids]);
+    const denseRetrievalScore = new Map(denseResults.map((r) => [r.id, r.score]));
+    const unionArray = [...unionIds];
+    const chunks = this.store.getChunksByIds(unionArray);
+    const chunkMap = new Map(chunks.map((c) => [c.id, c]));
+    const unionIndexOf = new Map(unionArray.map((id, idx) => [id, idx]));
+    const recencyOrdered = [...unionArray].sort((a, b) => {
+      const mtimeA = chunkMap.get(a)?.fileMtimeAt ?? 0;
+      const mtimeB = chunkMap.get(b)?.fileMtimeAt ?? 0;
+      if (mtimeB !== mtimeA) return mtimeB - mtimeA;
+      return (unionIndexOf.get(a) ?? 0) - (unionIndexOf.get(b) ?? 0);
+    });
     const scoreMap = /* @__PURE__ */ new Map();
     denseResults.forEach((r, rank) => {
-      scoreMap.set(r.id, { dense: 1 / (RRF_K + rank + 1), bm25: 0 });
+      scoreMap.set(r.id, { dense: 1 / (RRF_K + rank + 1), bm25: 0, recency: 0 });
     });
     bm25Results.forEach((r, rank) => {
-      const entry = scoreMap.get(r.id) ?? { dense: 0, bm25: 0 };
+      const entry = scoreMap.get(r.id) ?? { dense: 0, bm25: 0, recency: 0 };
       entry.bm25 = 1 / (RRF_K + rank + 1);
       scoreMap.set(r.id, entry);
     });
-    const hasDense = this.store.vecAvailable && denseResults.length > 0;
-    const numRetrievers = hasDense ? 2 : 1;
-    const maxScore = numRetrievers / (RRF_K + 1);
+    recencyOrdered.forEach((id, rank) => {
+      const entry = scoreMap.get(id);
+      if (!entry) return;
+      entry.recency = RECENCY_WEIGHT * (1 / (RRF_K + rank + 1));
+    });
+    const denseActive = denseResults.length > 0;
+    const bm25Active = bm25Results.length > 0;
+    const recencyActive = unionIds.size > 0;
+    const maxScore = ((denseActive ? 1 : 0) + (bm25Active ? 1 : 0) + (recencyActive ? RECENCY_WEIGHT : 0)) / (RRF_K + 1);
     const ranked = [...scoreMap.entries()].map(([id, scores]) => ({
       id,
-      totalScore: scores.dense + scores.bm25,
+      totalScore: scores.dense + scores.bm25 + scores.recency,
       hasDense: scores.dense > 0,
-      hasBm25: scores.bm25 > 0
-    })).sort((a, b) => b.totalScore - a.totalScore);
-    const chunks = this.store.getChunksByIds(ranked.map((r) => r.id));
-    const chunkMap = new Map(chunks.map((c) => [c.id, c]));
+      hasBm25: scores.bm25 > 0,
+      isDenseOnly: denseIds.has(id) && !bm25Ids.has(id)
+    })).filter((candidate) => {
+      if (!candidate.isDenseOnly) return true;
+      const retrieval = denseRetrievalScore.get(candidate.id);
+      if (retrieval === void 0) return true;
+      return retrieval >= DENSE_SCORE_FLOOR;
+    }).sort((a, b) => b.totalScore - a.totalScore);
     const results = [];
     const seenSources = /* @__PURE__ */ new Set();
     for (const r of ranked) {
@@ -37178,7 +37213,7 @@ var import_stopword = __toESM(require_stopword_cjs(), 1);
 import Database from "libsql";
 import * as fs7 from "fs";
 import * as path9 from "path";
-var SCHEMA_VERSION = 3;
+var SCHEMA_VERSION = 4;
 var LibsqlDatabase = Database;
 var StoreError = class extends Error {
   constructor(message, cause) {
@@ -37221,7 +37256,8 @@ var MemoryStore = class {
   createSchema(db) {
     try {
       const current = this.readUserVersion(db);
-      if (current < SCHEMA_VERSION) {
+      const currentVectorDimension = current >= SCHEMA_VERSION ? this.readEmbeddingColumnDimension(db) : void 0;
+      if (current < SCHEMA_VERSION || currentVectorDimension !== void 0 && currentVectorDimension !== this.config.vectorDimension) {
         db.exec(`
           DROP TRIGGER IF EXISTS memory_chunks_ai;
           DROP TRIGGER IF EXISTS memory_chunks_ad;
@@ -37278,6 +37314,22 @@ var MemoryStore = class {
       throw new StoreError("schema migration failed", err);
     }
   }
+  readEmbeddingColumnDimension(db) {
+    try {
+      const rows = db.pragma("table_info(memory_chunks)");
+      if (!Array.isArray(rows)) return void 0;
+      const embeddingColumn = rows.find((row) => {
+        if (!row || typeof row !== "object") return false;
+        const candidate = row;
+        return candidate.name === "embedding" && typeof candidate.type === "string";
+      });
+      const match = /^F32_BLOB\((\d+)\)$/i.exec(embeddingColumn?.type.trim() ?? "");
+      if (!match) return void 0;
+      return Number.parseInt(match[1], 10);
+    } catch {
+      return void 0;
+    }
+  }
   readUserVersion(db) {
     const value = db.pragma("user_version", { simple: true });
     if (typeof value === "number") return value;
@@ -37292,6 +37344,7 @@ var MemoryStore = class {
     return 0;
   }
   upsert(chunks, embeddings) {
+    const deleteChunk = this.db.prepare(`DELETE FROM memory_chunks WHERE id = ?`);
     const insertChunk = this.db.prepare(`
       INSERT OR REPLACE INTO memory_chunks
         (id, source, source_type, heading, heading_level, content, line_start, line_end, indexed_at, file_mtime_at, embedding)
@@ -37302,7 +37355,7 @@ var MemoryStore = class {
         const chunk = chunks[i];
         try {
           const vectorBinding = this.toVectorBinding(embeddings[i]);
-          this.db.prepare(`DELETE FROM memory_chunks WHERE id = ?`).run(chunk.id);
+          deleteChunk.run(chunk.id);
           insertChunk.run(
             chunk.id,
             chunk.source,
@@ -37331,11 +37384,10 @@ var MemoryStore = class {
     if (!embedding) throw new Error("missing embedding");
     if (!(embedding instanceof Float32Array)) throw new Error("missing embedding");
     if (embedding.length !== this.config.vectorDimension) throw new Error("embedding dimension mismatch");
-    const values = Array.from(embedding, (value) => {
-      if (!Number.isFinite(value)) throw new Error("embedding contains non-finite value");
-      return value;
-    });
-    return JSON.stringify(values);
+    for (let i = 0; i < embedding.length; i++) {
+      if (!Number.isFinite(embedding[i])) throw new Error("embedding contains non-finite value");
+    }
+    return Buffer.from(embedding.buffer, embedding.byteOffset, embedding.byteLength);
   }
   normalizeVectorDistance(distance) {
     if (distance <= 0) return 1;

package/dist/services/memory/constants.d.ts

@@ -1,5 +1,9 @@
-import { type MemoryConfig } from './types.js';
+import { type MemoryConfig, EmbeddingModelName } from './types.js';
+export declare const EMBEDDING_MODEL_DIMENSIONS: Record<EmbeddingModelName, number>;
 export declare const DEFAULT_MEMORY_CONFIG: MemoryConfig;
 export declare const LOCK_RETRY_MS = 50;
 export declare const LOCK_TIMEOUT_MS = 500;
 export declare const RRF_K = 60;
+export declare const FETCH_MULTIPLIER = 4;
+export declare const RECENCY_WEIGHT = 0.5;
+export declare const DENSE_SCORE_FLOOR = 0.2;

package/dist/services/memory/constants.js

@@ -1,4 +1,9 @@
 import { EmbeddingModelName } from './types.js';
+export const EMBEDDING_MODEL_DIMENSIONS = {
+    [EmbeddingModelName.TINY]: 384,
+    [EmbeddingModelName.BASE]: 384,
+    [EmbeddingModelName.LARGE]: 768,
+};
 export const DEFAULT_MEMORY_CONFIG = {
     enabled: false,
     wikiDir: '',
@@ -6,8 +11,14 @@ export const DEFAULT_MEMORY_CONFIG = {
     chunkSize: 1500,
     overlapLines: 2,
     embeddingModel: EmbeddingModelName.BASE,
-    vectorDimension: 384,
+    vectorDimension: EMBEDDING_MODEL_DIMENSIONS[EmbeddingModelName.BASE],
 };
 export const LOCK_RETRY_MS = 50;
 export const LOCK_TIMEOUT_MS = 500;
 export const RRF_K = 60;
+// Tunable starting default: fetchLimit = topK * FETCH_MULTIPLIER (was hardcoded topK * 2)
+export const FETCH_MULTIPLIER = 4;
+// Tunable starting default: weight on the recency RRF channel; < 1 so recency cannot outrank a dual-channel durable hit
+export const RECENCY_WEIGHT = 0.5;
+// Tunable starting default: min dense retrieval score [0,1] for a dense-only candidate to survive (permissive start)
+export const DENSE_SCORE_FLOOR = 0.2;

package/dist/services/memory/indexer.js

@@ -1,7 +1,7 @@
 import * as fs from 'fs';
 import * as path from 'path';
 import { chunkMarkdown } from './chunker.js';
-import { LOCK_RETRY_MS, LOCK_TIMEOUT_MS, RRF_K } from './constants.js';
+import { DENSE_SCORE_FLOOR, FETCH_MULTIPLIER, LOCK_RETRY_MS, LOCK_TIMEOUT_MS, RECENCY_WEIGHT, RRF_K, } from './constants.js';
 import { acquireLock, releaseLock } from '../../utils/files.js';
 export function deriveSourceType(source) {
     if (source.startsWith('compiled/provisional/conversation-digests/'))
@@ -118,7 +118,8 @@ export class MemoryIndexer {
         return totals;
     }
     async search(query, topK) {
-        const fetchLimit = topK * 2;
+        // Task 2.2: overfetch to supply enough distinct sources after per-source dedup
+        const fetchLimit = topK * FETCH_MULTIPLIER;
         let denseResults = [];
         if (this.store.vecAvailable) {
             try {
@@ -130,32 +131,65 @@ export class MemoryIndexer {
             }
         }
         const bm25Results = this.store.searchBm25(query, fetchLimit);
-        const bm25Ids = new Set(bm25Results.map((result) => result.id));
-        if (bm25Ids.size > 0) {
-            denseResults = denseResults.filter((result) => bm25Ids.has(result.id));
-        }
+        // Task 2.1: candidate set = dense ∪ bm25 — no intersection filter
+        const denseIds = new Set(denseResults.map((r) => r.id));
+        const bm25Ids = new Set(bm25Results.map((r) => r.id));
+        const unionIds = new Set([...denseIds, ...bm25Ids]);
+        // Task 2.5: preserve raw dense retrieval scores [0,1] for the precision floor check
+        const denseRetrievalScore = new Map(denseResults.map((r) => [r.id, r.score]));
+        // Task 2.3: fetch all union candidates once — supplies recency mtime AND final content (no second DB call)
+        const unionArray = [...unionIds];
+        const chunks = this.store.getChunksByIds(unionArray);
+        const chunkMap = new Map(chunks.map((c) => [c.id, c]));
+        // Task 2.3: recency channel — rank union by fileMtimeAt DESC; stable tiebreak on union insertion order
+        const unionIndexOf = new Map(unionArray.map((id, idx) => [id, idx]));
+        const recencyOrdered = [...unionArray].sort((a, b) => {
+            const mtimeA = chunkMap.get(a)?.fileMtimeAt ?? 0;
+            const mtimeB = chunkMap.get(b)?.fileMtimeAt ?? 0;
+            if (mtimeB !== mtimeA)
+                return mtimeB - mtimeA;
+            return (unionIndexOf.get(a) ?? 0) - (unionIndexOf.get(b) ?? 0);
+        });
+        // RRF score accumulation: dense + bm25 + weighted recency channels
         const scoreMap = new Map();
         denseResults.forEach((r, rank) => {
-            scoreMap.set(r.id, { dense: 1 / (RRF_K + rank + 1), bm25: 0 });
+            scoreMap.set(r.id, { dense: 1 / (RRF_K + rank + 1), bm25: 0, recency: 0 });
         });
         bm25Results.forEach((r, rank) => {
-            const entry = scoreMap.get(r.id) ?? { dense: 0, bm25: 0 };
+            const entry = scoreMap.get(r.id) ?? { dense: 0, bm25: 0, recency: 0 };
             entry.bm25 = 1 / (RRF_K + rank + 1);
             scoreMap.set(r.id, entry);
         });
-        const hasDense = this.store.vecAvailable && denseResults.length > 0;
-        const numRetrievers = hasDense ? 2 : 1;
-        const maxScore = numRetrievers / (RRF_K + 1);
+        recencyOrdered.forEach((id, rank) => {
+            const entry = scoreMap.get(id);
+            if (!entry)
+                return;
+            entry.recency = RECENCY_WEIGHT * (1 / (RRF_K + rank + 1));
+        });
+        // Task 2.4: active-channel normalization — maxScore sums weights of channels that produced ≥1 result
+        const denseActive = denseResults.length > 0;
+        const bm25Active = bm25Results.length > 0;
+        const recencyActive = unionIds.size > 0;
+        const maxScore = ((denseActive ? 1 : 0) + (bm25Active ? 1 : 0) + (recencyActive ? RECENCY_WEIGHT : 0)) / (RRF_K + 1);
+        // Task 2.5: build ranked list, dropping dense-only candidates below the precision floor
         const ranked = [...scoreMap.entries()]
             .map(([id, scores]) => ({
             id,
-            totalScore: scores.dense + scores.bm25,
+            totalScore: scores.dense + scores.bm25 + scores.recency,
             hasDense: scores.dense > 0,
             hasBm25: scores.bm25 > 0,
+            isDenseOnly: denseIds.has(id) && !bm25Ids.has(id),
         }))
+            .filter((candidate) => {
+            if (!candidate.isDenseOnly)
+                return true;
+            const retrieval = denseRetrievalScore.get(candidate.id);
+            // Only drop when a dense retrieval score exists and is below the floor
+            if (retrieval === undefined)
+                return true;
+            return retrieval >= DENSE_SCORE_FLOOR;
+        })
             .sort((a, b) => b.totalScore - a.totalScore);
-        const chunks = this.store.getChunksByIds(ranked.map((r) => r.id));
-        const chunkMap = new Map(chunks.map((c) => [c.id, c]));
         const results = [];
         const seenSources = new Set();
         for (const r of ranked) {

package/dist/services/memory/indexer.test.js

@@ -266,8 +266,10 @@ describe('MemoryIndexer', () => {
             fs.rmSync(testDir, { recursive: true, force: true });
         }
     });
-    test('search does not include dense-only results when BM25 has matches', async () => {
-        const testCfg = makeConfig('/tmp/search-dense-filter');
+    // Task 3.1: Rewrite — asserts union behavior (previously asserted the removed intersection filter).
+    // BC1 + BC2: dense-only high-score candidate surfaces; dual-channel hit ranks first.
+    test('search includes high-score dense-only results alongside BM25 matches', async () => {
+        const testCfg = makeConfig('/tmp/search-union-behavior');
         const chunks = [
             {
                 id: 'preference-1',
@@ -291,7 +293,7 @@ describe('MemoryIndexer', () => {
         const fakeStore = {
             vecAvailable: true,
             searchDense: () => [
-                { id: 'dense-only-1', score: 0.99 },
+                { id: 'dense-only-1', score: 0.99 }, // score >= DENSE_SCORE_FLOOR (0.2) → survives floor
                 { id: 'preference-1', score: 0.98 },
             ],
             searchBm25: () => [{ id: 'preference-1', score: 1 }],
@@ -299,8 +301,361 @@ describe('MemoryIndexer', () => {
         };
         const testIndexer = new MemoryIndexer(fakeStore, new StubEmbedder(), testCfg);
         const results = await testIndexer.search('personal likes and preferences of the user', 5);
-        assert.deepEqual(results.map((result) => result.chunk.id), ['preference-1']);
+        const resultIds = results.map((r) => r.chunk.id);
+        assert.ok(resultIds.includes('preference-1'), `Expected preference-1 in results, got: ${resultIds.join(', ')}`);
+        assert.ok(resultIds.includes('dense-only-1'), `Expected dense-only-1 in results, got: ${resultIds.join(', ')}`);
+        assert.equal(results[0].chunk.id, 'preference-1', 'dual-channel hit must rank first');
         assert.equal(results[0].retriever, 'both');
+        const denseOnlyResult = results.find((r) => r.chunk.id === 'dense-only-1');
+        assert.ok(denseOnlyResult, 'dense-only-1 must be present in results');
+        assert.equal(denseOnlyResult.retriever, 'dense');
+    });
+    // Task 3.2 — Regression tests BC1–BC9
+    // BC3: durable dual-channel memory ranks above a newer single-channel chunk despite lower recency score
+    test('BC3: durable dual-channel chunk ranks above newer single-channel chunk', async () => {
+        const testCfg = makeConfig('/tmp/bc3-durable-vs-recent');
+        const chunks = [
+            {
+                id: 'durable-1',
+                source: 'compiled/preferences.md',
+                heading: '',
+                headingLevel: 0,
+                content: 'I prefer dark mode',
+                lineStart: 1,
+                lineEnd: 1,
+                fileMtimeAt: 100, // old mtime
+            },
+            {
+                id: 'recent-1',
+                source: 'compiled/entities/meeting.md',
+                heading: 'Meeting',
+                headingLevel: 1,
+                content: 'Meeting notes from today',
+                lineStart: 1,
+                lineEnd: 2,
+                fileMtimeAt: 9_999_999_999_999, // very new mtime
+            },
+        ];
+        const fakeStore = {
+            vecAvailable: true,
+            searchDense: () => [{ id: 'durable-1', score: 0.9 }],
+            searchBm25: () => [
+                { id: 'durable-1', score: 1 }, // rank 0 in bm25
+                { id: 'recent-1', score: 0.8 }, // rank 1 in bm25 — newer mtime but single bm25 channel
+            ],
+            getChunksByIds: (ids) => chunks.filter((c) => ids.includes(c.id)),
+        };
+        const testIndexer = new MemoryIndexer(fakeStore, new StubEmbedder(), testCfg);
+        const results = await testIndexer.search('preferences', 5);
+        assert.ok(results.length >= 2, `Expected at least 2 results, got ${results.length}`);
+        assert.equal(results[0].chunk.id, 'durable-1', 'dual-channel durable memory must rank above newer single-channel chunk');
+        assert.equal(results[0].retriever, 'both');
+        const recentResult = results.find((r) => r.chunk.id === 'recent-1');
+        assert.ok(recentResult, 'recent-1 must still surface');
+    });
+    // BC4: search returns dense results when BM25 is empty, with recency channel applied
+    test('BC4: search returns dense results and applies recency when BM25 has no matches', async () => {
+        const testCfg = makeConfig('/tmp/bc4-dense-only-recency');
+        const chunks = [
+            {
+                id: 'semantic-old',
+                source: 'compiled/concepts/topic.md',
+                heading: 'Topic',
+                headingLevel: 1,
+                content: 'Concept about topic',
+                lineStart: 1,
+                lineEnd: 2,
+                fileMtimeAt: 1, // very old
+            },
+            {
+                id: 'semantic-new',
+                source: 'compiled/entities/recent-entity.md',
+                heading: 'Recent',
+                headingLevel: 1,
+                content: 'Recent entity content',
+                lineStart: 1,
+                lineEnd: 2,
+                fileMtimeAt: 9_999_999_999_999, // very new
+            },
+        ];
+        const fakeStore = {
+            vecAvailable: true,
+            searchDense: () => [
+                { id: 'semantic-old', score: 0.9 }, // dense rank 0
+                { id: 'semantic-new', score: 0.85 }, // dense rank 1
+            ],
+            searchBm25: () => [],
+            getChunksByIds: (ids) => chunks.filter((c) => ids.includes(c.id)),
+        };
+        const testIndexer = new MemoryIndexer(fakeStore, new StubEmbedder(), testCfg);
+        const results = await testIndexer.search('topic', 5);
+        assert.ok(results.length >= 2, `Expected at least 2 dense results, got ${results.length}`);
+        const ids = results.map((r) => r.chunk.id);
+        assert.ok(ids.includes('semantic-old'), 'semantic-old must be present');
+        assert.ok(ids.includes('semantic-new'), 'semantic-new must be present');
+        for (const result of results) {
+            assert.equal(result.retriever, 'dense', `Expected retriever 'dense', got '${result.retriever}'`);
+            assert.ok(result.score > 0, 'Normalized score must be positive');
+        }
+    });
+    // BC5: dense channel unavailable — bm25 results returned with finite normalized score, no throw
+    test('BC5: bm25 results are returned with normalized score when dense channel is unavailable', async () => {
+        const testCfg = makeConfig('/tmp/bc5-dense-unavailable');
+        const chunks = [
+            {
+                id: 'keyword-1',
+                source: 'compiled/concepts/keyword.md',
+                heading: 'Keyword',
+                headingLevel: 1,
+                content: 'Keyword concept content',
+                lineStart: 1,
+                lineEnd: 2,
+            },
+        ];
+        const fakeStore = {
+            vecAvailable: false,
+            searchBm25: () => [{ id: 'keyword-1', score: 1 }],
+            getChunksByIds: (ids) => chunks.filter((c) => ids.includes(c.id)),
+        };
+        const testIndexer = new MemoryIndexer(fakeStore, new StubEmbedder(), testCfg);
+        const results = await testIndexer.search('keyword', 5);
+        assert.equal(results.length, 1, 'Must return bm25 result when dense is unavailable');
+        assert.equal(results[0].chunk.id, 'keyword-1');
+        assert.equal(results[0].retriever, 'bm25');
+        assert.ok(Number.isFinite(results[0].score), 'Score must be finite');
+        assert.ok(results[0].score >= 0 && results[0].score <= 1, `Score must be in [0,1], got ${results[0].score}`);
+    });
+    // BC6: both channels empty → search returns []
+    test('BC6: search returns empty array when both dense and bm25 channels are empty', async () => {
+        const testCfg = makeConfig('/tmp/bc6-both-empty');
+        const fakeStore = {
+            vecAvailable: false,
+            searchBm25: () => [],
+            getChunksByIds: () => [],
+        };
+        const testIndexer = new MemoryIndexer(fakeStore, new StubEmbedder(), testCfg);
+        const results = await testIndexer.search('anything', 5);
+        assert.deepEqual(results, []);
+    });
+    // BC7: per-source dedup yields up to topK distinct sources even when one source dominates the pool
+    test('BC7: per-source dedup yields topK distinct sources when one source dominates the pool', async () => {
+        const testDir = fs.mkdtempSync(path.join(os.tmpdir(), 'bc7-overfetch-'));
+        const testCfg = makeConfig(path.join(testDir, 'wiki'));
+        const allChunks = [
+            {
+                id: 'dom-1',
+                source: 'compiled/entities/dominant.md',
+                heading: '',
+                headingLevel: 0,
+                content: 'dom 1',
+                lineStart: 1,
+                lineEnd: 1,
+            },
+            {
+                id: 'dom-2',
+                source: 'compiled/entities/dominant.md',
+                heading: '',
+                headingLevel: 0,
+                content: 'dom 2',
+                lineStart: 2,
+                lineEnd: 2,
+            },
+            {
+                id: 'dom-3',
+                source: 'compiled/entities/dominant.md',
+                heading: '',
+                headingLevel: 0,
+                content: 'dom 3',
+                lineStart: 3,
+                lineEnd: 3,
+            },
+            {
+                id: 'dom-4',
+                source: 'compiled/entities/dominant.md',
+                heading: '',
+                headingLevel: 0,
+                content: 'dom 4',
+                lineStart: 4,
+                lineEnd: 4,
+            },
+            {
+                id: 'dom-5',
+                source: 'compiled/entities/dominant.md',
+                heading: '',
+                headingLevel: 0,
+                content: 'dom 5',
+                lineStart: 5,
+                lineEnd: 5,
+            },
+            {
+                id: 'src-b-1',
+                source: 'compiled/entities/source-b.md',
+                heading: '',
+                headingLevel: 0,
+                content: 'source b',
+                lineStart: 1,
+                lineEnd: 1,
+            },
+            {
+                id: 'src-c-1',
+                source: 'compiled/entities/source-c.md',
+                heading: '',
+                headingLevel: 0,
+                content: 'source c',
+                lineStart: 1,
+                lineEnd: 1,
+            },
+        ];
+        const fakeStore = {
+            vecAvailable: false,
+            searchBm25: () => [
+                { id: 'dom-1', score: 5 },
+                { id: 'dom-2', score: 4.9 },
+                { id: 'dom-3', score: 4.8 },
+                { id: 'dom-4', score: 4.7 },
+                { id: 'dom-5', score: 4.6 },
+                { id: 'src-b-1', score: 3 },
+                { id: 'src-c-1', score: 2 },
+            ],
+            getChunksByIds: (ids) => allChunks.filter((c) => ids.includes(c.id)),
+        };
+        const testIndexer = new MemoryIndexer(fakeStore, new StubEmbedder(), testCfg);
+        try {
+            const entitiesDir = path.join(testCfg.wikiDir, 'compiled', 'entities');
+            fs.mkdirSync(entitiesDir, { recursive: true });
+            fs.writeFileSync(path.join(entitiesDir, 'dominant.md'), 'dominant content', 'utf8');
+            fs.writeFileSync(path.join(entitiesDir, 'source-b.md'), 'source b content', 'utf8');
+            fs.writeFileSync(path.join(entitiesDir, 'source-c.md'), 'source c content', 'utf8');
+            const results = await testIndexer.search('query', 3);
+            assert.equal(results.length, 3, `Expected 3 results, got ${results.length}`);
+            const sources = results.map((r) => r.chunk.source);
+            const uniqueSources = new Set(sources);
+            assert.equal(uniqueSources.size, 3, 'Each result must be from a distinct source');
+            assert.ok(sources.includes('compiled/entities/dominant.md'), 'dominant source must be present');
+            assert.ok(sources.includes('compiled/entities/source-b.md'), 'source-b must be present');
+            assert.ok(sources.includes('compiled/entities/source-c.md'), 'source-c must be present');
+        }
+        finally {
+            fs.rmSync(testDir, { recursive: true, force: true });
+        }
+    });
+    // BC8: dense-only candidate below DENSE_SCORE_FLOOR (0.2) is dropped; at/above floor is kept; bm25-only never dropped
+    test('BC8: dense-only candidate below DENSE_SCORE_FLOOR is dropped; bm25-only and above-floor are kept', async () => {
+        const testCfg = makeConfig('/tmp/bc8-floor');
+        const chunks = [
+            {
+                id: 'below-floor',
+                source: 'compiled/entities/below.md',
+                heading: '',
+                headingLevel: 0,
+                content: 'below floor dense',
+                lineStart: 1,
+                lineEnd: 1,
+            },
+            {
+                id: 'above-floor',
+                source: 'compiled/entities/above.md',
+                heading: '',
+                headingLevel: 0,
+                content: 'above floor dense',
+                lineStart: 1,
+                lineEnd: 1,
+            },
+            {
+                id: 'bm25-overlap',
+                source: 'compiled/concepts/overlap.md',
+                heading: '',
+                headingLevel: 0,
+                content: 'overlap content',
+                lineStart: 1,
+                lineEnd: 1,
+            },
+            {
+                id: 'bm25-only',
+                source: 'compiled/concepts/keyword-only.md',
+                heading: '',
+                headingLevel: 0,
+                content: 'keyword only',
+                lineStart: 1,
+                lineEnd: 1,
+            },
+        ];
+        const fakeStore = {
+            vecAvailable: true,
+            // below-floor: dense-only, score 0.1 < DENSE_SCORE_FLOOR (0.2) → must be dropped
+            // above-floor: dense-only, score 0.9 >= DENSE_SCORE_FLOOR (0.2) → must be kept
+            // bm25-overlap: in both channels → never dropped regardless of dense score
+            searchDense: () => [
+                { id: 'below-floor', score: 0.1 },
+                { id: 'above-floor', score: 0.9 },
+                { id: 'bm25-overlap', score: 0.3 },
+            ],
+            searchBm25: () => [
+                { id: 'bm25-overlap', score: 1 },
+                { id: 'bm25-only', score: 0.8 },
+            ],
+            getChunksByIds: (ids) => chunks.filter((c) => ids.includes(c.id)),
+        };
+        const testIndexer = new MemoryIndexer(fakeStore, new StubEmbedder(), testCfg);
+        const results = await testIndexer.search('query', 10);
+        const resultIds = results.map((r) => r.chunk.id);
+        assert.ok(!resultIds.includes('below-floor'), `below-floor (score 0.1 < 0.2) must be dropped; got: ${resultIds.join(', ')}`);
+        assert.ok(resultIds.includes('above-floor'), `above-floor (score 0.9 >= 0.2) must be kept; got: ${resultIds.join(', ')}`);
+        assert.ok(resultIds.includes('bm25-overlap'), `bm25-overlap (dual-channel) must always be kept`);
+        assert.ok(resultIds.includes('bm25-only'), `bm25-only must never be dropped by the floor`);
+    });
+    // BC9: recency tiebreak is stable — repeated calls with tied/absent fileMtimeAt return identical order
+    test('BC9: repeated search calls with equal-mtime candidates return deterministic order', async () => {
+        const testCfg = makeConfig('/tmp/bc9-determinism');
+        const chunks = [
+            {
+                id: 'c1',
+                source: 'compiled/entities/c1.md',
+                heading: '',
+                headingLevel: 0,
+                content: 'c1 content',
+                lineStart: 1,
+                lineEnd: 1,
+                fileMtimeAt: 0,
+            },
+            {
+                id: 'c2',
+                source: 'compiled/entities/c2.md',
+                heading: '',
+                headingLevel: 0,
+                content: 'c2 content',
+                lineStart: 1,
+                lineEnd: 1,
+                fileMtimeAt: 0,
+            },
+            {
+                id: 'c3',
+                source: 'compiled/entities/c3.md',
+                heading: '',
+                headingLevel: 0,
+                content: 'c3 content',
+                lineStart: 1,
+                lineEnd: 1,
+                fileMtimeAt: 0,
+            },
+        ];
+        const fakeStore = {
+            vecAvailable: true,
+            searchDense: () => [
+                { id: 'c1', score: 0.9 },
+                { id: 'c2', score: 0.85 },
+                { id: 'c3', score: 0.8 },
+            ],
+            searchBm25: () => [],
+            getChunksByIds: (ids) => chunks.filter((c) => ids.includes(c.id)),
+        };
+        const testIndexer = new MemoryIndexer(fakeStore, new StubEmbedder(), testCfg);
+        const firstCall = await testIndexer.search('query', 5);
+        const secondCall = await testIndexer.search('query', 5);
+        assert.equal(firstCall.length, secondCall.length, 'Result count must be identical across calls');
+        for (let idx = 0; idx < firstCall.length; idx++) {
+            assert.equal(firstCall[idx].chunk.id, secondCall[idx].chunk.id, `Position ${idx} must be deterministic: got '${firstCall[idx].chunk.id}' vs '${secondCall[idx].chunk.id}'`);
+        }
     });
     test('search still returns dense-only results when BM25 has no matches', async () => {
         const testCfg = makeConfig('/tmp/search-dense-fallback');

package/dist/services/memory/memory.test.js

@@ -402,4 +402,14 @@ describe('resolveMemoryConfig', () => {
         const config = resolveMemoryConfig({ memory: { wikiDir: '/custom/wiki' } }, '/repo');
         assert.equal(config.wikiDir, '/custom/wiki');
     });
+    test('derives vector dimension from embedding model', () => {
+        const config = resolveMemoryConfig({ memory: { embeddingModel: EmbeddingModelName.LARGE } }, '/repo');
+        assert.equal(config.embeddingModel, EmbeddingModelName.LARGE);
+        assert.equal(config.vectorDimension, 768);
+    });
+    test('preserves explicit vector dimension override', () => {
+        const config = resolveMemoryConfig({ memory: { embeddingModel: EmbeddingModelName.LARGE, vectorDimension: 1024 } }, '/repo');
+        assert.equal(config.embeddingModel, EmbeddingModelName.LARGE);
+        assert.equal(config.vectorDimension, 1024);
+    });
 });

package/dist/services/memory/store.d.ts

@@ -1,5 +1,5 @@
 import type { MemoryChunk, MemoryConfig, RecentSource, SourceType } from './types.js';
-export declare const SCHEMA_VERSION = 3;
+export declare const SCHEMA_VERSION = 4;
 export declare class StoreError extends Error {
     constructor(message: string, cause?: unknown);
 }
@@ -9,6 +9,7 @@ export declare class MemoryStore {
     constructor(dbPath: string, config: MemoryConfig);
     private openDatabase;
     private createSchema;
+    private readEmbeddingColumnDimension;
     private readUserVersion;
     upsert(chunks: MemoryChunk[], embeddings: Float32Array[]): void;
     private toVectorBinding;

package/dist/services/memory/store.js

@@ -2,7 +2,7 @@ import Database from 'libsql';
 import * as fs from 'fs';
 import * as path from 'path';
 import { eng, removeStopwords } from 'stopword';
-export const SCHEMA_VERSION = 3;
+export const SCHEMA_VERSION = 4;
 const LibsqlDatabase = Database;
 export class StoreError extends Error {
     constructor(message, cause) {
@@ -51,7 +51,9 @@ export class MemoryStore {
     createSchema(db) {
         try {
             const current = this.readUserVersion(db);
-            if (current < SCHEMA_VERSION) {
+            const currentVectorDimension = current >= SCHEMA_VERSION ? this.readEmbeddingColumnDimension(db) : undefined;
+            if (current < SCHEMA_VERSION ||
+                (currentVectorDimension !== undefined && currentVectorDimension !== this.config.vectorDimension)) {
                 db.exec(`
           DROP TRIGGER IF EXISTS memory_chunks_ai;
           DROP TRIGGER IF EXISTS memory_chunks_ad;
@@ -109,6 +111,26 @@ export class MemoryStore {
             throw new StoreError('schema migration failed', err);
         }
     }
+    readEmbeddingColumnDimension(db) {
+        try {
+            const rows = db.pragma('table_info(memory_chunks)');
+            if (!Array.isArray(rows))
+                return undefined;
+            const embeddingColumn = rows.find((row) => {
+                if (!row || typeof row !== 'object')
+                    return false;
+                const candidate = row;
+                return candidate.name === 'embedding' && typeof candidate.type === 'string';
+            });
+            const match = /^F32_BLOB\((\d+)\)$/i.exec(embeddingColumn?.type.trim() ?? '');
+            if (!match)
+                return undefined;
+            return Number.parseInt(match[1], 10);
+        }
+        catch {
+            return undefined;
+        }
+    }
     readUserVersion(db) {
         const value = db.pragma('user_version', { simple: true });
         if (typeof value === 'number')
@@ -124,6 +146,7 @@ export class MemoryStore {
         return 0;
     }
     upsert(chunks, embeddings) {
+        const deleteChunk = this.db.prepare(`DELETE FROM memory_chunks WHERE id = ?`);
         const insertChunk = this.db.prepare(`
       INSERT OR REPLACE INTO memory_chunks
         (id, source, source_type, heading, heading_level, content, line_start, line_end, indexed_at, file_mtime_at, embedding)
@@ -135,7 +158,7 @@ export class MemoryStore {
                 try {
                     const vectorBinding = this.toVectorBinding(embeddings[i]);
                     // Delete existing row first to get correct rowid
-                    this.db.prepare(`DELETE FROM memory_chunks WHERE id = ?`).run(chunk.id);
+                    deleteChunk.run(chunk.id);
                     insertChunk.run(chunk.id, chunk.source, chunk.sourceType, chunk.heading, chunk.headingLevel, chunk.content, chunk.lineStart, chunk.lineEnd, Date.now(), chunk.fileMtimeAt, vectorBinding);
                 }
                 catch (err) {
@@ -157,12 +180,11 @@ export class MemoryStore {
             throw new Error('missing embedding');
         if (embedding.length !== this.config.vectorDimension)
             throw new Error('embedding dimension mismatch');
-        const values = Array.from(embedding, (value) => {
-            if (!Number.isFinite(value))
+        for (let i = 0; i < embedding.length; i++) {
+            if (!Number.isFinite(embedding[i]))
                 throw new Error('embedding contains non-finite value');
-            return value;
-        });
-        return JSON.stringify(values);
+        }
+        return Buffer.from(embedding.buffer, embedding.byteOffset, embedding.byteLength);
     }
     normalizeVectorDistance(distance) {
         if (distance <= 0)

package/dist/services/memory/store.test.js

@@ -387,4 +387,47 @@ describe('MemoryStore', () => {
             fs.rmSync(migrationDir, { recursive: true, force: true });
         }
     });
+    test('recreates schema when existing vector dimension differs from config', () => {
+        const dimensionDir = fs.mkdtempSync(path.join(os.tmpdir(), 'memory-dimension-migration-'));
+        const dimensionDbPath = path.join(dimensionDir, 'index.db');
+        const baseStore = new MemoryStore(dimensionDbPath, { ...TEST_CONFIG, wikiDir: dimensionDir });
+        try {
+            baseStore.upsert([makeChunk({ id: 'old-dimension-row', source: 'dimension.md' })], [makeEmbedding(17)]);
+        }
+        finally {
+            baseStore.close();
+        }
+        const largeConfig = {
+            ...TEST_CONFIG,
+            wikiDir: dimensionDir,
+            embeddingModel: EmbeddingModelName.LARGE,
+            vectorDimension: 768,
+        };
+        const largeStore = new MemoryStore(dimensionDbPath, largeConfig);
+        try {
+            const verifyDb = new Database(dimensionDbPath, { readonly: true });
+            try {
+                const columns = verifyDb.prepare(`PRAGMA table_info(memory_chunks)`).all();
+                const embeddingColumn = columns.find((column) => column.name === 'embedding');
+                assert.equal(embeddingColumn?.type, 'F32_BLOB(768)');
+                const rowCount = verifyDb.prepare(`SELECT COUNT(*) AS count FROM memory_chunks`).get();
+                assert.equal(rowCount.count, 0);
+            }
+            finally {
+                verifyDb.close();
+            }
+            const chunk = makeChunk({
+                id: 'new-dimension-row',
+                source: 'dimension.md',
+                content: 'large dimension vector can be indexed',
+            });
+            largeStore.upsert([chunk], [makeEmbedding(18, 768)]);
+            const results = largeStore.searchBm25('large dimension vector', 5);
+            assert.ok(results.some((result) => result.id === 'new-dimension-row'));
+        }
+        finally {
+            largeStore.close();
+            fs.rmSync(dimensionDir, { recursive: true, force: true });
+        }
+    });
 });

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@hanhnd/agent-kit",
-  "version": "1.0.36",
+  "version": "1.0.38",
   "description": "Agent Kit MCP server for software development agent workflows",
   "type": "module",
   "main": "dist/server.js",