agent-working-memory 0.13.1 → 0.14.1

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

@@ -254,6 +254,22 @@ export interface PhaseScores {
  */
 export type QueryMode = 'targeted' | 'exploratory' | 'balanced' | 'auto';
 
+/** Why a recall returned nothing, when the cause was a gate rather than an empty store. */
+export interface AbstentionInfo {
+  /** `confidence` = score-distribution gate (`requireConfidence`).
+   *  `agreement`  = cross-channel agreement gate (`abstentionThreshold`). */
+  reason: 'confidence' | 'agreement';
+  /** Candidates that survived scoring and were then withheld. Never 0 — a genuinely
+   *  empty result does not produce an AbstentionInfo at all. */
+  candidates: number;
+  /** Score of the best withheld candidate. Compare against `minScore`, not against
+   *  the confidence threshold — they measure different things. */
+  topScore: number;
+  /** Computed recall confidence, and the threshold it failed. */
+  confidence?: number;
+  threshold?: number;
+}
+
 export interface ActivationQuery {
   agentId: string;
   context: string;
@@ -273,11 +289,27 @@ export interface ActivationQuery {
    * 0.25 (balanced), 0.40 (aggressive — only return high-confidence recall).
    */
   requireConfidence?: number;
+  /**
+   * Called when a gate withholds results, INSTEAD of silently returning [].
+   *
+   * An empty array cannot distinguish "nothing matched" from "matches were found
+   * and withheld", and callers reliably read the second as the first — including
+   * when the withheld results scored well above `minScore`. If you act on an empty
+   * recall, wire this up.
+   */
+  onAbstain?: (info: AbstentionInfo) => void;
   internal?: boolean;          // Skip access count increment, Hebbian update, and event logging (for system calls)
   spread?: boolean;            // R2: when AWM_SPREAD=1, set false to skip iterative spreading activation (connection-discovery uses this so edge-building doesn't recurse)
   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).