memory decay + pruning (auto+man)

Author: tatoalo

apps/code/src/main/services/memory/service.ts

@@ -8,20 +8,33 @@ import { logger } from "../../utils/logger";
 
 const log = logger.scope("memory");
 
+const MAINTENANCE_INTERVAL_MS = 6 * 60 * 60 * 1000; // 6 hours
+const DECAY_RATE = 0.02;
+const DECAY_MIN_AGE_DAYS = 1;
+const PRUNE_THRESHOLD = 0.1;
+const PRUNE_MIN_AGE_DAYS = 30;
+
 function getDataDir(): string {
   return join(app.getPath("userData"), "memory");
 }
 
 @injectable()
 export class MemoryService {
   private svc: AgentMemoryService | null = null;
+  private maintenanceTimer: ReturnType<typeof setInterval> | null = null;
 
   @postConstruct()
   initialize(): void {
     const dataDir = getDataDir();
     log.info("Initializing memory service", { dataDir });
     this.svc = new AgentMemoryService({ dataDir });
     log.info("Memory service ready", { count: this.svc.count() });
+
+    this.runMaintenance();
+    this.maintenanceTimer = setInterval(
+      () => this.runMaintenance(),
+      MAINTENANCE_INTERVAL_MS,
+    );
   }
 
   get service(): AgentMemoryService {
@@ -81,8 +94,28 @@ export class MemoryService {
     return this.service.getAssociations(memoryId);
   }
 
+  runMaintenance(): { decayed: number; pruned: number } {
+    try {
+      const decayed = this.service.decayImportance(
+        DECAY_RATE,
+        DECAY_MIN_AGE_DAYS,
+      );
+      const pruned = this.service.prune(PRUNE_THRESHOLD, PRUNE_MIN_AGE_DAYS);
+      const total = this.service.count();
+      log.info("Memory maintenance complete", { decayed, pruned, total });
+      return { decayed, pruned };
+    } catch (error) {
+      log.error("Memory maintenance failed", { error });
+      return { decayed: 0, pruned: 0 };
+    }
+  }
+
   @preDestroy()
   close(): void {
+    if (this.maintenanceTimer) {
+      clearInterval(this.maintenanceTimer);
+      this.maintenanceTimer = null;
+    }
     if (this.svc) {
       log.info("Closing memory service");
       this.svc.close();

apps/code/src/main/trpc/routers/memory.ts

@@ -49,6 +49,10 @@ export const memoryRouter = router({
     .output(z.array(associationSchema))
     .query(({ input }) => getService().getAssociations(input.memoryId)),
 
+  maintenance: publicProcedure
+    .output(z.object({ decayed: z.number(), pruned: z.number() }))
+    .mutation(() => getService().runMaintenance()),
+
   seed: publicProcedure.output(z.number()).mutation(() => getService().seed()),
 
   reset: publicProcedure.mutation(() => {

apps/code/src/renderer/features/settings/components/sections/AdvancedSettings.tsx

@@ -242,6 +242,23 @@ export function AdvancedSettings() {
     }),
   );
 
+  const maintenanceMutation = useMutation(
+    trpc.memory.maintenance.mutationOptions({
+      onSuccess: ({ decayed, pruned }) => {
+        toast.success(`Maintenance: decayed ${decayed}, pruned ${pruned}`);
+        queryClient.invalidateQueries({
+          queryKey: trpc.memory.count.queryKey(),
+        });
+        queryClient.invalidateQueries({
+          queryKey: trpc.memory.list.queryKey(),
+        });
+      },
+      onError: () => {
+        toast.error("Failed to run memory maintenance");
+      },
+    }),
+  );
+
   return (
     <Flex direction="column">
       <SettingRow
@@ -312,6 +329,19 @@ export function AdvancedSettings() {
           {resetMutation.isPending ? "Resetting..." : "Reset"}
         </Button>
       </SettingRow>
+      <SettingRow
+        label="Run maintenance"
+        description="Decay old memory importance and prune low-value memories"
+      >
+        <Button
+          variant="soft"
+          size="1"
+          disabled={maintenanceMutation.isPending}
+          onClick={() => maintenanceMutation.mutate()}
+        >
+          {maintenanceMutation.isPending ? "Running..." : "Maintain"}
+        </Button>
+      </SettingRow>
       <SettingRow
         label="Browse memory data"
         description="Inspect raw memory records and associations"

packages/agent/src/adapters/claude/claude-agent.ts

@@ -375,6 +375,16 @@ export class ClaudeAcpAgent extends BaseAcpAgent {
             if (message.subtype === "compact_boundary") {
               lastAssistantTotalUsage = 0;
               promptReplayed = true;
+
+              // Flush memory buffer before context is compacted
+              if (this.options?.memoryService) {
+                this.logger.info("Compaction detected, flushing memory buffer");
+                this.options.memoryService.distill().catch((err: unknown) => {
+                  this.logger.error("Pre-compaction distillation failed", {
+                    error: err,
+                  });
+                });
+              }
             }
             if (message.subtype === "local_command_output") {
               promptReplayed = true;

packages/agent/src/memory/agent-memory.ts

@@ -27,8 +27,11 @@ import {
 
 const DEFAULT_DISTILL_INTERVAL_MS = 5 * 60 * 1000; // 5 minutes
 const DEFAULT_DISTILL_MIN_CHUNK = 2000; // chars
+const EAGER_DISTILL_THRESHOLD = 8000; // chars — trigger distill mid-conversation
 const DEFAULT_RECALL_TOKEN_BUDGET = 1500;
 const DEFAULT_EXTRACTION_MODEL = "claude-sonnet-4-20250514";
+const DECAY_RATE = 0.02;
+const DECAY_MIN_AGE_DAYS = 1;
 
 // ── Scoring ─────────────────────────────────────────────────────────────────
 
@@ -115,6 +118,7 @@ export class AgentMemoryManager {
   // Periodic distillation timer
   private distillTimer: ReturnType<typeof setInterval> | null = null;
   private distilling = false;
+  private hasRunMaintenance = false;
 
   constructor(config: MemoryServiceConfig) {
     this.config = config;
@@ -157,6 +161,12 @@ export class AgentMemoryManager {
       query: context.slice(0, 80),
     });
 
+    if (!this.hasRunMaintenance) {
+      const decayed = this.svc.decayImportance(DECAY_RATE, DECAY_MIN_AGE_DAYS);
+      this.hasRunMaintenance = true;
+      this.logger.info("Session maintenance: decayed memories", { decayed });
+    }
+
     const scored = this.searchScored(context, options);
     const selected = this.selectWithinBudget(scored, tokenBudget);
 
@@ -201,6 +211,18 @@ export class AgentMemoryManager {
       bufferSize: this.bufferCharCount,
       bufferEntries: this.buffer.length,
     });
+
+    if (this.bufferCharCount >= EAGER_DISTILL_THRESHOLD) {
+      this.logger.info(
+        "Buffer threshold reached, triggering eager distillation",
+        {
+          bufferSize: this.bufferCharCount,
+        },
+      );
+      this.distill().catch((err) => {
+        this.logger.error("Eager distillation error", { error: err });
+      });
+    }
   }
 
   /**