recallnest 1.4.1 → 2.2.0

package/scripts/verify-emotion-decay.ts

@@ -0,0 +1,148 @@
+#!/usr/bin/env bun
+/**
+ * Phase 1 Manual Verification: Emotional Valence in Decay
+ *
+ * Demonstrates:
+ * 1. detectEmotion → salience + source fields
+ * 2. adjustHalfLifeForEmotion → emotional memories get longer half-life
+ * 3. computeDecayScore → emotion-aware weights
+ * 4. End-to-end: emotional memory scores higher than neutral at same age
+ */
+
+import { detectEmotion } from "../src/emotion-detector.js";
+import { adjustHalfLifeForEmotion, computeArousalBoost, weibullDecay, resolveTier } from "../src/decay-engine.js";
+import { computeDecayScore, type EvolutionMetadata } from "../src/memory-evolution.js";
+import { parseEmotion } from "../src/memory-schema.js";
+
+// Force emotion flag on for verification
+process.env.RECALLNEST_EMOTION_SCORING = "true";
+
+const DIVIDER = "─".repeat(60);
+
+// ── 1. detectEmotion: salience + source ──────────────────────
+
+console.log("\n" + DIVIDER);
+console.log("1️⃣  detectEmotion: salience + source");
+console.log(DIVIDER);
+
+const samples = [
+  { label: "愤怒调试", text: "CRITICAL BUG! 这个问题搞了三天还是崩溃，太frustrating了！" },
+  { label: "成功修复", text: "Finally fixed it! Everything works perfectly, all tests pass!" },
+  { label: "中性日志", text: "Updated the config file and ran the migration script." },
+  { label: "中文负面", text: "这个方案不好用，不开心，又失败了" },
+];
+
+for (const s of samples) {
+  const e = detectEmotion(s.text);
+  console.log(`\n  [${s.label}]`);
+  console.log(`  text:     "${s.text.slice(0, 50)}..."`);
+  console.log(`  valence:  ${e.valence.toFixed(2)}  arousal: ${e.arousal.toFixed(2)}  label: ${e.label}`);
+  console.log(`  salience: ${e.salience?.toFixed(3)}  source: ${e.source}`);
+}
+
+// ── 2. Half-life adjustment ──────────────────────────────────
+
+console.log("\n" + DIVIDER);
+console.log("2️⃣  adjustHalfLifeForEmotion: half-life extension");
+console.log(DIVIDER);
+
+const baseHL = 60; // 60 days
+for (const s of samples) {
+  const e = detectEmotion(s.text);
+  const adjustedHL = adjustHalfLifeForEmotion(baseHL, e);
+  const boost = computeArousalBoost(e);
+  const delta = ((adjustedHL / baseHL - 1) * 100).toFixed(1);
+  console.log(`\n  [${s.label}]`);
+  console.log(`  base HL:     ${baseHL}d → adjusted: ${adjustedHL.toFixed(1)}d (+${delta}%)`);
+  console.log(`  arousal boost: ${boost.toFixed(3)}x`);
+}
+
+// ── 3. Weibull decay comparison at 30d, 60d, 90d ────────────
+
+console.log("\n" + DIVIDER);
+console.log("3️⃣  Weibull decay: emotional vs neutral at different ages");
+console.log(DIVIDER);
+
+const emotionalText = "CRITICAL BUG! 这个问题搞了三天还是崩溃，太frustrating了！";
+const neutralText = "Updated the config file and ran the migration script.";
+const emotionalEmo = detectEmotion(emotionalText);
+const neutralEmo = detectEmotion(neutralText);
+const emotionalHL = adjustHalfLifeForEmotion(baseHL, emotionalEmo);
+const neutralHL = adjustHalfLifeForEmotion(baseHL, neutralEmo);
+const emotionalBoost = computeArousalBoost(emotionalEmo);
+const neutralBoost = computeArousalBoost(neutralEmo);
+
+console.log(`\n  ${"Age".padEnd(8)} ${"Emotional".padEnd(14)} ${"Neutral".padEnd(14)} ${"Δ advantage".padEnd(14)}`);
+for (const ageDays of [7, 30, 60, 90, 120]) {
+  const emoDecay = weibullDecay(ageDays, emotionalHL, "working") * emotionalBoost;
+  const neuDecay = weibullDecay(ageDays, neutralHL, "working") * neutralBoost;
+  const advantage = ((emoDecay / neuDecay - 1) * 100).toFixed(1);
+  console.log(`  ${(ageDays + "d").padEnd(8)} ${emoDecay.toFixed(4).padEnd(14)} ${neuDecay.toFixed(4).padEnd(14)} +${advantage}%`);
+}
+
+// ── 4. computeDecayScore: full formula comparison ────────────
+
+console.log("\n" + DIVIDER);
+console.log("4️⃣  computeDecayScore: emotion-aware weights (0.15/0.25/0.45/0.15)");
+console.log(DIVIDER);
+
+const now = Date.now();
+const makeEvo = (ageDays: number, accessCount: number): EvolutionMetadata => ({
+  status: "active",
+  version: 1,
+  accessCount,
+  lastAccessedAt: now - 7 * 86_400_000,
+  supersededBy: null,
+  supersedes: null,
+  evolutionNote: null,
+  consolidatedInto: null,
+  contributedToPattern: null,
+  sourceMemories: [],
+  validFrom: now - ageDays * 86_400_000,
+  validUntil: null,
+});
+
+const scenarios = [
+  { label: "新记忆(7d), 3次访问, importance=0.7", age: 7, access: 3, importance: 0.7 },
+  { label: "旧记忆(60d), 3次访问, importance=0.7", age: 60, access: 3, importance: 0.7 },
+  { label: "很旧(120d), 低访问, importance=0.5", age: 120, access: 1, importance: 0.5 },
+];
+
+for (const sc of scenarios) {
+  const evo = makeEvo(sc.age, sc.access);
+  const emotionalMeta = JSON.stringify({
+    emotion: detectEmotion(emotionalText),
+  });
+  const neutralMeta = JSON.stringify({
+    emotion: detectEmotion(neutralText),
+  });
+
+  const emoScore = computeDecayScore(evo, sc.importance, now, emotionalMeta);
+  const neuScore = computeDecayScore(evo, sc.importance, now, neutralMeta);
+  const noMetaScore = computeDecayScore(evo, sc.importance, now); // backward compat
+
+  console.log(`\n  [${sc.label}]`);
+  console.log(`  emotional:  ${emoScore.toFixed(4)}`);
+  console.log(`  neutral:    ${neuScore.toFixed(4)}`);
+  console.log(`  no-meta:    ${noMetaScore.toFixed(4)}  (backward compat, base weights)`);
+  console.log(`  Δ emotion:  +${((emoScore / neuScore - 1) * 100).toFixed(1)}% vs neutral`);
+}
+
+// ── 5. parseEmotion backward compat ──────────────────────────
+
+console.log("\n" + DIVIDER);
+console.log("5️⃣  parseEmotion: backward compatibility");
+console.log(DIVIDER);
+
+const oldMeta = JSON.stringify({ emotion: { valence: 0.5, arousal: 0.3, label: "positive" } }); // no salience/source
+const newMeta = JSON.stringify({ emotion: { valence: 0.5, arousal: 0.3, label: "positive", salience: 0.4, source: "keyword" } });
+const noEmoMeta = JSON.stringify({ tier: "working" });
+
+console.log(`\n  old format (no salience): ${JSON.stringify(parseEmotion(oldMeta))}`);
+console.log(`  new format (with salience): ${JSON.stringify(parseEmotion(newMeta))}`);
+console.log(`  no emotion field: ${parseEmotion(noEmoMeta)}`);
+console.log(`  undefined: ${parseEmotion(undefined)}`);
+
+console.log("\n" + DIVIDER);
+console.log("✅ Phase 1 Verification Complete");
+console.log(DIVIDER + "\n");

package/src/__tests__/activity-counter.test.ts

@@ -0,0 +1,96 @@
+import { describe, it, expect, beforeEach, afterEach } from "bun:test";
+import { join } from "node:path";
+import { mkdirSync, rmSync, existsSync } from "node:fs";
+import {
+  incrementWriteCount,
+  getWriteCount,
+  resetWriteCount,
+  getDistillTier,
+  type ActivityCounterConfig,
+} from "../activity-counter.js";
+
+const TMP_DIR = join(import.meta.dir, "../../.tmp-activity-test");
+const testConfig: Partial<ActivityCounterConfig> = {
+  statsPath: join(TMP_DIR, "activity-stats.json"),
+  lightThreshold: 3,
+  standardThreshold: 10,
+  deepThreshold: 20,
+};
+
+describe("activity-counter (HP-3)", () => {
+  beforeEach(() => {
+    mkdirSync(TMP_DIR, { recursive: true });
+    // Ensure clean state
+    const p = testConfig.statsPath!;
+    if (existsSync(p)) rmSync(p);
+  });
+
+  afterEach(() => {
+    rmSync(TMP_DIR, { recursive: true, force: true });
+  });
+
+  describe("incrementWriteCount", () => {
+    it("starts at 0 and increments by 1", () => {
+      expect(getWriteCount(testConfig)).toBe(0);
+      expect(incrementWriteCount(1, testConfig)).toBe(1);
+      expect(incrementWriteCount(1, testConfig)).toBe(2);
+      expect(getWriteCount(testConfig)).toBe(2);
+    });
+
+    it("increments by arbitrary n", () => {
+      incrementWriteCount(5, testConfig);
+      expect(getWriteCount(testConfig)).toBe(5);
+      incrementWriteCount(3, testConfig);
+      expect(getWriteCount(testConfig)).toBe(8);
+    });
+  });
+
+  describe("resetWriteCount", () => {
+    it("resets count to 0", () => {
+      incrementWriteCount(7, testConfig);
+      expect(getWriteCount(testConfig)).toBe(7);
+      resetWriteCount(testConfig);
+      expect(getWriteCount(testConfig)).toBe(0);
+    });
+  });
+
+  describe("getDistillTier", () => {
+    it("returns 'none' when below light threshold", () => {
+      incrementWriteCount(2, testConfig);
+      expect(getDistillTier(testConfig)).toBe("none");
+    });
+
+    it("returns 'light' at light threshold", () => {
+      incrementWriteCount(3, testConfig);
+      expect(getDistillTier(testConfig)).toBe("light");
+    });
+
+    it("returns 'standard' at standard threshold", () => {
+      incrementWriteCount(10, testConfig);
+      expect(getDistillTier(testConfig)).toBe("standard");
+    });
+
+    it("returns 'deep' at deep threshold", () => {
+      incrementWriteCount(20, testConfig);
+      expect(getDistillTier(testConfig)).toBe("deep");
+    });
+
+    it("returns 'deep' well above deep threshold", () => {
+      incrementWriteCount(100, testConfig);
+      expect(getDistillTier(testConfig)).toBe("deep");
+    });
+  });
+
+  describe("resilience", () => {
+    it("handles missing stats file gracefully", () => {
+      expect(getWriteCount(testConfig)).toBe(0);
+      expect(getDistillTier(testConfig)).toBe("none");
+    });
+
+    it("handles corrupt stats file gracefully", () => {
+      const { writeFileSync } = require("node:fs");
+      writeFileSync(testConfig.statsPath!, "not-json{{{");
+      expect(getWriteCount(testConfig)).toBe(0);
+    });
+  });
+});

package/src/__tests__/admission-control.test.ts

@@ -0,0 +1,206 @@
+import { describe, expect, it } from "bun:test";
+
+import {
+  checkAdmission,
+  resolveAdmissionConfig,
+  ScopeRateLimiter,
+} from "../admission-control.js";
+
+// ---------------------------------------------------------------------------
+// resolveAdmissionConfig
+// ---------------------------------------------------------------------------
+
+describe("resolveAdmissionConfig", () => {
+  it("returns defaults when no overrides", () => {
+    const cfg = resolveAdmissionConfig();
+    expect(cfg.minTextLength).toBe(10);
+    expect(cfg.noiseFilterEnabled).toBe(true);
+    expect(cfg.minImportance).toBe(0.2);
+    expect(cfg.maxWritesPerScope).toBe(50);
+    expect(cfg.rateLimitWindowMs).toBe(60_000);
+  });
+
+  it("merges partial overrides", () => {
+    const cfg = resolveAdmissionConfig({ minImportance: 0.5 });
+    expect(cfg.minImportance).toBe(0.5);
+    expect(cfg.minTextLength).toBe(10); // unchanged
+  });
+});
+
+// ---------------------------------------------------------------------------
+// checkAdmission — text length
+// ---------------------------------------------------------------------------
+
+describe("checkAdmission — text length", () => {
+  it("rejects text shorter than minTextLength", () => {
+    const result = checkAdmission("short", 0.8, "project:test");
+    expect(result.verdict).toBe("rejected");
+    expect(result.reason).toBe("text_too_short");
+  });
+
+  it("rejects empty text", () => {
+    const result = checkAdmission("", 0.8, "project:test");
+    expect(result.verdict).toBe("rejected");
+    expect(result.reason).toBe("text_too_short");
+  });
+
+  it("rejects whitespace-only text", () => {
+    const result = checkAdmission("         ", 0.8, "project:test");
+    expect(result.verdict).toBe("rejected");
+    expect(result.reason).toBe("text_too_short");
+  });
+
+  it("accepts text at exactly minTextLength", () => {
+    const result = checkAdmission("abcdefghij", 0.8, "project:test");
+    expect(result.verdict).toBe("accepted");
+  });
+
+  it("respects custom minTextLength", () => {
+    const result = checkAdmission("hello world", 0.8, "project:test", undefined, { minTextLength: 20 });
+    expect(result.verdict).toBe("rejected");
+    expect(result.reason).toBe("text_too_short");
+  });
+});
+
+// ---------------------------------------------------------------------------
+// checkAdmission — noise filter
+// ---------------------------------------------------------------------------
+
+describe("checkAdmission — noise filter", () => {
+  it("rejects denial patterns", () => {
+    const result = checkAdmission("I don't have any information about that topic", 0.8, "project:test");
+    expect(result.verdict).toBe("rejected");
+    expect(result.reason).toBe("noise_detected");
+  });
+
+  it("rejects boilerplate greetings", () => {
+    const result = checkAdmission("hello there!", 0.8, "project:test");
+    expect(result.verdict).toBe("rejected");
+    expect(result.reason).toBe("noise_detected");
+  });
+
+  it("can be disabled via config", () => {
+    const result = checkAdmission(
+      "I don't have any information about that topic",
+      0.8,
+      "project:test",
+      undefined,
+      { noiseFilterEnabled: false },
+    );
+    expect(result.verdict).toBe("accepted");
+  });
+});
+
+// ---------------------------------------------------------------------------
+// checkAdmission — importance floor
+// ---------------------------------------------------------------------------
+
+describe("checkAdmission — importance floor", () => {
+  it("rejects importance below default threshold (0.2)", () => {
+    const result = checkAdmission("This is a valid memory text", 0.1, "project:test");
+    expect(result.verdict).toBe("rejected");
+    expect(result.reason).toBe("importance_too_low");
+  });
+
+  it("accepts importance at exactly the threshold", () => {
+    const result = checkAdmission("This is a valid memory text", 0.2, "project:test");
+    expect(result.verdict).toBe("accepted");
+  });
+
+  it("accepts importance above threshold", () => {
+    const result = checkAdmission("This is a valid memory text", 0.8, "project:test");
+    expect(result.verdict).toBe("accepted");
+  });
+
+  it("respects custom minImportance", () => {
+    const result = checkAdmission("This is a valid memory text", 0.4, "project:test", undefined, { minImportance: 0.5 });
+    expect(result.verdict).toBe("rejected");
+    expect(result.reason).toBe("importance_too_low");
+  });
+});
+
+// ---------------------------------------------------------------------------
+// ScopeRateLimiter
+// ---------------------------------------------------------------------------
+
+describe("ScopeRateLimiter", () => {
+  it("allows writes within limit", () => {
+    const limiter = new ScopeRateLimiter();
+    const cfg = resolveAdmissionConfig({ maxWritesPerScope: 3 });
+    expect(limiter.check("s1", cfg)).toBe(true);
+    expect(limiter.check("s1", cfg)).toBe(true);
+    expect(limiter.check("s1", cfg)).toBe(true);
+  });
+
+  it("blocks writes exceeding limit", () => {
+    const limiter = new ScopeRateLimiter();
+    const cfg = resolveAdmissionConfig({ maxWritesPerScope: 2 });
+    expect(limiter.check("s1", cfg)).toBe(true);
+    expect(limiter.check("s1", cfg)).toBe(true);
+    expect(limiter.check("s1", cfg)).toBe(false); // 3rd blocked
+  });
+
+  it("tracks scopes independently", () => {
+    const limiter = new ScopeRateLimiter();
+    const cfg = resolveAdmissionConfig({ maxWritesPerScope: 1 });
+    expect(limiter.check("s1", cfg)).toBe(true);
+    expect(limiter.check("s2", cfg)).toBe(true);
+    expect(limiter.check("s1", cfg)).toBe(false); // s1 exhausted
+    expect(limiter.check("s2", cfg)).toBe(false); // s2 exhausted
+  });
+
+  it("reports correct size", () => {
+    const limiter = new ScopeRateLimiter();
+    const cfg = resolveAdmissionConfig();
+    limiter.check("a", cfg);
+    limiter.check("b", cfg);
+    expect(limiter.size).toBe(2);
+  });
+
+  it("clears all state", () => {
+    const limiter = new ScopeRateLimiter();
+    const cfg = resolveAdmissionConfig();
+    limiter.check("a", cfg);
+    limiter.clear();
+    expect(limiter.size).toBe(0);
+  });
+});
+
+// ---------------------------------------------------------------------------
+// checkAdmission — rate limiting
+// ---------------------------------------------------------------------------
+
+describe("checkAdmission — rate limiting", () => {
+  it("rejects when rate limit exceeded", () => {
+    const limiter = new ScopeRateLimiter();
+    const cfg = { maxWritesPerScope: 2 } as const;
+    // First two pass
+    checkAdmission("valid memory text here", 0.8, "project:test", limiter, cfg);
+    checkAdmission("another valid memory text", 0.8, "project:test", limiter, cfg);
+    // Third is rate limited
+    const result = checkAdmission("yet another valid text", 0.8, "project:test", limiter, cfg);
+    expect(result.verdict).toBe("rejected");
+    expect(result.reason).toBe("rate_limited");
+  });
+
+  it("skips rate limiting when no limiter provided", () => {
+    const result = checkAdmission("valid memory text here", 0.8, "project:test");
+    expect(result.verdict).toBe("accepted");
+  });
+});
+
+// ---------------------------------------------------------------------------
+// checkAdmission — happy path
+// ---------------------------------------------------------------------------
+
+describe("checkAdmission — happy path", () => {
+  it("accepts valid memory with all checks passing", () => {
+    const result = checkAdmission(
+      "User prefers dark mode in all applications",
+      0.8,
+      "project:test",
+    );
+    expect(result.verdict).toBe("accepted");
+    expect(result.reason).toBeUndefined();
+  });
+});

package/src/__tests__/anchor-generator.test.ts

@@ -0,0 +1,67 @@
+import { describe, it, expect } from "bun:test";
+import { generateAnchor } from "../anchor-generator.js";
+
+describe("generateAnchor", () => {
+  it("returns undefined for short text (≤80 chars)", () => {
+    expect(generateAnchor("轮巡仓库每日检查")).toBeUndefined();
+    expect(generateAnchor("Short text that fits in 80 chars easily")).toBeUndefined();
+  });
+
+  it("extracts first sentence from long text", () => {
+    const text = "每天轮巡4个win4r仓库，检查Issue和PR。" +
+      "包括 ClawTeam-OpenClaw、openclaw-a2a-gateway、memory-lancedb-pro、UltraMemory。" +
+      "Issue 用中文回复，PR 用英文 review。不要重复回复已处理的。";
+    const anchor = generateAnchor(text);
+    expect(anchor).toBeDefined();
+    expect(anchor!.length).toBeLessThanOrEqual(80);
+    expect(anchor).toBe("每天轮巡4个win4r仓库，检查Issue和PR");
+  });
+
+  it("uses workflow pattern title from metadata", () => {
+    const text = "A very long workflow pattern description that spans multiple lines and paragraphs explaining the full procedure";
+    const metadata = {
+      workflowPattern: {
+        title: "Daily repo patrol",
+        trigger: "Every morning",
+      },
+    };
+    const anchor = generateAnchor(text, metadata);
+    expect(anchor).toBe("Daily repo patrol");
+  });
+
+  it("uses case memory title from metadata", () => {
+    const text = "A very long case description that spans multiple lines and paragraphs explaining the full case and its resolution";
+    const metadata = {
+      caseMemory: {
+        title: "Fix dedup over-kill in ingest",
+        problem: "72% of chunks were being dropped",
+      },
+    };
+    const anchor = generateAnchor(text, metadata);
+    expect(anchor).toBe("Fix dedup over-kill in ingest");
+  });
+
+  it("truncates long first sentences at CJK char boundary", () => {
+    const text = "这是一个非常非常非常非常非常非常非常非常非常非常非常非常非常非常长的第一句话，" +
+      "超过了八十个字符的限制需要被截断到合适的长度。" +
+      "第二句话在这里提供更多上下文信息用于测试截断功能是否正常工作。";
+    const anchor = generateAnchor(text);
+    expect(anchor).toBeDefined();
+    expect(anchor!.length).toBeLessThanOrEqual(80);
+  });
+
+  it("truncates long English sentences at word boundary", () => {
+    const text = "This is a very long first sentence that definitely exceeds the eighty character limit by quite a significant margin. Second sentence here.";
+    const anchor = generateAnchor(text);
+    expect(anchor).toBeDefined();
+    expect(anchor!.length).toBeLessThanOrEqual(80);
+    // Should not end mid-word
+    expect(anchor!).not.toMatch(/\s$/);
+  });
+
+  it("handles text with only newline separators", () => {
+    const text = "First line of important information that is a reasonable sentence\nSecond line with more details and context that expands on the first point";
+    const anchor = generateAnchor(text);
+    expect(anchor).toBe("First line of important information that is a reasonable sentence");
+  });
+});

package/src/__tests__/babel-integration.test.ts

@@ -0,0 +1,139 @@
+import { describe, expect, test, beforeAll, afterAll } from "bun:test";
+import {
+  detectLanguage,
+  tokenizeForFts,
+  initTokenizer,
+  getKgPrompt,
+  getSessionPrompt,
+} from "babel-memory";
+import { MemoryStore } from "../store.js";
+import { rmSync, mkdirSync } from "node:fs";
+import { join } from "node:path";
+import { tmpdir } from "node:os";
+
+beforeAll(async () => {
+  await initTokenizer();
+});
+
+describe("babel-memory integration", () => {
+  test("Chinese memory: language detected + fts_text tokenized", () => {
+    const text = "RecallNest 是一个基于 LanceDB 的 AI 记忆系统";
+    const language = detectLanguage(text);
+    const fts_text = tokenizeForFts(text, language);
+
+    expect(language).toBe("zh");
+    expect(fts_text).toContain("RecallNest");
+    expect(fts_text.includes(" ")).toBe(true);
+  });
+
+  test("English memory: language detected + fts_text unchanged", () => {
+    const text = "RecallNest is an AI memory system built on LanceDB";
+    const language = detectLanguage(text);
+    const fts_text = tokenizeForFts(text, language);
+
+    expect(language).toBe("en");
+    expect(fts_text).toBe(text);
+  });
+
+  test("BM25 query symmetry: tokenized query matches tokenized stored text", () => {
+    const storedText = "机器学习在自然语言处理中的应用";
+    const storedLang = detectLanguage(storedText);
+    const storedFts = tokenizeForFts(storedText, storedLang);
+
+    const query = "机器学习";
+    const queryLang = detectLanguage(query);
+    const queryFts = tokenizeForFts(query, queryLang);
+
+    const queryTerms = queryFts
+      .split(" ")
+      .filter((t) => t.length > 0);
+    const matchedTerms = queryTerms.filter((term) =>
+      storedFts.includes(term),
+    );
+    expect(matchedTerms.length).toBeGreaterThan(0);
+  });
+
+  test("KG prompt routes correctly for Chinese input", () => {
+    const text = "RecallNest 使用 LanceDB 存储记忆";
+    const lang = detectLanguage(text);
+    const { system } = getKgPrompt(lang);
+    expect(system).toContain("知识图谱");
+  });
+
+  test("Session prompt routes correctly for Chinese input", () => {
+    const text = "用户今天讨论了多语言支持方案";
+    const lang = detectLanguage(text);
+    const { dimensionLabels } = getSessionPrompt(lang);
+    expect(dimensionLabels.user_intent).toContain("用户意图");
+  });
+
+  test("backward compat: missing language defaults to en", () => {
+    const entry = { text: "some old text", language: undefined };
+    const lang = entry.language || "en";
+    const fts = tokenizeForFts(entry.text, lang);
+    expect(lang).toBe("en");
+    expect(fts).toBe(entry.text);
+  });
+});
+
+describe("store.update() preserves language + fts_text", () => {
+  const dbPath = join(tmpdir(), `recallnest-update-lang-test-${Date.now()}`);
+  let store: MemoryStore;
+
+  beforeAll(async () => {
+    mkdirSync(dbPath, { recursive: true });
+    store = new MemoryStore({ dbPath, vectorDim: 3 });
+    await (store as any).ensureInitialized();
+  });
+
+  afterAll(() => {
+    try { rmSync(dbPath, { recursive: true, force: true }); } catch {}
+  });
+
+  test("update preserves language and fts_text when not in updates", async () => {
+    const entry = await store.store({
+      text: "这是一条中文记忆",
+      vector: [0.1, 0.2, 0.3],
+      category: "events",
+      scope: "test:lang",
+      importance: 0.7,
+      metadata: "{}",
+      language: "zh",
+      fts_text: "这是 一条 中文 记忆",
+    });
+
+    // Update only text — language and fts_text should be preserved from old row
+    const updated = await store.update(entry.id, {
+      importance: 0.9,
+    });
+
+    expect(updated).not.toBeNull();
+    expect(updated!.language).toBe("zh");
+    expect(updated!.fts_text).toBe("这是 一条 中文 记忆");
+    expect(updated!.importance).toBe(0.9);
+  });
+
+  test("update overwrites language and fts_text when provided", async () => {
+    const entry = await store.store({
+      text: "old english text",
+      vector: [0.4, 0.5, 0.6],
+      category: "events",
+      scope: "test:lang",
+      importance: 0.6,
+      metadata: "{}",
+      language: "en",
+      fts_text: "old english text",
+    });
+
+    const updated = await store.update(entry.id, {
+      text: "新的中文文本",
+      language: "zh",
+      fts_text: "新的 中文 文本",
+    });
+
+    expect(updated).not.toBeNull();
+    expect(updated!.language).toBe("zh");
+    expect(updated!.fts_text).toBe("新的 中文 文本");
+    expect(updated!.text).toBe("新的中文文本");
+  });
+});