agent-working-memory 0.6.1 → 0.7.1

package/src/engine/consolidation.ts

@@ -99,8 +99,19 @@ export interface ConsolidationResult {
   stagingPromoted: number;
   stagingDiscarded: number;
   engramsProcessed: number;
+  synthesesCreated: number;
 }
 
+const MAX_SYNTHESES_PER_CYCLE = 5;
+const MIN_CLUSTER_SIZE_FOR_SYNTHESIS = 3;
+
+/** Shared stopwords for synthesis keyword extraction */
+const SYNTH_STOPWORDS = new Set(['the', 'is', 'a', 'an', 'and', 'or', 'of', 'to', 'in', 'for',
+  'on', 'with', 'that', 'this', 'it', 'was', 'are', 'be', 'has', 'had', 'but', 'not', 'from',
+  'by', 'as', 'at', 'i', 'you', 'we', 'my', 'your', 'can', 'will', 'do', 'did', 'if', 'user',
+  'assistant', 'would', 'like', 'just', 'also', 'about', 'really', 'think', 'know', 'want',
+  'here', 'there', 'some', 'more', 'very', 'been', 'have', 'what', 'when', 'how', 'they']);
+
 export class ConsolidationEngine {
   private store: EngramStore;
 
@@ -136,6 +147,7 @@ export class ConsolidationEngine {
       stagingPromoted: 0,
       stagingDiscarded: 0,
       engramsProcessed: 0,
+      synthesesCreated: 0,
     };
 
     // --- Phase 1: Replay ---
@@ -208,6 +220,153 @@ export class ConsolidationEngine {
       }
     }
 
+    // --- Phase 2.5: Two types of synthesis ---
+    //
+    // Type A: SESSION SYNTHESIS (perfect recall)
+    //   Groups by shared metadata tags (sid=, proj=, topic=).
+    //   Summarizes what happened in a conversation/project session.
+    //   Helps find specific facts by providing a topical anchor.
+    //
+    // Type B: PATTERN SYNTHESIS (novel recall)
+    //   Uses the existing vector-similarity clusters.
+    //   Finds structural patterns across disparate topics.
+    //   "Debugging X by Y" + "Resolving A by B" → pattern: "conflict → ordering"
+    //   Lower confidence — these are speculative connections, not facts.
+
+    let synthCount = 0;
+
+    // --- Type A: Session synthesis (tag-based grouping) ---
+    // Group engrams by shared session/project tags, NOT vector similarity
+    const tagGroups = new Map<string, Engram[]>();
+    for (const e of engrams) {
+      if (e.tags.includes('synth=true')) continue; // Skip existing syntheses
+      for (const tag of e.tags) {
+        if (tag.startsWith('sid=') || tag.startsWith('proj=') || tag.startsWith('topic=')) {
+          const group = tagGroups.get(tag) ?? [];
+          group.push(e);
+          tagGroups.set(tag, group);
+        }
+      }
+    }
+
+    for (const [tag, group] of tagGroups) {
+      if (group.length < MIN_CLUSTER_SIZE_FOR_SYNTHESIS) continue;
+      if (synthCount >= MAX_SYNTHESES_PER_CYCLE) break;
+
+      // Check if a synthesis for this tag already exists
+      const existing = engrams.find(e =>
+        e.tags.includes('synth=true') && e.tags.includes(tag)
+      );
+      if (existing) continue;
+
+      // Extract key terms from this group
+      const wordCounts = new Map<string, number>();
+      for (const e of group) {
+        const words = e.content.toLowerCase().replace(/[^\w\s]/g, '').split(/\s+/);
+        for (const w of words) {
+          if (w.length > 3 && !SYNTH_STOPWORDS.has(w)) {
+            wordCounts.set(w, (wordCounts.get(w) ?? 0) + 1);
+          }
+        }
+      }
+      const keyTerms = [...wordCounts.entries()]
+        .sort((a, b) => b[1] - a[1])
+        .slice(0, 15)
+        .map(([word]) => word);
+
+      // Extract unique concepts (deduplicated)
+      const concepts = [...new Set(group.map(e => e.concept))];
+
+      const synthContent = [
+        `Session summary (${tag}, ${group.length} turns).`,
+        `Key topics: ${keyTerms.slice(0, 8).join(', ')}.`,
+        `Discussed: ${keyTerms.slice(8).join(', ')}.`,
+      ].join(' ');
+
+      const synthEngram = this.store.createEngram({
+        agentId,
+        concept: `session: ${tag} (${keyTerms.slice(0, 3).join(', ')})`,
+        content: synthContent,
+        tags: [tag, 'synth=true', 'synth-type=session'],
+        salience: 0.6,
+        confidence: 0.55,
+        memoryType: 'semantic',
+      });
+
+      // Set embedding to group centroid
+      const centroid = this.computeCentroid(group);
+      if (centroid.length > 0) {
+        this.store.updateEmbedding(synthEngram.id, centroid);
+      }
+
+      // Link to sources
+      for (const source of group.slice(0, 10)) { // Cap links to prevent explosion
+        this.store.upsertAssociation(synthEngram.id, source.id, 0.4, 'causal');
+      }
+
+      synthCount++;
+      result.synthesesCreated++;
+    }
+
+    // --- Type B: Pattern synthesis (vector-similarity clusters, speculative) ---
+    // Only create these for clusters where members come from DIFFERENT sessions/projects.
+    // This finds cross-domain patterns: "debugging technique A" + "architecture pattern B"
+    for (const cluster of clusters) {
+      if (cluster.length < MIN_CLUSTER_SIZE_FOR_SYNTHESIS) continue;
+      if (synthCount >= MAX_SYNTHESES_PER_CYCLE) break;
+      if (cluster.some(e => e.tags.includes('synth=true'))) continue;
+
+      // Only create pattern synthesis if cluster spans multiple sessions
+      const sessionTags = new Set<string>();
+      for (const e of cluster) {
+        for (const tag of e.tags) {
+          if (tag.startsWith('sid=') || tag.startsWith('proj=')) sessionTags.add(tag);
+        }
+      }
+      if (sessionTags.size < 2) continue; // Same session → skip (Type A handles it)
+
+      const wordCounts = new Map<string, number>();
+      for (const e of cluster) {
+        const words = e.content.toLowerCase().replace(/[^\w\s]/g, '').split(/\s+/);
+        for (const w of words) {
+          if (w.length > 3 && !SYNTH_STOPWORDS.has(w)) {
+            wordCounts.set(w, (wordCounts.get(w) ?? 0) + 1);
+          }
+        }
+      }
+      const keyTerms = [...wordCounts.entries()]
+        .sort((a, b) => b[1] - a[1])
+        .slice(0, 10)
+        .map(([word]) => word);
+
+      const synthContent = [
+        `Pattern across ${sessionTags.size} sessions (${cluster.length} memories).`,
+        `Common themes: ${keyTerms.join(', ')}.`,
+      ].join(' ');
+
+      const synthEngram = this.store.createEngram({
+        agentId,
+        concept: `pattern: ${keyTerms.slice(0, 3).join(', ')}`,
+        content: synthContent,
+        tags: [...sessionTags, 'synth=true', 'synth-type=pattern'],
+        salience: 0.5,       // Lower — speculative
+        confidence: 0.4,     // Lower — these are hypotheses not facts
+        memoryType: 'semantic',
+      });
+
+      const centroid = this.computeCentroid(cluster);
+      if (centroid.length > 0) {
+        this.store.updateEmbedding(synthEngram.id, centroid);
+      }
+
+      for (const source of cluster.slice(0, 8)) {
+        this.store.upsertAssociation(synthEngram.id, source.id, 0.3, 'bridge');
+      }
+
+      synthCount++;
+      result.synthesesCreated++;
+    }
+
     // --- Phase 3: Direct cross-cluster bridging ---
     // Find the closest pair of memories between each cluster pair and bridge them.
     if (clusters.length >= 2) {
@@ -244,21 +403,18 @@ export class ConsolidationEngine {
     // that received positive feedback are more durable — just like how
     // practiced memories are more resistant to forgetting in the brain.
     // Base half-life: 7 days. High-confidence (0.8+) gets up to 30 days.
-    const engramConfMap = new Map(engrams.map(e => [e.id, e.confidence]));
+    const engramMap = new Map(engrams.map(e => [e.id, e]));
     const associations = this.store.getAllAssociations(agentId);
     for (const assoc of associations) {
       const daysSince =
         (Date.now() - assoc.lastActivated.getTime()) / (1000 * 60 * 60 * 24);
-      if (daysSince < 0.5) continue; // Skip recently activated
+      if (daysSince < 0.5) continue;
 
-      // Confidence + access-count modulated half-life (synaptic tagging for edges)
-      // Base: 7 days. High confidence (0.8+): up to 21 days.
-      // High access count: further extends half-life (log-scaled, capped at 2x boost).
-      const fromConf = engramConfMap.get(assoc.fromEngramId) ?? 0.5;
-      const toConf = engramConfMap.get(assoc.toEngramId) ?? 0.5;
+      const fromEngram = engramMap.get(assoc.fromEngramId);
+      const toEngram = engramMap.get(assoc.toEngramId);
+      const fromConf = fromEngram?.confidence ?? 0.5;
+      const toConf = toEngram?.confidence ?? 0.5;
       const maxConf = Math.max(fromConf, toConf);
-      const fromEngram = engrams.find(e => e.id === assoc.fromEngramId);
-      const toEngram = engrams.find(e => e.id === assoc.toEngramId);
       const maxAccess = Math.max(fromEngram?.accessCount ?? 0, toEngram?.accessCount ?? 0);
       const accessBoost = Math.min(2.0, 1.0 + 0.5 * Math.log1p(maxAccess));
       const halfLifeDays = Math.min(

package/src/index.ts

@@ -1,199 +1,199 @@
-// Copyright 2026 Robert Winter / Complete Ideas
-// SPDX-License-Identifier: Apache-2.0
-import { readFileSync, copyFileSync, existsSync, mkdirSync, readdirSync, unlinkSync } from 'node:fs';
-import { resolve, dirname, basename } from 'node:path';
-import Fastify from 'fastify';
-
-// Load .env file if present (no external dependency)
-try {
-  const envPath = resolve(process.cwd(), '.env');
-  const envContent = readFileSync(envPath, 'utf-8');
-  for (const line of envContent.split('\n')) {
-    const trimmed = line.trim();
-    if (!trimmed || trimmed.startsWith('#')) continue;
-    const eqIdx = trimmed.indexOf('=');
-    if (eqIdx === -1) continue;
-    const key = trimmed.slice(0, eqIdx).trim();
-    const val = trimmed.slice(eqIdx + 1).trim().replace(/^["']|["']$/g, '');
-    if (!process.env[key]) process.env[key] = val; // Don't override existing env
-  }
-} catch { /* No .env file — that's fine */ }
-import { EngramStore } from './storage/sqlite.js';
-import { ActivationEngine } from './engine/activation.js';
-import { ConnectionEngine } from './engine/connections.js';
-import { StagingBuffer } from './engine/staging.js';
-import { EvictionEngine } from './engine/eviction.js';
-import { RetractionEngine } from './engine/retraction.js';
-import { EvalEngine } from './engine/eval.js';
-import { ConsolidationEngine } from './engine/consolidation.js';
-import { ConsolidationScheduler } from './engine/consolidation-scheduler.js';
-import { registerRoutes } from './api/routes.js';
-import { DEFAULT_AGENT_CONFIG } from './types/agent.js';
-import { getEmbedder } from './core/embeddings.js';
-import { getReranker } from './core/reranker.js';
-import { getExpander } from './core/query-expander.js';
-import { initLogger } from './core/logger.js';
-
-const PORT = parseInt(process.env.AWM_PORT ?? '8400', 10);
-const DB_PATH = process.env.AWM_DB_PATH ?? 'memory.db';
-const API_KEY = process.env.AWM_API_KEY ?? null;
-
-async function main() {
-  // Auto-backup: copy DB to backups/ on startup (cheap insurance)
-  if (existsSync(DB_PATH)) {
-    const dbDir = dirname(resolve(DB_PATH));
-    const backupDir = resolve(dbDir, 'backups');
-    mkdirSync(backupDir, { recursive: true });
-    const ts = new Date().toISOString().replace(/[:.]/g, '-').slice(0, 19);
-    const backupPath = resolve(backupDir, `${basename(DB_PATH, '.db')}-${ts}.db`);
-    try {
-      copyFileSync(resolve(DB_PATH), backupPath);
-      console.log(`Backup: ${backupPath}`);
-    } catch (err) {
-      console.log(`Backup skipped: ${(err as Error).message}`);
-    }
-  }
-
-  // Logger — write activity to awm.log alongside the DB
-  initLogger(DB_PATH);
-
-  // 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);
-  const stagingBuffer = new StagingBuffer(store, activationEngine);
-  const evictionEngine = new EvictionEngine(store);
-  const retractionEngine = new RetractionEngine(store);
-  const evalEngine = new EvalEngine(store);
-  const consolidationEngine = new ConsolidationEngine(store);
-  const consolidationScheduler = new ConsolidationScheduler(store, consolidationEngine);
-
-  // API — disable Fastify's default request logging (too noisy for hive polling)
-  // 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) {
-    app.addHook('onRequest', async (req, reply) => {
-      if (req.url === '/health') return; // Health check is always public
-      const bearer = req.headers.authorization;
-      const xApiKey = req.headers['x-api-key'] as string | undefined;
-      if (bearer === `Bearer ${API_KEY}` || xApiKey === API_KEY) return;
-      reply.code(401).send({ error: 'Unauthorized' });
-    });
-    console.log('API key auth enabled (AWM_API_KEY set)');
-  }
-
-  registerRoutes(app, {
-    store, activationEngine, connectionEngine,
-    evictionEngine, retractionEngine, evalEngine,
-    consolidationEngine, consolidationScheduler,
-  });
-
-  // Coordination module (opt-in via AWM_COORDINATION=true)
-  const { isCoordinationEnabled, initCoordination, stopCoordinationCleanup } = await import('./coordination/index.js');
-  if (isCoordinationEnabled()) {
-    initCoordination(app, store.getDb(), store);
-  } else {
-    console.log('  Coordination module disabled (set AWM_COORDINATION=true to enable)');
-  }
-
-  // Background tasks
-  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));
-  getExpander().catch(err => console.warn('Query expander model unavailable:', err.message));
-
-  // Start server
-  await app.listen({ port: PORT, host: '0.0.0.0' });
-  console.log(`AgentWorkingMemory v0.6.0 listening on port ${PORT}`);
-
-  // Graceful shutdown
-  const shutdown = async () => {
-    clearInterval(backupTimer);
-    await stopCoordinationCleanup();
-    consolidationScheduler.stop();
-    stagingBuffer.stop();
-    try { store.walCheckpoint(); } catch { /* non-fatal */ }
-    store.close();
-    process.exit(0);
-  };
-  process.on('SIGINT', shutdown);
-  process.on('SIGTERM', shutdown);
-}
-
-main().catch(err => {
-  console.error('Failed to start:', err);
-  process.exit(1);
-});
+// Copyright 2026 Robert Winter / Complete Ideas
+// SPDX-License-Identifier: Apache-2.0
+import { readFileSync, copyFileSync, existsSync, mkdirSync, readdirSync, unlinkSync } from 'node:fs';
+import { resolve, dirname, basename } from 'node:path';
+import Fastify from 'fastify';
+
+// Load .env file if present (no external dependency)
+try {
+  const envPath = resolve(process.cwd(), '.env');
+  const envContent = readFileSync(envPath, 'utf-8');
+  for (const line of envContent.split('\n')) {
+    const trimmed = line.trim();
+    if (!trimmed || trimmed.startsWith('#')) continue;
+    const eqIdx = trimmed.indexOf('=');
+    if (eqIdx === -1) continue;
+    const key = trimmed.slice(0, eqIdx).trim();
+    const val = trimmed.slice(eqIdx + 1).trim().replace(/^["']|["']$/g, '');
+    if (!process.env[key]) process.env[key] = val; // Don't override existing env
+  }
+} catch { /* No .env file — that's fine */ }
+import { EngramStore } from './storage/sqlite.js';
+import { ActivationEngine } from './engine/activation.js';
+import { ConnectionEngine } from './engine/connections.js';
+import { StagingBuffer } from './engine/staging.js';
+import { EvictionEngine } from './engine/eviction.js';
+import { RetractionEngine } from './engine/retraction.js';
+import { EvalEngine } from './engine/eval.js';
+import { ConsolidationEngine } from './engine/consolidation.js';
+import { ConsolidationScheduler } from './engine/consolidation-scheduler.js';
+import { registerRoutes } from './api/routes.js';
+import { DEFAULT_AGENT_CONFIG } from './types/agent.js';
+import { getEmbedder } from './core/embeddings.js';
+import { getReranker } from './core/reranker.js';
+import { getExpander } from './core/query-expander.js';
+import { initLogger } from './core/logger.js';
+
+const PORT = parseInt(process.env.AWM_PORT ?? '8400', 10);
+const DB_PATH = process.env.AWM_DB_PATH ?? 'memory.db';
+const API_KEY = process.env.AWM_API_KEY ?? null;
+
+async function main() {
+  // Auto-backup: copy DB to backups/ on startup (cheap insurance)
+  if (existsSync(DB_PATH)) {
+    const dbDir = dirname(resolve(DB_PATH));
+    const backupDir = resolve(dbDir, 'backups');
+    mkdirSync(backupDir, { recursive: true });
+    const ts = new Date().toISOString().replace(/[:.]/g, '-').slice(0, 19);
+    const backupPath = resolve(backupDir, `${basename(DB_PATH, '.db')}-${ts}.db`);
+    try {
+      copyFileSync(resolve(DB_PATH), backupPath);
+      console.log(`Backup: ${backupPath}`);
+    } catch (err) {
+      console.log(`Backup skipped: ${(err as Error).message}`);
+    }
+  }
+
+  // Logger — write activity to awm.log alongside the DB
+  initLogger(DB_PATH);
+
+  // 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);
+  const stagingBuffer = new StagingBuffer(store, activationEngine);
+  const evictionEngine = new EvictionEngine(store);
+  const retractionEngine = new RetractionEngine(store);
+  const evalEngine = new EvalEngine(store);
+  const consolidationEngine = new ConsolidationEngine(store);
+  const consolidationScheduler = new ConsolidationScheduler(store, consolidationEngine);
+
+  // API — disable Fastify's default request logging (too noisy for hive polling)
+  // 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) {
+    app.addHook('onRequest', async (req, reply) => {
+      if (req.url === '/health') return; // Health check is always public
+      const bearer = req.headers.authorization;
+      const xApiKey = req.headers['x-api-key'] as string | undefined;
+      if (bearer === `Bearer ${API_KEY}` || xApiKey === API_KEY) return;
+      reply.code(401).send({ error: 'Unauthorized' });
+    });
+    console.log('API key auth enabled (AWM_API_KEY set)');
+  }
+
+  registerRoutes(app, {
+    store, activationEngine, connectionEngine,
+    evictionEngine, retractionEngine, evalEngine,
+    consolidationEngine, consolidationScheduler,
+  });
+
+  // Coordination module (opt-in via AWM_COORDINATION=true)
+  const { isCoordinationEnabled, initCoordination, stopCoordinationCleanup } = await import('./coordination/index.js');
+  if (isCoordinationEnabled()) {
+    initCoordination(app, store.getDb(), store);
+  } else {
+    console.log('  Coordination module disabled (set AWM_COORDINATION=true to enable)');
+  }
+
+  // Background tasks
+  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));
+  getExpander().catch(err => console.warn('Query expander model unavailable:', err.message));
+
+  // Start server
+  await app.listen({ port: PORT, host: '0.0.0.0' });
+  console.log(`AgentWorkingMemory v0.7.1 listening on port ${PORT}`);
+
+  // Graceful shutdown
+  const shutdown = async () => {
+    clearInterval(backupTimer);
+    await stopCoordinationCleanup();
+    consolidationScheduler.stop();
+    stagingBuffer.stop();
+    try { store.walCheckpoint(); } catch { /* non-fatal */ }
+    store.close();
+    process.exit(0);
+  };
+  process.on('SIGINT', shutdown);
+  process.on('SIGTERM', shutdown);
+}
+
+main().catch(err => {
+  console.error('Failed to start:', err);
+  process.exit(1);
+});