agent-working-memory 0.6.0 → 0.6.1

package/src/engine/activation.ts

@@ -203,10 +203,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);
       }
     }
 
@@ -522,7 +528,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.

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 */ }

package/src/mcp.ts

@@ -26,7 +26,7 @@
 
 import { readFileSync } from 'node:fs';
 import { resolve } from 'node:path';
-import { McpServer } from '@modelcontextprotocol/sdk/server/mcp.js';
+import { McpServer, ResourceTemplate } from '@modelcontextprotocol/sdk/server/mcp.js';
 
 // Load .env file if present (no external dependency)
 try {
@@ -42,6 +42,12 @@ try {
     if (!process.env[key]) process.env[key] = val;
   }
 } catch { /* No .env file */ }
+
+// MCP uses stdout for JSON-RPC. Redirect console.log to stderr so engine
+// startup messages (ConsolidationScheduler, model loading, etc.) don't
+// corrupt the transport. This MUST happen before any engine imports.
+console.log = console.error;
+
 import { StdioServerTransport } from '@modelcontextprotocol/sdk/server/stdio.js';
 import { z } from 'zod';
 
@@ -62,6 +68,7 @@ import { DEFAULT_AGENT_CONFIG } from './types/agent.js';
 import { embed } from './core/embeddings.js';
 import { startSidecar } from './hooks/sidecar.js';
 import { initLogger, log, getLogPath } from './core/logger.js';
+import { queryPeerDecisions, formatPeerDecisions } from './coordination/peer-decisions.js';
 
 // --- Incognito Mode ---
 // When AWM_INCOGNITO=1, register zero tools. Claude won't see memory tools at all.
@@ -106,12 +113,64 @@ consolidationScheduler.start();
 // Coordination DB handle — set when AWM_COORDINATION=true, used by memory_write for decision propagation
 let coordDb: import('better-sqlite3').Database | null = null;
 
-const server = new McpServer({
-  name: 'agent-working-memory',
-  version: '0.6.0',
-});
-
-// --- Auto-classification for memory types ---
+const server = new McpServer({
+  name: 'agent-working-memory',
+  version: '0.6.0',
+});
+
+server.registerResource(
+  'awm-overview',
+  'awm://server/overview',
+  {
+    title: 'AWM Overview',
+    description: 'AgentWorkingMemory MCP server metadata and discovery notes',
+    mimeType: 'text/markdown',
+  },
+  async () => ({
+    contents: [{
+      uri: 'awm://server/overview',
+      text: [
+        '# Agent Working Memory',
+        '',
+        `Agent: ${AGENT_ID}`,
+        `DB: ${DB_PATH}`,
+        `Coordination: ${process.env.AWM_COORDINATION === 'true' || process.env.AWM_COORDINATION === '1' ? 'enabled' : 'disabled'}`,
+        '',
+        'This MCP server primarily exposes tools such as `memory_restore`, `memory_recall`, `memory_write`, and task/checkpoint operations.',
+        'The resources below exist so generic MCP clients can discover the server through `resources/list` and `resources/templates/list`.',
+      ].join('\n'),
+      mimeType: 'text/markdown',
+    }],
+  })
+);
+
+server.registerResource(
+  'awm-memory-template',
+  new ResourceTemplate('awm://memory/{id}', { list: undefined }),
+  {
+    title: 'AWM Memory By ID',
+    description: 'Metadata resource template for a memory identifier',
+    mimeType: 'text/markdown',
+  },
+  async (_uri, variables) => ({
+    contents: [{
+      uri: `awm://memory/${variables.id ?? ''}`,
+      text: [
+        '# AWM Memory Reference',
+        '',
+        `Requested memory id: ${variables.id ?? ''}`,
+        '',
+        'Use the AWM memory tools for actual retrieval and mutation:',
+        '- `memory_recall` for cognitive retrieval',
+        '- `memory_restore` for session state',
+        '- `memory_feedback`, `memory_retract`, `memory_supersede` for memory maintenance',
+      ].join('\n'),
+      mimeType: 'text/markdown',
+    }],
+  })
+);
+
+// --- Auto-classification for memory types ---
 
 function classifyMemoryType(content: string): 'episodic' | 'semantic' | 'procedural' | 'unclassified' {
   const lower = content.toLowerCase();
@@ -349,11 +408,16 @@ Returns the most relevant memories ranked by text relevance, temporal recency, a
 
     log(AGENT_ID, 'recall', `"${queryText.slice(0, 80)}" → ${results.length} results`);
 
+    // Peer decisions: append recent decisions by other agents relevant to this query
+    const peerSuffix = coordDb
+      ? formatPeerDecisions(queryPeerDecisions(coordDb, AGENT_ID, queryText))
+      : '';
+
     if (results.length === 0) {
       return {
         content: [{
           type: 'text' as const,
-          text: 'No relevant memories found.',
+          text: 'No relevant memories found.' + peerSuffix,
         }],
       };
     }
@@ -365,7 +429,7 @@ Returns the most relevant memories ranked by text relevance, temporal recency, a
     return {
       content: [{
         type: 'text' as const,
-        text: lines.join('\n'),
+        text: lines.join('\n') + peerSuffix,
       }],
     };
   }

package/src/storage/sqlite.ts

@@ -30,6 +30,7 @@ const DEFAULT_SALIENCE_FEATURES: SalienceFeatures = {
 
 export class EngramStore {
   private db: Database.Database;
+  private walTimer: ReturnType<typeof setInterval> | null = null;
 
   constructor(dbPath: string = 'memory.db') {
     this.db = new Database(dbPath);
@@ -37,7 +38,9 @@ export class EngramStore {
     this.db.pragma('foreign_keys = ON');
     this.db.pragma('busy_timeout = 5000');
     this.db.pragma('synchronous = NORMAL');
+    this.db.pragma('wal_autocheckpoint = 1000');
     this.init();
+    this.startWalCheckpointTimer();
   }
 
   /** Expose the raw database handle for the coordination module. */
@@ -63,7 +66,27 @@ export class EngramStore {
 
   /** Flush WAL to main database file. */
   walCheckpoint(): void {
-    this.db.pragma('wal_checkpoint(TRUNCATE)');
+    try {
+      this.db.pragma('wal_checkpoint(TRUNCATE)');
+    } catch {
+      // Checkpoint can fail if another connection holds the DB; non-fatal
+    }
+  }
+
+  /** Start periodic WAL checkpoint every 5 minutes to prevent unbounded WAL growth. */
+  private startWalCheckpointTimer(): void {
+    this.walTimer = setInterval(() => {
+      this.walCheckpoint();
+    }, 5 * 60 * 1000);
+    this.walTimer.unref();
+  }
+
+  /** Stop the WAL checkpoint timer (call before close). */
+  stopWalCheckpointTimer(): void {
+    if (this.walTimer) {
+      clearInterval(this.walTimer);
+      this.walTimer = null;
+    }
   }
 
   private init(): void {
@@ -212,6 +235,13 @@ export class EngramStore {
       `);
     }
 
+    // Migration: add embedding_model for version tracking (prevents drift on model change)
+    try {
+      this.db.prepare('SELECT embedding_model FROM engrams LIMIT 0').get();
+    } catch {
+      this.db.exec(`ALTER TABLE engrams ADD COLUMN embedding_model TEXT`);
+    }
+
     // Migration: add conscious_state table for checkpointing
     this.db.exec(`
       CREATE TABLE IF NOT EXISTS conscious_state (
@@ -327,9 +357,13 @@ export class EngramStore {
     );
   }
 
-  updateEmbedding(id: string, embedding: number[]): void {
+  updateEmbedding(id: string, embedding: number[], modelId?: string): void {
     const blob = Buffer.from(new Float32Array(embedding).buffer);
-    this.db.prepare('UPDATE engrams SET embedding = ? WHERE id = ?').run(blob, id);
+    if (modelId) {
+      this.db.prepare('UPDATE engrams SET embedding = ?, embedding_model = ? WHERE id = ?').run(blob, modelId, id);
+    } else {
+      this.db.prepare('UPDATE engrams SET embedding = ? WHERE id = ?').run(blob, id);
+    }
   }
 
   retractEngram(id: string, retractedBy: string | null): void {
@@ -1012,6 +1046,8 @@ export class EngramStore {
   }
 
   close(): void {
+    this.stopWalCheckpointTimer();
+    this.walCheckpoint();
     this.db.close();
   }
 }