agent-working-memory 0.5.5 → 0.6.0

package/src/engine/connections.ts

@@ -1,103 +1,103 @@
-// Copyright 2026 Robert Winter / Complete Ideas
-// SPDX-License-Identifier: Apache-2.0
-/**
- * Connection Engine — discovers links between memories.
- *
- * Runs asynchronously. When a new engram is written, the connection
- * engine checks it against existing memories and forms association
- * edges where resonance exceeds a threshold.
- *
- * Connection memories are first-class engrams — they can themselves
- * activate and form higher-order connections, producing emergent
- * associative structure over time.
- */
-
-import type { EngramStore } from '../storage/sqlite.js';
-import type { ActivationEngine } from './activation.js';
-import type { Engram } from '../types/index.js';
-
-export class ConnectionEngine {
-  private store: EngramStore;
-  private engine: ActivationEngine;
-  private threshold: number;
-  private queue: string[] = [];
-  private processing = false;
-
-  constructor(
-    store: EngramStore,
-    engine: ActivationEngine,
-    threshold: number = 0.7
-  ) {
-    this.store = store;
-    this.engine = engine;
-    this.threshold = threshold;
-  }
-
-  /**
-   * Queue a newly written engram for connection discovery.
-   */
-  enqueue(engramId: string): void {
-    this.queue.push(engramId);
-    if (!this.processing) {
-      this.processQueue();
-    }
-  }
-
-  private async processQueue(): Promise<void> {
-    this.processing = true;
-
-    while (this.queue.length > 0) {
-      const engramId = this.queue.shift()!;
-      const engram = this.store.getEngram(engramId);
-      if (!engram || engram.stage !== 'active') continue;
-
-      try {
-        await this.findConnections(engram);
-      } catch {
-        // Connection discovery is best-effort — don't crash the server
-      }
-    }
-
-    this.processing = false;
-  }
-
-  /**
-   * Find and create connections for a given engram.
-   */
-  private async findConnections(engram: Engram): Promise<void> {
-    const results = await this.engine.activate({
-      agentId: engram.agentId,
-      context: `${engram.concept} ${engram.content}`,
-      limit: 5,
-      minScore: this.threshold,
-      internal: true,
-    });
-
-    // Filter out self and already-connected engrams
-    const existing = this.store.getAssociationsFor(engram.id);
-    const existingIds = new Set(existing.map(a =>
-      a.fromEngramId === engram.id ? a.toEngramId : a.fromEngramId
-    ));
-
-    for (const result of results) {
-      if (result.engram.id === engram.id) continue;
-      if (existingIds.has(result.engram.id)) continue;
-
-      // Create a connection association
-      this.store.upsertAssociation(
-        engram.id,
-        result.engram.id,
-        result.score,
-        'connection'
-      );
-
-      // Bidirectional
-      this.store.upsertAssociation(
-        result.engram.id,
-        engram.id,
-        result.score,
-        'connection'
-      );
-    }
-  }
-}
+// Copyright 2026 Robert Winter / Complete Ideas
+// SPDX-License-Identifier: Apache-2.0
+/**
+ * Connection Engine — discovers links between memories.
+ *
+ * Runs asynchronously. When a new engram is written, the connection
+ * engine checks it against existing memories and forms association
+ * edges where resonance exceeds a threshold.
+ *
+ * Connection memories are first-class engrams — they can themselves
+ * activate and form higher-order connections, producing emergent
+ * associative structure over time.
+ */
+
+import type { EngramStore } from '../storage/sqlite.js';
+import type { ActivationEngine } from './activation.js';
+import type { Engram } from '../types/index.js';
+
+export class ConnectionEngine {
+  private store: EngramStore;
+  private engine: ActivationEngine;
+  private threshold: number;
+  private queue: string[] = [];
+  private processing = false;
+
+  constructor(
+    store: EngramStore,
+    engine: ActivationEngine,
+    threshold: number = 0.7
+  ) {
+    this.store = store;
+    this.engine = engine;
+    this.threshold = threshold;
+  }
+
+  /**
+   * Queue a newly written engram for connection discovery.
+   */
+  enqueue(engramId: string): void {
+    this.queue.push(engramId);
+    if (!this.processing) {
+      this.processQueue();
+    }
+  }
+
+  private async processQueue(): Promise<void> {
+    this.processing = true;
+
+    while (this.queue.length > 0) {
+      const engramId = this.queue.shift()!;
+      const engram = this.store.getEngram(engramId);
+      if (!engram || engram.stage !== 'active') continue;
+
+      try {
+        await this.findConnections(engram);
+      } catch {
+        // Connection discovery is best-effort — don't crash the server
+      }
+    }
+
+    this.processing = false;
+  }
+
+  /**
+   * Find and create connections for a given engram.
+   */
+  private async findConnections(engram: Engram): Promise<void> {
+    const results = await this.engine.activate({
+      agentId: engram.agentId,
+      context: `${engram.concept} ${engram.content}`,
+      limit: 5,
+      minScore: this.threshold,
+      internal: true,
+    });
+
+    // Filter out self and already-connected engrams
+    const existing = this.store.getAssociationsFor(engram.id);
+    const existingIds = new Set(existing.map(a =>
+      a.fromEngramId === engram.id ? a.toEngramId : a.fromEngramId
+    ));
+
+    for (const result of results) {
+      if (result.engram.id === engram.id) continue;
+      if (existingIds.has(result.engram.id)) continue;
+
+      // Create a connection association
+      this.store.upsertAssociation(
+        engram.id,
+        result.engram.id,
+        result.score,
+        'connection'
+      );
+
+      // Bidirectional
+      this.store.upsertAssociation(
+        result.engram.id,
+        engram.id,
+        result.score,
+        'connection'
+      );
+    }
+  }
+}

package/src/engine/consolidation-scheduler.ts

@@ -1,125 +1,125 @@
-// Copyright 2026 Robert Winter / Complete Ideas
-// SPDX-License-Identifier: Apache-2.0
-/**
- * Consolidation Scheduler — automatically triggers sleep cycles.
- *
- * Four triggers:
- *   1. Idle — agent inactive >10min → full consolidation
- *   2. Volume — 50+ writes since last consolidation → full consolidation
- *   3. Time — 30min since last consolidation → full consolidation
- *   4. Adaptive — retrieval precision <0.4 → full consolidation
- *
- * Also provides mini-consolidation for restore (fire-and-forget, lightweight).
- * Checks every 30 seconds across all active agents.
- */
-
-import type { EngramStore } from '../storage/sqlite.js';
-import type { ConsolidationEngine } from './consolidation.js';
-
-const TICK_INTERVAL_MS = 30_000;         // Check every 30s
-const IDLE_THRESHOLD_MS = 10 * 60_000;   // 10 minutes
-const VOLUME_THRESHOLD = 50;             // 50 writes
-const TIME_THRESHOLD_MS = 30 * 60_000;   // 30 minutes
-const PRECISION_THRESHOLD = 0.4;         // Below this triggers consolidation
-
-export class ConsolidationScheduler {
-  private timer: ReturnType<typeof setInterval> | null = null;
-  private running = false;
-
-  constructor(
-    private store: EngramStore,
-    private consolidationEngine: ConsolidationEngine,
-  ) {}
-
-  start(): void {
-    if (this.timer) return;
-    this.timer = setInterval(() => this.tick(), TICK_INTERVAL_MS);
-    console.log('ConsolidationScheduler started (30s tick)');
-  }
-
-  stop(): void {
-    if (this.timer) {
-      clearInterval(this.timer);
-      this.timer = null;
-    }
-    console.log('ConsolidationScheduler stopped');
-  }
-
-  /**
-   * Mini-consolidation — lightweight, called from restore path.
-   * Only runs replay + strengthen (phases 1-2), skips heavy phases.
-   */
-  async runMiniConsolidation(agentId: string): Promise<void> {
-    if (this.running) return;
-    this.running = true;
-    try {
-      console.log(`[scheduler] mini-consolidation for ${agentId}`);
-      await this.consolidationEngine.consolidate(agentId);
-      this.store.markConsolidation(agentId, true);
-    } catch (err) {
-      console.error(`[scheduler] mini-consolidation failed for ${agentId}:`, err);
-    } finally {
-      this.running = false;
-    }
-  }
-
-  private tick(): void {
-    if (this.running) return;
-
-    const agents = this.store.getActiveAgents();
-    const now = Date.now();
-
-    for (const agent of agents) {
-      const idleMs = now - agent.lastActivityAt.getTime();
-      const sinceConsolidation = agent.lastConsolidationAt
-        ? now - agent.lastConsolidationAt.getTime()
-        : Infinity;
-
-      let trigger: string | null = null;
-
-      // 1. Idle trigger — agent stopped writing/recalling >10min ago
-      if (idleMs > IDLE_THRESHOLD_MS && sinceConsolidation > IDLE_THRESHOLD_MS) {
-        trigger = `idle (${Math.round(idleMs / 60_000)}min)`;
-      }
-
-      // 2. Volume trigger — many writes accumulated
-      if (!trigger && agent.writeCount >= VOLUME_THRESHOLD) {
-        trigger = `volume (${agent.writeCount} writes)`;
-      }
-
-      // 3. Time trigger — been too long since last consolidation
-      if (!trigger && sinceConsolidation > TIME_THRESHOLD_MS) {
-        trigger = `time (${Math.round(sinceConsolidation / 60_000)}min)`;
-      }
-
-      // 4. Adaptive trigger — precision is low
-      if (!trigger) {
-        try {
-          const precision = this.store.getRetrievalPrecision(agent.agentId, 1);
-          if (precision > 0 && precision < PRECISION_THRESHOLD) {
-            trigger = `adaptive (precision ${(precision * 100).toFixed(0)}%)`;
-          }
-        } catch { /* precision check is non-fatal */ }
-      }
-
-      if (trigger) {
-        this.runFullConsolidation(agent.agentId, trigger);
-        return; // One consolidation per tick to avoid overload
-      }
-    }
-  }
-
-  private async runFullConsolidation(agentId: string, reason: string): Promise<void> {
-    this.running = true;
-    try {
-      console.log(`[scheduler] full consolidation for ${agentId} — trigger: ${reason}`);
-      const result = await this.consolidationEngine.consolidate(agentId);
-      this.store.markConsolidation(agentId, false);
-      console.log(`[scheduler] consolidation done: ${result.edgesStrengthened} strengthened, ${result.memoriesForgotten} forgotten`);
-    } catch (err) {
-      console.error(`[scheduler] consolidation failed for ${agentId}:`, err);
-    } finally {
-      this.running = false;
-    }
-  }
-}
+// Copyright 2026 Robert Winter / Complete Ideas
+// SPDX-License-Identifier: Apache-2.0
+/**
+ * Consolidation Scheduler — automatically triggers sleep cycles.
+ *
+ * Four triggers:
+ *   1. Idle — agent inactive >10min → full consolidation
+ *   2. Volume — 50+ writes since last consolidation → full consolidation
+ *   3. Time — 30min since last consolidation → full consolidation
+ *   4. Adaptive — retrieval precision <0.4 → full consolidation
+ *
+ * Also provides mini-consolidation for restore (fire-and-forget, lightweight).
+ * Checks every 30 seconds across all active agents.
+ */
+
+import type { EngramStore } from '../storage/sqlite.js';
+import type { ConsolidationEngine } from './consolidation.js';
+
+const TICK_INTERVAL_MS = 30_000;         // Check every 30s
+const IDLE_THRESHOLD_MS = 10 * 60_000;   // 10 minutes
+const VOLUME_THRESHOLD = 50;             // 50 writes
+const TIME_THRESHOLD_MS = 30 * 60_000;   // 30 minutes
+const PRECISION_THRESHOLD = 0.4;         // Below this triggers consolidation
+
+export class ConsolidationScheduler {
+  private timer: ReturnType<typeof setInterval> | null = null;
+  private running = false;
+
+  constructor(
+    private store: EngramStore,
+    private consolidationEngine: ConsolidationEngine,
+  ) {}
+
+  start(): void {
+    if (this.timer) return;
+    this.timer = setInterval(() => this.tick(), TICK_INTERVAL_MS);
+    console.log('ConsolidationScheduler started (30s tick)');
+  }
+
+  stop(): void {
+    if (this.timer) {
+      clearInterval(this.timer);
+      this.timer = null;
+    }
+    console.log('ConsolidationScheduler stopped');
+  }
+
+  /**
+   * Mini-consolidation — lightweight, called from restore path.
+   * Only runs replay + strengthen (phases 1-2), skips heavy phases.
+   */
+  async runMiniConsolidation(agentId: string): Promise<void> {
+    if (this.running) return;
+    this.running = true;
+    try {
+      console.log(`[scheduler] mini-consolidation for ${agentId}`);
+      await this.consolidationEngine.consolidate(agentId);
+      this.store.markConsolidation(agentId, true);
+    } catch (err) {
+      console.error(`[scheduler] mini-consolidation failed for ${agentId}:`, err);
+    } finally {
+      this.running = false;
+    }
+  }
+
+  private tick(): void {
+    if (this.running) return;
+
+    const agents = this.store.getActiveAgents();
+    const now = Date.now();
+
+    for (const agent of agents) {
+      const idleMs = now - agent.lastActivityAt.getTime();
+      const sinceConsolidation = agent.lastConsolidationAt
+        ? now - agent.lastConsolidationAt.getTime()
+        : Infinity;
+
+      let trigger: string | null = null;
+
+      // 1. Idle trigger — agent stopped writing/recalling >10min ago
+      if (idleMs > IDLE_THRESHOLD_MS && sinceConsolidation > IDLE_THRESHOLD_MS) {
+        trigger = `idle (${Math.round(idleMs / 60_000)}min)`;
+      }
+
+      // 2. Volume trigger — many writes accumulated
+      if (!trigger && agent.writeCount >= VOLUME_THRESHOLD) {
+        trigger = `volume (${agent.writeCount} writes)`;
+      }
+
+      // 3. Time trigger — been too long since last consolidation
+      if (!trigger && sinceConsolidation > TIME_THRESHOLD_MS) {
+        trigger = `time (${Math.round(sinceConsolidation / 60_000)}min)`;
+      }
+
+      // 4. Adaptive trigger — precision is low
+      if (!trigger) {
+        try {
+          const precision = this.store.getRetrievalPrecision(agent.agentId, 1);
+          if (precision > 0 && precision < PRECISION_THRESHOLD) {
+            trigger = `adaptive (precision ${(precision * 100).toFixed(0)}%)`;
+          }
+        } catch { /* precision check is non-fatal */ }
+      }
+
+      if (trigger) {
+        this.runFullConsolidation(agent.agentId, trigger);
+        return; // One consolidation per tick to avoid overload
+      }
+    }
+  }
+
+  private async runFullConsolidation(agentId: string, reason: string): Promise<void> {
+    this.running = true;
+    try {
+      console.log(`[scheduler] full consolidation for ${agentId} — trigger: ${reason}`);
+      const result = await this.consolidationEngine.consolidate(agentId);
+      this.store.markConsolidation(agentId, false);
+      console.log(`[scheduler] consolidation done: ${result.edgesStrengthened} strengthened, ${result.memoriesForgotten} forgotten`);
+    } catch (err) {
+      console.error(`[scheduler] consolidation failed for ${agentId}:`, err);
+    } finally {
+      this.running = false;
+    }
+  }
+}

package/src/engine/consolidation.ts

@@ -68,11 +68,15 @@ const FORGET_ARCHIVE_DAYS = 30;
 /** Age at which archived, never-retrieved, unconnected memories get deleted (days) */
 const FORGET_DELETE_DAYS = 90;
 
-/** Cosine similarity above which two low-confidence memories are considered redundant */
-const REDUNDANCY_THRESHOLD = 0.85;
+/** Cosine similarity above which two low-confidence memories are considered redundant.
+ * MiniLM-L6 paraphrases typically score 0.75-0.88 cosine; 0.85 misses most of them.
+ * 0.75 catches paraphrases while keeping precision above 0.60 for unrelated facts. */
+const REDUNDANCY_THRESHOLD = 0.75;
 
-/** Max redundant memories to prune per cycle (gradual, not sudden) */
-const MAX_REDUNDANCY_PRUNE_PER_CYCLE = 10;
+/** Max redundant memories to prune per cycle (gradual, not sudden).
+ * Raised from 10 to 25 — the eval harness runs multiple cycles anyway,
+ * but faster convergence reduces consolidation time for larger pools. */
+const MAX_REDUNDANCY_PRUNE_PER_CYCLE = 25;
 
 /** Max confidence drift per consolidation cycle (prevents runaway) */
 const CONFIDENCE_DRIFT_CAP = 0.03;
@@ -404,9 +408,28 @@ export class ConsolidationEngine {
 
         const sim = cosineSimilarity(sortedLow[i].embedding!, sortedLow[j].embedding!);
         if (sim >= REDUNDANCY_THRESHOLD) {
+          const survivorId = sortedLow[i].id;
+          const prunedId = sortedLow[j].id;
+
+          // Transfer associations from pruned memory to survivor
+          const prunedEdges = this.store.getAssociationsFor(prunedId);
+          for (const edge of prunedEdges) {
+            const peerId = edge.fromEngramId === prunedId ? edge.toEngramId : edge.fromEngramId;
+            if (peerId === survivorId) continue; // Skip self-loops
+            this.store.upsertAssociation(survivorId, peerId, edge.weight, edge.type, edge.confidence);
+          }
+
+          // Merge tags from pruned to survivor
+          const survivor = sortedLow[i];
+          const prunedMem = sortedLow[j];
+          const mergedTags = [...new Set([...survivor.tags, ...prunedMem.tags])];
+          if (mergedTags.length > survivor.tags.length) {
+            this.store.updateTags(survivorId, mergedTags);
+          }
+
           // Archive the lower-quality duplicate
-          this.store.updateStage(sortedLow[j].id, 'archived');
-          pruned.add(sortedLow[j].id);
+          this.store.updateStage(prunedId, 'archived');
+          pruned.add(prunedId);
           redundancyCount++;
         }
       }