agent-working-memory 0.13.0 → 0.14.0

package/src/storage/pglite.ts

@@ -512,7 +512,11 @@ export class PGliteEngramStore {
       sql += ` AND id != $${params.length + 1}`;
       params.push(excludeId);
     }
-    sql += ` ORDER BY created_at DESC LIMIT 1`;
+    // FIX 2026-08-23: created_at is millisecond-resolution, so two engrams written in
+    // the same millisecond TIE and "most recent" became whichever row the engine
+    // happened to return. Postgres has no stable insert-order column (ctid moves on
+    // update/vacuum), so id is the tiebreak: deterministic, though not chronological.
+    sql += ` ORDER BY created_at DESC, id DESC LIMIT 1`;
     const result = await this.db.query<any>(sql, params);
     return result.rows.length > 0 ? rowToEngram(result.rows[0]) : null;
   }
@@ -734,7 +738,11 @@ export class PGliteEngramStore {
         params.push(tagLike(tag));
       }
     }
-    sql += ` ORDER BY created_at DESC LIMIT 1`;
+    // FIX 2026-08-23: created_at is millisecond-resolution, so two engrams written in
+    // the same millisecond TIE and "most recent" became whichever row the engine
+    // happened to return. Postgres has no stable insert-order column (ctid moves on
+    // update/vacuum), so id is the tiebreak: deterministic, though not chronological.
+    sql += ` ORDER BY created_at DESC, id DESC LIMIT 1`;
     const result = await this.db.query<any>(sql, params);
     return result.rows.length > 0 ? rowToEngram(result.rows[0]) : null;
   }

package/src/storage/postgres.ts

@@ -611,7 +611,11 @@ export class PostgresEngramStore {
       sql += ` AND id != $${params.length + 1}`;
       params.push(excludeId);
     }
-    sql += ` ORDER BY created_at DESC LIMIT 1`;
+    // FIX 2026-08-23: created_at is millisecond-resolution, so two engrams written in
+    // the same millisecond TIE and "most recent" became whichever row the engine
+    // happened to return. Postgres has no stable insert-order column (ctid moves on
+    // update/vacuum), so id is the tiebreak: deterministic, though not chronological.
+    sql += ` ORDER BY created_at DESC, id DESC LIMIT 1`;
     const result = await this.q<any>(sql, params);
     return result.rows.length > 0 ? rowToEngram(result.rows[0]) : null;
   }
@@ -833,7 +837,11 @@ export class PostgresEngramStore {
         params.push(tagLike(tag));
       }
     }
-    sql += ` ORDER BY created_at DESC LIMIT 1`;
+    // FIX 2026-08-23: created_at is millisecond-resolution, so two engrams written in
+    // the same millisecond TIE and "most recent" became whichever row the engine
+    // happened to return. Postgres has no stable insert-order column (ctid moves on
+    // update/vacuum), so id is the tiebreak: deterministic, though not chronological.
+    sql += ` ORDER BY created_at DESC, id DESC LIMIT 1`;
     const result = await this.q<any>(sql, params);
     return result.rows.length > 0 ? rowToEngram(result.rows[0]) : null;
   }

package/src/storage/sqlite.ts

@@ -956,7 +956,12 @@ export class EngramStore {
       sql += ' AND id != ?';
       params.push(excludeId);
     }
-    sql += ' ORDER BY created_at DESC LIMIT 1';
+    // FIX 2026-08-23: created_at is millisecond-resolution ISO text, so two engrams
+    // written in the same millisecond TIE and "most recent" became whichever row the
+    // engine happened to return. Surfaced on Linux (same-ms writes) while passing on
+    // Windows, whose coarser timer separated them. rowid is monotonic with insert
+    // order, so it is both deterministic AND chronologically correct as a tiebreak.
+    sql += ' ORDER BY created_at DESC, rowid DESC LIMIT 1';
     const row = this.db.prepare(sql).get(...params) as any;
     return row ? this.rowToEngram(row) : null;
   }
@@ -1058,7 +1063,12 @@ export class EngramStore {
         params.push(`%"${tag}"%`);
       }
     }
-    sql += ' ORDER BY created_at DESC LIMIT 1';
+    // FIX 2026-08-23: created_at is millisecond-resolution ISO text, so two engrams
+    // written in the same millisecond TIE and "most recent" became whichever row the
+    // engine happened to return. Surfaced on Linux (same-ms writes) while passing on
+    // Windows, whose coarser timer separated them. rowid is monotonic with insert
+    // order, so it is both deterministic AND chronologically correct as a tiebreak.
+    sql += ' ORDER BY created_at DESC, rowid DESC LIMIT 1';
     const row = this.db.prepare(sql).get(...params) as any;
     return row ? this.rowToEngram(row) : null;
   }

package/src/types/engram.ts

@@ -278,6 +278,13 @@ export interface ActivationQuery {
   memoryType?: MemoryType;     // Filter by memory type (episodic, semantic, procedural)
   mode?: QueryMode;            // Pipeline mode — 'auto' by default
   workspace?: string;          // Search across all agents in this workspace (hive mode). If unset, agent-scoped only.
+  /**
+   * Anchor for relative temporal expressions ("last Friday", "last week").
+   * Defaults to now. Passed explicitly by evals so a fixture stays
+   * reproducible — with the wall clock, "last week" would silently mean
+   * something different on every run.
+   */
+  asOf?: number;
   bm25Only?: boolean;          // Skip embedding — fast text-only retrieval for bulk/benchmark scenarios
   /**
    * Output granularity (Paper 3: cognitive teaming, Brill 2018 ACT-R collaboration).