agent-working-memory 0.7.4 → 0.7.7

package/src/core/salience.ts

@@ -41,6 +41,41 @@ export function detectUserFeedback(content: string): boolean {
   return USER_FEEDBACK_PATTERN.test(content.trim());
 }
 
+/**
+ * Auto-detect verified operational findings: batch records, completion summaries,
+ * incident reconciliations. These have low BM25 novelty (terminology repeats across
+ * runs — "USEF results submission", "Freshdesk triage batch") but the SPECIFIC
+ * event/ticket IDs, dates, and counts make each one uniquely valuable for future
+ * recall.
+ *
+ * Why this exists: the salience filter discarded a 6-event USEF batch summary at
+ * 0.14 (verified in activity log 2026-05-07T18:44:14) because the topic words
+ * collided with the long-running USEF history. The procedural memory beside it
+ * scored 0.70 — same topic, different content shape. The novelty signal alone
+ * can't distinguish a useful operational record from a duplicate observation.
+ *
+ * Pattern requires BOTH:
+ *   1. An action-verb header (Submitted/Finalized/Completed/Reconciled/Triaged/Posted/Resolved/Stamped)
+ *   2. At least 2 concrete identifiers — absolute dates (YYYY-MM-DD) OR numeric IDs
+ *      with context (event \d+, ticket #\d+, USEF \d+, USEA \d+).
+ *
+ * Matched memories get a salience floor of 0.45 (active, but below canonical
+ * 0.7) — preserves the record without claiming source-of-truth status.
+ */
+const OPERATIONAL_VERB_PATTERN = /\b(Submitted|Finalized|Completed|Reconciled|Triaged|Posted|Resolved|Stamped|Pushed|Deployed|Migrated|Imported|Exported|Backfilled)\b/i;
+const ISO_DATE_PATTERN = /\b\d{4}-\d{2}-\d{2}\b/g;
+const CONCRETE_ID_PATTERN = /\b(?:events?|tickets?|comps?|comp_id|usef|usea|classes|class|cases?|orders?|payments?|member_id|horse_id|user_id|orgs?|#)\s*[#:]?\s*\d{3,}/gi;
+
+/** Returns true if the content looks like a verified operational/batch record that should auto-bump salience. */
+export function detectVerifiedFinding(content: string): boolean {
+  if (typeof content !== 'string' || content.length === 0) return false;
+  const text = content.trim();
+  if (!OPERATIONAL_VERB_PATTERN.test(text)) return false;
+  const dateCount = (text.match(ISO_DATE_PATTERN) || []).length;
+  const idCount = (text.match(CONCRETE_ID_PATTERN) || []).length;
+  return dateCount + idCount >= 2;
+}
+
 export interface SalienceInput {
   content: string;
   eventType?: SalienceEventType;
@@ -88,10 +123,19 @@ export function evaluateSalience(
   let resolvedEventType: SalienceEventType = input.eventType ?? 'observation';
   let resolvedMemoryClass: MemoryClass = input.memoryClass ?? 'working';
   let autoPromoted = false;
+  let verifiedFindingFloor = false;
   if (detectUserFeedback(input.content)) {
     resolvedEventType = 'user_feedback';
     resolvedMemoryClass = 'canonical';
     autoPromoted = true;
+  } else if (detectVerifiedFinding(input.content)) {
+    // Operational record: bump eventType to 'decision' (typeBonus +0.15) and
+    // remember to apply a 0.45 salience floor below. Do NOT promote to canonical
+    // — these records are verified, not source-of-truth.
+    if (resolvedEventType === 'observation') {
+      resolvedEventType = 'decision';
+    }
+    verifiedFindingFloor = true;
   }
 
   const features: SalienceFeatures = {
@@ -104,6 +148,7 @@ export function evaluateSalience(
 
   const reasonCodes: string[] = [];
   if (autoPromoted) reasonCodes.push('auto:user_feedback');
+  if (verifiedFindingFloor) reasonCodes.push('auto:verified_finding');
 
   // Novelty: 1.0 = completely new info, 0 = exact duplicate exists
   // Default to 0.8 (assume mostly novel) when caller doesn't check
@@ -145,6 +190,9 @@ export function evaluateSalience(
     reasonCodes.push('class:canonical');
   } else if (memoryClass === 'ephemeral') {
     reasonCodes.push('class:ephemeral');
+  } else if (verifiedFindingFloor) {
+    // Verified operational record: 0.45 floor — keeps it active without canonical promotion
+    score = Math.max(score, 0.45);
   }
 
   let disposition: 'active' | 'staging' | 'discard';

package/src/engine/activation.ts

@@ -293,10 +293,62 @@ export class ActivationEngine {
     // Floor stddev at 0.10 to prevent z-score inflation with small candidate pools
     const simStdDev = Math.max(rawStdDev, 0.10);
 
-    // Phase 3b: Score each candidate with per-phase breakdown
-    const scored = candidates.map(engram => {
+    // Phase 3a': Cheap pre-filter — deep scoring (with associations + tokenize-content
+    // + Hebbian/centrality) only runs for candidates that have a non-trivial signal
+    // we can verify cheaply. Anything that fails this filter would score below the
+    // relevance gate (textMatch > 0.1) anyway and produce a near-zero composite.
+    //
+    // Why: phase-breakdown spike (2026-05-08) showed assocBatch over 10K candidates
+    // costs 1500ms and represents 68% of recall latency. Most candidates have zero
+    // BM25 hit, low cosine similarity, and no concept-jaccard match — so fetching
+    // their associations and tokenizing their full content is wasted work.
+    //
+    // Survival criteria (any one):
+    //   1. BM25 hit (bm25Score > 0)
+    //   2. Cosine z-score above the gate (would produce non-zero vectorMatch)
+    //   3. Concept-token overlap with query (cheap to compute — concept is short)
+    //
+    // Graph walk preserves correctness: it only boosts neighbors whose own textMatch
+    // already passes the relevance floor (0.05-0.1), and any candidate meeting that
+    // floor would also pass this filter (they'd have either BM25, cosine, or concept
+    // jaccard match). So no graph-walkable target is lost.
+    //
+    // Disable via AWM_DISABLE_POOL_FILTER=1 (for A/B testing or if a regression appears)
+    const poolFilterEnabled = process.env.AWM_DISABLE_POOL_FILTER !== '1';
+    let filteredCandidates: Engram[];
+    if (poolFilterEnabled) {
+      filteredCandidates = [];
+      for (const engram of candidates) {
+        const bm25 = bm25ScoreMap.get(engram.id) ?? 0;
+        if (bm25 > 0) {
+          filteredCandidates.push(engram);
+          continue;
+        }
+        const sim = rawCosineSims.get(engram.id);
+        if (sim !== undefined) {
+          const z = (sim - simMean) / simStdDev;
+          if (z > adaptive.zScoreGate) {
+            filteredCandidates.push(engram);
+            continue;
+          }
+        }
+        // Cheap concept jaccard — concepts are short (typically 3-8 tokens)
+        const conceptTokens = tokenize(engram.concept);
+        if (conceptTokens.size === 0) continue;
+        let conceptOverlap = 0;
+        for (const w of conceptTokens) if (queryTokens.has(w)) conceptOverlap++;
+        if (conceptOverlap > 0) filteredCandidates.push(engram);
+      }
+    } else {
+      filteredCandidates = candidates;
+    }
+
+    // Phase 3b: Score each filtered candidate with per-phase breakdown
+    // Batch-fetch associations only for survivors (was N+1 over 10K, now 1 query over ~200)
+    const associationsByEngram = this.store.getAssociationsForBatch(filteredCandidates.map(e => e.id));
+    const scored = filteredCandidates.map(engram => {
       const ageDays = (Date.now() - engram.createdAt.getTime()) / (1000 * 60 * 60 * 24);
-      const associations = this.store.getAssociationsFor(engram.id);
+      const associations = associationsByEngram.get(engram.id) ?? [];
 
       // --- Text relevance (keyword signals) ---
 

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.7.4 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.7 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);
+});