agent-working-memory 0.7.17 → 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';
@@ -72,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.17' });
+    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);
@@ -82,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();
@@ -103,7 +108,7 @@ else {
     let coordDb = null;
     const server = new McpServer({
         name: 'agent-working-memory',
-        version: '0.7.17',
+        version: '0.8.5',
     });
     server.registerResource('awm-overview', 'awm://server/overview', {
         title: 'AWM Overview',
@@ -163,15 +168,15 @@ else {
         return 'unclassified';
     }
     // --- Tools ---
-    server.tool('memory_write', `Store a memory. The salience filter decides whether it's worth keeping (active), needs more evidence (staging), or should be discarded.
-
-CALL THIS PROACTIVELY — do not wait to be asked. Write memories when you:
-- Discover something about the codebase, bugs, or architecture
-- Make a decision and want to remember why
-- Encounter and resolve an error
-- Learn a user preference or project pattern
-- Complete a significant piece of work
-
+    server.tool('memory_write', `Store a memory. The salience filter decides whether it's worth keeping (active), needs more evidence (staging), or should be discarded.
+
+CALL THIS PROACTIVELY — do not wait to be asked. Write memories when you:
+- Discover something about the codebase, bugs, or architecture
+- Make a decision and want to remember why
+- Encounter and resolve an error
+- Learn a user preference or project pattern
+- Complete a significant piece of work
+
 The concept should be a short label (3-8 words). The content should be the full detail.`, {
         concept: z.string().describe('Short label for this memory (3-8 words)'),
         content: z.string().describe('Full detail of what was learned'),
@@ -223,7 +228,7 @@ The concept should be a short label (3-8 words). The content should be the full
         if (params.intent)
             metaTags.push(`intent=${params.intent}`);
         const memoryType = params.memory_type ?? classifyMemoryType(params.content);
-        const result = performWrite({ store, connectionEngine }, {
+        const result = await performWrite({ store, connectionEngine }, {
             agentId: AGENT_ID,
             concept: params.concept,
             content: params.content,
@@ -239,7 +244,7 @@ The concept should be a short label (3-8 words). The content should be the full
         });
         // Auto-checkpoint — covers create/reinforce/supersede uniformly
         try {
-            store.updateAutoCheckpointWrite(AGENT_ID, result.engram.id);
+            await store.updateAutoCheckpointWrite(AGENT_ID, result.engram.id);
         }
         catch { /* non-fatal */ }
         if (result.action === 'reinforce') {
@@ -275,15 +280,15 @@ The concept should be a short label (3-8 words). The content should be the full
                 }],
         };
     });
-    server.tool('memory_recall', `Recall memories relevant to a query. Uses cognitive activation — not keyword search.
-
-ALWAYS call this when:
-- Starting work on a project or topic (recall what you know)
-- Debugging (recall similar errors and solutions)
-- Making decisions (recall past decisions and outcomes)
-- The user mentions a topic you might have stored memories about
-
-Accepts either "query" or "context" parameter — both work identically.
+    server.tool('memory_recall', `Recall memories relevant to a query. Uses cognitive activation — not keyword search.
+
+ALWAYS call this when:
+- Starting work on a project or topic (recall what you know)
+- Debugging (recall similar errors and solutions)
+- Making decisions (recall past decisions and outcomes)
+- The user mentions a topic you might have stored memories about
+
+Accepts either "query" or "context" parameter — both work identically.
 Returns the most relevant memories ranked by text relevance, temporal recency, and associative strength.`, {
         query: z.string().optional().describe('What to search for — describe the situation, question, or topic'),
         context: z.string().optional().describe('Alias for query (either works)'),
@@ -294,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) {
@@ -316,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`);
@@ -337,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: [{
@@ -346,23 +359,23 @@ Returns the most relevant memories ranked by text relevance, temporal recency, a
                 }],
         };
     });
-    server.tool('memory_feedback', `Report whether a recalled memory was actually useful. This updates the memory's confidence score — useful memories become stronger, useless ones weaken.
-
+    server.tool('memory_feedback', `Report whether a recalled memory was actually useful. This updates the memory's confidence score — useful memories become stronger, useless ones weaken.
+
 Always call this after using a recalled memory so the system learns what's valuable.`, {
         engram_id: z.string().describe('ID of the memory (from memory_recall results)'),
         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',
@@ -370,14 +383,14 @@ Always call this after using a recalled memory so the system learns what's valua
                 }],
         };
     });
-    server.tool('memory_retract', `Retract a memory that turned out to be wrong. Creates a correction and reduces confidence of related memories.
-
+    server.tool('memory_retract', `Retract a memory that turned out to be wrong. Creates a correction and reduces confidence of related memories.
+
 Use this when you discover a memory contains incorrect information.`, {
         engram_id: z.string().describe('ID of the wrong memory'),
         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,
@@ -395,31 +408,31 @@ Use this when you discover a memory contains incorrect information.`, {
                 }],
         };
     });
-    server.tool('memory_supersede', `Replace an outdated memory with a newer one. Unlike retraction (which marks memories as wrong), supersession marks the old memory as outdated but historically correct.
-
-Use this when:
-- A status or count has changed (e.g., "5 reviews done" → "7 reviews done")
-- Architecture or infrastructure evolved (e.g., "two-repo model" → "three-repo model")
-- A schedule or plan was updated
-
+    server.tool('memory_supersede', `Replace an outdated memory with a newer one. Unlike retraction (which marks memories as wrong), supersession marks the old memory as outdated but historically correct.
+
+Use this when:
+- A status or count has changed (e.g., "5 reviews done" → "7 reviews done")
+- Architecture or infrastructure evolved (e.g., "two-repo model" → "three-repo model")
+- A schedule or plan was updated
+
 The old memory stays in the database (searchable for history) but is heavily down-ranked in recall so the current version dominates.`, {
         old_engram_id: z.string().describe('ID of the outdated memory'),
         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: [{
@@ -428,10 +441,10 @@ 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.
+    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}`,
@@ -459,13 +472,13 @@ Also shows the activity log path so the user can tail it to see what's happening
         };
     });
     // --- Checkpointing Tools ---
-    server.tool('memory_checkpoint', `Save your current execution state so you can recover after context compaction.
-
-ALWAYS call this before:
-- Long operations (multi-file generation, large refactors, overnight work)
-- Anything that might fill the context window
-- Switching to a different task
-
+    server.tool('memory_checkpoint', `Save your current execution state so you can recover after context compaction.
+
+ALWAYS call this before:
+- Long operations (multi-file generation, large refactors, overnight work)
+- Anything that might fill the context window
+- Switching to a different task
+
 Also call periodically during long sessions to avoid losing state. The state is saved per-agent and overwrites any previous checkpoint.`, {
         current_task: z.string().describe('What you are currently working on'),
         decisions: z.array(z.string()).optional().default([])
@@ -490,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: [{
@@ -499,16 +512,16 @@ Also call periodically during long sessions to avoid losing state. The state is
                 }],
         };
     });
-    server.tool('memory_restore', `Restore your previous execution state after context compaction or at session start.
-
-Returns:
-- Your saved execution state (task, decisions, next steps, files)
-- Recently recalled memories for context
-- Your last write for continuity
-- How long you were idle
-
+    server.tool('memory_restore', `Restore your previous execution state after context compaction or at session start.
+
+Returns:
+- Your saved execution state (task, decisions, next steps, files)
+- Recently recalled memories for context
+- Your last write for continuity
+- 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()
@@ -516,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 };
             }
@@ -562,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 */ }
@@ -614,9 +627,9 @@ Use this at the start of every session or after compaction to pick up where you
         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);
-                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')
+                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 ?? '');
                 if (peerDecisions.length > 0) {
                     parts.push(`\n**Peer decisions (last 30 min):**`);
@@ -635,13 +648,13 @@ Use this at the start of every session or after compaction to pick up where you
         };
     });
     // --- Task Management Tools ---
-    server.tool('memory_task_add', `Create a task that you need to come back to. Tasks are memories with status and priority tracking.
-
-Use this when:
-- You identify work that needs doing but can't do it right now
-- The user mentions something to do later
-- You want to park a sub-task while focusing on something more urgent
-
+    server.tool('memory_task_add', `Create a task that you need to come back to. Tasks are memories with status and priority tracking.
+
+Use this when:
+- You identify work that needs doing but can't do it right now
+- The user mentions something to do later
+- You want to park a sub-task while focusing on something more urgent
+
 Tasks automatically get high salience so they won't be discarded.`, {
         concept: z.string().describe('Short task title (3-10 words)'),
         content: z.string().describe('Full task description — what needs doing, context, acceptance criteria'),
@@ -650,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,
@@ -671,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: [{
@@ -681,11 +694,11 @@ Tasks automatically get high salience so they won't be discarded.`, {
                 }],
         };
     });
-    server.tool('memory_task_update', `Update a task's status or priority. Use this to:
-- Start working on a task (open → in_progress)
-- Mark a task done (→ done)
-- Block a task on another (→ blocked)
-- Reprioritize (change priority)
+    server.tool('memory_task_update', `Update a task's status or priority. Use this to:
+- Start working on a task (open → in_progress)
+- Mark a task done (→ done)
+- Block a task on another (→ blocked)
+- Reprioritize (change priority)
 - Unblock a task (clear blocked_by)`, {
         task_id: z.string().describe('ID of the task to update'),
         status: z.enum(['open', 'in_progress', 'blocked', 'done']).optional()
@@ -694,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',
@@ -715,15 +728,15 @@ Tasks automatically get high salience so they won't be discarded.`, {
                 }],
         };
     });
-    server.tool('memory_task_list', `List tasks with optional status filter. Shows tasks ordered by priority (urgent first).
-
+    server.tool('memory_task_list', `List tasks with optional status filter. Shows tasks ordered by priority (urgent first).
+
 Use at the start of a session to see what's pending, or to check blocked/done tasks.`, {
         status: z.enum(['open', 'in_progress', 'blocked', 'done']).optional()
             .describe('Filter by status (omit to see all active tasks)'),
         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');
         }
@@ -742,12 +755,12 @@ Use at the start of a session to see what's pending, or to check blocked/done ta
                 }],
         };
     });
-    server.tool('memory_task_next', `Get the single most important task to work on next.
-
-Prioritizes: in_progress tasks first (finish what you started), then by priority level, then oldest first. Skips blocked and done tasks.
-
+    server.tool('memory_task_next', `Get the single most important task to work on next.
+
+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!' }] };
         }
@@ -761,13 +774,13 @@ Use this when you finish a task or need to decide what to do next.`, {}, async (
         };
     });
     // --- Task Bracket Tools ---
-    server.tool('memory_task_begin', `Signal that you're starting a significant task. Auto-checkpoints current state and recalls relevant memories.
-
-CALL THIS when starting:
-- A multi-step operation (doc generation, large refactor, migration)
-- Work on a new topic or project area
-- Anything that might fill the context window
-
+    server.tool('memory_task_begin', `Signal that you're starting a significant task. Auto-checkpoints current state and recalls relevant memories.
+
+CALL THIS when starting:
+- A multi-step operation (doc generation, large refactor, migration)
+- Work on a new topic or project area
+- Anything that might fill the context window
+
 This ensures your state is saved before you start, and primes recall with relevant context.`, {
         topic: z.string().describe('What task are you starting? (3-15 words)'),
         files: z.array(z.string()).optional().default([])
@@ -776,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,
@@ -806,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 */ }
@@ -818,13 +831,13 @@ This ensures your state is saved before you start, and primes recall with releva
                 }],
         };
     });
-    server.tool('memory_task_end', `Signal that you've finished a significant task. Writes a summary memory and auto-checkpoints.
-
-CALL THIS when you finish:
-- A multi-step operation
-- Before switching to a different topic
-- At the end of a work session
-
+    server.tool('memory_task_end', `Signal that you've finished a significant task. Writes a summary memory and auto-checkpoints.
+
+CALL THIS when you finish:
+- A multi-step operation
+- Before switching to a different topic
+- At the end of a work session
+
 This captures what was accomplished so future sessions can recall it.`, {
         summary: z.string().describe('What was accomplished? Include key outcomes, decisions, and any issues.'),
         tags: z.array(z.string()).optional().default([])
@@ -842,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: )+/, '');
@@ -851,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,
@@ -865,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: [],
@@ -887,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 {
@@ -910,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)');
@@ -930,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);