agent-working-memory 0.7.16 → 0.8.5

package/dist/api/routes.d.ts.map

@@ -1 +1 @@
-{"version":3,"file":"routes.d.ts","sourceRoot":"","sources":["../../src/api/routes.ts"],"names":[],"mappings":"AAEA;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;GA+BG;AAEH,OAAO,KAAK,EAAE,eAAe,EAAE,MAAM,SAAS,CAAC;AAC/C,OAAO,KAAK,EAAE,WAAW,EAAE,MAAM,sBAAsB,CAAC;AACxD,OAAO,KAAK,EAAE,gBAAgB,EAAE,MAAM,yBAAyB,CAAC;AAChE,OAAO,KAAK,EAAE,gBAAgB,EAAE,MAAM,0BAA0B,CAAC;AACjE,OAAO,KAAK,EAAE,cAAc,EAAE,MAAM,uBAAuB,CAAC;AAC5D,OAAO,KAAK,EAAE,gBAAgB,EAAE,MAAM,yBAAyB,CAAC;AAChE,OAAO,KAAK,EAAE,UAAU,EAAE,MAAM,mBAAmB,CAAC;AACpD,OAAO,KAAK,EAAE,mBAAmB,EAAE,MAAM,4BAA4B,CAAC;AACtE,OAAO,KAAK,EAAE,sBAAsB,EAAE,MAAM,sCAAsC,CAAC;AAQnF,MAAM,WAAW,UAAU;IACzB,KAAK,EAAE,WAAW,CAAC;IACnB,gBAAgB,EAAE,gBAAgB,CAAC;IACnC,gBAAgB,EAAE,gBAAgB,CAAC;IACnC,cAAc,EAAE,cAAc,CAAC;IAC/B,gBAAgB,EAAE,gBAAgB,CAAC;IACnC,UAAU,EAAE,UAAU,CAAC;IACvB,mBAAmB,EAAE,mBAAmB,CAAC;IACzC,sBAAsB,EAAE,sBAAsB,CAAC;CAChD;AAED,wBAAgB,cAAc,CAAC,GAAG,EAAE,eAAe,EAAE,IAAI,EAAE,UAAU,GAAG,IAAI,CAopB3E"}
+{"version":3,"file":"routes.d.ts","sourceRoot":"","sources":["../../src/api/routes.ts"],"names":[],"mappings":"AAEA;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;GA+BG;AAEH,OAAO,KAAK,EAAE,eAAe,EAAE,MAAM,SAAS,CAAC;AAC/C,OAAO,KAAK,EAAE,YAAY,IAAI,WAAW,EAAE,MAAM,qBAAqB,CAAC;AACvE,OAAO,KAAK,EAAE,gBAAgB,EAAE,MAAM,yBAAyB,CAAC;AAChE,OAAO,KAAK,EAAE,gBAAgB,EAAE,MAAM,0BAA0B,CAAC;AACjE,OAAO,KAAK,EAAE,cAAc,EAAE,MAAM,uBAAuB,CAAC;AAC5D,OAAO,KAAK,EAAE,gBAAgB,EAAE,MAAM,yBAAyB,CAAC;AAChE,OAAO,KAAK,EAAE,UAAU,EAAE,MAAM,mBAAmB,CAAC;AACpD,OAAO,KAAK,EAAE,mBAAmB,EAAE,MAAM,4BAA4B,CAAC;AACtE,OAAO,KAAK,EAAE,sBAAsB,EAAE,MAAM,sCAAsC,CAAC;AASnF,MAAM,WAAW,UAAU;IACzB,KAAK,EAAE,WAAW,CAAC;IACnB,gBAAgB,EAAE,gBAAgB,CAAC;IACnC,gBAAgB,EAAE,gBAAgB,CAAC;IACnC,cAAc,EAAE,cAAc,CAAC;IAC/B,gBAAgB,EAAE,gBAAgB,CAAC;IACnC,UAAU,EAAE,UAAU,CAAC;IACvB,mBAAmB,EAAE,mBAAmB,CAAC;IACzC,sBAAsB,EAAE,sBAAsB,CAAC;CAChD;AAED,wBAAgB,cAAc,CAAC,GAAG,EAAE,eAAe,EAAE,IAAI,EAAE,UAAU,GAAG,IAAI,CA04B3E"}

package/dist/api/routes.js

@@ -32,7 +32,7 @@
  *   POST /system/consolidate — run sleep cycle (strengthen, decay, sweep)
  *   GET  /health             — health check
  */
-import { evaluateSalience, computeNovelty } from '../core/salience.js';
+import { performWrite } from '../core/write-pipeline.js';
 import { DEFAULT_AGENT_CONFIG } from '../types/agent.js';
 import { embed, embedBatch } from '../core/embeddings.js';
 export function registerRoutes(app, deps) {
@@ -47,21 +47,6 @@ export function registerRoutes(app, deps) {
             !body.content || typeof body.content !== 'string') {
             return reply.status(400).send({ error: 'agentId, concept, and content are required strings' });
         }
-        const novelty = computeNovelty(store, body.agentId, body.concept, body.content);
-        const salience = evaluateSalience({
-            content: body.content,
-            eventType: body.eventType,
-            surprise: body.surprise,
-            decisionMade: body.decisionMade,
-            causalDepth: body.causalDepth,
-            resolutionEffort: body.resolutionEffort,
-            novelty,
-        });
-        // v0.5.4: No longer discard — store with low confidence for ranking.
-        const isLowSalience = salience.disposition === 'discard';
-        const confidence = isLowSalience
-            ? 0.25
-            : body.confidence ?? (salience.disposition === 'staging' ? 0.40 : 0.50);
         // Assemble tags: user-provided + agent metadata
         const userTags = body.tags ?? [];
         const metaTags = [];
@@ -77,59 +62,90 @@ export function registerRoutes(app, deps) {
             metaTags.push(`sid=${body.sessionId}`);
         if (body.intent)
             metaTags.push(`intent=${body.intent}`);
-        const allTags = isLowSalience
-            ? [...userTags, ...metaTags, 'low-salience']
-            : [...userTags, ...metaTags];
-        const engram = store.createEngram({
+        // Resolve references (0.8 Cluster D): if matchConcept is given without
+        // matchEngramId, look up the most recent active engram with that concept
+        // (+ optional matchTags) and store both. Stable link survives concept
+        // edits. No match found → store just matchConcept so the intent
+        // (link-to-future or link-to-deleted) is preserved.
+        const resolvedRefs = await Promise.all((body.references ?? []).map(async (ref) => {
+            if (!ref.matchEngramId && ref.matchConcept) {
+                const matched = await store.findActiveMatchByConcept(body.agentId, ref.matchConcept, ref.matchTags);
+                if (matched) {
+                    return { type: ref.type, matchEngramId: matched.id, matchConcept: ref.matchConcept };
+                }
+            }
+            return { type: ref.type, matchEngramId: ref.matchEngramId, matchConcept: ref.matchConcept };
+        }));
+        const result = await performWrite({ store, connectionEngine }, {
             agentId: body.agentId,
             concept: body.concept,
             content: body.content,
-            tags: allTags,
-            salience: salience.score,
-            confidence,
-            salienceFeatures: salience.features,
-            reasonCodes: salience.reasonCodes,
-            ttl: salience.disposition === 'staging' ? DEFAULT_AGENT_CONFIG.stagingTtlMs : undefined,
+            tags: [...userTags, ...metaTags],
+            memoryClass: body.memory_class,
+            eventType: body.eventType,
+            surprise: body.surprise,
+            decisionMade: body.decisionMade,
+            causalDepth: body.causalDepth,
+            resolutionEffort: body.resolutionEffort,
+            confidence: body.confidence,
+            sequence: body.sequence,
+            embed: body.embed,
+            references: resolvedRefs.length > 0 ? resolvedRefs : undefined,
         });
-        if (salience.disposition === 'staging') {
-            store.updateStage(engram.id, 'staging');
-        }
-        // Create temporal adjacency edge to previous memory (conversation thread graph)
-        // This enables multi-hop graph walk through conversation sequences
+        // Auto-checkpoint always (covers create, reinforce, and supersede).
         try {
-            const prev = store.getLatestEngram(body.agentId, engram.id);
-            if (prev) {
-                store.upsertAssociation(prev.id, engram.id, 0.3, 'temporal', 0.8);
-            }
+            await store.updateAutoCheckpointWrite(body.agentId, result.engram.id);
+        }
+        catch { /* non-fatal */ }
+        if (result.action === 'reinforce') {
+            return reply.code(200).send({
+                stored: false,
+                action: 'reinforce',
+                disposition: 'reinforced',
+                engram: result.engram,
+                reinforce: result.reinforce,
+                novelty: result.noveltyResult.novelty,
+            });
         }
-        catch { /* Temporal edge creation is non-fatal */ }
-        if (salience.disposition === 'active' || isLowSalience) {
-            connectionEngine.enqueue(engram.id);
-            // Auto-assign to episode (1-hour window per agent)
+        // create / supersede paths follow legacy temporal-edge + episode logic.
+        // Structural-class writes (0.8 Cluster A) skip these: they're system-written
+        // event-log records, not conversational beats, so keeping them out of the
+        // temporal graph + episode index keeps cognitive retrieval clean.
+        const isStructural = body.memory_class === 'structural';
+        if (!isStructural) {
             try {
-                let episode = store.getActiveEpisode(body.agentId, 3600_000);
-                if (!episode) {
-                    episode = store.createEpisode({ agentId: body.agentId, label: body.concept });
+                const prev = await store.getLatestEngram(body.agentId, result.engram.id);
+                if (prev) {
+                    await store.upsertAssociation(prev.id, result.engram.id, 0.3, 'temporal', 0.8);
                 }
-                store.addEngramToEpisode(engram.id, episode.id);
             }
-            catch { /* Episode assignment is non-fatal */ }
-        }
-        // Generate embedding asynchronously (don't block response)
-        embed(`${body.concept} ${body.content}`).then(vec => {
-            store.updateEmbedding(engram.id, vec);
-        }).catch(() => { }); // Embedding failure is non-fatal
-        // Auto-checkpoint: track write for consolidation scheduling
-        try {
-            store.updateAutoCheckpointWrite(body.agentId, engram.id);
+            catch { /* Temporal edge creation is non-fatal */ }
+            if (result.salience
+                && (result.salience.disposition === 'active' || result.salience.disposition === 'discard')) {
+                try {
+                    let episode = await store.getActiveEpisode(body.agentId, 3600_000);
+                    if (!episode) {
+                        episode = await store.createEpisode({ agentId: body.agentId, label: body.concept });
+                    }
+                    await store.addEngramToEpisode(result.engram.id, episode.id);
+                }
+                catch { /* Episode assignment is non-fatal */ }
+            }
         }
-        catch { /* non-fatal */ }
+        const isLowSalience = result.salience?.disposition === 'discard';
         return reply.code(201).send({
             stored: true,
-            disposition: isLowSalience ? 'low-salience' : salience.disposition,
-            salience: salience.score,
-            reasonCodes: salience.reasonCodes,
-            engram,
+            action: result.action,
+            // disposition: legacy field — 'low-salience' is returned for discard so
+            // callers know the engram was kept but marked low-value. The raw inner
+            // salience decision is exposed as `salienceDisposition` for callers
+            // (and tests) that want the unmapped value.
+            disposition: isLowSalience ? 'low-salience' : (result.salience?.disposition ?? 'active'),
+            salienceDisposition: result.salience?.disposition ?? null,
+            salience: result.salience?.score ?? 0,
+            reasonCodes: result.salience?.reasonCodes ?? [],
+            engram: result.engram,
+            supersedeOf: result.supersedeOf,
         });
     });
     /**
@@ -149,7 +165,7 @@ export function registerRoutes(app, deps) {
             const memTags = [...(mem.tags ?? [])];
             if (sid)
                 memTags.push(`sid=${sid}`);
-            const engram = store.createEngram({
+            const engram = await store.createEngram({
                 agentId: body.agentId,
                 concept: mem.concept,
                 content: mem.content,
@@ -160,9 +176,9 @@ export function registerRoutes(app, deps) {
             });
             // Handle supersession inline — archive superseded memory to remove from active pool
             if (mem.supersedes) {
-                store.supersedeEngram(mem.supersedes, engram.id);
-                store.updateConfidence(mem.supersedes, 0.1);
-                store.updateStage(mem.supersedes, 'archived'); // Remove from active search pool
+                await store.supersedeEngram(mem.supersedes, engram.id);
+                await store.updateConfidence(mem.supersedes, 0.1);
+                await store.updateStage(mem.supersedes, 'archived'); // Remove from active search pool
             }
             results.push({ id: engram.id, concept: mem.concept, disposition: 'active' });
         }
@@ -172,13 +188,13 @@ export function registerRoutes(app, deps) {
             const vecs = await embedBatch(texts);
             for (let i = 0; i < vecs.length; i++) {
                 if (results[i]) {
-                    store.updateEmbedding(results[i].id, vecs[i]);
+                    await store.updateEmbedding(results[i].id, vecs[i]);
                 }
             }
         }
         catch { /* Embedding failure is non-fatal */ }
         try {
-            store.updateAutoCheckpointWrite(body.agentId, results[results.length - 1]?.id ?? '');
+            await store.updateAutoCheckpointWrite(body.agentId, results[results.length - 1]?.id ?? '');
         }
         catch { }
         return reply.code(201).send({
@@ -197,33 +213,39 @@ export function registerRoutes(app, deps) {
             useReranker: body.useReranker,
             useExpansion: body.useExpansion,
             abstentionThreshold: body.abstentionThreshold,
+            requireConfidence: body.requireConfidence,
             workspace: body.workspace,
             bm25Only: body.bm25Only,
+            granularity: body.granularity,
         });
         // Auto-checkpoint: track recall for consolidation scheduling
         try {
             const ids = results.map(r => r.engram.id);
-            store.updateAutoCheckpointRecall(body.agentId, body.context, ids);
+            await store.updateAutoCheckpointRecall(body.agentId, body.context, ids);
         }
         catch { /* non-fatal */ }
-        return reply.send({ results });
+        // Surface recall confidence as a top-level field too — same value is on
+        // every result, but it describes the recall as a whole, so exposing it
+        // once is easier for consumers (and lets them inspect 0-result recalls).
+        const confidence = results[0]?.confidence ?? 0;
+        return reply.send({ results, confidence });
     });
     app.post('/memory/feedback', async (req, reply) => {
         const body = req.body;
-        store.logRetrievalFeedback(body.activationEventId ?? null, body.engramId, body.useful, body.context ?? '');
+        await store.logRetrievalFeedback(body.activationEventId ?? null, body.engramId, body.useful, body.context ?? '');
         // Update engram confidence based on feedback
-        const engram = store.getEngram(body.engramId);
+        const engram = await store.getEngram(body.engramId);
         if (engram) {
             const config = DEFAULT_AGENT_CONFIG;
             const delta = body.useful
                 ? config.feedbackPositiveBoost
                 : -config.feedbackNegativePenalty;
-            store.updateConfidence(engram.id, engram.confidence + delta);
+            await store.updateConfidence(engram.id, engram.confidence + delta);
         }
         // Touch activity for consolidation scheduling
         if (engram) {
             try {
-                store.touchActivity(engram.agentId);
+                await store.touchActivity(engram.agentId);
             }
             catch { /* non-fatal */ }
         }
@@ -231,7 +253,7 @@ export function registerRoutes(app, deps) {
     });
     app.post('/memory/retract', async (req, reply) => {
         const body = req.body;
-        const result = retractionEngine.retract({
+        const result = await retractionEngine.retract({
             agentId: body.agentId,
             targetEngramId: body.targetEngramId,
             reason: body.reason,
@@ -239,33 +261,83 @@ export function registerRoutes(app, deps) {
         });
         // Touch activity for consolidation scheduling
         try {
-            store.touchActivity(body.agentId);
+            await store.touchActivity(body.agentId);
         }
         catch { /* non-fatal */ }
         return reply.send(result);
     });
     app.post('/memory/supersede', async (req, reply) => {
         const body = req.body;
-        const oldEngram = store.getEngram(body.oldEngramId);
-        const newEngram = store.getEngram(body.newEngramId);
-        if (!oldEngram)
-            return reply.code(404).send({ error: `Old engram ${body.oldEngramId} not found` });
-        if (!newEngram)
-            return reply.code(404).send({ error: `New engram ${body.newEngramId} not found` });
-        // Create causal association (new → old)
-        store.upsertAssociation(body.newEngramId, body.oldEngramId, 0.8, 'causal', 1.0);
-        // Reduce old engram confidence to 20% (keep for historical reference)
-        store.updateConfidence(body.oldEngramId, oldEngram.confidence * 0.2);
-        // Mark supersession via store method
-        store.supersedeEngram(body.oldEngramId, body.newEngramId);
+        const isFormA = !!(body.oldEngramId && body.newEngramId);
+        const isFormB = !!(body.matchConcept && body.newEngram && body.agentId);
+        if (isFormA && isFormB) {
+            return reply.code(400).send({
+                error: 'Pass either {oldEngramId, newEngramId} (Form A) OR ' +
+                    '{agentId, matchConcept, newEngram} (Form B), not both.',
+            });
+        }
+        if (!isFormA && !isFormB) {
+            return reply.code(400).send({
+                error: 'Missing required fields. Form A: {oldEngramId, newEngramId}. ' +
+                    'Form B: {agentId, matchConcept, newEngram}.',
+            });
+        }
+        // ── Form A — by IDs ──
+        if (isFormA) {
+            const oldEngram = await store.getEngram(body.oldEngramId);
+            const newEngram = await store.getEngram(body.newEngramId);
+            if (!oldEngram)
+                return reply.code(404).send({ error: `Old engram ${body.oldEngramId} not found` });
+            if (!newEngram)
+                return reply.code(404).send({ error: `New engram ${body.newEngramId} not found` });
+            await store.upsertAssociation(body.newEngramId, body.oldEngramId, 0.8, 'causal', 1.0);
+            await store.updateConfidence(body.oldEngramId, oldEngram.confidence * 0.2);
+            await store.supersedeEngram(body.oldEngramId, body.newEngramId);
+            try {
+                await store.touchActivity(oldEngram.agentId);
+            }
+            catch { /* non-fatal */ }
+            return reply.send({
+                superseded: body.oldEngramId,
+                supersededBy: body.newEngramId,
+                reason: body.reason ?? 'outdated',
+            });
+        }
+        // ── Form B — atomic write-and-supersede by concept match ──
+        // Find old (most recent active match by concept + optional tags), write
+        // new engram via performWrite, link them — all in one SQL transaction.
+        // If no match: write new anyway, return { superseded: null }.
+        // AWM 0.8.x P4b follow-up: Form B atomicity via withTransaction.
+        // Holds the SQLite/PGlite lock across the async write + supersede pair
+        // so callers never observe a half-completed state.
+        const result = await store.withTransaction(async () => {
+            const matched = await store.findActiveMatchByConcept(body.agentId, body.matchConcept, body.matchTags);
+            const writeRes = await performWrite({ store, connectionEngine }, {
+                agentId: body.agentId,
+                concept: body.newEngram.concept,
+                content: body.newEngram.content,
+                tags: body.newEngram.tags ?? [],
+                memoryClass: body.newEngram.memory_class,
+                sequence: body.newEngram.sequence,
+                eventType: body.newEngram.eventType,
+                enableReinforcement: false,
+            });
+            if (matched) {
+                await store.upsertAssociation(writeRes.engram.id, matched.id, 0.8, 'causal', 1.0);
+                await store.updateConfidence(matched.id, matched.confidence * 0.2);
+                await store.supersedeEngram(matched.id, writeRes.engram.id);
+            }
+            return { writeRes, matched };
+        });
         try {
-            store.touchActivity(oldEngram.agentId);
+            await store.touchActivity(body.agentId);
         }
         catch { /* non-fatal */ }
-        return reply.send({
-            superseded: body.oldEngramId,
-            supersededBy: body.newEngramId,
-            reason: body.reason ?? 'outdated',
+        return reply.code(201).send({
+            newEngram: result.writeRes.engram,
+            superseded: result.matched ? result.matched.id : null,
+            supersededBy: result.writeRes.engram.id,
+            reason: body.reason ?? 'resolved by concept match',
         });
     });
     // ============================================================
@@ -273,32 +345,122 @@ export function registerRoutes(app, deps) {
     // ============================================================
     app.post('/memory/search', async (req, reply) => {
         const body = req.body;
-        const results = store.search({
+        const results = await store.search({
             agentId: body.agentId,
             text: body.text,
             concept: body.concept,
             tags: body.tags,
+            tagsAll: body.tagsAll,
+            tagsAny: body.tagsAny,
+            tagsNone: body.tagsNone,
             stage: body.stage,
             retracted: body.retracted,
             limit: body.limit,
             offset: body.offset,
+            sortBy: body.sortBy,
+            sortOrder: body.sortOrder,
         });
         return reply.send({ results, count: results.length });
     });
+    // ============================================================
+    // 0.8 Cluster C — materialized-view + atomic-counter endpoints
+    // ============================================================
+    /**
+     * For each distinct value of `tagKey`, return the most recent active
+     * engram. Used by NovelForge for "latest emotional state per character",
+     * "latest motif phase per motif", etc.
+     */
+    app.post('/memory/latest-by-tag', async (req, reply) => {
+        const body = req.body;
+        if (!body.agentId || !body.tagKey) {
+            return reply.code(400).send({ error: 'agentId and tagKey are required' });
+        }
+        const results = await store.getLatestByTag({
+            agentId: body.agentId,
+            tagKeyPrefix: body.tagKey,
+            scopeTagsAll: body.scopeTagsAll,
+            retracted: body.retracted ?? false,
+            sortBy: body.sortBy,
+            limit: body.limit,
+        });
+        return reply.send({ results, count: results.length });
+    });
+    /**
+     * Filter by tag-set operators, sort by numeric value extracted from a
+     * tag prefix, return top N. Used by NovelForge for "top N active
+     * promises by weight".
+     */
+    app.post('/memory/top-by', async (req, reply) => {
+        const body = req.body;
+        if (!body.agentId || !body.sortField) {
+            return reply.code(400).send({ error: 'agentId and sortField are required' });
+        }
+        const results = await store.getTopBy({
+            agentId: body.agentId,
+            sortField: body.sortField,
+            order: body.order ?? 'desc',
+            filterTagsAll: body.filterTagsAll,
+            filterTagsAny: body.filterTagsAny,
+            filterTagsNone: body.filterTagsNone,
+            retracted: body.retracted ?? false,
+            limit: body.limit,
+        });
+        return reply.send({ results, count: results.length });
+    });
+    /**
+     * Compute effective state of an engram from referenced events. Two
+     * targeting modes: by ID, or by concept match (same semantics as Form B's
+     * findActiveMatchByConcept).
+     */
+    app.post('/memory/resolve', async (req, reply) => {
+        const body = req.body;
+        if (!body.agentId) {
+            return reply.code(400).send({ error: 'agentId is required' });
+        }
+        let targetId = body.targetEngramId;
+        if (!targetId && body.matchConcept) {
+            const matched = await store.findActiveMatchByConcept(body.agentId, body.matchConcept, body.matchTags);
+            if (!matched) {
+                return reply.code(404).send({
+                    error: `No active engram matches concept "${body.matchConcept}"`,
+                });
+            }
+            targetId = matched.id;
+        }
+        if (!targetId) {
+            return reply.code(400).send({
+                error: 'Provide either targetEngramId or matchConcept',
+            });
+        }
+        const result = await store.resolveEffectiveState(targetId);
+        if (!result)
+            return reply.code(404).send({ error: `Engram ${targetId} not found` });
+        return reply.send(result);
+    });
+    /**
+     * Race-free next-sequence allocator. Caller writes the engram with the
+     * returned value in `sequence`. Doesn't reserve — concurrent allocations
+     * always serialize via BEGIN IMMEDIATE.
+     */
+    app.get('/memory/sequence/:agentId/next', async (req, reply) => {
+        const { agentId } = req.params;
+        const next = await store.allocateNextSequence(agentId);
+        return reply.send({ agentId, next });
+    });
     app.get('/memory/:id', async (req, reply) => {
         const { id } = req.params;
-        const engram = store.getEngram(id);
+        const engram = await store.getEngram(id);
         if (!engram)
             return reply.code(404).send({ error: 'Not found' });
-        const associations = store.getAssociationsFor(id);
+        const associations = await store.getAssociationsFor(id);
         return reply.send({ engram, associations });
     });
     app.get('/agent/:id/stats', async (req, reply) => {
         const { id } = req.params;
-        const active = store.getEngramsByAgent(id, 'active');
-        const staging = store.getEngramsByAgent(id, 'staging');
-        const retracted = store.getEngramsByAgent(id, undefined, true).filter(e => e.retracted);
-        const associations = store.getAllAssociations(id);
+        const active = await store.getEngramsByAgent(id, 'active');
+        const staging = await store.getEngramsByAgent(id, 'staging');
+        const retracted = (await store.getEngramsByAgent(id, undefined, true)).filter(e => e.retracted);
+        const associations = await store.getAllAssociations(id);
         return reply.send({
             agentId: id,
             engrams: {
@@ -316,7 +478,7 @@ export function registerRoutes(app, deps) {
     app.get('/agent/:id/metrics', async (req, reply) => {
         const { id } = req.params;
         const windowHours = parseInt(req.query.window ?? '24', 10);
-        const metrics = evalEngine.computeMetrics(id, windowHours);
+        const metrics = await evalEngine.computeMetrics(id, windowHours);
         return reply.send({ metrics });
     });
     app.post('/agent/register', async (req, reply) => {
@@ -333,12 +495,12 @@ export function registerRoutes(app, deps) {
     // ============================================================
     app.post('/system/evict', async (req, reply) => {
         const body = req.body;
-        const result = evictionEngine.enforceCapacity(body.agentId, DEFAULT_AGENT_CONFIG);
+        const result = await evictionEngine.enforceCapacity(body.agentId, DEFAULT_AGENT_CONFIG);
         return reply.send(result);
     });
     app.post('/system/decay', async (req, reply) => {
         const body = req.body;
-        const decayed = evictionEngine.decayEdges(body.agentId, body.halfLifeDays);
+        const decayed = await evictionEngine.decayEdges(body.agentId, body.halfLifeDays);
         return reply.send({ edgesDecayed: decayed });
     });
     app.post('/system/consolidate', async (req, reply) => {
@@ -365,7 +527,7 @@ export function registerRoutes(app, deps) {
     });
     app.get('/memory/restore/:agentId', async (req, reply) => {
         const { agentId } = req.params;
-        const checkpoint = store.getCheckpoint(agentId);
+        const checkpoint = await store.getCheckpoint(agentId);
         const now = Date.now();
         const idleMs = checkpoint
             ? now - checkpoint.auto.lastActivityAt.getTime()
@@ -373,7 +535,7 @@ export function registerRoutes(app, deps) {
         // Get last written engram for context
         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 };
             }
@@ -423,7 +585,7 @@ export function registerRoutes(app, deps) {
     // ============================================================
     app.post('/task/create', async (req, reply) => {
         const body = req.body;
-        const engram = store.createEngram({
+        const engram = await store.createEngram({
             agentId: body.agentId,
             concept: body.concept,
             content: body.content,
@@ -440,32 +602,32 @@ export function registerRoutes(app, deps) {
             blockedBy: body.blockedBy,
         });
         connectionEngine.enqueue(engram.id);
-        embed(`${body.concept} ${body.content}`).then(vec => {
-            store.updateEmbedding(engram.id, vec);
+        embed(`${body.concept} ${body.content}`).then(async (vec) => {
+            await store.updateEmbedding(engram.id, vec);
         }).catch(() => { });
         return reply.send(engram);
     });
     app.post('/task/update', async (req, reply) => {
         const body = req.body;
-        const engram = store.getEngram(body.taskId);
+        const engram = await store.getEngram(body.taskId);
         if (!engram || !engram.taskStatus) {
             return reply.code(404).send({ error: 'Task not found' });
         }
         if (body.blockedBy !== undefined) {
-            store.updateBlockedBy(body.taskId, body.blockedBy);
+            await store.updateBlockedBy(body.taskId, body.blockedBy);
         }
         if (body.status) {
-            store.updateTaskStatus(body.taskId, body.status);
+            await store.updateTaskStatus(body.taskId, body.status);
         }
         if (body.priority) {
-            store.updateTaskPriority(body.taskId, body.priority);
+            await store.updateTaskPriority(body.taskId, body.priority);
         }
-        return reply.send(store.getEngram(body.taskId));
+        return reply.send(await store.getEngram(body.taskId));
     });
     app.get('/task/list/:agentId', async (req, reply) => {
         const { agentId } = req.params;
         const { status, includeDone } = req.query;
-        let tasks = store.getTasks(agentId, status);
+        let tasks = await store.getTasks(agentId, status);
         if (includeDone !== 'true' && !status) {
             tasks = tasks.filter(t => t.taskStatus !== 'done');
         }
@@ -473,20 +635,25 @@ export function registerRoutes(app, deps) {
     });
     app.get('/task/next/:agentId', async (req, reply) => {
         const { agentId } = req.params;
-        const next = store.getNextTask(agentId);
+        const next = await store.getNextTask(agentId);
         return reply.send(next ? { task: next } : { task: null, message: 'No actionable tasks' });
     });
     // Time warp — shift all timestamps backward by N days (for testing)
     app.post('/system/time-warp', async (req, reply) => {
         const body = req.body;
         const ms = body.days * 24 * 60 * 60 * 1000;
-        const shifted = store.timeWarp(body.agentId, ms);
+        const shifted = await store.timeWarp(body.agentId, ms);
         return reply.send({ shifted, days: body.days });
     });
     // ─── Export ─────────────────────────────────────────────────────────────
     app.get('/memory/export', async (req, reply) => {
         const { agentId, all } = req.query;
         const includeAll = all === 'true';
+        // /memory/export uses raw SQL — SQLite-only. On PGlite, callers should use
+        // the awm CLI export/merge tools instead.
+        if (typeof store.getDb !== 'function') {
+            return reply.code(501).send({ error: 'export endpoint requires the SQLite backend' });
+        }
         const db = store.getDb();
         let engramSql = `SELECT id, agent_id, concept, content, confidence, salience, access_count,
       last_accessed, created_at, salience_features, reason_codes, stage, ttl,
@@ -527,10 +694,10 @@ export function registerRoutes(app, deps) {
         const base = {
             status: 'ok',
             timestamp: new Date().toISOString(),
-            version: '0.7.16',
+            version: '0.8.5',
             coordination: coordEnabled,
         };
-        if (coordEnabled) {
+        if (coordEnabled && typeof deps.store.getDb === 'function') {
             try {
                 const db = deps.store.getDb();
                 const stats = db.prepare(`SELECT