Skip to content

#1 Persistent memory for AI coding agents based on real-world benchmarks

perf(consolidation): write only decayed rows that changed (#1417)

Rohit Ghumaree69a606e8faf
diff --git a/src/functions/consolidation-pipeline.ts b/src/functions/consolidation-pipeline.ts
index 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.ts
index 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.ts
index 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);
+ });
+});