recallnest 1.4.1 → 2.2.0

package/src/__tests__/skill-promotion.test.ts

@@ -0,0 +1,349 @@
+import { describe, expect, it } from "bun:test";
+
+import { scanForPromotions, formatPromotionResult, type PromotionScanResult } from "../skill-promotion.js";
+import type { MemoryEntry, MemorySearchResult } from "../store.js";
+
+// ---------------------------------------------------------------------------
+// Mock Helpers
+// ---------------------------------------------------------------------------
+
+let idSeq = 0;
+
+function makeEntry(overrides: Partial<MemoryEntry> = {}): MemoryEntry {
+  idSeq += 1;
+  return {
+    id: `entry-${String(idSeq).padStart(4, "0")}`,
+    text: `Case about deploying to production #${idSeq}`,
+    vector: [1, 0, 0],
+    category: "cases",
+    scope: "project:test",
+    importance: 0.7,
+    timestamp: 1_700_000_000_000 + idSeq,
+    metadata: JSON.stringify({
+      evolution: {
+        status: "active",
+        version: 1,
+        accessCount: 0,
+        lastAccessedAt: null,
+        supersededBy: null,
+        consolidatedInto: null,
+        sourceMemories: [],
+        validFrom: Date.now(),
+        validUntil: null,
+      },
+    }),
+    ...overrides,
+  };
+}
+
+/** Create a vector that is similar to the base [1,0,0] with controlled similarity. */
+function similarVector(sim: number): number[] {
+  // For cosine similarity, we want cos(theta) = sim
+  // Use 2D vector [sim, sqrt(1-sim^2), 0] dot [1, 0, 0] = sim
+  const complement = Math.sqrt(1 - sim * sim);
+  return [sim, complement, 0];
+}
+
+function createMockStore(entries: MemoryEntry[]) {
+  return {
+    async list(
+      _scopeFilter?: string[],
+      _category?: string,
+      _limit?: number,
+      _offset?: number,
+    ): Promise<MemoryEntry[]> {
+      return entries;
+    },
+    async vectorSearch(
+      vector: number[],
+      limit = 5,
+      minScore = 0.3,
+      _scopeFilter?: string[],
+    ): Promise<MemorySearchResult[]> {
+      // Simple mock: return entries sorted by cosine similarity to vector
+      const scored = entries
+        .filter(e => e.vector?.length > 0)
+        .map(e => {
+          let dot = 0, normA = 0, normB = 0;
+          for (let i = 0; i < vector.length; i++) {
+            dot += vector[i] * (e.vector[i] ?? 0);
+            normA += vector[i] * vector[i];
+            normB += (e.vector[i] ?? 0) * (e.vector[i] ?? 0);
+          }
+          const score = (normA > 0 && normB > 0)
+            ? dot / (Math.sqrt(normA) * Math.sqrt(normB))
+            : 0;
+          return { entry: e, score };
+        })
+        .filter(r => r.score >= minScore)
+        .sort((a, b) => b.score - a.score)
+        .slice(0, limit);
+      return scored;
+    },
+  };
+}
+
+// ---------------------------------------------------------------------------
+// Tests
+// ---------------------------------------------------------------------------
+
+describe("scanForPromotions", () => {
+  it("returns 0 candidates for empty scope", async () => {
+    const store = createMockStore([]);
+    const result = await scanForPromotions(store, "project:empty");
+
+    expect(result.candidates).toHaveLength(0);
+    expect(result.scannedCases).toBe(0);
+    expect(result.scannedPatterns).toBe(0);
+  });
+
+  it("returns 0 candidates when fewer than minCaseOccurrences similar cases", async () => {
+    // Two cases with the same vector — below default threshold of 3
+    const entries = [
+      makeEntry({ vector: [1, 0, 0] }),
+      makeEntry({ vector: [0.99, 0.14, 0] }),
+    ];
+    const store = createMockStore(entries);
+    const result = await scanForPromotions(store, "project:test");
+
+    expect(result.candidates).toHaveLength(0);
+    expect(result.scannedCases).toBe(2);
+  });
+
+  it("produces case_to_pattern candidate when 3+ similar cases exist", async () => {
+    const entries = [
+      makeEntry({ text: "Deploy error: missing env var", vector: [1, 0, 0] }),
+      makeEntry({ text: "Deploy failure: env variable not set", vector: similarVector(0.95) }),
+      makeEntry({ text: "Deploy issue: environment config missing", vector: similarVector(0.90) }),
+    ];
+    const store = createMockStore(entries);
+    const result = await scanForPromotions(store, "project:test", {
+      minCaseOccurrences: 3,
+      caseSimilarityThreshold: 0.75,
+    });
+
+    expect(result.candidates.length).toBeGreaterThanOrEqual(1);
+    const caseCandidate = result.candidates.find(c => c.type === "case_to_pattern");
+    expect(caseCandidate).toBeDefined();
+    expect(caseCandidate!.sourceEntries.length).toBeGreaterThanOrEqual(3);
+    expect(caseCandidate!.suggestedName).toBeTruthy();
+    expect(caseCandidate!.suggestedDescription).toContain("cases");
+  });
+
+  it("does not produce candidates from dissimilar cases", async () => {
+    // 3 cases with very different vectors
+    const entries = [
+      makeEntry({ text: "Case A", vector: [1, 0, 0] }),
+      makeEntry({ text: "Case B", vector: [0, 1, 0] }),
+      makeEntry({ text: "Case C", vector: [0, 0, 1] }),
+    ];
+    const store = createMockStore(entries);
+    const result = await scanForPromotions(store, "project:test", {
+      minCaseOccurrences: 3,
+      caseSimilarityThreshold: 0.75,
+    });
+
+    expect(result.candidates).toHaveLength(0);
+  });
+
+  it("computes confidence using Bayesian smoothing", async () => {
+    // 4 similar cases: confidence = 4 / (4 + 2) = 0.667
+    const entries = [
+      makeEntry({ text: "Deploy error A", vector: [1, 0, 0] }),
+      makeEntry({ text: "Deploy error B", vector: similarVector(0.95) }),
+      makeEntry({ text: "Deploy error C", vector: similarVector(0.92) }),
+      makeEntry({ text: "Deploy error D", vector: similarVector(0.88) }),
+    ];
+    const store = createMockStore(entries);
+    const result = await scanForPromotions(store, "project:test", {
+      minCaseOccurrences: 3,
+      caseSimilarityThreshold: 0.75,
+    });
+
+    expect(result.candidates.length).toBeGreaterThanOrEqual(1);
+    const c = result.candidates[0];
+    // cluster of 4: confidence = 4/(4+2) = 0.6667
+    expect(c.confidence).toBeCloseTo(4 / 6, 2);
+  });
+
+  it("produces pattern_to_skill when pattern has steps and related cases", async () => {
+    const patternVec: number[] = [0.9, 0.43, 0]; // cos sim with [1,0,0] ~ 0.9
+    const entries = [
+      makeEntry({
+        category: "patterns",
+        text: "Production Deploy Pattern\n\nSteps:\n1. Check environment\n2. Run preflight\n3. Deploy containers",
+        vector: patternVec,
+      }),
+      makeEntry({ text: "Deploy case: ran preflight then deployed", vector: [1, 0, 0] }),
+      makeEntry({ text: "Deploy fix: environment check before push", vector: similarVector(0.88) }),
+    ];
+    const store = createMockStore(entries);
+    const result = await scanForPromotions(store, "project:test", {
+      caseSimilarityThreshold: 0.75,
+    });
+
+    const skillCandidate = result.candidates.find(c => c.type === "pattern_to_skill");
+    expect(skillCandidate).toBeDefined();
+    expect(skillCandidate!.suggestedImplementation).toContain("Check environment");
+    expect(skillCandidate!.sourceEntries.length).toBeGreaterThanOrEqual(3); // pattern + 2 cases
+  });
+
+  it("does not produce pattern_to_skill when pattern lacks structured steps", async () => {
+    const patternVec: number[] = [0.9, 0.43, 0];
+    const entries = [
+      makeEntry({
+        category: "patterns",
+        text: "Just a general note about deploying without structured steps",
+        vector: patternVec,
+      }),
+      makeEntry({ text: "Deploy case one", vector: [1, 0, 0] }),
+      makeEntry({ text: "Deploy case two", vector: similarVector(0.88) }),
+    ];
+    const store = createMockStore(entries);
+    const result = await scanForPromotions(store, "project:test", {
+      caseSimilarityThreshold: 0.75,
+    });
+
+    const skillCandidate = result.candidates.find(c => c.type === "pattern_to_skill");
+    expect(skillCandidate).toBeUndefined();
+  });
+
+  it("respects maxCandidates limit", async () => {
+    // Create two distinct clusters of 3, but set maxCandidates=1
+    const entries = [
+      // Cluster 1
+      makeEntry({ text: "Deploy A", vector: [1, 0, 0] }),
+      makeEntry({ text: "Deploy B", vector: similarVector(0.95) }),
+      makeEntry({ text: "Deploy C", vector: similarVector(0.90) }),
+      // Cluster 2
+      makeEntry({ text: "Auth fix A", vector: [0, 1, 0] }),
+      makeEntry({ text: "Auth fix B", vector: [0.1, 0.99, 0] }),
+      makeEntry({ text: "Auth fix C", vector: [0.15, 0.98, 0] }),
+    ];
+    const store = createMockStore(entries);
+    const result = await scanForPromotions(store, "project:test", {
+      minCaseOccurrences: 3,
+      caseSimilarityThreshold: 0.75,
+      maxCandidates: 1,
+    });
+
+    expect(result.candidates).toHaveLength(1);
+  });
+
+  it("filters out archived entries", async () => {
+    const archivedMeta = JSON.stringify({
+      evolution: {
+        status: "archived",
+        version: 1,
+        accessCount: 0,
+        lastAccessedAt: null,
+        supersededBy: null,
+        consolidatedInto: null,
+        sourceMemories: [],
+        validFrom: Date.now(),
+        validUntil: null,
+      },
+    });
+    const entries = [
+      makeEntry({ text: "Active case", vector: [1, 0, 0] }),
+      makeEntry({ text: "Archived case", vector: similarVector(0.95), metadata: archivedMeta }),
+      makeEntry({ text: "Another archived", vector: similarVector(0.90), metadata: archivedMeta }),
+    ];
+    const store = createMockStore(entries);
+    const result = await scanForPromotions(store, "project:test", {
+      minCaseOccurrences: 3,
+    });
+
+    // Only 1 active case, so no candidates
+    expect(result.candidates).toHaveLength(0);
+    expect(result.scannedCases).toBe(1);
+  });
+
+  it("skips entries without vectors", async () => {
+    const entries = [
+      makeEntry({ text: "No vector case A", vector: [] }),
+      makeEntry({ text: "No vector case B", vector: [] }),
+      makeEntry({ text: "No vector case C", vector: [] }),
+    ];
+    const store = createMockStore(entries);
+    const result = await scanForPromotions(store, "project:test");
+
+    expect(result.candidates).toHaveLength(0);
+  });
+
+  it("candidates are sorted by confidence descending", async () => {
+    // Cluster 1: 5 similar cases -> confidence 5/7
+    // Cluster 2: 3 similar cases -> confidence 3/5
+    const entries = [
+      // Large cluster
+      makeEntry({ text: "Deploy err 1", vector: [1, 0, 0] }),
+      makeEntry({ text: "Deploy err 2", vector: similarVector(0.95) }),
+      makeEntry({ text: "Deploy err 3", vector: similarVector(0.93) }),
+      makeEntry({ text: "Deploy err 4", vector: similarVector(0.91) }),
+      makeEntry({ text: "Deploy err 5", vector: similarVector(0.89) }),
+      // Small cluster (orthogonal direction)
+      makeEntry({ text: "Auth bug 1", vector: [0, 1, 0] }),
+      makeEntry({ text: "Auth bug 2", vector: [0.1, 0.99, 0] }),
+      makeEntry({ text: "Auth bug 3", vector: [0.15, 0.98, 0] }),
+    ];
+    const store = createMockStore(entries);
+    const result = await scanForPromotions(store, "project:test", {
+      minCaseOccurrences: 3,
+      caseSimilarityThreshold: 0.75,
+    });
+
+    if (result.candidates.length >= 2) {
+      expect(result.candidates[0].confidence).toBeGreaterThanOrEqual(result.candidates[1].confidence);
+    }
+  });
+});
+
+describe("formatPromotionResult", () => {
+  it("formats empty results", () => {
+    const result: PromotionScanResult = {
+      candidates: [],
+      scannedCases: 5,
+      scannedPatterns: 2,
+    };
+    const text = formatPromotionResult(result);
+    expect(text).toContain("5 cases");
+    expect(text).toContain("2 patterns");
+    expect(text).toContain("No promotion candidates found");
+  });
+
+  it("formats candidates with type and confidence", () => {
+    const result: PromotionScanResult = {
+      candidates: [{
+        type: "case_to_pattern",
+        sourceEntries: [{ id: "a", text: "test", score: 0.9 }],
+        suggestedName: "Test Pattern",
+        suggestedDescription: "A test",
+        confidence: 0.6,
+      }],
+      scannedCases: 3,
+      scannedPatterns: 1,
+    };
+    const text = formatPromotionResult(result);
+    expect(text).toContain("case_to_pattern");
+    expect(text).toContain("Test Pattern");
+    expect(text).toContain("60.0%");
+  });
+
+  it("includes implementation in pattern_to_skill output", () => {
+    const result: PromotionScanResult = {
+      candidates: [{
+        type: "pattern_to_skill",
+        sourceEntries: [{ id: "a", text: "test", score: 1.0 }],
+        suggestedName: "Deploy Skill",
+        suggestedDescription: "Deploy automation",
+        suggestedImplementation: "1. Check env\n2. Deploy",
+        confidence: 0.5,
+      }],
+      scannedCases: 2,
+      scannedPatterns: 1,
+    };
+    const text = formatPromotionResult(result);
+    expect(text).toContain("1. Check env");
+    expect(text).toContain("Implementation:");
+  });
+});

package/src/__tests__/supersede-chain.test.ts

@@ -0,0 +1,154 @@
+import { describe, it, expect } from "bun:test";
+import {
+  buildSupersedeMetadata,
+  buildSupersedeMetadataForNew,
+  parseEvolution,
+  traceEvolution,
+  patchEvolution,
+  defaultEvolution,
+} from "../memory-evolution.js";
+
+describe("HP-1: Superseded chain enhancement", () => {
+  describe("bidirectional linking", () => {
+    it("buildSupersedeMetadata marks old → supersededBy", () => {
+      const oldMeta = patchEvolution("{}", defaultEvolution());
+      const result = buildSupersedeMetadata(oldMeta, "new-id");
+      const evo = parseEvolution(result);
+      expect(evo.status).toBe("superseded");
+      expect(evo.supersededBy).toBe("new-id");
+      expect(evo.validUntil).toBeGreaterThan(0);
+    });
+
+    it("buildSupersedeMetadataForNew marks new → supersedes + note", () => {
+      const newMeta = patchEvolution("{}", defaultEvolution());
+      const result = buildSupersedeMetadataForNew(newMeta, "old-id", "updated preference");
+      const evo = parseEvolution(result);
+      expect(evo.status).toBe("active"); // new memory stays active
+      expect(evo.supersedes).toBe("old-id");
+      expect(evo.evolutionNote).toBe("updated preference");
+    });
+
+    it("bidirectional: old.supersededBy == new.id AND new.supersedes == old.id", () => {
+      const oldMeta = patchEvolution("{}", defaultEvolution());
+      const newMeta = patchEvolution("{}", defaultEvolution());
+
+      const updatedOld = buildSupersedeMetadata(oldMeta, "new-id");
+      const updatedNew = buildSupersedeMetadataForNew(newMeta, "old-id");
+
+      const oldEvo = parseEvolution(updatedOld);
+      const newEvo = parseEvolution(updatedNew);
+
+      expect(oldEvo.supersededBy).toBe("new-id");
+      expect(newEvo.supersedes).toBe("old-id");
+    });
+  });
+
+  describe("traceEvolution", () => {
+    it("traces a 3-node chain", async () => {
+      // v1 → v2 → v3
+      const entries: Record<string, { metadata: string; timestamp: number }> = {
+        v1: {
+          metadata: patchEvolution("{}", {
+            status: "superseded",
+            supersededBy: "v2",
+            validFrom: 1000,
+            validUntil: 2000,
+          }),
+          timestamp: 1000,
+        },
+        v2: {
+          metadata: patchEvolution("{}", {
+            status: "superseded",
+            supersedes: "v1",
+            supersededBy: "v3",
+            evolutionNote: "added detail",
+            validFrom: 2000,
+            validUntil: 3000,
+          }),
+          timestamp: 2000,
+        },
+        v3: {
+          metadata: patchEvolution("{}", {
+            status: "active",
+            supersedes: "v2",
+            evolutionNote: "corrected error",
+            validFrom: 3000,
+          }),
+          timestamp: 3000,
+        },
+      };
+
+      const getEntry = async (id: string) => entries[id] ?? null;
+
+      // Trace from v2 (middle)
+      const trace = await traceEvolution("v2", getEntry);
+      expect(trace.length).toBe(3);
+      expect(trace[0].id).toBe("v1");
+      expect(trace[0].direction).toBe("predecessor");
+      expect(trace[1].id).toBe("v2");
+      expect(trace[1].direction).toBe("self");
+      expect(trace[2].id).toBe("v3");
+      expect(trace[2].direction).toBe("successor");
+    });
+
+    it("handles single node (no chain)", async () => {
+      const getEntry = async (id: string) => {
+        if (id === "solo") return { metadata: patchEvolution("{}", defaultEvolution()), timestamp: 1000 };
+        return null;
+      };
+
+      const trace = await traceEvolution("solo", getEntry);
+      expect(trace.length).toBe(1);
+      expect(trace[0].direction).toBe("self");
+    });
+
+    it("respects maxDepth", async () => {
+      // Create a long chain: v0 → v1 → v2 → ... → v20
+      const entries: Record<string, { metadata: string; timestamp: number }> = {};
+      for (let i = 0; i <= 20; i++) {
+        entries[`v${i}`] = {
+          metadata: patchEvolution("{}", {
+            status: i < 20 ? "superseded" : "active",
+            supersedes: i > 0 ? `v${i - 1}` : null,
+            supersededBy: i < 20 ? `v${i + 1}` : null,
+            validFrom: i * 1000,
+          }),
+          timestamp: i * 1000,
+        };
+      }
+
+      const getEntry = async (id: string) => entries[id] ?? null;
+      const trace = await traceEvolution("v10", getEntry, 3);
+      // maxDepth=3: at most 3 predecessors + self + 3 successors = 7
+      expect(trace.length).toBeLessThanOrEqual(7);
+    });
+
+    it("handles missing entries gracefully", async () => {
+      const entries: Record<string, { metadata: string; timestamp: number }> = {
+        v1: {
+          metadata: patchEvolution("{}", {
+            status: "active",
+            supersedes: "missing",
+            validFrom: 1000,
+          }),
+          timestamp: 1000,
+        },
+      };
+      const getEntry = async (id: string) => entries[id] ?? null;
+      const trace = await traceEvolution("v1", getEntry);
+      expect(trace.length).toBe(1); // only self, missing predecessor stops chain
+    });
+  });
+
+  describe("backward compatibility", () => {
+    it("parseEvolution defaults new fields to null", () => {
+      // Old metadata without supersedes/evolutionNote
+      const oldMeta = JSON.stringify({
+        evolution: { status: "active", version: 1, accessCount: 0 },
+      });
+      const evo = parseEvolution(oldMeta);
+      expect(evo.supersedes).toBeNull();
+      expect(evo.evolutionNote).toBeNull();
+    });
+  });
+});

package/src/__tests__/temporal-validity.test.ts

@@ -0,0 +1,160 @@
+/**
+ * F3: Temporal Validity Windows — tests for eventTime, validUntil,
+ * retrieval filtering, and auto-GC decay acceleration.
+ */
+
+import { describe, expect, test } from "bun:test";
+import {
+  defaultEvolution,
+  parseEvolution,
+  patchEvolution,
+  type EvolutionMetadata,
+} from "../memory-evolution.js";
+
+// ---------------------------------------------------------------------------
+// Schema: eventTime field
+// ---------------------------------------------------------------------------
+
+describe("F3: eventTime in EvolutionMetadata", () => {
+  test("defaultEvolution includes eventTime: null", () => {
+    const evo = defaultEvolution(1000);
+    expect(evo.eventTime).toBeNull();
+    expect(evo.validFrom).toBe(1000);
+    expect(evo.validUntil).toBeNull();
+  });
+
+  test("parseEvolution extracts eventTime from metadata", () => {
+    const metadata = JSON.stringify({
+      evolution: {
+        status: "active",
+        version: 1,
+        accessCount: 0,
+        lastAccessedAt: null,
+        supersededBy: null,
+        supersedes: null,
+        evolutionNote: null,
+        consolidatedInto: null,
+        contributedToPattern: null,
+        sourceMemories: [],
+        validFrom: 1000,
+        validUntil: null,
+        eventTime: 5000,
+      },
+    });
+    const evo = parseEvolution(metadata);
+    expect(evo.eventTime).toBe(5000);
+  });
+
+  test("parseEvolution defaults eventTime to null when missing", () => {
+    const metadata = JSON.stringify({
+      evolution: {
+        status: "active",
+        version: 1,
+        validFrom: 1000,
+      },
+    });
+    const evo = parseEvolution(metadata);
+    expect(evo.eventTime).toBeNull();
+  });
+
+  test("patchEvolution can set eventTime", () => {
+    const metadata = JSON.stringify({ evolution: defaultEvolution(1000) });
+    const patched = patchEvolution(metadata, { eventTime: 9999 });
+    const evo = parseEvolution(patched);
+    expect(evo.eventTime).toBe(9999);
+  });
+
+  test("patchEvolution can set validUntil", () => {
+    const metadata = JSON.stringify({ evolution: defaultEvolution(1000) });
+    const patched = patchEvolution(metadata, { validUntil: 2000 });
+    const evo = parseEvolution(patched);
+    expect(evo.validUntil).toBe(2000);
+    // Other fields unchanged
+    expect(evo.validFrom).toBe(1000);
+    expect(evo.status).toBe("active");
+  });
+});
+
+// ---------------------------------------------------------------------------
+// Retrieval: filterByValidity (unit-level via import)
+// ---------------------------------------------------------------------------
+
+// We test the filterByValidity logic indirectly through the exported
+// parseEvolution + the contract: expired memories get score * 0.2.
+// Direct integration tested via full retriever in separate test files.
+
+describe("F3: validity window logic", () => {
+  function makeEvo(overrides: Partial<EvolutionMetadata> = {}): EvolutionMetadata {
+    return { ...defaultEvolution(1000), ...overrides };
+  }
+
+  test("memory with validUntil in the future is not expired", () => {
+    const now = 5000;
+    const evo = makeEvo({ validUntil: 10000 });
+    // validUntil > now → not expired
+    expect(evo.validUntil).toBeGreaterThan(now);
+  });
+
+  test("memory with validUntil in the past is expired", () => {
+    const now = 5000;
+    const evo = makeEvo({ validUntil: 3000 });
+    // validUntil < now → expired
+    expect(evo.validUntil).toBeLessThan(now);
+  });
+
+  test("memory without validUntil never expires", () => {
+    const evo = makeEvo({ validUntil: null });
+    expect(evo.validUntil).toBeNull();
+  });
+
+  test("point-in-time query: memory valid in range", () => {
+    const evo = makeEvo({ validFrom: 1000, validUntil: 5000 });
+    const queryTime = 3000;
+    expect(evo.validFrom).toBeLessThanOrEqual(queryTime);
+    expect(evo.validUntil).toBeGreaterThanOrEqual(queryTime);
+  });
+
+  test("point-in-time query: memory not yet valid", () => {
+    const evo = makeEvo({ validFrom: 5000, validUntil: 10000 });
+    const queryTime = 3000;
+    expect(evo.validFrom).toBeGreaterThan(queryTime);
+  });
+
+  test("point-in-time query: memory already expired at query time", () => {
+    const evo = makeEvo({ validFrom: 1000, validUntil: 3000 });
+    const queryTime = 5000;
+    expect(evo.validUntil).toBeLessThan(queryTime);
+  });
+});
+
+// ---------------------------------------------------------------------------
+// Auto-GC: decay acceleration for expired memories
+// ---------------------------------------------------------------------------
+
+describe("F3: GC decay acceleration", () => {
+  test("expired memory decay score is halved", () => {
+    // Simulate the GC logic: if validUntil < now, decayScore *= 0.5
+    const baseDecayScore = 0.30;
+    const now = 10000;
+    const validUntil = 5000; // expired
+    const adjusted = validUntil < now ? baseDecayScore * 0.5 : baseDecayScore;
+    expect(adjusted).toBe(0.15);
+  });
+
+  test("non-expired memory decay score unchanged", () => {
+    const baseDecayScore = 0.30;
+    const now = 10000;
+    const validUntil = 20000; // still valid
+    const adjusted = validUntil < now ? baseDecayScore * 0.5 : baseDecayScore;
+    expect(adjusted).toBe(0.30);
+  });
+
+  test("memory without validUntil — decay score unchanged", () => {
+    const baseDecayScore = 0.30;
+    const validUntil = null;
+    const adjusted = (validUntil != null && validUntil < Date.now())
+      ? baseDecayScore * 0.5
+      : baseDecayScore;
+    expect(adjusted).toBe(0.30);
+  });
+});