agent-working-memory 0.17.0 → 0.18.1

package/dist/storage/postgres.js

@@ -120,6 +120,7 @@ function rowToEngram(row) {
         recipeId: row.recipe_id ?? null,
         validFrom: row.valid_from ?? null,
         validTo: row.valid_to ?? null,
+        stageChangedAt: row.stage_changed_at ?? null,
     };
 }
 function rowToAssociation(row) {
@@ -279,7 +280,7 @@ export class PostgresEngramStore {
             // ALWAYS the pool, never this.q(): this background flush is fire-and-forget and must
             // not route to a transaction's client (a future caller that logs an activation inside a
             // withTransaction would otherwise collide with the tx's in-flight query on one pg client).
-            await this.pool.query(`INSERT INTO activation_events (id, agent_id, timestamp, context, results_returned, top_score, latency_ms, engram_ids)
+            await this.pool.query(`INSERT INTO activation_events (id, agent_id, timestamp, context, results_returned, top_score, latency_ms, engram_ids)
          VALUES ${values.join(',')}`, params);
         }
         catch {
@@ -326,20 +327,20 @@ export class PostgresEngramStore {
         await this.readyPromise;
         const id = input.id ?? randomUUID();
         const now = new Date().toISOString();
-        await this.q(`INSERT INTO engrams (
-        id, agent_id, concept, content, embedding, embedding_model,
-        confidence, salience, access_count, last_accessed, created_at,
-        salience_features, reason_codes, stage, ttl, retracted,
-        tags, memory_type, memory_class, supersedes, episode_id,
-        task_status, task_priority, blocked_by, sequence, references_json,
-        origin_class, writer_session, recipe_id, valid_from, valid_to
-      ) VALUES (
-        $1, $2, $3, $4, $5::vector, $6,
-        $7, $8, 0, $9, $10,
-        $11, $12, 'active', $13, FALSE,
-        $14, $15, $16, $17, $18,
-        $19, $20, $21, $22, $23,
-        $24, $25, $26, $27, $28
+        await this.q(`INSERT INTO engrams (
+        id, agent_id, concept, content, embedding, embedding_model,
+        confidence, salience, access_count, last_accessed, created_at,
+        salience_features, reason_codes, stage, ttl, retracted,
+        tags, memory_type, memory_class, supersedes, episode_id,
+        task_status, task_priority, blocked_by, sequence, references_json,
+        origin_class, writer_session, recipe_id, valid_from, valid_to
+      ) VALUES (
+        $1, $2, $3, $4, $5::vector, $6,
+        $7, $8, 0, $9, $10,
+        $11, $12, 'active', $13, FALSE,
+        $14, $15, $16, $17, $18,
+        $19, $20, $21, $22, $23,
+        $24, $25, $26, $27, $28
       )`, [
             id,
             input.agentId,
@@ -491,11 +492,11 @@ export class PostgresEngramStore {
         await this.readyPromise;
         const rows = [];
         for (const agentId of agentIds) {
-            const result = await this.q(`
-        SELECT tags, access_count AS "accessCount", id FROM engrams
-        WHERE agent_id = $1 AND stage = $2 AND retracted = FALSE
-        ORDER BY access_count DESC, id
-        LIMIT $3
+            const result = await this.q(`
+        SELECT tags, access_count AS "accessCount", id FROM engrams
+        WHERE agent_id = $1 AND stage = $2 AND retracted = FALSE
+        ORDER BY access_count DESC, id
+        LIMIT $3
       `, [agentId, stage, topN]);
             rows.push(...result.rows);
         }
@@ -535,15 +536,15 @@ export class PostgresEngramStore {
     }
     async touchEngram(id) {
         await this.readyPromise;
-        await this.q(`UPDATE engrams
-       SET access_count = access_count + 1,
-           last_accessed = $1,
-           confidence = LEAST(0.85, confidence + 0.02 / (1.0 + sqrt(access_count::float)))
+        await this.q(`UPDATE engrams
+       SET access_count = access_count + 1,
+           last_accessed = $1,
+           confidence = LEAST(0.85, confidence + 0.02 / (1.0 + sqrt(access_count::float)))
        WHERE id = $2`, [new Date().toISOString(), id]);
     }
     async updateStage(id, stage) {
         await this.readyPromise;
-        await this.q(`UPDATE engrams SET stage = $1 WHERE id = $2`, [stage, id]);
+        await this.q(`UPDATE engrams SET stage = $1, stage_changed_at = $2 WHERE id = $3`, [stage, new Date().toISOString(), id]);
     }
     /**
      * Replace an engram's content. Used by the fade phase of consolidation
@@ -573,9 +574,20 @@ export class PostgresEngramStore {
         await this.readyPromise;
         await this.q(`UPDATE engrams SET retracted = TRUE, retracted_by = $1, retracted_at = $2 WHERE id = $3`, [retractedBy, new Date().toISOString(), id]);
     }
+    /**
+     * Delete an engram and the rows that point at it. Parity with the SQLite backend —
+     * see src/storage/sqlite.ts deleteEngram for the orphan counts that prompted this.
+     * activation_events is left alone on purpose: it records a recall that happened.
+     */
     async deleteEngram(id) {
         await this.readyPromise;
-        await this.q(`DELETE FROM engrams WHERE id = $1`, [id]);
+        // One statement: a data-modifying CTE runs atomically, so a failure cannot leave the
+        // engram alive with its dependents gone. withTransaction is not re-entrant, and this
+        // can be called inside one (/memory/write-batch), so it does not open its own.
+        await this.q(`WITH f AS (DELETE FROM retrieval_feedback WHERE engram_id = $1),
+            m AS (DELETE FROM entity_mentions WHERE engram_id = $1),
+            s AS (DELETE FROM staging_events WHERE engram_id = $1)
+       DELETE FROM engrams WHERE id = $1`, [id]);
     }
     /**
      * Time warp - shift all timestamps backward by ms milliseconds.
@@ -584,9 +596,9 @@ export class PostgresEngramStore {
     async timeWarp(agentId, ms) {
         await this.readyPromise;
         const seconds = Math.round(ms / 1000);
-        const r1 = await this.q(`UPDATE engrams SET
-         created_at = to_char(($1::timestamptz - interval '1 second' * $2), 'YYYY-MM-DD"T"HH24:MI:SS.MS"Z"'),
-         last_accessed = to_char(($3::timestamptz - interval '1 second' * $2), 'YYYY-MM-DD"T"HH24:MI:SS.MS"Z"')
+        const r1 = await this.q(`UPDATE engrams SET
+         created_at = to_char(($1::timestamptz - interval '1 second' * $2), 'YYYY-MM-DD"T"HH24:MI:SS.MS"Z"'),
+         last_accessed = to_char(($3::timestamptz - interval '1 second' * $2), 'YYYY-MM-DD"T"HH24:MI:SS.MS"Z"')
        WHERE agent_id = $4`, ['now', seconds, 'now', agentId]);
         // node-postgres reports the affected-row count as `rowCount` (PGlite called it
         // `affectedRows` — the one result-shape field that differs between the drivers).
@@ -616,13 +628,13 @@ export class PostgresEngramStore {
         // Restrict to active + fading. Faded engrams (Paper 1: storage degradation)
         // retain their embedding so they still participate in semantic recall, even
         // though their content has been trimmed. Excludes staging/consolidated/archived.
-        const result = await this.q(`SELECT *, (embedding <=> $2::vector) AS distance
-       FROM engrams
-       WHERE agent_id = $1
-         AND embedding IS NOT NULL
-         AND retracted = FALSE
-         AND stage IN ('active', 'fading')
-       ORDER BY distance ASC
+        const result = await this.q(`SELECT *, (embedding <=> $2::vector) AS distance
+       FROM engrams
+       WHERE agent_id = $1
+         AND embedding IS NOT NULL
+         AND retracted = FALSE
+         AND stage IN ('active', 'fading')
+       ORDER BY distance ASC
        LIMIT $3`, [agentId, vectorToLiteral(vec), limit]);
         return result.rows.map((r) => ({ engram: rowToEngram(r), distance: r.distance }));
     }
@@ -641,11 +653,11 @@ export class PostgresEngramStore {
         if (tokens.length === 0)
             return [];
         const websearchQuery = tokens.join(' OR ');
-        const result = await this.q(`SELECT *, ts_rank_cd(fts, websearch_to_tsquery('english', $2)) AS rank
-       FROM engrams
-       WHERE agent_id = $1 AND retracted = FALSE
-         AND fts @@ websearch_to_tsquery('english', $2)
-       ORDER BY rank DESC
+        const result = await this.q(`SELECT *, ts_rank_cd(fts, websearch_to_tsquery('english', $2)) AS rank
+       FROM engrams
+       WHERE agent_id = $1 AND retracted = FALSE
+         AND fts @@ websearch_to_tsquery('english', $2)
+       ORDER BY rank DESC
        LIMIT $3`, [agentId, websearchQuery, limit]);
         return result.rows.map((r) => ({ engram: rowToEngram(r), bm25Score: calibrateBm25(Number(r.rank)) }));
     }
@@ -659,11 +671,11 @@ export class PostgresEngramStore {
         if (tokens.length === 0)
             return [];
         const websearchQuery = tokens.join(' OR ');
-        const result = await this.q(`SELECT *, ts_rank_cd(fts, websearch_to_tsquery('english', $2)) AS rank
-       FROM engrams
-       WHERE agent_id = ANY($1::text[]) AND retracted = FALSE
-         AND fts @@ websearch_to_tsquery('english', $2)
-       ORDER BY rank DESC
+        const result = await this.q(`SELECT *, ts_rank_cd(fts, websearch_to_tsquery('english', $2)) AS rank
+       FROM engrams
+       WHERE agent_id = ANY($1::text[]) AND retracted = FALSE
+         AND fts @@ websearch_to_tsquery('english', $2)
+       ORDER BY rank DESC
        LIMIT $3`, [agentIds, websearchQuery, limit]);
         return result.rows.map((r) => ({ engram: rowToEngram(r), bm25Score: calibrateBm25(Number(r.rank)) }));
     }
@@ -744,32 +756,32 @@ export class PostgresEngramStore {
             sql += ` AND task_status = $${params.length + 1}`;
             params.push(status);
         }
-        sql += ` ORDER BY
-      CASE task_priority
-        WHEN 'urgent' THEN 0
-        WHEN 'high' THEN 1
-        WHEN 'medium' THEN 2
-        WHEN 'low' THEN 3
-        ELSE 4
-      END,
+        sql += ` ORDER BY
+      CASE task_priority
+        WHEN 'urgent' THEN 0
+        WHEN 'high' THEN 1
+        WHEN 'medium' THEN 2
+        WHEN 'low' THEN 3
+        ELSE 4
+      END,
       created_at DESC`;
         const result = await this.q(sql, params);
         return result.rows.map(rowToEngram);
     }
     async getNextTask(agentId) {
         await this.readyPromise;
-        const result = await this.q(`SELECT * FROM engrams
-       WHERE agent_id = $1 AND task_status IN ('open', 'in_progress') AND retracted = FALSE
-       ORDER BY
-         CASE task_status WHEN 'in_progress' THEN 0 ELSE 1 END,
-         CASE task_priority
-           WHEN 'urgent' THEN 0
-           WHEN 'high' THEN 1
-           WHEN 'medium' THEN 2
-           WHEN 'low' THEN 3
-           ELSE 4
-         END,
-         created_at ASC
+        const result = await this.q(`SELECT * FROM engrams
+       WHERE agent_id = $1 AND task_status IN ('open', 'in_progress') AND retracted = FALSE
+       ORDER BY
+         CASE task_status WHEN 'in_progress' THEN 0 ELSE 1 END,
+         CASE task_priority
+           WHEN 'urgent' THEN 0
+           WHEN 'high' THEN 1
+           WHEN 'medium' THEN 2
+           WHEN 'low' THEN 3
+           ELSE 4
+         END,
+         created_at ASC
        LIMIT 1`, [agentId]);
         return result.rows.length > 0 ? rowToEngram(result.rows[0]) : null;
     }
@@ -783,11 +795,11 @@ export class PostgresEngramStore {
     }
     async findActiveMatchByConcept(agentId, concept, requiredTags) {
         await this.readyPromise;
-        let sql = `SELECT * FROM engrams
-               WHERE agent_id = $1
-                 AND LOWER(TRIM(concept)) = LOWER(TRIM($2))
-                 AND stage = 'active'
-                 AND retracted = FALSE
+        let sql = `SELECT * FROM engrams
+               WHERE agent_id = $1
+                 AND LOWER(TRIM(concept)) = LOWER(TRIM($2))
+                 AND stage = 'active'
+                 AND retracted = FALSE
                  AND superseded_by IS NULL`;
         const params = [agentId, concept];
         if (requiredTags && requiredTags.length > 0) {
@@ -824,12 +836,12 @@ export class PostgresEngramStore {
         await this.readyPromise;
         const id = randomUUID();
         const now = new Date().toISOString();
-        await this.q(`INSERT INTO associations (id, from_engram_id, to_engram_id, weight, confidence, type, activation_count, created_at, last_activated)
-       VALUES ($1, $2, $3, $4, $5, $6, 0, $7, $7)
-       ON CONFLICT (from_engram_id, to_engram_id) DO UPDATE SET
-         weight = EXCLUDED.weight,
-         confidence = EXCLUDED.confidence,
-         last_activated = EXCLUDED.last_activated,
+        await this.q(`INSERT INTO associations (id, from_engram_id, to_engram_id, weight, confidence, type, activation_count, created_at, last_activated)
+       VALUES ($1, $2, $3, $4, $5, $6, 0, $7, $7)
+       ON CONFLICT (from_engram_id, to_engram_id) DO UPDATE SET
+         weight = EXCLUDED.weight,
+         confidence = EXCLUDED.confidence,
+         last_activated = EXCLUDED.last_activated,
          activation_count = associations.activation_count + 1`, [id, fromId, toId, weight, confidence, type, now]);
         const assoc = await this.getAssociation(fromId, toId);
         if (!assoc)
@@ -851,12 +863,12 @@ export class PostgresEngramStore {
         if (engramIds.length === 0)
             return result;
         await this.readyPromise;
-        const r = await this.q(`SELECT id, SUM(cnt) AS count, SUM(sw) AS sum_weight FROM (
-         SELECT from_engram_id AS id, 1 AS cnt, weight AS sw FROM associations WHERE from_engram_id = ANY($1::text[])
-         UNION ALL
-         SELECT to_engram_id   AS id, 1 AS cnt, weight AS sw FROM associations WHERE to_engram_id   = ANY($1::text[])
-       ) t
-       WHERE id = ANY($1::text[])
+        const r = await this.q(`SELECT id, SUM(cnt) AS count, SUM(sw) AS sum_weight FROM (
+         SELECT from_engram_id AS id, 1 AS cnt, weight AS sw FROM associations WHERE from_engram_id = ANY($1::text[])
+         UNION ALL
+         SELECT to_engram_id   AS id, 1 AS cnt, weight AS sw FROM associations WHERE to_engram_id   = ANY($1::text[])
+       ) t
+       WHERE id = ANY($1::text[])
        GROUP BY id`, [engramIds]);
         for (const row of r.rows) {
             result.set(row.id, { count: Number(row.count), sumWeight: Number(row.sum_weight) });
@@ -872,7 +884,7 @@ export class PostgresEngramStore {
         if (engramIds.length === 0)
             return result;
         await this.readyPromise;
-        const r = await this.q(`SELECT * FROM associations
+        const r = await this.q(`SELECT * FROM associations
        WHERE from_engram_id = ANY($1::text[]) OR to_engram_id = ANY($1::text[])`, [engramIds]);
         for (const row of r.rows) {
             const a = rowToAssociation(row);
@@ -912,8 +924,8 @@ export class PostgresEngramStore {
     }
     async getAllAssociations(agentId) {
         await this.readyPromise;
-        const result = await this.q(`SELECT a.* FROM associations a
-       JOIN engrams e ON a.from_engram_id = e.id
+        const result = await this.q(`SELECT a.* FROM associations a
+       JOIN engrams e ON a.from_engram_id = e.id
        WHERE e.agent_id = $1`, [agentId]);
         return result.rows.map(rowToAssociation);
     }
@@ -922,11 +934,11 @@ export class PostgresEngramStore {
     // ============================================================
     async getEvictionCandidates(agentId, limit) {
         await this.readyPromise;
-        const result = await this.q(`SELECT * FROM engrams
-       WHERE agent_id = $1 AND stage = 'active' AND retracted = FALSE
-       ORDER BY (salience * 0.3 + confidence * 0.3
-                 + (access_count::float / (access_count + 5)) * 0.2
-                 + (1.0 / (1.0 + EXTRACT(EPOCH FROM (now() - last_accessed::timestamptz)) / 86400.0)) * 0.2) ASC
+        const result = await this.q(`SELECT * FROM engrams
+       WHERE agent_id = $1 AND stage = 'active' AND retracted = FALSE
+       ORDER BY (salience * 0.3 + confidence * 0.3
+                 + (access_count::float / (access_count + 5)) * 0.2
+                 + (1.0 / (1.0 + EXTRACT(EPOCH FROM (now() - last_accessed::timestamptz)) / 86400.0)) * 0.2) ASC
        LIMIT $2`, [agentId, limit]);
         return result.rows.map(rowToEngram);
     }
@@ -961,7 +973,7 @@ export class PostgresEngramStore {
     }
     async logStagingEvent(event) {
         await this.readyPromise;
-        await this.q(`INSERT INTO staging_events (engram_id, agent_id, action, resonance_score, timestamp, age_ms)
+        await this.q(`INSERT INTO staging_events (engram_id, agent_id, action, resonance_score, timestamp, age_ms)
        VALUES ($1, $2, $3, $4, $5, $6)`, [
             event.engramId, event.agentId, event.action,
             event.resonanceScore, event.timestamp.toISOString(), event.ageMs,
@@ -969,18 +981,18 @@ export class PostgresEngramStore {
     }
     async logRetrievalFeedback(activationEventId, engramId, useful, context) {
         await this.readyPromise;
-        await this.q(`INSERT INTO retrieval_feedback (id, activation_event_id, engram_id, useful, context, timestamp)
+        await this.q(`INSERT INTO retrieval_feedback (id, activation_event_id, engram_id, useful, context, timestamp)
        VALUES ($1, $2, $3, $4, $5, $6)`, [randomUUID(), activationEventId, engramId, useful, context, new Date().toISOString()]);
     }
     async getRetrievalPrecision(agentId, windowHours = 24) {
         await this.readyPromise;
         const since = new Date(Date.now() - windowHours * 3600_000).toISOString();
-        const result = await this.q(`SELECT
-         COUNT(CASE WHEN useful = TRUE THEN 1 END) AS useful_count,
-         COUNT(*) AS total_count
-       FROM retrieval_feedback rf
-       LEFT JOIN activation_events ae ON rf.activation_event_id = ae.id
-       JOIN engrams e ON rf.engram_id = e.id
+        const result = await this.q(`SELECT
+         COUNT(CASE WHEN useful = TRUE THEN 1 END) AS useful_count,
+         COUNT(*) AS total_count
+       FROM retrieval_feedback rf
+       LEFT JOIN activation_events ae ON rf.activation_event_id = ae.id
+       JOIN engrams e ON rf.engram_id = e.id
        WHERE e.agent_id = $1 AND rf.timestamp > $2`, [agentId, since]);
         const row = result.rows[0];
         const total = Number(row?.total_count ?? 0);
@@ -989,10 +1001,10 @@ export class PostgresEngramStore {
     }
     async getStagingMetrics(agentId) {
         await this.readyPromise;
-        const result = await this.q(`SELECT
-         COUNT(CASE WHEN action = 'promoted' THEN 1 END) AS promoted,
-         COUNT(CASE WHEN action = 'discarded' THEN 1 END) AS discarded,
-         COUNT(CASE WHEN action = 'expired' THEN 1 END) AS expired
+        const result = await this.q(`SELECT
+         COUNT(CASE WHEN action = 'promoted' THEN 1 END) AS promoted,
+         COUNT(CASE WHEN action = 'discarded' THEN 1 END) AS discarded,
+         COUNT(CASE WHEN action = 'expired' THEN 1 END) AS expired
        FROM staging_events WHERE agent_id = $1`, [agentId]);
         const row = result.rows[0] ?? { promoted: 0, discarded: 0, expired: 0 };
         return {
@@ -1006,8 +1018,8 @@ export class PostgresEngramStore {
         // Flush any buffered activation events so stats reflect the latest writes.
         await this.flushActivationEvents();
         const since = new Date(Date.now() - windowHours * 3600_000).toISOString();
-        const result = await this.q(`SELECT latency_ms FROM activation_events
-       WHERE agent_id = $1 AND timestamp > $2
+        const result = await this.q(`SELECT latency_ms FROM activation_events
+       WHERE agent_id = $1 AND timestamp > $2
        ORDER BY latency_ms ASC`, [agentId, since]);
         if (result.rows.length === 0)
             return { count: 0, avgLatencyMs: 0, p50LatencyMs: 0, p90LatencyMs: 0, p95LatencyMs: 0 };
@@ -1027,9 +1039,9 @@ export class PostgresEngramStore {
     async getLinkedFeedbackStats(agentId, windowHours = 24 * 7) {
         await this.readyPromise;
         const since = new Date(Date.now() - windowHours * 3600_000).toISOString();
-        const result = await this.q(`SELECT COUNT(*) AS total, COUNT(CASE WHEN rf.useful = TRUE THEN 1 END) AS useful
-       FROM retrieval_feedback rf
-       JOIN activation_events ae ON ae.id = rf.activation_event_id
+        const result = await this.q(`SELECT COUNT(*) AS total, COUNT(CASE WHEN rf.useful = TRUE THEN 1 END) AS useful
+       FROM retrieval_feedback rf
+       JOIN activation_events ae ON ae.id = rf.activation_event_id
        WHERE ae.agent_id = $1 AND rf.timestamp > $2`, [agentId, since]);
         const row = result.rows[0] ?? { total: 0, useful: 0 };
         return { total: Number(row.total), useful: Number(row.useful) };
@@ -1046,7 +1058,7 @@ export class PostgresEngramStore {
         await this.readyPromise;
         const id = randomUUID();
         const now = new Date().toISOString();
-        await this.q(`INSERT INTO episodes (id, agent_id, label, embedding, engram_count, start_time, end_time, created_at)
+        await this.q(`INSERT INTO episodes (id, agent_id, label, embedding, engram_count, start_time, end_time, created_at)
        VALUES ($1, $2, $3, $4::vector, 0, $5, $5, $5)`, [id, input.agentId, input.label, vectorToLiteral(input.embedding ?? null), now]);
         const ep = await this.getEpisode(id);
         if (!ep)
@@ -1072,9 +1084,9 @@ export class PostgresEngramStore {
     async addEngramToEpisode(engramId, episodeId) {
         await this.readyPromise;
         await this.q(`UPDATE engrams SET episode_id = $1 WHERE id = $2`, [episodeId, engramId]);
-        await this.q(`UPDATE episodes SET
-         engram_count = engram_count + 1,
-         end_time = GREATEST(end_time, $1)
+        await this.q(`UPDATE episodes SET
+         engram_count = engram_count + 1,
+         end_time = GREATEST(end_time, $1)
        WHERE id = $2`, [new Date().toISOString(), episodeId]);
     }
     async getEngramsByEpisode(episodeId) {
@@ -1113,44 +1125,44 @@ export class PostgresEngramStore {
     async updateAutoCheckpointWrite(agentId, engramId) {
         await this.readyPromise;
         const now = new Date().toISOString();
-        await this.q(`INSERT INTO conscious_state (agent_id, last_write_id, last_activity_at, write_count_since_consolidation, updated_at)
-       VALUES ($1, $2, $3, 1, $3)
-       ON CONFLICT(agent_id) DO UPDATE SET
-         last_write_id = EXCLUDED.last_write_id,
-         last_activity_at = EXCLUDED.last_activity_at,
-         write_count_since_consolidation = conscious_state.write_count_since_consolidation + 1,
+        await this.q(`INSERT INTO conscious_state (agent_id, last_write_id, last_activity_at, write_count_since_consolidation, updated_at)
+       VALUES ($1, $2, $3, 1, $3)
+       ON CONFLICT(agent_id) DO UPDATE SET
+         last_write_id = EXCLUDED.last_write_id,
+         last_activity_at = EXCLUDED.last_activity_at,
+         write_count_since_consolidation = conscious_state.write_count_since_consolidation + 1,
          updated_at = EXCLUDED.updated_at`, [agentId, engramId, now]);
     }
     async updateAutoCheckpointRecall(agentId, context, engramIds) {
         await this.readyPromise;
         const now = new Date().toISOString();
-        await this.q(`INSERT INTO conscious_state (agent_id, last_recall_context, last_recall_ids, last_activity_at, recall_count_since_consolidation, updated_at)
-       VALUES ($1, $2, $3, $4, 1, $4)
-       ON CONFLICT(agent_id) DO UPDATE SET
-         last_recall_context = EXCLUDED.last_recall_context,
-         last_recall_ids = EXCLUDED.last_recall_ids,
-         last_activity_at = EXCLUDED.last_activity_at,
-         recall_count_since_consolidation = conscious_state.recall_count_since_consolidation + 1,
+        await this.q(`INSERT INTO conscious_state (agent_id, last_recall_context, last_recall_ids, last_activity_at, recall_count_since_consolidation, updated_at)
+       VALUES ($1, $2, $3, $4, 1, $4)
+       ON CONFLICT(agent_id) DO UPDATE SET
+         last_recall_context = EXCLUDED.last_recall_context,
+         last_recall_ids = EXCLUDED.last_recall_ids,
+         last_activity_at = EXCLUDED.last_activity_at,
+         recall_count_since_consolidation = conscious_state.recall_count_since_consolidation + 1,
          updated_at = EXCLUDED.updated_at`, [agentId, context, JSON.stringify(engramIds), now]);
     }
     async touchActivity(agentId) {
         await this.readyPromise;
         const now = new Date().toISOString();
-        await this.q(`INSERT INTO conscious_state (agent_id, last_activity_at, updated_at)
-       VALUES ($1, $2, $2)
-       ON CONFLICT(agent_id) DO UPDATE SET
-         last_activity_at = EXCLUDED.last_activity_at,
+        await this.q(`INSERT INTO conscious_state (agent_id, last_activity_at, updated_at)
+       VALUES ($1, $2, $2)
+       ON CONFLICT(agent_id) DO UPDATE SET
+         last_activity_at = EXCLUDED.last_activity_at,
          updated_at = EXCLUDED.updated_at`, [agentId, now]);
     }
     async saveCheckpoint(agentId, state) {
         await this.readyPromise;
         const now = new Date().toISOString();
-        await this.q(`INSERT INTO conscious_state (agent_id, execution_state, checkpoint_at, last_activity_at, updated_at)
-       VALUES ($1, $2, $3, $3, $3)
-       ON CONFLICT(agent_id) DO UPDATE SET
-         execution_state = EXCLUDED.execution_state,
-         checkpoint_at = EXCLUDED.checkpoint_at,
-         last_activity_at = EXCLUDED.last_activity_at,
+        await this.q(`INSERT INTO conscious_state (agent_id, execution_state, checkpoint_at, last_activity_at, updated_at)
+       VALUES ($1, $2, $3, $3, $3)
+       ON CONFLICT(agent_id) DO UPDATE SET
+         execution_state = EXCLUDED.execution_state,
+         checkpoint_at = EXCLUDED.checkpoint_at,
+         last_activity_at = EXCLUDED.last_activity_at,
          updated_at = EXCLUDED.updated_at`, [agentId, JSON.stringify(state), now]);
     }
     /** Distinct agent ids present in this store (D3 whoami; includes all stages). */
@@ -1169,9 +1181,9 @@ export class PostgresEngramStore {
         const t = term.toLowerCase().replace(/[%_]/g, '');
         if (!t)
             return [];
-        const res = await this.pool.query(`SELECT DISTINCT entity FROM (
-         SELECT entity FROM entity_mentions WHERE entity LIKE $1
-         UNION SELECT entity FROM entity_aliases WHERE alias LIKE $1
+        const res = await this.pool.query(`SELECT DISTINCT entity FROM (
+         SELECT entity FROM entity_mentions WHERE entity LIKE $1
+         UNION SELECT entity FROM entity_aliases WHERE alias LIKE $1
        ) u LIMIT $2`, [`%${t}%`, limit]);
         return res.rows.map(r => r.entity);
     }
@@ -1213,13 +1225,13 @@ export class PostgresEngramStore {
             await this.q(`UPDATE conscious_state SET last_mini_consolidation_at = $1, updated_at = $1 WHERE agent_id = $2`, [now, agentId]);
         }
         else {
-            await this.q(`UPDATE conscious_state SET
-           last_consolidation_at = $1,
-           last_mini_consolidation_at = $1,
-           write_count_since_consolidation = 0,
-           recall_count_since_consolidation = 0,
-           consolidation_cycle_count = consolidation_cycle_count + 1,
-           updated_at = $1
+            await this.q(`UPDATE conscious_state SET
+           last_consolidation_at = $1,
+           last_mini_consolidation_at = $1,
+           write_count_since_consolidation = 0,
+           recall_count_since_consolidation = 0,
+           consolidation_cycle_count = consolidation_cycle_count + 1,
+           updated_at = $1
          WHERE agent_id = $2`, [now, agentId]);
         }
     }
@@ -1244,10 +1256,10 @@ export class PostgresEngramStore {
     // ============================================================
     async getLatestByTag(opts) {
         await this.readyPromise;
-        let sql = `SELECT * FROM engrams
-               WHERE agent_id = $1
-                 AND retracted = $2
-                 AND stage = 'active'
+        let sql = `SELECT * FROM engrams
+               WHERE agent_id = $1
+                 AND retracted = $2
+                 AND stage = 'active'
                  AND tags LIKE $3`;
         const params = [opts.agentId, opts.retracted ?? false, `%"${opts.tagKeyPrefix}%`];
         if (opts.scopeTagsAll && opts.scopeTagsAll.length > 0) {
@@ -1274,10 +1286,10 @@ export class PostgresEngramStore {
     }
     async getTopBy(opts) {
         await this.readyPromise;
-        let sql = `SELECT * FROM engrams
-               WHERE agent_id = $1
-                 AND retracted = $2
-                 AND stage = 'active'
+        let sql = `SELECT * FROM engrams
+               WHERE agent_id = $1
+                 AND retracted = $2
+                 AND stage = 'active'
                  AND tags LIKE $3`;
         const params = [opts.agentId, opts.retracted ?? false, `%"${opts.sortField}%`];
         if (opts.filterTagsAll && opts.filterTagsAll.length > 0) {