agent-working-memory 0.9.1 → 0.10.0

package/src/core/salience.ts

@@ -493,12 +493,21 @@ export async function computeNoveltyWithMatch(
         : typeof created === 'number' ? created : Date.parse(created);
       return Number.isFinite(createdMs) && createdMs >= cutoffMs;
     };
+    // Novelty PENALTY: an exact-concept recent match on EITHER channel (including cross-agent workspace
+    // results) is a near-duplicate for novelty-scoring purposes.
     const exactConceptRecent = allBm25.some(r => checkExactConcept(r.engram))
       || (topCosine ? checkExactConcept(topCosine.engram) : false);
+    // REINFORCE redirect: prefer an exact same-concept match as the matched engram so a true duplicate
+    // REINFORCES it (R1) instead of creating a new one even when a different-concept engram out-scores it.
+    // CRUCIALLY, only consider AGENT-SCOPED candidates — bm25Results and the cosine channel are scoped to
+    // this agent, but `wsResults` are OTHER agents' engrams; redirecting to one would make the write
+    // pipeline reinforce/supersede a foreign agent's memory (cross-agent contamination).
+    const exactMatch = bm25Results.find(r => checkExactConcept(r.engram))?.engram
+      ?? (topCosine && checkExactConcept(topCosine.engram) ? topCosine.engram : undefined);
     const conceptPenalty = exactConceptRecent ? 0.3 : 0;
 
     const novelty = Math.max(0.05, Math.min(0.95, baseNovelty - conceptPenalty));
-    return { novelty, matchedEngramId: combinedTop.engramId, matchScore: topScore };
+    return { novelty, matchedEngramId: exactMatch?.id ?? combinedTop.engramId, matchScore: topScore };
   } catch {
     return { novelty: 0.8, matchedEngramId: null, matchScore: 0 };
   }

package/src/core/write-pipeline.ts

@@ -220,7 +220,11 @@ export async function performWrite(
   let result: WriteResult | null = null;
   if (enableReinforcement && noveltyResult.matchedEngramId) {
     const matched = await store.getEngram(noveltyResult.matchedEngramId);
-    if (matched) {
+    // Agent-scope guard: NEVER reinforce/supersede an engram that belongs to a DIFFERENT agent. A
+    // workspace/hive recall can surface another agent's same-concept engram as the match; mutating it
+    // (merge content, re-embed, bump confidence, or supersede) would corrupt that agent's memory. A
+    // cross-agent match falls through to createNewEngram so this agent gets its own copy.
+    if (matched && matched.agentId === input.agentId) {
       const newConcept = (input.concept ?? '').toLowerCase().trim();
       const matchedConcept = (matched.concept ?? '').toLowerCase().trim();
       const sameConcept = newConcept === matchedConcept && newConcept.length > 0;

package/src/storage/factory.ts

@@ -39,7 +39,7 @@
 import { existsSync, statSync } from 'node:fs';
 import type { IEngramStore } from './store.js';
 
-export type StoreBackend = 'sqlite' | 'pglite';
+export type StoreBackend = 'sqlite' | 'pglite' | 'postgres';
 
 /**
  * Auto-detect the backend from on-disk state. Used when `AWM_STORE_BACKEND`
@@ -71,6 +71,7 @@ export function getConfiguredBackend(): StoreBackend {
     const normalized = raw.toLowerCase();
     if (normalized === 'pglite') return 'pglite';
     if (normalized === 'sqlite') return 'sqlite';
+    if (normalized === 'postgres') return 'postgres';
     console.warn(`Unknown AWM_STORE_BACKEND=${raw}; falling back to sqlite`);
     return 'sqlite';
   }
@@ -80,8 +81,11 @@ export function getConfiguredBackend(): StoreBackend {
 }
 
 export function getConfiguredPath(): string {
+  const backend = getConfiguredBackend();
+  // Postgres uses a connection URL, not an on-disk path.
+  if (backend === 'postgres') return process.env.AWM_DATABASE_URL ?? 'postgres://localhost:5432/awm';
   if (process.env.AWM_DB_PATH) return process.env.AWM_DB_PATH;
-  return getConfiguredBackend() === 'pglite' ? 'memory-pglite' : 'memory.db';
+  return backend === 'pglite' ? 'memory-pglite' : 'memory.db';
 }
 
 /**
@@ -132,7 +136,15 @@ export async function openStore(): Promise<{
   const backend = getConfiguredBackend();
   const path = getConfiguredPath();
 
-  warnIfBackendDisagreesWithDisk(backend, path);
+  // The on-disk mismatch warning only applies to file/dir backends.
+  if (backend !== 'postgres') warnIfBackendDisagreesWithDisk(backend, path);
+
+  if (backend === 'postgres') {
+    const { PostgresEngramStore } = await import('./postgres.js');
+    const store = new PostgresEngramStore(path);
+    await store.ready();
+    return { store: store as unknown as IEngramStore, backend, path };
+  }
 
   if (backend === 'pglite') {
     const { PGliteEngramStore } = await import('./pglite.js');

package/src/storage/pglite.ts

@@ -141,6 +141,8 @@ function extractTagValue(tags: string[], prefix: string): string | null {
   return null;
 }
 
+let warnedNoCoordPglite = false; // one-time warning when workspace/hive recall falls back (coord_agents absent)
+
 export class PGliteEngramStore {
   private db!: PGlite;
   private readyPromise: Promise<void>;
@@ -395,6 +397,13 @@ export class PGliteEngramStore {
       if (!names.includes(agentId)) names.push(agentId);
       return names;
     } catch {
+      // coord_agents isn't provisioned on PGlite — workspace/hive coordination is currently SQLite-only.
+      // Warn ONCE so this degrades VISIBLY (recall scoped to self) instead of silently.
+      if (!warnedNoCoordPglite) {
+        warnedNoCoordPglite = true;
+        console.warn('[awm:pglite] workspace/hive coordination is not available on the PGlite backend ' +
+          '(coord_agents not provisioned) — recall is scoped to THIS agent only. Hive coordination is SQLite-only for now.');
+      }
       return [agentId];
     }
   }