#1 Persistent memory for AI coding agents based on real-world benchmarks
TypeScript agentmemoryagentsaiclaudeclaudecodecodexcopilotcursorgenaiharnesshermesmemoryompopenclawopencodepi
perf(consolidation): write only decayed rows that changed (#1417)
Rohit Ghumaree69a606e8faf
diff --git a/src/functions/consolidation-pipeline.ts b/src/functions/consolidation-pipeline.tsindex 65a23767..2a480dc9 100644--- a/src/functions/consolidation-pipeline.ts+++ b/src/functions/consolidation-pipeline.ts@@ -24,6 +24,7 @@ function applyDecay(strength: number;lastAccessedAt?: string;updatedAt: string;+ lastDecayedAt?: string;}>,decayDays: number,): void {@@ -31,18 +32,52 @@ function applyDecay(const now = Date.now();for (const item of items) {const lastAccess = item.lastAccessedAt || item.updatedAt;- const daysSince =- (now - new Date(lastAccess).getTime()) / (1000 * 60 * 60 * 24);+ const lastAccessTime = new Date(lastAccess).getTime();+ const lastDecayedTime = item.lastDecayedAt+ ? new Date(item.lastDecayedAt).getTime()+ : -Infinity;+ const anchor = Math.max(lastAccessTime, lastDecayedTime);+ const daysSince = (now - anchor) / (1000 * 60 * 60 * 24);if (daysSince > decayDays) {const decayPeriods = Math.floor(daysSince / decayDays);item.strength = Math.max(0.1,item.strength * Math.pow(0.9, decayPeriods),);+ item.lastDecayedAt = new Date(now).toISOString();}}}+const DECAY_STRENGTH_EPSILON = 1e-9;++function strengthChanged(before: number, after: number): boolean {+ return Math.abs(after - before) > DECAY_STRENGTH_EPSILON;+}++async function decayAndWriteChanged<+ T extends {+ id: string;+ strength: number;+ lastAccessedAt?: string;+ updatedAt: string;+ lastDecayedAt?: string;+ },+>(+ kv: StateKV,+ scope: string,+ items: T[],+ decayDays: number,+): Promise<{ scanned: number; written: number }> {+ const before = items.map((item) => item.strength);+ applyDecay(items, decayDays);+ const dirty = items.filter((item, i) => strengthChanged(before[i], item.strength));+ for (const item of dirty) {+ await kv.set(scope, item.id, item);+ }+ return { scanned: items.length, written: dirty.length };+}+export function registerConsolidationPipelineFunction(sdk: IIIClient,kv: StateKV,@@ -231,20 +266,24 @@ export function registerConsolidationPipelineFunction(if (tier === "all" || tier === "decay") {const semantic = await kv.list<SemanticMemory>(KV.semantic);- applyDecay(semantic, decayDays);- for (const s of semantic) {- await kv.set(KV.semantic, s.id, s);- }-const procedural = await kv.list<ProceduralMemory>(KV.procedural);- applyDecay(procedural, decayDays);- for (const p of procedural) {- await kv.set(KV.procedural, p.id, p);- }++ const semanticResult = await decayAndWriteChanged(+ kv,+ KV.semantic,+ semantic,+ decayDays,+ );+ const proceduralResult = await decayAndWriteChanged(+ kv,+ KV.procedural,+ procedural,+ decayDays,+ );results.decay = {- semantic: semantic.length,- procedural: procedural.length,+ semantic: semanticResult,+ procedural: proceduralResult,};}diff --git a/src/types.ts b/src/types.tsindex 38b385f0..4ee305bc 100644--- a/src/types.ts+++ b/src/types.ts@@ -530,6 +530,7 @@ export interface SemanticMemory {strength: number;createdAt: string;updatedAt: string;+ lastDecayedAt?: string;}export interface ProceduralMemory {@@ -546,6 +547,7 @@ export interface ProceduralMemory {strength: number;createdAt: string;updatedAt: string;+ lastDecayedAt?: string;}export interface TeamConfig {diff --git a/test/consolidation-pipeline.test.ts b/test/consolidation-pipeline.test.tsindex 5f72090c..2bdd77da 100644--- a/test/consolidation-pipeline.test.ts+++ b/test/consolidation-pipeline.test.ts@@ -1,4 +1,4 @@-import { describe, it, expect, beforeEach, vi } from "vitest";+import { describe, it, expect, beforeEach, afterEach, vi } from "vitest";vi.mock("../src/logger.js", () => ({logger: { info: vi.fn(), warn: vi.fn(), error: vi.fn() },@@ -83,6 +83,39 @@ function makePattern(i: number): Memory {};}+function makeSemanticMemory(overrides: Partial<SemanticMemory> = {}): SemanticMemory {+ const now = new Date().toISOString();+ return {+ id: "sem_1",+ fact: "TypeScript is the primary language",+ confidence: 0.9,+ sourceSessionIds: [],+ sourceMemoryIds: [],+ accessCount: 1,+ lastAccessedAt: now,+ strength: 1,+ createdAt: now,+ updatedAt: now,+ ...overrides,+ };+}++function makeProceduralMemory(overrides: Partial<ProceduralMemory> = {}): ProceduralMemory {+ const now = new Date().toISOString();+ return {+ id: "proc_1",+ name: "Test Workflow",+ steps: ["step 1"],+ triggerCondition: "always",+ frequency: 1,+ sourceSessionIds: [],+ strength: 1,+ createdAt: now,+ updatedAt: now,+ ...overrides,+ };+}+describe("Consolidation Pipeline", () => {let sdk: ReturnType<typeof mockSdk>;let kv: ReturnType<typeof mockKV>;@@ -250,3 +283,145 @@ describe("Consolidation Pipeline", () => {vi.mocked(isConsolidationEnabled).mockReturnValue(true);});});++describe("Consolidation Pipeline decay tier", () => {+ let sdk: ReturnType<typeof mockSdk>;+ let kv: ReturnType<typeof mockKV>;++ beforeEach(() => {+ sdk = mockSdk();+ kv = mockKV();+ vi.useFakeTimers();+ vi.setSystemTime(new Date("2026-01-01T00:00:00Z"));+ });++ afterEach(() => {+ vi.useRealTimers();+ });++ it("does not write rows whose decay is not yet due", async () => {+ const provider = { name: "test", compress: vi.fn(), summarize: vi.fn() };+ registerConsolidationPipelineFunction(sdk as never, kv as never, provider as never);++ await kv.set(+ "mem:semantic",+ "sem_1",+ makeSemanticMemory({ id: "sem_1", lastAccessedAt: new Date().toISOString(), strength: 1 }),+ );+ await kv.set(+ "mem:procedural",+ "proc_1",+ makeProceduralMemory({ id: "proc_1", updatedAt: new Date().toISOString(), strength: 1 }),+ );++ const setSpy = vi.spyOn(kv, "set");++ const result = (await sdk.trigger("mem::consolidate-pipeline", {+ tier: "decay",+ })) as { success: boolean; results: Record<string, unknown> };++ expect(result.success).toBe(true);+ const memoryWriteCalls = setSpy.mock.calls.filter(+ (c) => c[0] === "mem:semantic" || c[0] === "mem:procedural",+ );+ expect(memoryWriteCalls.length).toBe(0);+ expect(result.results.decay).toEqual({+ semantic: { scanned: 1, written: 0 },+ procedural: { scanned: 1, written: 0 },+ });++ const storedSemantic = await kv.list<SemanticMemory>("mem:semantic");+ const storedProcedural = await kv.list<ProceduralMemory>("mem:procedural");+ expect(storedSemantic[0].strength).toBe(1);+ expect(storedProcedural[0].strength).toBe(1);+ });++ it("writes only rows whose decayed strength actually changed", async () => {+ const provider = { name: "test", compress: vi.fn(), summarize: vi.fn() };+ registerConsolidationPipelineFunction(sdk as never, kv as never, provider as never);++ const staleAccess = new Date(Date.now() - 45 * 86400000).toISOString();+ const freshAccess = new Date().toISOString();++ await kv.set(+ "mem:semantic",+ "sem_stale",+ makeSemanticMemory({ id: "sem_stale", lastAccessedAt: staleAccess, strength: 1 }),+ );+ await kv.set(+ "mem:semantic",+ "sem_fresh",+ makeSemanticMemory({ id: "sem_fresh", lastAccessedAt: freshAccess, strength: 1 }),+ );++ const setSpy = vi.spyOn(kv, "set");++ const result = (await sdk.trigger("mem::consolidate-pipeline", {+ tier: "decay",+ })) as { success: boolean; results: Record<string, unknown> };++ expect(result.success).toBe(true);+ const decay = result.results.decay as {+ semantic: { scanned: number; written: number };+ procedural: { scanned: number; written: number };+ };+ expect(decay.semantic).toEqual({ scanned: 2, written: 1 });+ expect(decay.procedural).toEqual({ scanned: 0, written: 0 });++ const semanticSetCalls = setSpy.mock.calls.filter((c) => c[0] === "mem:semantic");+ expect(semanticSetCalls.length).toBe(1);+ expect(semanticSetCalls[0][1]).toBe("sem_stale");++ const stored = await kv.list<SemanticMemory>("mem:semantic");+ const stale = stored.find((s) => s.id === "sem_stale");+ const fresh = stored.find((s) => s.id === "sem_fresh");+ expect(stale?.strength).toBeCloseTo(0.9, 10);+ expect(fresh?.strength).toBe(1);+ });++ it("decays at most once per period, anchored to the previous decay", async () => {+ const provider = { name: "test", compress: vi.fn(), summarize: vi.fn() };+ registerConsolidationPipelineFunction(sdk as never, kv as never, provider as never);++ const createdAt = new Date().toISOString();+ await kv.set(+ "mem:semantic",+ "sem_1",+ makeSemanticMemory({ id: "sem_1", lastAccessedAt: createdAt, strength: 1 }),+ );++ const setSpy = vi.spyOn(kv, "set");+ const semanticWrites = () =>+ setSpy.mock.calls.filter((c) => c[0] === "mem:semantic" && c[1] === "sem_1");++ await sdk.trigger("mem::consolidate-pipeline", { tier: "decay" });+ let stored = await kv.list<SemanticMemory>("mem:semantic");+ expect(stored[0].strength).toBe(1);+ expect(stored[0].lastDecayedAt).toBeUndefined();+ expect(semanticWrites().length).toBe(0);++ const day45 = new Date(new Date(createdAt).getTime() + 45 * 86400000);+ vi.setSystemTime(day45);+ await sdk.trigger("mem::consolidate-pipeline", { tier: "decay" });+ stored = await kv.list<SemanticMemory>("mem:semantic");+ expect(stored[0].strength).toBeCloseTo(0.9, 10);+ expect(stored[0].lastDecayedAt).toBe(day45.toISOString());+ expect(semanticWrites().length).toBe(1);++ const day50 = new Date(new Date(createdAt).getTime() + 50 * 86400000);+ vi.setSystemTime(day50);+ await sdk.trigger("mem::consolidate-pipeline", { tier: "decay" });+ stored = await kv.list<SemanticMemory>("mem:semantic");+ expect(stored[0].strength).toBeCloseTo(0.9, 10);+ expect(stored[0].lastDecayedAt).toBe(day45.toISOString());+ expect(semanticWrites().length).toBe(1);++ const day95 = new Date(new Date(createdAt).getTime() + 95 * 86400000);+ vi.setSystemTime(day95);+ await sdk.trigger("mem::consolidate-pipeline", { tier: "decay" });+ stored = await kv.list<SemanticMemory>("mem:semantic");+ expect(stored[0].strength).toBeCloseTo(0.81, 10);+ expect(stored[0].lastDecayedAt).toBe(day95.toISOString());+ expect(semanticWrites().length).toBe(2);+ });+});