agent-working-memory 0.6.0 → 0.7.0

package/src/core/hebbian.ts

@@ -30,14 +30,25 @@ export function strengthenAssociation(
 
 /**
  * Weaken an association weight due to lack of co-activation.
- * Called periodically by the connection engine.
+ * Uses power-law decay (DASH model) instead of exponential.
+ * Power law has a longer tail — old but valuable associations
+ * don't vanish as aggressively as exponential decay.
+ *
+ * DASH: weight = initial × (1 + t/scale)^(-exponent)
+ * vs exponential: weight = initial × 0.5^(t/halfLife)
+ *
+ * At 7 days: power-law retains ~58% vs exponential 50%
+ * At 30 days: power-law retains ~32% vs exponential 6%
+ * At 90 days: power-law retains ~20% vs exponential 0.02%
  */
 export function decayAssociation(
   currentWeight: number,
   daysSinceActivation: number,
-  halfLife: number = 7.0 // days
+  halfLife: number = 7.0 // scale parameter (days)
 ): number {
-  const decayFactor = Math.pow(0.5, daysSinceActivation / halfLife);
+  // Power-law decay: (1 + t/scale)^(-exponent)
+  const exponent = 0.8; // Controls steepness — 0.8 gives a good balance
+  const decayFactor = Math.pow(1 + daysSinceActivation / halfLife, -exponent);
   return Math.max(currentWeight * decayFactor, MIN_WEIGHT);
 }
 
@@ -91,3 +102,73 @@ export class CoActivationBuffer {
     this.buffer = [];
   }
 }
+
+/**
+ * Validation-gated Hebbian buffer (Kairos-inspired).
+ *
+ * Instead of strengthening associations immediately on co-activation,
+ * pairs are held pending until feedback arrives. This prevents hub toxicity
+ * from noisy co-retrieval — edges only strengthen when the retrieval was
+ * actually useful.
+ *
+ * - Positive feedback → strengthen the pending pairs
+ * - Negative feedback → slightly weaken them
+ * - No feedback within GATE_TIMEOUT_MS → discard (neutral)
+ */
+const GATE_TIMEOUT_MS = 60_000; // 60 seconds to receive feedback
+
+interface PendingHebbianUpdate {
+  pairs: [string, string][];
+  engramIds: string[];
+  timestamp: number;
+}
+
+export class ValidationGatedBuffer {
+  private pending: PendingHebbianUpdate[] = [];
+
+  /** Record co-activated pairs as pending (awaiting feedback validation) */
+  addPending(engramIds: string[], pairs: [string, string][]): void {
+    this.pending.push({ pairs, engramIds, timestamp: Date.now() });
+    // Evict expired entries
+    const cutoff = Date.now() - GATE_TIMEOUT_MS;
+    this.pending = this.pending.filter(p => p.timestamp > cutoff);
+  }
+
+  /**
+   * Resolve pending updates for an engram that received feedback.
+   * Returns pairs to strengthen (positive) or weaken (negative).
+   */
+  resolveFeedback(engramId: string, useful: boolean): { pairs: [string, string][]; signal: number } {
+    const cutoff = Date.now() - GATE_TIMEOUT_MS;
+    const matching: [string, string][] = [];
+
+    // Find all pending updates that include this engram and are still within the gate window
+    this.pending = this.pending.filter(p => {
+      if (p.timestamp < cutoff) return false; // expired
+      if (p.engramIds.includes(engramId)) {
+        matching.push(...p.pairs);
+        return false; // consumed
+      }
+      return true; // keep
+    });
+
+    // Deduplicate pairs
+    const seen = new Set<string>();
+    const unique: [string, string][] = [];
+    for (const [a, b] of matching) {
+      const key = a < b ? `${a}:${b}` : `${b}:${a}`;
+      if (!seen.has(key)) {
+        seen.add(key);
+        unique.push([a, b]);
+      }
+    }
+
+    return {
+      pairs: unique,
+      signal: useful ? 1.0 : -0.3, // positive = full strengthen, negative = slight weaken
+    };
+  }
+
+  /** Get count of pending updates (for stats) */
+  get pendingCount(): number { return this.pending.length; }
+}

package/src/engine/activation.ts

@@ -21,7 +21,7 @@
 
 import { randomUUID } from 'node:crypto';
 import { baseLevelActivation, softplus } from '../core/decay.js';
-import { strengthenAssociation, CoActivationBuffer } from '../core/hebbian.js';
+import { strengthenAssociation, CoActivationBuffer, ValidationGatedBuffer } from '../core/hebbian.js';
 import { embed, cosineSimilarity } from '../core/embeddings.js';
 import { rerank } from '../core/reranker.js';
 import { expandQuery } from '../core/query-expander.js';
@@ -163,10 +163,12 @@ function jaccard(a: Set<string>, b: Set<string>): number {
 export class ActivationEngine {
   private store: EngramStore;
   private coActivationBuffer: CoActivationBuffer;
+  readonly validationGate: ValidationGatedBuffer;
 
   constructor(store: EngramStore) {
     this.store = store;
     this.coActivationBuffer = new CoActivationBuffer(50);
+    this.validationGate = new ValidationGatedBuffer();
   }
 
   /**
@@ -181,14 +183,18 @@ export class ActivationEngine {
     const abstentionThreshold = query.abstentionThreshold ?? 0;
     const adaptive = resolveAdaptiveParams(query);
 
+    // Resolve workspace scope: if workspace is set, search across all agents in that workspace
+    const agentIds = query.workspace
+      ? this.store.getWorkspaceAgentIds(query.agentId, query.workspace)
+      : [query.agentId];
+    const isWorkspaceScoped = agentIds.length > 1;
+
     // Phase -1: Coref expansion — if query has pronouns, append recent entity names
-    // Helps conversational recall where "she/he/they/it" refers to a named entity.
     let queryContext = query.context;
     const pronounPattern = /\b(she|he|they|her|his|him|their|it|that|this|there)\b/i;
     if (pronounPattern.test(queryContext)) {
-      // Pull recent entity names from the agent's most-accessed memories
       try {
-        const recentEntities = this.store.getEngramsByAgent(query.agentId, 'active')
+        const recentEntities = this.store.getEngramsByAgents(agentIds, 'active')
           .sort((a, b) => b.accessCount - a.accessCount)
           .slice(0, 10)
           .flatMap(e => e.tags.filter(t => t.length >= 3 && !/^(session-|low-|D\d)/.test(t)))
@@ -203,10 +209,16 @@ export class ActivationEngine {
     // Phase 0: Query expansion — add related terms to improve BM25 recall
     let searchContext = queryContext;
     if (useExpansion) {
+      let timer: ReturnType<typeof setTimeout> | undefined;
       try {
-        searchContext = await expandQuery(query.context);
+        searchContext = await Promise.race([
+          expandQuery(query.context),
+          new Promise<string>((_, reject) => { timer = setTimeout(() => reject(new Error('expansion timeout')), 5000); }),
+        ]);
       } catch {
-        // Expansion unavailable — use original query
+        // Expansion unavailable or timed out — use original query
+      } finally {
+        if (timer) clearTimeout(timer);
       }
     }
 
@@ -222,9 +234,9 @@ export class ActivationEngine {
     // Two-pass BM25: (1) keyword-stripped query for precision, (2) expanded query for recall.
     const keywordQuery = Array.from(tokenize(query.context)).join(' ');
     const bm25Keyword = keywordQuery.length > 2
-      ? this.store.searchBM25WithRank(query.agentId, keywordQuery, limit * 3)
+      ? this.store.searchBM25WithRankMultiAgent(agentIds, keywordQuery, limit * 3)
       : [];
-    const bm25Expanded = this.store.searchBM25WithRank(query.agentId, searchContext, limit * 3);
+    const bm25Expanded = this.store.searchBM25WithRankMultiAgent(agentIds, searchContext, limit * 3);
 
     // Merge: take the best BM25 score per engram from either pass
     const bm25ScoreMap = new Map<string, number>();
@@ -240,8 +252,8 @@ export class ActivationEngine {
       engram, bm25Score: bm25ScoreMap.get(id) ?? 0,
     }));
 
-    const allActive = this.store.getEngramsByAgent(
-      query.agentId,
+    const allActive = this.store.getEngramsByAgents(
+      agentIds,
       query.includeStaging ? undefined : 'active',
       query.includeRetracted ?? false
     );
@@ -396,7 +408,7 @@ export class ActivationEngine {
       // Take top 5 feedback terms and re-search
       const extraTerms = Array.from(feedbackTerms).slice(0, 5).join(' ');
       if (extraTerms) {
-        const feedbackBM25 = this.store.searchBM25WithRank(query.agentId, `${searchContext} ${extraTerms}`, limit * 2);
+        const feedbackBM25 = this.store.searchBM25WithRankMultiAgent(agentIds, `${searchContext} ${extraTerms}`, limit * 2);
         for (const r of feedbackBM25) {
           if (!candidateMap.has(r.engram.id)) {
             candidateMap.set(r.engram.id, r.engram);
@@ -522,7 +534,11 @@ export class ActivationEngine {
         const passages = rerankPool.map(r =>
           `${r.engram.concept}: ${r.engram.content}`
         );
-        const rerankResults = await rerank(query.context, passages);
+        let rerankTimer: ReturnType<typeof setTimeout> | undefined;
+        const rerankResults = await Promise.race([
+          rerank(query.context, passages),
+          new Promise<never>((_, reject) => { rerankTimer = setTimeout(() => reject(new Error('reranker timeout')), 10000); }),
+        ]).finally(() => { if (rerankTimer) clearTimeout(rerankTimer); });
 
         // Adaptive reranker blend (Codex recommendation):
         // When BM25/text signals are strong, trust them more; when weak, lean on reranker.
@@ -622,13 +638,21 @@ export class ActivationEngine {
 
     const activatedIds = results.map(r => r.engram.id);
 
-    // Side effects: touch, co-activate, Hebbian update (skip for internal/system calls)
+    // Side effects: touch, co-activate, defer Hebbian to validation gate (skip for internal/system calls)
     if (!query.internal) {
       for (const id of activatedIds) {
         this.store.touchEngram(id);
       }
       this.coActivationBuffer.pushBatch(activatedIds);
-      this.updateHebbianWeights();
+      // Validation-gated Hebbian: defer strengthening until feedback arrives
+      const pairs = this.coActivationBuffer.getCoActivatedPairs(10_000);
+      const seen = new Set<string>();
+      const uniquePairs: [string, string][] = [];
+      for (const [a, b] of pairs) {
+        const key = a < b ? `${a}:${b}` : `${b}:${a}`;
+        if (!seen.has(key)) { seen.add(key); uniquePairs.push([a, b]); }
+      }
+      this.validationGate.addPending(activatedIds, uniquePairs);
 
       // Log activation event for eval
       const latencyMs = performance.now() - startTime;
@@ -648,10 +672,27 @@ export class ActivationEngine {
   }
 
   /**
-   * Beam search graph walk — replaces naive BFS.
-   * Scores paths (not just nodes), uses query-dependent edge filtering,
-   * and supports deeper exploration with focused beams.
+   * Multi-graph traversal (MAGMA-inspired).
+   *
+   * Instead of one beam search over all edge types, runs independent traversals
+   * per graph type with specialized scoring, then fuses the boosts.
+   *
+   * Four sub-graphs:
+   * - Semantic (connection + hebbian edges) → standard weight-based walk
+   * - Temporal (temporal edges) → recency-weighted (favor recent connections)
+   * - Causal (causal edges) → full weight walk (causal links are high-value)
+   * - Entity (bridge edges) → entity-tag-weighted walk
+   *
+   * Each sub-graph contributes independently to the final graph boost,
+   * weighted by configurable per-graph weights.
    */
+  private static readonly GRAPH_WEIGHTS = {
+    semantic: 0.40,   // connection + hebbian
+    temporal: 0.20,   // temporal edges
+    causal: 0.25,     // causal edges (high-value signal)
+    entity: 0.15,     // bridge edges
+  };
+
   private graphWalk(
     scored: { engram: Engram; score: number; phaseScores: PhaseScores; associations: Association[] }[],
     maxDepth: number,
@@ -660,85 +701,120 @@ export class ActivationEngine {
   ): void {
     const scoreMap = new Map(scored.map(s => [s.engram.id, s]));
     const MAX_TOTAL_BOOST = 0.25;
-    const BEAM_WIDTH = beamWidth;
 
-    // Seed the beam with high-scoring, text-relevant items
-    const beam = scored
-      .filter(item => item.phaseScores.textMatch >= 0.15)
-      .sort((a, b) => b.score - a.score)
-      .slice(0, BEAM_WIDTH);
+    // Define which edge types belong to each sub-graph
+    const graphTypes: Record<string, string[]> = {
+      semantic: ['connection', 'hebbian'],
+      temporal: ['temporal'],
+      causal: ['causal'],
+      entity: ['bridge'],
+    };
+
+    // Run independent traversals per sub-graph, accumulate boosts
+    const boostAccum = new Map<string, number>(); // engramId → total boost
 
-    // Track which engrams have been explored (avoid cycles)
-    const explored = new Set<string>();
+    for (const [graphName, edgeTypes] of Object.entries(graphTypes)) {
+      const graphWeight = ActivationEngine.GRAPH_WEIGHTS[graphName as keyof typeof ActivationEngine.GRAPH_WEIGHTS];
+      const subBeamWidth = Math.max(3, Math.ceil(beamWidth * graphWeight));
 
-    for (let depth = 0; depth < maxDepth; depth++) {
-      const nextBeam: typeof beam = [];
+      // Seed beam
+      const beam = scored
+        .filter(item => item.phaseScores.textMatch >= 0.15)
+        .sort((a, b) => b.score - a.score)
+        .slice(0, subBeamWidth);
+
+      const explored = new Set<string>();
+
+      for (let depth = 0; depth < maxDepth; depth++) {
+        const nextBeam: typeof beam = [];
 
-      for (const item of beam) {
-        if (explored.has(item.engram.id)) continue;
-        explored.add(item.engram.id);
+        for (const item of beam) {
+          if (explored.has(item.engram.id)) continue;
+          explored.add(item.engram.id);
 
-        // Get associations — for depth > 0, fetch from store if not in scored set
-        const associations = item.associations.length > 0
-          ? item.associations
-          : this.store.getAssociationsFor(item.engram.id);
+          const associations = item.associations.length > 0
+            ? item.associations
+            : this.store.getAssociationsFor(item.engram.id);
 
-        for (const assoc of associations) {
-          const neighborId = assoc.fromEngramId === item.engram.id
-            ? assoc.toEngramId
-            : assoc.fromEngramId;
+          // Filter to only edges of this sub-graph type
+          const relevantEdges = associations.filter(a => edgeTypes.includes(a.type));
 
-          if (explored.has(neighborId)) continue;
+          for (const assoc of relevantEdges) {
+            const neighborId = assoc.fromEngramId === item.engram.id
+              ? assoc.toEngramId
+              : assoc.fromEngramId;
 
-          const neighbor = scoreMap.get(neighborId);
-          if (!neighbor) continue;
+            if (explored.has(neighborId)) continue;
+            const neighbor = scoreMap.get(neighborId);
+            if (!neighbor) continue;
 
-          // Query-dependent edge filtering: neighbor must have SOME relevance
-          // (textMatch > 0.05 for deeper hops, relaxed from 0.1)
-          const relevanceFloor = depth === 0 ? 0.1 : 0.05;
-          if (neighbor.phaseScores.textMatch < relevanceFloor) continue;
+            const relevanceFloor = depth === 0 ? 0.1 : 0.05;
+            if (neighbor.phaseScores.textMatch < relevanceFloor) continue;
 
-          // Skip if neighbor already at boost cap
-          if (neighbor.phaseScores.graphBoost >= MAX_TOTAL_BOOST) continue;
+            // Path score with graph-type-specific weighting
+            const normalizedWeight = Math.min(assoc.weight, 5.0) / 5.0;
+            let pathScore = item.score * normalizedWeight * Math.pow(hopPenalty, depth + 1);
 
-          // Path score: source score * edge weight * hop penalty^(depth+1)
-          const normalizedWeight = Math.min(assoc.weight, 5.0) / 5.0;
-          const pathScore = item.score * normalizedWeight * Math.pow(hopPenalty, depth + 1);
+            // Causal edges get a 2x boost — they represent verified reasoning chains
+            if (graphName === 'causal') pathScore *= 2.0;
 
-          const boost = Math.min(pathScore, 0.15, MAX_TOTAL_BOOST - neighbor.phaseScores.graphBoost);
-          if (boost > 0.001) {
-            neighbor.score += boost;
-            neighbor.phaseScores.graphBoost += boost;
-            nextBeam.push(neighbor);
+            // Weight by sub-graph importance
+            const boost = Math.min(pathScore * graphWeight, 0.15);
+            if (boost > 0.001) {
+              boostAccum.set(neighborId, (boostAccum.get(neighborId) ?? 0) + boost);
+              nextBeam.push(neighbor);
+            }
           }
         }
+
+        if (nextBeam.length === 0) break;
+        beam.length = 0;
+        beam.push(...nextBeam
+          .sort((a, b) => b.score - a.score)
+          .slice(0, subBeamWidth)
+        );
       }
+    }
 
-      // Prune beam for next depth level
-      if (nextBeam.length === 0) break;
-      beam.length = 0;
-      beam.push(...nextBeam
-        .sort((a, b) => b.score - a.score)
-        .slice(0, BEAM_WIDTH)
-      );
+    // Apply fused boosts to scored items
+    for (const [engramId, totalBoost] of boostAccum) {
+      const item = scoreMap.get(engramId);
+      if (!item) continue;
+      const capped = Math.min(totalBoost, MAX_TOTAL_BOOST - item.phaseScores.graphBoost);
+      if (capped > 0.001) {
+        item.score += capped;
+        item.phaseScores.graphBoost += capped;
+      }
     }
   }
 
-  private updateHebbianWeights(): void {
-    const pairs = this.coActivationBuffer.getCoActivatedPairs(10_000);
-    // Deduplicate pairs to prevent repeated strengthening
-    const seen = new Set<string>();
-    for (const [a, b] of pairs) {
-      const key = a < b ? `${a}:${b}` : `${b}:${a}`;
-      if (seen.has(key)) continue;
-      seen.add(key);
+  /**
+   * Resolve validation-gated Hebbian update for a specific engram.
+   * Called by memory_feedback — only strengthens when retrieval was useful.
+   * This prevents hub toxicity from noisy co-retrieval (Kairos-inspired).
+   */
+  resolveHebbianFeedback(engramId: string, useful: boolean): number {
+    const { pairs, signal } = this.validationGate.resolveFeedback(engramId, useful);
+    let updated = 0;
 
+    for (const [a, b] of pairs) {
       const existing = this.store.getAssociation(a, b) ?? this.store.getAssociation(b, a);
       const currentWeight = existing?.weight ?? 0.1;
-      const newWeight = strengthenAssociation(currentWeight);
-      this.store.upsertAssociation(a, b, newWeight, 'hebbian');
-      this.store.upsertAssociation(b, a, newWeight, 'hebbian');
+
+      if (signal > 0) {
+        // Positive feedback → strengthen
+        const newWeight = strengthenAssociation(currentWeight, signal);
+        this.store.upsertAssociation(a, b, newWeight, 'hebbian');
+        this.store.upsertAssociation(b, a, newWeight, 'hebbian');
+      } else {
+        // Negative feedback → slight weakening (decay by signal magnitude)
+        const newWeight = Math.max(0.001, currentWeight * (1 + signal)); // signal is -0.3
+        this.store.upsertAssociation(a, b, newWeight, 'hebbian');
+        this.store.upsertAssociation(b, a, newWeight, 'hebbian');
+      }
+      updated++;
     }
+    return updated;
   }
 
   private explain(phases: PhaseScores, engram: Engram, associations: Association[]): string {

package/src/engine/consolidation.ts

@@ -144,13 +144,22 @@ export class ConsolidationEngine {
     const needsEmbedding = allActive.filter(e => !e.embedding || e.embedding.length === 0);
     if (needsEmbedding.length > 0) {
       try {
-        const { embed } = await import('../core/embeddings.js');
-        for (const e of needsEmbedding) {
+        const { embedBatch, getModelId } = await import('../core/embeddings.js');
+        const BATCH_SIZE = 32;
+        const modelId = getModelId?.() ?? 'unknown';
+        for (let b = 0; b < needsEmbedding.length; b += BATCH_SIZE) {
+          const batch = needsEmbedding.slice(b, b + BATCH_SIZE);
           try {
-            const vec = await embed(`${e.concept} ${e.content}`);
-            this.store.updateEmbedding(e.id, vec);
-            e.embedding = vec;
-          } catch { /* non-fatal */ }
+            const texts = batch.map(e => `${e.concept} ${e.content}`);
+            const vecs = await embedBatch(texts);
+            for (let j = 0; j < batch.length; j++) {
+              this.store.updateEmbedding(batch[j].id, vecs[j], modelId);
+              batch[j].embedding = vecs[j];
+            }
+          } catch { /* batch failed, skip — non-fatal */ }
+        }
+        if (needsEmbedding.length > 0) {
+          console.log(`[consolidation] Backfilled ${needsEmbedding.filter(e => e.embedding?.length).length}/${needsEmbedding.length} embeddings (model: ${modelId})`);
         }
       } catch { /* embeddings module unavailable */ }
     }

package/src/engine/retraction.ts

@@ -60,40 +60,56 @@ export class RetractionEngine {
       this.store.retractEngram(target.id, correction.id);
     }
 
-    // Reduce confidence of closely associated engrams (contamination spread)
-    const associatesAffected = this.propagateConfidenceReduction(target.id, 0.1, 1);
+    // Reduce confidence of associated engrams (contamination spread)
+    // Depth 2 with 50% decay per hop, capped at 20 total affected nodes
+    const associatesAffected = this.propagateConfidenceReduction(target.id, 0.1, 2);
 
     return { retractedId: target.id, correctionId, associatesAffected };
   }
 
   /**
    * Reduce confidence of engrams associated with a retracted engram.
-   * Shallow propagation (depth 1) to avoid over-penalizing.
+   * Propagates up to maxDepth hops with decaying penalty (50% per hop).
+   * Capped at MAX_AFFECTED to prevent cascading through the graph.
    */
+  private static readonly MAX_AFFECTED = 20;
+
   private propagateConfidenceReduction(
     engramId: string,
     penalty: number,
     maxDepth: number,
-    currentDepth: number = 0
+    currentDepth: number = 0,
+    visited: Set<string> = new Set(),
   ): number {
     if (currentDepth >= maxDepth) return 0;
+    if (visited.size >= RetractionEngine.MAX_AFFECTED) return 0;
+    visited.add(engramId);
 
     let affected = 0;
     const associations = this.store.getAssociationsFor(engramId);
     for (const assoc of associations) {
       if (assoc.type === 'invalidation') continue; // Don't penalize corrections
+      if (visited.size >= RetractionEngine.MAX_AFFECTED) break;
 
       const neighborId = assoc.fromEngramId === engramId
         ? assoc.toEngramId
         : assoc.fromEngramId;
+      if (visited.has(neighborId)) continue;
+
       const neighbor = this.store.getEngram(neighborId);
       if (!neighbor || neighbor.retracted) continue;
 
-      // Scale penalty by association weight
-      const scaledPenalty = penalty * assoc.weight;
+      // Scale penalty by association weight and decay per hop (50% per depth level)
+      const depthDecay = Math.pow(0.5, currentDepth);
+      const scaledPenalty = penalty * assoc.weight * depthDecay;
       const newConfidence = Math.max(0.1, neighbor.confidence - scaledPenalty);
       this.store.updateConfidence(neighborId, newConfidence);
       affected++;
+
+      // Recurse to next depth
+      affected += this.propagateConfidenceReduction(
+        neighborId, penalty, maxDepth, currentDepth + 1, visited
+      );
     }
     return affected;
   }

package/src/index.ts

@@ -101,7 +101,8 @@ async function main() {
   const consolidationScheduler = new ConsolidationScheduler(store, consolidationEngine);
 
   // API — disable Fastify's default request logging (too noisy for hive polling)
-  const app = Fastify({ logger: false });
+  // bodyLimit: 512KB to prevent Content-Length mismatch errors with large task payloads
+  const app = Fastify({ logger: false, bodyLimit: 512_000 });
 
   // Bearer token auth — only enforced when AWM_API_KEY is explicitly set and non-empty
   if (API_KEY && API_KEY !== 'NONE' && API_KEY.length > 1) {
@@ -122,19 +123,9 @@ async function main() {
   });
 
   // Coordination module (opt-in via AWM_COORDINATION=true)
-  let heartbeatPruneTimer: ReturnType<typeof setInterval> | null = null;
-  const { isCoordinationEnabled, initCoordination } = await import('./coordination/index.js');
+  const { isCoordinationEnabled, initCoordination, stopCoordinationCleanup } = await import('./coordination/index.js');
   if (isCoordinationEnabled()) {
-    initCoordination(app, store.getDb());
-    // Prune stale heartbeat events every 30s (keeps assignment/command events permanently)
-    // Purge dead agents older than 24h every 30s to prevent table bloat
-    const { pruneOldHeartbeats, purgeDeadAgents } = await import('./coordination/stale.js');
-    heartbeatPruneTimer = setInterval(() => {
-      const pruned = pruneOldHeartbeats(store.getDb());
-      if (pruned > 0) console.log(`[coordination] pruned ${pruned} old heartbeat event(s)`);
-      const purged = purgeDeadAgents(store.getDb());
-      if (purged > 0) console.log(`[coordination] purged ${purged} dead agent(s) older than 24h`);
-    }, 30_000);
+    initCoordination(app, store.getDb(), store);
   } else {
     console.log('  Coordination module disabled (set AWM_COORDINATION=true to enable)');
   }
@@ -189,9 +180,9 @@ async function main() {
   console.log(`AgentWorkingMemory v0.6.0 listening on port ${PORT}`);
 
   // Graceful shutdown
-  const shutdown = () => {
+  const shutdown = async () => {
     clearInterval(backupTimer);
-    if (heartbeatPruneTimer) clearInterval(heartbeatPruneTimer);
+    await stopCoordinationCleanup();
     consolidationScheduler.stop();
     stagingBuffer.stop();
     try { store.walCheckpoint(); } catch { /* non-fatal */ }