agent-working-memory 0.5.6 → 0.6.0

package/src/engine/activation.ts

@@ -26,10 +26,104 @@ import { embed, cosineSimilarity } from '../core/embeddings.js';
 import { rerank } from '../core/reranker.js';
 import { expandQuery } from '../core/query-expander.js';
 import type {
-  Engram, ActivationResult, ActivationQuery, Association, PhaseScores,
+  Engram, ActivationResult, ActivationQuery, Association, PhaseScores, QueryMode,
 } from '../types/index.js';
 import type { EngramStore } from '../storage/sqlite.js';
 
+// ─── Query-adaptive pipeline parameters ───────────────────────────
+
+interface AdaptiveParams {
+  mode: 'targeted' | 'exploratory' | 'balanced';
+  textWeight: number;       // Weight for text match in composite (default 0.6)
+  temporalWeight: number;   // Weight for temporal signals (default 0.4)
+  decayExponentBase: number;// Base ACT-R decay exponent (default 0.5)
+  zScoreGate: number;       // Z-score threshold for vector match (default 0.5)
+  beamWidth: number;        // Graph walk beam width (default 15)
+  hopPenalty: number;       // Graph walk hop penalty (default 0.3)
+}
+
+const ADAPTIVE_PRESETS: Record<'targeted' | 'exploratory' | 'balanced', AdaptiveParams> = {
+  targeted: {
+    mode: 'targeted',
+    textWeight: 0.75,       // Heavy BM25/keyword emphasis
+    temporalWeight: 0.25,
+    decayExponentBase: 0.6, // Stronger decay — recent exact matches matter more
+    zScoreGate: 0.8,        // Strict vector gate — only strong semantic matches
+    beamWidth: 3,           // Narrow beam — don't wander
+    hopPenalty: 0.2,        // Steeper hop penalty
+  },
+  exploratory: {
+    mode: 'exploratory',
+    textWeight: 0.4,        // Lower BM25 weight
+    temporalWeight: 0.6,    // Lean on temporal/associative signals
+    decayExponentBase: 0.3, // Weaker decay — surface older memories
+    zScoreGate: 0.3,        // Relaxed vector gate — cast wider net
+    beamWidth: 20,          // Wide beam — explore associations
+    hopPenalty: 0.4,        // Gentler hop penalty
+  },
+  balanced: {
+    mode: 'balanced',
+    textWeight: 0.6,
+    temporalWeight: 0.4,
+    decayExponentBase: 0.5,
+    zScoreGate: 0.5,
+    beamWidth: 15,
+    hopPenalty: 0.3,
+  },
+};
+
+/**
+ * Classify a query as targeted, exploratory, or balanced.
+ *
+ * Targeted signals: identifiers (PROJ-123, camelCase, snake_case, UUIDs),
+ * short queries (< 8 words), quoted strings, file paths.
+ *
+ * Exploratory signals: question words, long queries (> 15 words),
+ * vague modifiers ("general", "overview", "about", "related to").
+ */
+function classifyQuery(context: string): 'targeted' | 'exploratory' | 'balanced' {
+  const words = context.split(/\s+/).filter(w => w.length > 0);
+  const wordCount = words.length;
+  const lower = context.toLowerCase();
+
+  let targetedScore = 0;
+  let exploratoryScore = 0;
+
+  // Identifier patterns
+  if (/[A-Z]+-\d+/.test(context)) targetedScore += 2;          // PROJ-123
+  if (/[a-z][A-Z]/.test(context)) targetedScore += 1;          // camelCase
+  if (/\w+_\w+/.test(context)) targetedScore += 1;             // snake_case
+  if (/[0-9a-f]{8}-[0-9a-f]{4}/.test(lower)) targetedScore += 2; // UUID fragment
+  if (/["']/.test(context)) targetedScore += 1;                 // Quoted strings
+  if (/[\/\\]/.test(context)) targetedScore += 1;               // File paths
+  if (/\.\w{1,4}$/.test(context.trim())) targetedScore += 1;   // File extensions
+
+  // Short queries are usually targeted
+  if (wordCount <= 5) targetedScore += 2;
+  else if (wordCount <= 8) targetedScore += 1;
+
+  // Question words / exploratory modifiers
+  if (/^(what|how|why|when|where|who|which|can|does|is|are)\b/i.test(context)) exploratoryScore += 1;
+  if (/\b(overview|general|about|related|similar|like|broad|concept|idea|approach|strategy)\b/i.test(lower)) exploratoryScore += 1;
+  if (/\b(any|all|everything|anything)\b/i.test(lower)) exploratoryScore += 1;
+
+  // Long queries are usually exploratory
+  if (wordCount > 15) exploratoryScore += 2;
+  else if (wordCount > 10) exploratoryScore += 1;
+
+  const diff = targetedScore - exploratoryScore;
+  if (diff >= 2) return 'targeted';
+  if (diff <= -2) return 'exploratory';
+  return 'balanced';
+}
+
+function resolveAdaptiveParams(query: ActivationQuery): AdaptiveParams {
+  const mode = query.mode ?? 'auto';
+  if (mode !== 'auto') return ADAPTIVE_PRESETS[mode];
+  const classified = classifyQuery(query.context);
+  return ADAPTIVE_PRESETS[classified];
+}
+
 /**
  * Common English stopwords — filtered from similarity calculations.
  * These words carry no semantic signal for memory retrieval.
@@ -85,6 +179,7 @@ export class ActivationEngine {
     const useReranker = query.useReranker ?? true;
     const useExpansion = query.useExpansion ?? true;
     const abstentionThreshold = query.abstentionThreshold ?? 0;
+    const adaptive = resolveAdaptiveParams(query);
 
     // 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.
@@ -155,7 +250,12 @@ export class ActivationEngine {
     const candidateMap = new Map<string, Engram>();
     for (const r of bm25Ranked) candidateMap.set(r.engram.id, r.engram);
     for (const e of allActive) candidateMap.set(e.id, e);
-    const candidates = Array.from(candidateMap.values());
+    let candidates = Array.from(candidateMap.values());
+
+    // Filter by memory type if specified
+    if (query.memoryType) {
+      candidates = candidates.filter(e => e.memoryType === query.memoryType);
+    }
 
     if (candidates.length === 0) return [];
 
@@ -208,30 +308,31 @@ export class ActivationEngine {
 
       // --- Vector similarity (semantic signal) ---
       // Two-stage: absolute floor prevents noise, then z-score ranks within matches.
-      // Stage 1: Raw cosine must exceed mean + 1 stddev (absolute relevance gate)
-      // Stage 2: Z-score maps relative position to 0-1 for ranking quality
+      // z-gate adapts to query mode: targeted uses strict gate (0.8), exploratory relaxes (0.3).
       let vectorMatch = 0;
       const rawSim = rawCosineSims.get(engram.id);
       if (rawSim !== undefined) {
         const zScore = (rawSim - simMean) / simStdDev;
-        // Gate: must be at least 1 stddev above mean to be considered a match
-        if (zScore > 1.0) {
-          // Map z=1..3 → 0..1 linearly
-          vectorMatch = Math.min(1, (zScore - 1.0) / 2.0);
+        if (zScore > adaptive.zScoreGate) {
+          vectorMatch = Math.min(1, (zScore - adaptive.zScoreGate) / 2.0);
         }
       }
 
-      // Combined text match: best of keyword and vector signals
-      const textMatch = Math.max(keywordMatch, vectorMatch);
+      // Combined text match: weighted blend of keyword and vector signals.
+      // BM25 is better at lexical discrimination; vector is better at semantic matching.
+      // When both are non-zero, blend favors the stronger signal with a boost.
+      const textMatch = keywordMatch > 0 && vectorMatch > 0
+        ? 0.5 * Math.max(keywordMatch, vectorMatch) + 0.3 * Math.min(keywordMatch, vectorMatch) + 0.2 * (keywordMatch * vectorMatch)
+        : Math.max(keywordMatch, vectorMatch);
 
       // --- Temporal signals ---
 
       // ACT-R decay — confidence + replay modulated (synaptic tagging)
       // High-confidence memories decay slower. Heavily-accessed memories also resist decay.
-      // Default exponent: 0.5. High confidence (0.8+): 0.3. High access (10+): further -0.05.
+      // Base exponent adapts to query mode: targeted (0.6) decays harder, exploratory (0.3) preserves older memories.
       const confMod = 0.2 * Math.max(0, (engram.confidence - 0.5) / 0.5);
       const replayMod = Math.min(0.1, 0.05 * Math.log1p(engram.accessCount));
-      const decayExponent = Math.max(0.2, 0.5 - confMod - replayMod);
+      const decayExponent = Math.max(0.2, adaptive.decayExponentBase - confMod - replayMod);
       const decayScore = baseLevelActivation(engram.accessCount, ageDays, decayExponent);
 
       // Hebbian boost from associations — capped to prevent popular memories
@@ -261,12 +362,10 @@ export class ActivationEngine {
         : 0;
 
       // --- Composite score: relevance-gated additive ---
-      // Text relevance must be present for temporal signals to contribute.
-      // Without text relevance, a memory shouldn't activate regardless of recency.
-      // Temporal contribution scales with text relevance (weak match = weak temporal boost).
+      // Text/temporal weights adapt to query mode: targeted (0.75/0.25), exploratory (0.4/0.6).
       const temporalNorm = Math.min(softplus(decayScore + hebbianBoost), 3.0) / 3.0;
       const relevanceGate = textMatch > 0.1 ? textMatch : 0.0; // Proportional gate
-      const composite = (0.6 * textMatch + 0.4 * temporalNorm * relevanceGate + centralityBoost * relevanceGate + feedbackBonus * relevanceGate) * confidenceGate;
+      const composite = (adaptive.textWeight * textMatch + adaptive.temporalWeight * temporalNorm * relevanceGate + centralityBoost * relevanceGate + feedbackBonus * relevanceGate) * confidenceGate;
 
       const phaseScores: PhaseScores = {
         textMatch,
@@ -316,14 +415,16 @@ export class ActivationEngine {
             const rs = rawCosineSims.get(engram.id) ?? (queryEmbedding && engram.embedding ? cosineSimilarity(queryEmbedding, engram.embedding) : 0);
             if (rs) {
               const z = (rs - simMean) / simStdDev;
-              if (z > 1.0) vm = Math.min(1, (z - 1.0) / 2.0);
+              if (z > adaptive.zScoreGate) vm = Math.min(1, (z - adaptive.zScoreGate) / 2.0);
             }
-            const tm = Math.max(km, vm);
+            const tm = km > 0 && vm > 0
+              ? 0.5 * Math.max(km, vm) + 0.3 * Math.min(km, vm) + 0.2 * (km * vm)
+              : Math.max(km, vm);
             const ds = baseLevelActivation(engram.accessCount, ageDays);
             const rh = associations.length > 0 ? Math.min(associations.reduce((s, a) => s + a.weight, 0) / associations.length, 0.5) : 0;
             const tn = Math.min(softplus(ds + rh), 3.0) / 3.0;
             const rg = tm > 0.1 ? tm : 0.0;
-            const comp = (0.6 * tm + 0.4 * tn * rg) * engram.confidence;
+            const comp = (adaptive.textWeight * tm + adaptive.temporalWeight * tn * rg) * engram.confidence;
             scored.push({ engram, score: comp, phaseScores: { textMatch: tm, vectorMatch: vm, decayScore: ds, hebbianBoost: rh, graphBoost: 0, confidenceGate: engram.confidence, composite: comp, rerankerScore: 0 }, associations });
           }
         }
@@ -405,7 +506,7 @@ export class ActivationEngine {
     // Only walk from engrams that had text relevance (composite > 0 pre-walk)
     const sorted = scored.sort((a, b) => b.score - a.score);
     const topN = sorted.slice(0, limit * 3);
-    this.graphWalk(topN, 2, 0.3);
+    this.graphWalk(topN, 2, adaptive.hopPenalty, adaptive.beamWidth);
 
     // Phase 6: Initial filter and sort for re-ranking pool
     const pool = topN
@@ -554,11 +655,12 @@ export class ActivationEngine {
   private graphWalk(
     scored: { engram: Engram; score: number; phaseScores: PhaseScores; associations: Association[] }[],
     maxDepth: number,
-    hopPenalty: number
+    hopPenalty: number,
+    beamWidth: number = 15
   ): void {
     const scoreMap = new Map(scored.map(s => [s.engram.id, s]));
-    const MAX_TOTAL_BOOST = 0.25; // Slightly higher cap for beam search (deeper paths earn it)
-    const BEAM_WIDTH = 15;
+    const MAX_TOTAL_BOOST = 0.25;
+    const BEAM_WIDTH = beamWidth;
 
     // Seed the beam with high-scoring, text-relevant items
     const beam = scored

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++;
         }
       }

package/src/index.ts

@@ -1,6 +1,6 @@
 // Copyright 2026 Robert Winter / Complete Ideas
 // SPDX-License-Identifier: Apache-2.0
-import { readFileSync, copyFileSync, existsSync, mkdirSync } from 'node:fs';
+import { readFileSync, copyFileSync, existsSync, mkdirSync, readdirSync, unlinkSync } from 'node:fs';
 import { resolve, dirname, basename } from 'node:path';
 import Fastify from 'fastify';
 
@@ -60,6 +60,36 @@ async function main() {
   // Storage
   const store = new EngramStore(DB_PATH);
 
+  // Integrity check
+  const integrity = store.integrityCheck();
+  if (!integrity.ok) {
+    console.error(`DB integrity check FAILED: ${integrity.result}`);
+    // Close corrupt DB, restore from backup, and exit for process manager to restart
+    store.close();
+    const dbDir = dirname(resolve(DB_PATH));
+    const backupDir = resolve(dbDir, 'backups');
+    if (existsSync(backupDir)) {
+      const backups = readdirSync(backupDir)
+        .filter(f => f.endsWith('.db'))
+        .sort()
+        .reverse();
+      if (backups.length > 0) {
+        const restorePath = resolve(backupDir, backups[0]);
+        console.error(`Attempting restore from: ${restorePath}`);
+        try {
+          copyFileSync(restorePath, resolve(DB_PATH));
+          console.error('Restore complete — exiting for restart with restored DB');
+          process.exit(1);
+        } catch (restoreErr) {
+          console.error(`Restore failed: ${(restoreErr as Error).message}`);
+        }
+      }
+    }
+    console.error('No backup available — continuing with potentially corrupt DB');
+  } else {
+    console.log('  DB integrity check: ok');
+  }
+
   // Engines
   const activationEngine = new ActivationEngine(store);
   const connectionEngine = new ConnectionEngine(store, activationEngine);
@@ -97,10 +127,13 @@ async function main() {
   if (isCoordinationEnabled()) {
     initCoordination(app, store.getDb());
     // Prune stale heartbeat events every 30s (keeps assignment/command events permanently)
-    const { pruneOldHeartbeats } = await import('./coordination/stale.js');
+    // 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);
   } else {
     console.log('  Coordination module disabled (set AWM_COORDINATION=true to enable)');
@@ -110,6 +143,42 @@ async function main() {
   stagingBuffer.start(DEFAULT_AGENT_CONFIG.stagingTtlMs);
   consolidationScheduler.start();
 
+  // Periodic hot backup every 10 minutes (keep last 6 = 1hr coverage)
+  const dbDir = dirname(resolve(DB_PATH));
+  const backupDir = resolve(dbDir, 'backups');
+  mkdirSync(backupDir, { recursive: true });
+
+  // Cleanup old backups on startup (older than 2 hours)
+  try {
+    const TWO_HOURS_MS = 2 * 60 * 60 * 1000;
+    const now = Date.now();
+    for (const f of readdirSync(backupDir).filter(f => f.endsWith('.db'))) {
+      const match = f.match(/(\d{4})-(\d{2})-(\d{2})T(\d{2})-(\d{2})-(\d{2})/);
+      if (match) {
+        const fileDate = new Date(`${match[1]}-${match[2]}-${match[3]}T${match[4]}:${match[5]}:${match[6]}Z`);
+        if (now - fileDate.getTime() > TWO_HOURS_MS) {
+          unlinkSync(resolve(backupDir, f));
+        }
+      }
+    }
+  } catch { /* cleanup is non-fatal */ }
+
+  const backupTimer = setInterval(() => {
+    try {
+      const ts = new Date().toISOString().replace(/[:.]/g, '-').slice(0, 19);
+      const backupPath = resolve(backupDir, `${basename(DB_PATH, '.db')}-${ts}.db`);
+      store.backup(backupPath);
+      // Prune: keep only last 6 backups
+      const backups = readdirSync(backupDir).filter(f => f.endsWith('.db')).sort();
+      while (backups.length > 6) {
+        const old = backups.shift()!;
+        try { unlinkSync(resolve(backupDir, old)); } catch { /* non-fatal */ }
+      }
+    } catch (err) {
+      console.warn(`[backup] failed: ${(err as Error).message}`);
+    }
+  }, 10 * 60_000); // 10 minutes
+
   // Pre-load ML models (downloads on first run: embeddings ~22MB, reranker ~22MB, expander ~80MB)
   getEmbedder().catch(err => console.warn('Embedding model unavailable:', err.message));
   getReranker().catch(err => console.warn('Reranker model unavailable:', err.message));
@@ -117,13 +186,15 @@ async function main() {
 
   // Start server
   await app.listen({ port: PORT, host: '0.0.0.0' });
-  console.log(`AgentWorkingMemory v0.5.5 listening on port ${PORT}`);
+  console.log(`AgentWorkingMemory v0.6.0 listening on port ${PORT}`);
 
   // Graceful shutdown
   const shutdown = () => {
+    clearInterval(backupTimer);
     if (heartbeatPruneTimer) clearInterval(heartbeatPruneTimer);
     consolidationScheduler.stop();
     stagingBuffer.stop();
+    try { store.walCheckpoint(); } catch { /* non-fatal */ }
     store.close();
     process.exit(0);
   };

package/src/mcp.ts

@@ -71,7 +71,7 @@ const INCOGNITO = process.env.AWM_INCOGNITO === '1' || process.env.AWM_INCOGNITO
 
 if (INCOGNITO) {
   console.error('AWM: incognito mode — all memory tools disabled, nothing will be recorded');
-  const server = new McpServer({ name: 'agent-working-memory', version: '0.5.5' });
+  const server = new McpServer({ name: 'agent-working-memory', version: '0.6.0' });
   const transport = new StdioServerTransport();
   server.connect(transport).catch(err => {
     console.error('MCP server failed:', err);
@@ -103,11 +103,33 @@ const consolidationScheduler = new ConsolidationScheduler(store, consolidationEn
 stagingBuffer.start(DEFAULT_AGENT_CONFIG.stagingTtlMs);
 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.5.5',
+  version: '0.6.0',
 });
 
+// --- Auto-classification for memory types ---
+
+function classifyMemoryType(content: string): 'episodic' | 'semantic' | 'procedural' | 'unclassified' {
+  const lower = content.toLowerCase();
+  // Procedural: how-to, steps, numbered lists
+  if (/\bhow to\b|\bsteps?:/i.test(content) || /^\s*\d+[\.\)]\s/m.test(content) || /\bthen run\b|\bfirst,?\s/i.test(content)) {
+    return 'procedural';
+  }
+  // Episodic: past tense events, incidents, specific time references
+  if (/\b(discovered|debugged|fixed|encountered|happened|resolved|found that|we did|i did|yesterday|last week|today)\b/i.test(content)) {
+    return 'episodic';
+  }
+  // Semantic: facts, decisions, rules, patterns
+  if (/\b(is|are|should|always|never|must|uses?|requires?|means|pattern|decision|rule|convention)\b/i.test(content) && content.length < 500) {
+    return 'semantic';
+  }
+  return 'unclassified';
+}
+
 // --- Tools ---
 
 server.tool(
@@ -139,6 +161,8 @@ The concept should be a short label (3-8 words). The content should be the full
       .describe('How much effort to resolve? 0=trivial, 1=significant debugging'),
     memory_class: z.enum(['canonical', 'working', 'ephemeral']).optional().default('working')
       .describe('Memory class: canonical (source-of-truth, never stages), working (default), ephemeral (temporary, decays faster)'),
+    memory_type: z.enum(['episodic', 'semantic', 'procedural', 'unclassified']).optional()
+      .describe('Memory type: episodic (events/incidents), semantic (facts/decisions), procedural (how-to/steps). Auto-classified if omitted.'),
     supersedes: z.string().optional()
       .describe('ID of an older memory this one replaces. The old memory is down-ranked, not deleted.'),
   },
@@ -206,6 +230,8 @@ The concept should be a short label (3-8 words). The content should be the full
       ? 0.40
       : CONFIDENCE_PRIORS[params.event_type ?? 'observation'] ?? 0.45;
 
+    const memoryType = params.memory_type ?? classifyMemoryType(params.content);
+
     const engram = store.createEngram({
       agentId: AGENT_ID,
       concept: params.concept,
@@ -217,6 +243,7 @@ The concept should be a short label (3-8 words). The content should be the full
       reasonCodes: salience.reasonCodes,
       ttl: salience.disposition === 'staging' ? DEFAULT_AGENT_CONFIG.stagingTtlMs : undefined,
       memoryClass: params.memory_class,
+      memoryType,
       supersedes: params.supersedes,
     });
 
@@ -244,13 +271,28 @@ The concept should be a short label (3-8 words). The content should be the full
     // Auto-checkpoint: track write
     try { store.updateAutoCheckpointWrite(AGENT_ID, engram.id); } catch { /* non-fatal */ }
 
+    // Decision propagation: when decision_made=true and coordination is enabled,
+    // broadcast to coord_decisions so other agents can discover it
+    if (params.decision_made && coordDb) {
+      try {
+        const agent = coordDb.prepare(
+          `SELECT id, current_task FROM coord_agents WHERE name = ? AND status != 'dead' ORDER BY last_seen DESC LIMIT 1`
+        ).get(AGENT_ID) as { id: string; current_task: string | null } | undefined;
+        if (agent) {
+          coordDb.prepare(
+            `INSERT INTO coord_decisions (author_id, assignment_id, tags, summary) VALUES (?, ?, ?, ?)`
+          ).run(agent.id, agent.current_task, params.tags ? JSON.stringify(params.tags) : null, params.concept);
+        }
+      } catch { /* decision propagation is non-fatal */ }
+    }
+
     const logDisposition = isLowSalience ? 'low-salience' : salience.disposition;
     log(AGENT_ID, `write:${logDisposition}`, `"${params.concept}" salience=${salience.score.toFixed(2)} novelty=${novelty.toFixed(1)} id=${engram.id}`);
 
     return {
       content: [{
         type: 'text' as const,
-        text: `Stored (${salience.disposition}) "${params.concept}" [${salience.score.toFixed(2)}]`,
+        text: `Stored (${salience.disposition}) "${params.concept}" [${salience.score.toFixed(2)}]\nID: ${engram.id}`,
       }],
     };
   }
@@ -276,6 +318,7 @@ Returns the most relevant memories ranked by text relevance, temporal recency, a
     include_staging: z.boolean().optional().default(false).describe('Include weak/unconfirmed memories?'),
     use_reranker: z.boolean().optional().default(true).describe('Use cross-encoder re-ranking for better relevance (default true)'),
     use_expansion: z.boolean().optional().default(true).describe('Expand query with synonyms for better recall (default true)'),
+    memory_type: z.enum(['episodic', 'semantic', 'procedural']).optional().describe('Filter by memory type (omit to search all types)'),
   },
   async (params) => {
     const queryText = params.query ?? params.context;
@@ -295,6 +338,7 @@ Returns the most relevant memories ranked by text relevance, temporal recency, a
       includeStaging: params.include_staging,
       useReranker: params.use_reranker,
       useExpansion: params.use_expansion,
+      memoryType: params.memory_type,
     });
 
     // Auto-checkpoint: track recall
@@ -638,6 +682,29 @@ Use this at the start of every session or after compaction to pick up where you
       }
     }
 
+    // Peer decisions: show recent decisions from other agents (last 30 min)
+    if (coordDb) {
+      try {
+        const myAgent = coordDb.prepare(
+          `SELECT id FROM coord_agents WHERE name = ? AND status != 'dead' ORDER BY last_seen DESC LIMIT 1`
+        ).get(AGENT_ID) as { id: string } | undefined;
+
+        const peerDecisions = coordDb.prepare(
+          `SELECT d.summary, a.name AS author_name, d.created_at
+           FROM coord_decisions d JOIN coord_agents a ON d.author_id = a.id
+           WHERE d.author_id != ? AND d.created_at > datetime('now', '-30 minutes')
+           ORDER BY d.created_at DESC LIMIT 10`
+        ).all(myAgent?.id ?? '') as Array<{ summary: string; author_name: string; created_at: string }>;
+
+        if (peerDecisions.length > 0) {
+          parts.push(`\n**Peer decisions (last 30 min):**`);
+          for (const d of peerDecisions) {
+            parts.push(`- [${d.author_name}] ${d.summary} (${d.created_at})`);
+          }
+        }
+      } catch { /* peer decisions are non-fatal */ }
+    }
+
     return {
       content: [{
         type: 'text' as const,
@@ -997,6 +1064,7 @@ async function main() {
     const { registerCoordinationTools } = await import('./coordination/mcp-tools.js');
     initCoordinationTables(store.getDb());
     registerCoordinationTools(server, store.getDb());
+    coordDb = store.getDb();
   } else {
     console.error('AWM: coordination tools disabled (set AWM_COORDINATION=true to enable)');
   }
@@ -1010,6 +1078,7 @@ async function main() {
     sidecar.close();
     consolidationScheduler.stop();
     stagingBuffer.stop();
+    try { store.walCheckpoint(); } catch { /* non-fatal */ }
     store.close();
   };
   process.on('SIGINT', () => { cleanup(); process.exit(0); });