agent-working-memory 0.7.16 → 0.8.5

package/dist/mcp.js

@@ -50,7 +50,7 @@ catch { /* No .env file */ }
 console.log = console.error;
 import { StdioServerTransport } from '@modelcontextprotocol/sdk/server/stdio.js';
 import { z } from 'zod';
-import { EngramStore } from './storage/sqlite.js';
+import { openStore, getConfiguredBackend } from './storage/factory.js';
 import { ActivationEngine } from './engine/activation.js';
 import { ConnectionEngine } from './engine/connections.js';
 import { StagingBuffer } from './engine/staging.js';
@@ -59,7 +59,8 @@ 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 { evaluateSalience, computeNoveltyWithMatch } from './core/salience.js';
+import { evaluateSalience } from './core/salience.js';
+import { performWrite } from './core/write-pipeline.js';
 import { DEFAULT_AGENT_CONFIG } from './types/agent.js';
 import { embed } from './core/embeddings.js';
 import { startSidecar } from './hooks/sidecar.js';
@@ -71,7 +72,7 @@ import { queryPeerDecisions, formatPeerDecisions } from './coordination/peer-dec
 const INCOGNITO = process.env.AWM_INCOGNITO === '1' || process.env.AWM_INCOGNITO === 'true';
 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.7.16' });
+    const server = new McpServer({ name: 'agent-working-memory', version: '0.8.5' });
     const transport = new StdioServerTransport();
     server.connect(transport).catch(err => {
         console.error('MCP server failed:', err);
@@ -81,20 +82,25 @@ if (INCOGNITO) {
 }
 else {
     // --- Setup ---
-    const DB_PATH = process.env.AWM_DB_PATH ?? 'memory.db';
+    const BACKEND = getConfiguredBackend();
+    const DB_PATH = process.env.AWM_DB_PATH ?? (BACKEND === 'pglite' ? 'memory-pglite' : 'memory.db');
     const AGENT_ID = process.env.AWM_AGENT_ID ?? process.env.WORKER_NAME ?? 'claude-code';
     const HOOK_PORT = parseInt(process.env.AWM_HOOK_PORT ?? '8401', 10);
     const HOOK_SECRET = process.env.AWM_HOOK_SECRET ?? null;
     initLogger(DB_PATH);
-    log(AGENT_ID, 'startup', `MCP server starting (db: ${DB_PATH}, hooks: ${HOOK_PORT})`);
-    const store = new EngramStore(DB_PATH);
+    log(AGENT_ID, 'startup', `MCP server starting (backend: ${BACKEND}, db: ${DB_PATH}, hooks: ${HOOK_PORT})`);
+    // AWM 0.8.x: openStore() returns either SQLite (sync) or PGlite (async) store.
+    // Engines accept either via IEngramStore (MaybePromise<T> contract).
+    const { store: storeAny } = await openStore();
+    // Engines accept the async contract; SQLite-only call sites must guard on BACKEND.
+    const store = storeAny;
     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 consolidationEngine = new ConsolidationEngine(store, connectionEngine);
     const consolidationScheduler = new ConsolidationScheduler(store, consolidationEngine);
     stagingBuffer.start(DEFAULT_AGENT_CONFIG.stagingTtlMs);
     consolidationScheduler.start();
@@ -102,7 +108,7 @@ else {
     let coordDb = null;
     const server = new McpServer({
         name: 'agent-working-memory',
-        version: '0.7.16',
+        version: '0.8.5',
     });
     server.registerResource('awm-overview', 'awm://server/overview', {
         title: 'AWM Overview',
@@ -206,70 +212,6 @@ The concept should be a short label (3-8 words). The content should be the full
         intent: z.enum(['decision', 'question', 'todo', 'finding', 'context']).optional()
             .describe('What kind of memory this is.'),
     }, async (params) => {
-        // Check novelty with match info for reinforcement
-        const noveltyResult = computeNoveltyWithMatch(store, AGENT_ID, params.concept, params.content);
-        const novelty = noveltyResult.novelty;
-        // --- Reinforce-on-Duplicate check ---
-        // Tightened thresholds: require near-exact match (novelty < 0.3, BM25 > 0.85, 60% content overlap)
-        if (novelty < 0.3
-            && noveltyResult.matchScore > 0.85
-            && noveltyResult.matchedEngramId) {
-            const matchedEngram = store.getEngram(noveltyResult.matchedEngramId);
-            if (matchedEngram) {
-                const existingTokens = new Set(matchedEngram.content.toLowerCase().split(/\s+/).filter(w => w.length > 3));
-                const newTokens = new Set(params.content.toLowerCase().split(/\s+/).filter(w => w.length > 3));
-                let overlap = 0;
-                for (const t of newTokens) {
-                    if (existingTokens.has(t))
-                        overlap++;
-                }
-                const contentOverlap = newTokens.size > 0 ? overlap / newTokens.size : 0;
-                if (contentOverlap > 0.6) {
-                    // True duplicate — reinforce existing and skip creation
-                    store.touchEngram(noveltyResult.matchedEngramId);
-                    try {
-                        store.updateAutoCheckpointWrite(AGENT_ID, noveltyResult.matchedEngramId);
-                    }
-                    catch { /* non-fatal */ }
-                    log(AGENT_ID, 'write:reinforce', `"${params.concept}" → reinforced "${matchedEngram.concept}" (overlap=${contentOverlap.toFixed(2)})`);
-                    return {
-                        content: [{
-                                type: 'text',
-                                text: `Reinforced existing memory "${matchedEngram.concept}" (overlap ${(contentOverlap * 100).toFixed(0)}%)`,
-                            }],
-                    };
-                }
-                // Partial match — continue to create new memory
-                log(AGENT_ID, 'write:partial-match', `"${params.concept}" partially matched "${matchedEngram.concept}" (overlap=${contentOverlap.toFixed(2)}), creating new memory`);
-            }
-        }
-        const salience = evaluateSalience({
-            content: params.content,
-            eventType: params.event_type,
-            surprise: params.surprise,
-            decisionMade: params.decision_made,
-            causalDepth: params.causal_depth,
-            resolutionEffort: params.resolution_effort,
-            novelty,
-            memoryClass: params.memory_class,
-        });
-        // v0.5.4: No longer discard — store everything, use salience for ranking.
-        // Low-salience memories get low confidence so they rank below high-salience
-        // in retrieval, but remain available for recall when needed.
-        const isLowSalience = salience.disposition === 'discard';
-        const CONFIDENCE_PRIORS = {
-            decision: 0.65,
-            friction: 0.60,
-            causal: 0.60,
-            surprise: 0.55,
-            observation: 0.45,
-        };
-        const confidencePrior = isLowSalience
-            ? 0.25
-            : salience.disposition === 'staging'
-                ? 0.40
-                : CONFIDENCE_PRIORS[params.event_type ?? 'observation'] ?? 0.45;
-        const memoryType = params.memory_type ?? classifyMemoryType(params.content);
         // Assemble tags: user-provided + agent metadata (stored as searchable prefixed tags)
         const userTags = params.tags ?? [];
         const metaTags = [];
@@ -285,47 +227,39 @@ The concept should be a short label (3-8 words). The content should be the full
             metaTags.push(`sid=${params.session_id}`);
         if (params.intent)
             metaTags.push(`intent=${params.intent}`);
-        const allTags = isLowSalience
-            ? [...userTags, ...metaTags, 'low-salience']
-            : [...userTags, ...metaTags];
-        const engram = store.createEngram({
+        const memoryType = params.memory_type ?? classifyMemoryType(params.content);
+        const result = await performWrite({ store, connectionEngine }, {
             agentId: AGENT_ID,
             concept: params.concept,
             content: params.content,
-            tags: allTags,
-            salience: salience.score,
-            confidence: confidencePrior,
-            salienceFeatures: salience.features,
-            reasonCodes: salience.reasonCodes,
-            ttl: salience.disposition === 'staging' ? DEFAULT_AGENT_CONFIG.stagingTtlMs : undefined,
+            tags: [...userTags, ...metaTags],
+            eventType: params.event_type,
+            surprise: params.surprise,
+            decisionMade: params.decision_made,
+            causalDepth: params.causal_depth,
+            resolutionEffort: params.resolution_effort,
             memoryClass: params.memory_class,
             memoryType,
             supersedes: params.supersedes,
         });
-        if (salience.disposition === 'staging') {
-            store.updateStage(engram.id, 'staging');
-        }
-        else {
-            connectionEngine.enqueue(engram.id);
-        }
-        // Handle supersession: mark old memory as superseded
-        if (params.supersedes) {
-            const oldEngram = store.getEngram(params.supersedes);
-            if (oldEngram) {
-                store.supersedeEngram(params.supersedes, engram.id);
-                // Create supersession association
-                store.upsertAssociation(engram.id, oldEngram.id, 0.8, 'causal', 0.9);
-            }
-        }
-        // Generate embedding asynchronously (don't block response)
-        embed(`${params.concept} ${params.content}`).then(vec => {
-            store.updateEmbedding(engram.id, vec);
-        }).catch(() => { }); // Embedding failure is non-fatal
-        // Auto-checkpoint: track write
+        // Auto-checkpoint — covers create/reinforce/supersede uniformly
         try {
-            store.updateAutoCheckpointWrite(AGENT_ID, engram.id);
+            await store.updateAutoCheckpointWrite(AGENT_ID, result.engram.id);
         }
         catch { /* non-fatal */ }
+        if (result.action === 'reinforce') {
+            log(AGENT_ID, 'write:reinforce', `"${params.concept}" → reinforced "${result.engram.concept}" (conf ${result.reinforce.previousConfidence.toFixed(2)} → ${result.reinforce.newConfidence.toFixed(2)}, novelty=${result.noveltyResult.novelty.toFixed(2)})`);
+            return {
+                content: [{
+                        type: 'text',
+                        text: `Reinforced existing memory "${result.engram.concept}" (confidence ${result.reinforce.previousConfidence.toFixed(2)} → ${result.reinforce.newConfidence.toFixed(2)})`,
+                    }],
+            };
+        }
+        const engram = result.engram;
+        const salience = result.salience; // create/supersede always have salience
+        const novelty = result.noveltyResult.novelty;
+        const isLowSalience = salience.disposition === 'discard';
         // 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) {
@@ -365,6 +299,8 @@ Returns the most relevant memories ranked by text relevance, temporal recency, a
         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)'),
         workspace: z.string().optional().describe('Search across all agents in this workspace (hive mode). Omit for agent-scoped recall only.'),
+        require_confidence: z.number().optional().describe('Opt-in: abstain (return []) when recall confidence is below this threshold. Typical values: 0.10 (strict), 0.25 (balanced), 0.40 (aggressive). Confidence is the shape of the result-score distribution; low confidence indicates a noisy or best-of-bad-bunch recall.'),
+        granularity: z.enum(['full', 'compact', 'auto']).optional().describe('Output granularity (Paper 3: cognitive teaming). "full" (default): no change. "compact": every result carries a short summary field. "auto": confidence-adaptive — top result gets a longer summary when there is a clear winner, otherwise everything is compact for scanning.'),
     }, async (params) => {
         const queryText = params.query ?? params.context;
         if (!queryText) {
@@ -387,11 +323,13 @@ Returns the most relevant memories ranked by text relevance, temporal recency, a
             useExpansion: params.use_expansion,
             memoryType: params.memory_type,
             workspace,
+            requireConfidence: params.require_confidence,
+            granularity: params.granularity,
         });
         // Auto-checkpoint: track recall
         try {
             const ids = results.map(r => r.engram.id);
-            store.updateAutoCheckpointRecall(AGENT_ID, queryText, ids);
+            await store.updateAutoCheckpointRecall(AGENT_ID, queryText, ids);
         }
         catch { /* non-fatal */ }
         log(AGENT_ID, 'recall', `"${queryText.slice(0, 80)}" → ${results.length} results`);
@@ -408,7 +346,11 @@ Returns the most relevant memories ranked by text relevance, temporal recency, a
             };
         }
         const lines = results.map((r, i) => {
-            return `${i + 1}. **${r.engram.concept}** (${r.score.toFixed(3)}): ${r.engram.content}`;
+            // Confidence-adaptive output (Paper 3: cognitive teaming). When the caller
+            // requested 'compact' or 'auto' granularity, surface the engine-computed
+            // summary instead of the full content — same engram, less to read.
+            const body = r.summary ?? r.engram.content;
+            return `${i + 1}. **${r.engram.concept}** (${r.score.toFixed(3)}): ${body}`;
         });
         return {
             content: [{
@@ -424,16 +366,16 @@ Always call this after using a recalled memory so the system learns what's valua
         useful: z.boolean().describe('Was this memory actually helpful?'),
         context: z.string().optional().describe('Brief note on why it was/wasn\'t useful'),
     }, async (params) => {
-        store.logRetrievalFeedback(null, params.engram_id, params.useful, params.context ?? '');
-        const engram = store.getEngram(params.engram_id);
+        await store.logRetrievalFeedback(null, params.engram_id, params.useful, params.context ?? '');
+        const engram = await store.getEngram(params.engram_id);
         if (engram) {
             const delta = params.useful
                 ? DEFAULT_AGENT_CONFIG.feedbackPositiveBoost
                 : -DEFAULT_AGENT_CONFIG.feedbackNegativePenalty;
-            store.updateConfidence(engram.id, engram.confidence + delta);
+            await store.updateConfidence(engram.id, engram.confidence + delta);
         }
         // Validation-gated Hebbian: resolve pending co-activation pairs for this engram
-        const hebbianUpdated = activationEngine.resolveHebbianFeedback(params.engram_id, params.useful);
+        const hebbianUpdated = await activationEngine.resolveHebbianFeedback(params.engram_id, params.useful);
         return {
             content: [{
                     type: 'text',
@@ -448,7 +390,7 @@ Use this when you discover a memory contains incorrect information.`, {
         reason: z.string().describe('Why is this memory wrong?'),
         correction: z.string().optional().describe('What is the correct information? (creates a new memory)'),
     }, async (params) => {
-        const result = retractionEngine.retract({
+        const result = await retractionEngine.retract({
             agentId: AGENT_ID,
             targetEngramId: params.engram_id,
             reason: params.reason,
@@ -478,19 +420,19 @@ The old memory stays in the database (searchable for history) but is heavily dow
         new_engram_id: z.string().describe('ID of the replacement memory'),
         reason: z.string().optional().describe('Why the old memory is outdated'),
     }, async (params) => {
-        const oldEngram = store.getEngram(params.old_engram_id);
+        const oldEngram = await store.getEngram(params.old_engram_id);
         if (!oldEngram) {
             return { content: [{ type: 'text', text: `Old memory not found: ${params.old_engram_id}` }] };
         }
-        const newEngram = store.getEngram(params.new_engram_id);
+        const newEngram = await store.getEngram(params.new_engram_id);
         if (!newEngram) {
             return { content: [{ type: 'text', text: `New memory not found: ${params.new_engram_id}` }] };
         }
-        store.supersedeEngram(params.old_engram_id, params.new_engram_id);
+        await store.supersedeEngram(params.old_engram_id, params.new_engram_id);
         // Create supersession association (new → old)
-        store.upsertAssociation(params.new_engram_id, params.old_engram_id, 0.8, 'causal', 0.9);
+        await store.upsertAssociation(params.new_engram_id, params.old_engram_id, 0.8, 'causal', 0.9);
         // Reduce old memory's confidence (not to zero — it's historical, not wrong)
-        store.updateConfidence(params.old_engram_id, Math.max(0.2, oldEngram.confidence * 0.4));
+        await store.updateConfidence(params.old_engram_id, Math.max(0.2, oldEngram.confidence * 0.4));
         log(AGENT_ID, 'supersede', `"${oldEngram.concept}" → "${newEngram.concept}"${params.reason ? ` (${params.reason})` : ''}`);
         return {
             content: [{
@@ -501,8 +443,8 @@ The old memory stays in the database (searchable for history) but is heavily dow
     });
     server.tool('memory_stats', `Get memory health stats — how many memories, confidence levels, association count, and system performance.
 Also shows the activity log path so the user can tail it to see what's happening.`, {}, async () => {
-        const metrics = evalEngine.computeMetrics(AGENT_ID);
-        const checkpoint = store.getCheckpoint(AGENT_ID);
+        const metrics = await evalEngine.computeMetrics(AGENT_ID);
+        const checkpoint = await store.getCheckpoint(AGENT_ID);
         const lines = [
             `Agent: ${AGENT_ID}`,
             `Active memories: ${metrics.activeEngramCount}`,
@@ -561,7 +503,7 @@ Also call periodically during long sessions to avoid losing state. The state is
             notes: params.notes,
             episodeId: params.episode_id ?? null,
         };
-        store.saveCheckpoint(AGENT_ID, state);
+        await store.saveCheckpoint(AGENT_ID, state);
         log(AGENT_ID, 'checkpoint', `"${params.current_task}" decisions=${params.decisions.length} files=${params.active_files.length}`);
         return {
             content: [{
@@ -579,7 +521,7 @@ Returns:
 - How long you were idle
 
 Use this at the start of every session or after compaction to pick up where you left off.`, {}, async () => {
-        const checkpoint = store.getCheckpoint(AGENT_ID);
+        const checkpoint = await store.getCheckpoint(AGENT_ID);
         const now = Date.now();
         const idleMs = checkpoint
             ? now - checkpoint.auto.lastActivityAt.getTime()
@@ -587,7 +529,7 @@ Use this at the start of every session or after compaction to pick up where you
         // Get last written engram
         let lastWrite = null;
         if (checkpoint?.auto.lastWriteId) {
-            const engram = store.getEngram(checkpoint.auto.lastWriteId);
+            const engram = await store.getEngram(checkpoint.auto.lastWriteId);
             if (engram) {
                 lastWrite = { id: engram.id, concept: engram.concept, content: engram.content };
             }
@@ -633,7 +575,7 @@ Use this at the start of every session or after compaction to pick up where you
                 fullConsolidationTriggered = true;
                 try {
                     const result = await consolidationEngine.consolidate(AGENT_ID);
-                    store.markConsolidation(AGENT_ID, false);
+                    await store.markConsolidation(AGENT_ID, false);
                     log(AGENT_ID, 'consolidation', `full sleep cycle on restore (no graceful exit, idle ${Math.round(idleMs / 60_000)}min, last consolidation ${Math.round(sinceLastConsolidation / 60_000)}min ago) — ${result.edgesStrengthened} strengthened, ${result.memoriesForgotten} forgotten`);
                 }
                 catch { /* consolidation failure is non-fatal */ }
@@ -721,7 +663,7 @@ Tasks automatically get high salience so they won't be discarded.`, {
             .describe('Task priority: urgent (do now), high (do soon), medium (normal), low (backlog)'),
         blocked_by: z.string().optional().describe('ID of a task that must finish first'),
     }, async (params) => {
-        const engram = store.createEngram({
+        const engram = await store.createEngram({
             agentId: AGENT_ID,
             concept: params.concept,
             content: params.content,
@@ -742,8 +684,8 @@ Tasks automatically get high salience so they won't be discarded.`, {
         });
         connectionEngine.enqueue(engram.id);
         // Generate embedding asynchronously
-        embed(`${params.concept} ${params.content}`).then(vec => {
-            store.updateEmbedding(engram.id, vec);
+        embed(`${params.concept} ${params.content}`).then(async (vec) => {
+            await store.updateEmbedding(engram.id, vec);
         }).catch(() => { });
         return {
             content: [{
@@ -765,20 +707,20 @@ Tasks automatically get high salience so they won't be discarded.`, {
             .describe('New priority'),
         blocked_by: z.string().optional().describe('ID of blocking task (set to empty string to unblock)'),
     }, async (params) => {
-        const engram = store.getEngram(params.task_id);
+        const engram = await store.getEngram(params.task_id);
         if (!engram || !engram.taskStatus) {
             return { content: [{ type: 'text', text: `Task not found: ${params.task_id}` }] };
         }
         if (params.blocked_by !== undefined) {
-            store.updateBlockedBy(params.task_id, params.blocked_by || null);
+            await store.updateBlockedBy(params.task_id, params.blocked_by || null);
         }
         if (params.status) {
-            store.updateTaskStatus(params.task_id, params.status);
+            await store.updateTaskStatus(params.task_id, params.status);
         }
         if (params.priority) {
-            store.updateTaskPriority(params.task_id, params.priority);
+            await store.updateTaskPriority(params.task_id, params.priority);
         }
-        const updated = store.getEngram(params.task_id);
+        const updated = (await store.getEngram(params.task_id));
         return {
             content: [{
                     type: 'text',
@@ -794,7 +736,7 @@ Use at the start of a session to see what's pending, or to check blocked/done ta
         include_done: z.boolean().optional().default(false)
             .describe('Include completed tasks?'),
     }, async (params) => {
-        let tasks = store.getTasks(AGENT_ID, params.status);
+        let tasks = await store.getTasks(AGENT_ID, params.status);
         if (!params.include_done && !params.status) {
             tasks = tasks.filter(t => t.taskStatus !== 'done');
         }
@@ -818,7 +760,7 @@ Use at the start of a session to see what's pending, or to check blocked/done ta
 Prioritizes: in_progress tasks first (finish what you started), then by priority level, then oldest first. Skips blocked and done tasks.
 
 Use this when you finish a task or need to decide what to do next.`, {}, async () => {
-        const next = store.getNextTask(AGENT_ID);
+        const next = await store.getNextTask(AGENT_ID);
         if (!next) {
             return { content: [{ type: 'text', text: 'No actionable tasks. All clear!' }] };
         }
@@ -847,9 +789,9 @@ This ensures your state is saved before you start, and primes recall with releva
             .describe('Any additional context'),
     }, async (params) => {
         // 1. Checkpoint current state
-        const checkpoint = store.getCheckpoint(AGENT_ID);
+        const checkpoint = await store.getCheckpoint(AGENT_ID);
         const prevTask = checkpoint?.executionState?.currentTask ?? 'None';
-        store.saveCheckpoint(AGENT_ID, {
+        await store.saveCheckpoint(AGENT_ID, {
             currentTask: params.topic,
             decisions: [],
             activeFiles: params.files,
@@ -877,7 +819,7 @@ This ensures your state is saved before you start, and primes recall with releva
                 });
                 recalledSummary = `\n\n**Recalled memories (${results.length}):**\n${lines.join('\n')}`;
                 // Track recall
-                store.updateAutoCheckpointRecall(AGENT_ID, params.topic, results.map(r => r.engram.id));
+                await store.updateAutoCheckpointRecall(AGENT_ID, params.topic, results.map(r => r.engram.id));
             }
         }
         catch { /* recall failure is non-fatal */ }
@@ -913,7 +855,7 @@ This captures what was accomplished so future sessions can recall it.`, {
             resolutionEffort: 0.5,
         });
         // Determine the real task name for the summary engram
-        const checkpoint = store.getCheckpoint(AGENT_ID);
+        const checkpoint = await store.getCheckpoint(AGENT_ID);
         const rawTask = checkpoint?.executionState?.currentTask ?? 'Unknown task';
         // Strip any "Completed: " prefixes to avoid cascading
         const cleanedTask = rawTask.replace(/^(Completed: )+/, '');
@@ -922,7 +864,7 @@ This captures what was accomplished so future sessions can recall it.`, {
         const completedTask = isNamedTask
             ? cleanedTask
             : params.summary.slice(0, 60).replace(/\n/g, ' ');
-        const engram = store.createEngram({
+        const engram = await store.createEngram({
             agentId: AGENT_ID,
             concept: completedTask.slice(0, 80),
             content: params.summary,
@@ -936,20 +878,20 @@ This captures what was accomplished so future sessions can recall it.`, {
         // 2. Handle supersessions — mark old memories as outdated
         let supersededCount = 0;
         for (const oldId of params.supersedes) {
-            const oldEngram = store.getEngram(oldId);
+            const oldEngram = await store.getEngram(oldId);
             if (oldEngram) {
-                store.supersedeEngram(oldId, engram.id);
-                store.upsertAssociation(engram.id, oldId, 0.8, 'causal', 0.9);
-                store.updateConfidence(oldId, Math.max(0.2, oldEngram.confidence * 0.4));
+                await store.supersedeEngram(oldId, engram.id);
+                await store.upsertAssociation(engram.id, oldId, 0.8, 'causal', 0.9);
+                await store.updateConfidence(oldId, Math.max(0.2, oldEngram.confidence * 0.4));
                 supersededCount++;
             }
         }
         // Generate embedding asynchronously
-        embed(`Task completed: ${params.summary}`).then(vec => {
-            store.updateEmbedding(engram.id, vec);
+        embed(`Task completed: ${params.summary}`).then(async (vec) => {
+            await store.updateEmbedding(engram.id, vec);
         }).catch(() => { });
         // 2. Update checkpoint to reflect completion
-        store.saveCheckpoint(AGENT_ID, {
+        await store.saveCheckpoint(AGENT_ID, {
             currentTask: `Completed: ${completedTask}`,
             decisions: checkpoint?.executionState?.decisions ?? [],
             activeFiles: [],
@@ -958,7 +900,7 @@ This captures what was accomplished so future sessions can recall it.`, {
             notes: `Task completed. Summary memory: ${engram.id}`,
             episodeId: null,
         });
-        store.updateAutoCheckpointWrite(AGENT_ID, engram.id);
+        await store.updateAutoCheckpointWrite(AGENT_ID, engram.id);
         log(AGENT_ID, 'task:end', `"${completedTask}" summary=${engram.id} salience=${salience.score.toFixed(2)} superseded=${supersededCount}`);
         const supersededNote = supersededCount > 0 ? ` (${supersededCount} old memories superseded)` : '';
         return {
@@ -981,18 +923,26 @@ This captures what was accomplished so future sessions can recall it.`, {
             onConsolidate: async (agentId, reason) => {
                 console.error(`[mcp] consolidation triggered: ${reason}`);
                 const result = await consolidationEngine.consolidate(agentId);
-                store.markConsolidation(agentId, false);
+                await store.markConsolidation(agentId, false);
                 console.error(`[mcp] consolidation done: ${result.edgesStrengthened} strengthened, ${result.memoriesForgotten} forgotten`);
             },
         });
         // Coordination MCP tools (opt-in via AWM_COORDINATION=true)
-        const coordEnabled = process.env.AWM_COORDINATION === 'true' || process.env.AWM_COORDINATION === '1';
+        // AWM 0.8.x: coordination requires SQLite (uses store.getDb()). On PGlite,
+        // coordination is auto-disabled with a warning; re-enable when coordination
+        // is ported to async/PGlite.
+        const coordRequested = process.env.AWM_COORDINATION === 'true' || process.env.AWM_COORDINATION === '1';
+        const coordEnabled = coordRequested && BACKEND === 'sqlite';
         if (coordEnabled) {
             const { initCoordinationTables } = await import('./coordination/schema.js');
             const { registerCoordinationTools } = await import('./coordination/mcp-tools.js');
-            initCoordinationTables(store.getDb());
-            registerCoordinationTools(server, store.getDb());
-            coordDb = store.getDb();
+            const sqliteStore = store;
+            initCoordinationTables(sqliteStore.getDb());
+            registerCoordinationTools(server, sqliteStore.getDb());
+            coordDb = sqliteStore.getDb();
+        }
+        else if (coordRequested && BACKEND === 'pglite') {
+            console.error('AWM: coordination requested but disabled — coordination plugin requires SQLite backend');
         }
         else {
             console.error('AWM: coordination tools disabled (set AWM_COORDINATION=true to enable)');
@@ -1001,18 +951,23 @@ This captures what was accomplished so future sessions can recall it.`, {
         console.error(`AgentWorkingMemory MCP server started (agent: ${AGENT_ID}, db: ${DB_PATH})`);
         console.error(`Hook sidecar on 127.0.0.1:${HOOK_PORT}${HOOK_SECRET ? ' (auth enabled)' : ' (no auth — set AWM_HOOK_SECRET)'}`);
         // Clean shutdown
-        const cleanup = () => {
+        const cleanup = async () => {
             sidecar.close();
             consolidationScheduler.stop();
             stagingBuffer.stop();
+            if (BACKEND === 'sqlite') {
+                try {
+                    store.walCheckpoint?.();
+                }
+                catch { /* non-fatal */ }
+            }
             try {
-                store.walCheckpoint();
+                await store.close?.();
             }
-            catch { /* non-fatal */ }
-            store.close();
+            catch { /* best-effort */ }
         };
-        process.on('SIGINT', () => { cleanup(); process.exit(0); });
-        process.on('SIGTERM', () => { cleanup(); process.exit(0); });
+        process.on('SIGINT', () => { void cleanup().finally(() => process.exit(0)); });
+        process.on('SIGTERM', () => { void cleanup().finally(() => process.exit(0)); });
     }
     main().catch(err => {
         console.error('MCP server failed:', err);