agent-working-memory 0.7.16 → 0.8.5

package/src/api/routes.ts

@@ -34,7 +34,7 @@
  */
 
 import type { FastifyInstance } from 'fastify';
-import type { EngramStore } from '../storage/sqlite.js';
+import type { IEngramStore as EngramStore } from '../storage/store.js';
 import type { ActivationEngine } from '../engine/activation.js';
 import type { ConnectionEngine } from '../engine/connections.js';
 import type { EvictionEngine } from '../engine/eviction.js';
@@ -44,6 +44,7 @@ import type { ConsolidationEngine } from '../engine/consolidation.js';
 import type { ConsolidationScheduler } from '../engine/consolidation-scheduler.js';
 import { evaluateSalience, computeNovelty } from '../core/salience.js';
 import type { SalienceEventType } from '../core/salience.js';
+import { performWrite } from '../core/write-pipeline.js';
 import type { TaskStatus, TaskPriority } from '../types/engram.js';
 import type { ConsciousState } from '../types/checkpoint.js';
 import { DEFAULT_AGENT_CONFIG } from '../types/agent.js';
@@ -79,6 +80,34 @@ export function registerRoutes(app: FastifyInstance, deps: MemoryDeps): void {
       causalDepth?: number;
       resolutionEffort?: number;
       confidence?: number;
+      // Memory class — canonical bypasses salience filter; structural is
+      // for system-written event-log records (see 0.8 spec). Restored in
+      // 0.8.0 after the field was dropped from the HTTP body schema during
+      // the 0.7.x refactor — core/salience.ts:88-89,124,187 and
+      // core/write-pipeline.ts:77 still expect and honor it, so HTTP
+      // callers were silently losing the canonical-bypass signal.
+      memory_class?: 'canonical' | 'working' | 'ephemeral' | 'structural';
+      // Optional story-time / sequence ordering (0.8 Cluster A). NULL by
+      // default. Used by sortBy: "sequence" on /memory/search and by
+      // /memory/latest-by-tag (0.8 Cluster C).
+      sequence?: number;
+      // Force embedding for structural-class writes. Defaults to false for
+      // structural (deterministic retrieval only) — opt in here when cognitive
+      // recall over a structural engram is desired. (0.8 Cluster A)
+      embed?: boolean;
+      // Typed cross-record links (0.8 Cluster D). Each reference is
+      // {type, matchEngramId?, matchConcept?}. If matchConcept is given
+      // without matchEngramId, AWM resolves it to the most recent active
+      // engram at write time and stores BOTH on the reference (stable link).
+      // If no match found, stores just matchConcept (caller may be linking
+      // to a future or deleted engram). Types: advances | resolves |
+      // subverts | abandons | extends | supersedes.
+      references?: Array<{
+        type: 'advances' | 'resolves' | 'subverts' | 'abandons' | 'extends' | 'supersedes';
+        matchEngramId?: string;
+        matchConcept?: string;
+        matchTags?: string[];
+      }>;
       // Agent-provided metadata (stored as searchable tags)
       project?: string;
       topic?: string;
@@ -94,24 +123,6 @@ export function registerRoutes(app: FastifyInstance, deps: MemoryDeps): void {
       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: string[] = [];
@@ -121,62 +132,94 @@ export function registerRoutes(app: FastifyInstance, deps: MemoryDeps): void {
     if (body.confidenceLevel) metaTags.push(`conf=${body.confidenceLevel}`);
     if (body.sessionId) 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');
+    // Auto-checkpoint always (covers create, reinforce, and supersede).
+    try { 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,
+      });
     }
 
-    // Create temporal adjacency edge to previous memory (conversation thread graph)
-    // This enables multi-hop graph walk through conversation sequences
-    try {
-      const prev = store.getLatestEngram(body.agentId, engram.id);
-      if (prev) {
-        store.upsertAssociation(prev.id, engram.id, 0.3, 'temporal', 0.8);
-      }
-    } 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 */ }
+      } 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 */ }
+      }
     }
 
-    // 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 { /* 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,
     });
   });
 
@@ -210,7 +253,7 @@ export function registerRoutes(app: FastifyInstance, deps: MemoryDeps): void {
       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,
@@ -222,9 +265,9 @@ export function registerRoutes(app: FastifyInstance, deps: MemoryDeps): void {
 
       // 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' });
@@ -236,12 +279,12 @@ export function registerRoutes(app: FastifyInstance, deps: MemoryDeps): void {
       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 ?? ''); } catch {}
+    try { await store.updateAutoCheckpointWrite(body.agentId, results[results.length - 1]?.id ?? ''); } catch {}
 
     return reply.code(201).send({
       stored: results.length,
@@ -259,8 +302,10 @@ export function registerRoutes(app: FastifyInstance, deps: MemoryDeps): void {
       useReranker?: boolean;
       useExpansion?: boolean;
       abstentionThreshold?: number;
+      requireConfidence?: number;
       workspace?: string;
       bm25Only?: boolean;
+      granularity?: 'full' | 'compact' | 'auto';
     };
 
     const results = await activationEngine.activate({
@@ -272,17 +317,23 @@ export function registerRoutes(app: FastifyInstance, deps: MemoryDeps): void {
       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) => {
@@ -293,7 +344,7 @@ export function registerRoutes(app: FastifyInstance, deps: MemoryDeps): void {
       context?: string;
     };
 
-    store.logRetrievalFeedback(
+    await store.logRetrievalFeedback(
       body.activationEventId ?? null,
       body.engramId,
       body.useful,
@@ -301,18 +352,18 @@ export function registerRoutes(app: FastifyInstance, deps: MemoryDeps): void {
     );
 
     // 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); } catch { /* non-fatal */ }
+      try { await store.touchActivity(engram.agentId); } catch { /* non-fatal */ }
     }
 
     return reply.send({ recorded: true });
@@ -326,7 +377,7 @@ export function registerRoutes(app: FastifyInstance, deps: MemoryDeps): void {
       counterContent?: string;
     };
 
-    const result = retractionEngine.retract({
+    const result = await retractionEngine.retract({
       agentId: body.agentId,
       targetEngramId: body.targetEngramId,
       reason: body.reason,
@@ -334,38 +385,105 @@ export function registerRoutes(app: FastifyInstance, deps: MemoryDeps): void {
     });
 
     // Touch activity for consolidation scheduling
-    try { store.touchActivity(body.agentId); } catch { /* non-fatal */ }
+    try { await store.touchActivity(body.agentId); } catch { /* non-fatal */ }
 
     return reply.send(result);
   });
 
   app.post('/memory/supersede', async (req, reply) => {
     const body = req.body as {
-      oldEngramId: string;
-      newEngramId: string;
+      // ── Form A — supersede by existing engram IDs (pre-0.8 behavior) ──
+      oldEngramId?: string;
+      newEngramId?: string;
+      // ── Form B — atomic write-and-supersede by concept match (0.8 Cluster D) ──
+      agentId?: string;
+      matchConcept?: string;
+      matchTags?: string[];
+      newEngram?: {
+        concept: string;
+        content: string;
+        tags?: string[];
+        memory_class?: 'canonical' | 'working' | 'ephemeral' | 'structural';
+        sequence?: number;
+        eventType?: SalienceEventType;
+      };
+      // Common
       reason?: string;
     };
 
-    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` });
+    const isFormA = !!(body.oldEngramId && body.newEngramId);
+    const isFormB = !!(body.matchConcept && body.newEngram && body.agentId);
 
-    // Create causal association (new → old)
-    store.upsertAssociation(body.newEngramId, body.oldEngramId, 0.8, 'causal', 1.0);
+    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',
+      });
+    }
 
-    // Reduce old engram confidence to 20% (keep for historical reference)
-    store.updateConfidence(body.oldEngramId, oldEngram.confidence * 0.2);
+    // ── 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,
+      });
 
-    // Mark supersession via store method
-    store.supersedeEngram(body.oldEngramId, body.newEngramId);
+      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 };
+    }) as Promise<{ writeRes: Awaited<ReturnType<typeof performWrite>>; matched: any }>);
 
-    try { store.touchActivity(oldEngram.agentId); } catch { /* non-fatal */ }
+    try { 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',
     });
   });
 
@@ -378,42 +496,166 @@ export function registerRoutes(app: FastifyInstance, deps: MemoryDeps): void {
       agentId: string;
       text?: string;
       concept?: string;
-      tags?: string[];
+      tags?: string[];          // legacy AND-filter — preserved, equivalent to tagsAll
+      tagsAll?: string[];       // 0.8 Cluster B — explicit AND
+      tagsAny?: string[];       // 0.8 Cluster B — OR (at least one)
+      tagsNone?: string[];      // 0.8 Cluster B — NOT (exclude all)
       stage?: string;
       retracted?: boolean;
       limit?: number;
       offset?: number;
+      sortBy?: 'createdAt' | 'sequence' | 'salience' | 'confidence' | 'lastAccessed';
+      sortOrder?: 'asc' | 'desc';
     };
 
-    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 as any,
       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 as {
+      agentId: string;
+      tagKey: string;                // e.g. "character=", "motif="
+      scopeTagsAll?: string[];       // optional narrowing
+      retracted?: boolean;
+      sortBy?: 'createdAt' | 'sequence';
+      limit?: number;
+    };
+    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 as {
+      agentId: string;
+      sortField: string;             // tag prefix, e.g. "weight="
+      order?: 'asc' | 'desc';        // default desc
+      filterTagsAll?: string[];
+      filterTagsAny?: string[];
+      filterTagsNone?: string[];
+      retracted?: boolean;
+      limit?: number;
+    };
+    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 as {
+      agentId: string;
+      targetEngramId?: string;
+      matchConcept?: string;
+      matchTags?: string[];
+    };
+    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 as { agentId: string };
+    const next = await store.allocateNextSequence(agentId);
+    return reply.send({ agentId, next });
+  });
+
   app.get('/memory/:id', async (req, reply) => {
     const { id } = req.params as { id: string };
-    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 as { id: string };
-    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,
@@ -433,7 +675,7 @@ export function registerRoutes(app: FastifyInstance, deps: MemoryDeps): void {
   app.get('/agent/:id/metrics', async (req, reply) => {
     const { id } = req.params as { id: string };
     const windowHours = parseInt((req.query as any).window ?? '24', 10);
-    const metrics = evalEngine.computeMetrics(id, windowHours);
+    const metrics = await evalEngine.computeMetrics(id, windowHours);
     return reply.send({ metrics });
   });
 
@@ -453,13 +695,13 @@ export function registerRoutes(app: FastifyInstance, deps: MemoryDeps): void {
 
   app.post('/system/evict', async (req, reply) => {
     const body = req.body as { agentId: string };
-    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 as { agentId: string; halfLifeDays?: number };
-    const decayed = evictionEngine.decayEdges(body.agentId, body.halfLifeDays);
+    const decayed = await evictionEngine.decayEdges(body.agentId, body.halfLifeDays);
     return reply.send({ edgesDecayed: decayed });
   });
 
@@ -501,7 +743,7 @@ export function registerRoutes(app: FastifyInstance, deps: MemoryDeps): void {
 
   app.get('/memory/restore/:agentId', async (req, reply) => {
     const { agentId } = req.params as { agentId: string };
-    const checkpoint = store.getCheckpoint(agentId);
+    const checkpoint = await store.getCheckpoint(agentId);
 
     const now = Date.now();
     const idleMs = checkpoint
@@ -511,7 +753,7 @@ export function registerRoutes(app: FastifyInstance, deps: MemoryDeps): void {
     // Get last written engram for context
     let lastWrite: { id: string; concept: string; content: string } | null = 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 };
       }
@@ -574,7 +816,7 @@ export function registerRoutes(app: FastifyInstance, deps: MemoryDeps): void {
       blockedBy?: string;
     };
 
-    const engram = store.createEngram({
+    const engram = await store.createEngram({
       agentId: body.agentId,
       concept: body.concept,
       content: body.content,
@@ -592,8 +834,8 @@ export function registerRoutes(app: FastifyInstance, deps: MemoryDeps): void {
     });
 
     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);
@@ -607,29 +849,29 @@ export function registerRoutes(app: FastifyInstance, deps: MemoryDeps): void {
       blockedBy?: string | null;
     };
 
-    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 as { agentId: string };
     const { status, includeDone } = req.query as { status?: TaskStatus; includeDone?: string };
 
-    let tasks = store.getTasks(agentId, status);
+    let tasks = await store.getTasks(agentId, status);
     if (includeDone !== 'true' && !status) {
       tasks = tasks.filter(t => t.taskStatus !== 'done');
     }
@@ -639,7 +881,7 @@ export function registerRoutes(app: FastifyInstance, deps: MemoryDeps): void {
 
   app.get('/task/next/:agentId', async (req, reply) => {
     const { agentId } = req.params as { agentId: string };
-    const next = store.getNextTask(agentId);
+    const next = await store.getNextTask(agentId);
     return reply.send(next ? { task: next } : { task: null, message: 'No actionable tasks' });
   });
 
@@ -647,7 +889,7 @@ export function registerRoutes(app: FastifyInstance, deps: MemoryDeps): void {
   app.post('/system/time-warp', async (req, reply) => {
     const body = req.body as { agentId: string; days: number };
     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 });
   });
 
@@ -656,7 +898,12 @@ export function registerRoutes(app: FastifyInstance, deps: MemoryDeps): void {
   app.get('/memory/export', async (req, reply) => {
     const { agentId, all } = req.query as { agentId?: string; all?: string };
     const includeAll = all === 'true';
-    const db = store.getDb();
+    // /memory/export uses raw SQL — SQLite-only. On PGlite, callers should use
+    // the awm CLI export/merge tools instead.
+    if (typeof (store as any).getDb !== 'function') {
+      return reply.code(501).send({ error: 'export endpoint requires the SQLite backend' });
+    }
+    const db = (store as any).getDb();
 
     let engramSql = `SELECT id, agent_id, concept, content, confidence, salience, access_count,
       last_accessed, created_at, salience_features, reason_codes, stage, ttl,
@@ -705,12 +952,12 @@ export function registerRoutes(app: FastifyInstance, deps: MemoryDeps): void {
     const base: Record<string, unknown> = {
       status: 'ok',
       timestamp: new Date().toISOString(),
-      version: '0.7.16',
+      version: '0.8.5',
       coordination: coordEnabled,
     };
-    if (coordEnabled) {
+    if (coordEnabled && typeof (deps.store as any).getDb === 'function') {
       try {
-        const db = deps.store.getDb();
+        const db = (deps.store as any).getDb();
         const stats = db.prepare(`SELECT
           (SELECT COUNT(*) FROM coord_agents WHERE status != 'dead') AS agents_alive,
           (SELECT COUNT(*) FROM coord_assignments WHERE status = 'pending') AS pending_tasks,