Garry's Opinionated OpenClaw/Hermes Agent Brain
TypeScript
/**
* v0.29 — Engine parity: salience + anomalies on PGLite vs Postgres.
*
* Codex flagged in the v0.22.0 source-boost review that engine-shape
* differences (postgres.js vs PGLite SQL idioms) can silently diverge
* results. The same risk applies to the new v0.29 ops:
* - getRecentSalience uses EXTRACT(EPOCH FROM ...), ln(), GROUP BY p.id.
* - findAnomalies uses generate_series + date_trunc + array_agg.
*
* This test seeds identical fixtures into both engines, runs the v0.29
* ops, and asserts the result sets line up.
*
* DATABASE_URL gated — skips gracefully when not set.
*/
import { describe, test, expect, beforeAll, afterAll } from 'bun:test';
import { PGLiteEngine } from '../../src/core/pglite-engine.ts';
import { hasDatabase, setupDB, teardownDB } from './helpers.ts';
import type { BrainEngine } from '../../src/core/engine.ts';
const SKIP_PG = !hasDatabase();
const describeBoth = SKIP_PG ? describe.skip : describe;
const TODAY = new Date().toISOString().slice(0, 10);
async function seedFixture(engine: BrainEngine): Promise<void> {
// 5 wedding-tagged pages, all updated today.
for (let i = 0; i < 5; i++) {
const slug = `personal/wedding/photos-${i}`;
await engine.putPage(slug, {
type: 'note',
title: `Wedding photo ${i}`,
compiled_truth: 'photos',
});
await engine.addTag(slug, 'wedding');
}
// 30 background pages backdated across 30 days.
for (let i = 0; i < 30; i++) {
const slug = `notes/random-${i}`;
await engine.putPage(slug, {
type: 'note',
title: `Random ${i}`,
compiled_truth: 'body',
});
await engine.addTag(slug, ['hardware', 'product', 'idea'][i % 3]);
}
await engine.executeRaw(
`UPDATE pages
SET updated_at = now() - interval '1 day' - (random() * interval '29 days')
WHERE slug LIKE 'notes/random-%'`
);
}
describeBoth('v0.29 engine parity — getRecentSalience', () => {
let pglite: PGLiteEngine;
let postgres: BrainEngine;
beforeAll(async () => {
pglite = new PGLiteEngine();
await pglite.connect({ engine: 'pglite' } as never);
await pglite.initSchema();
await seedFixture(pglite);
postgres = await setupDB();
await seedFixture(postgres);
}, 60_000);
afterAll(async () => {
if (pglite) await pglite.disconnect();
await teardownDB();
});
test('top result is a wedding page on both engines', async () => {
const pgliteRows = await pglite.getRecentSalience({ days: 7, limit: 5 });
const postgresRows = await postgres.getRecentSalience({ days: 7, limit: 5 });
expect(pgliteRows.length).toBeGreaterThan(0);
expect(postgresRows.length).toBeGreaterThan(0);
expect(pgliteRows[0].slug.startsWith('personal/wedding/')).toBe(true);
expect(postgresRows[0].slug.startsWith('personal/wedding/')).toBe(true);
});
test('same set of wedding slugs returned in the top 5 on both engines', async () => {
const pgliteRows = await pglite.getRecentSalience({ days: 7, limit: 10 });
const postgresRows = await postgres.getRecentSalience({ days: 7, limit: 10 });
const pgliteWedding = new Set(pgliteRows.filter(r => r.slug.startsWith('personal/wedding/')).map(r => r.slug));
const postgresWedding = new Set(postgresRows.filter(r => r.slug.startsWith('personal/wedding/')).map(r => r.slug));
expect(pgliteWedding.size).toBe(postgresWedding.size);
for (const s of pgliteWedding) expect(postgresWedding.has(s)).toBe(true);
});
});
// ---------------------------------------------------------------------------
// D5 — setEmotionalWeightBatch + getSalienceScores write/read parity.
//
// Pinned engine shapes (src/core/engine-sql/salience.ts +
// the getSalienceScores methods on both engine classes):
// - setEmotionalWeightBatch(rows: {slug, source_id, weight}[]) → number of
// CHANGED pages (composite (slug, source_id) join against unnest filtered
// by `pages.emotional_weight IS DISTINCT FROM u.weight`; a same-value row
// is NOT rewritten — no new tuple version, no BEFORE UPDATE trigger
// fan-out (#4797) — and is not counted; rows whose (slug, source_id)
// matches no page are silently dropped).
// - salience_touched_at = now() on every rewritten row (only changed rows
// are rewritten); a same-value write leaves the old timestamp untouched.
// - getSalienceScores(refs: {slug, source_id}[]) → Map keyed
// `${source_id}::${slug}`, score = COALESCE(emotional_weight,0)*5
// + ln(1 + COUNT(DISTINCT active takes)); unmatched refs are absent.
// ---------------------------------------------------------------------------
// Weights chosen to be exactly representable in REAL (float4) so read-back
// equality across engines is exact, not approximate.
const D5_PAGES = [
'salience/batch-changed', // 0.5 → 0.875 (changed → touched bumps)
'salience/batch-same', // 0.25 → 0.25 (same value → no bump)
'salience/batch-same-2', // 0.75 → 0.75 (same value → no bump)
'salience/batch-fresh', // 0.0 (column default) → 0.125 (changed → bump)
];
const D5_MISSING_SLUG = 'salience/no-such-page';
interface D5Snapshot {
firstCount: number;
mixedCount: number;
before: Map<string, number>; // slug → EXTRACT(EPOCH FROM salience_touched_at)
after: Map<string, number>;
weights: Map<string, number>; // slug → stored emotional_weight
xminBefore: Map<string, string>; // slug → xmin::text before the mixed batch
xminAfter: Map<string, string>;
}
async function readXmins(engine: BrainEngine): Promise<Map<string, string>> {
const rows = await engine.executeRaw<{ slug: string; row_xmin: string | number }>(
`SELECT slug, xmin::text AS row_xmin
FROM pages WHERE slug LIKE 'salience/batch-%'`
);
return new Map(rows.map(r => [String(r.slug), String(r.row_xmin)]));
}
async function readTouchedEpochs(engine: BrainEngine): Promise<Map<string, number>> {
const rows = await engine.executeRaw<{ slug: string; ts: string | number }>(
`SELECT slug, EXTRACT(EPOCH FROM salience_touched_at) AS ts
FROM pages WHERE slug LIKE 'salience/batch-%'`
);
return new Map(rows.map(r => [String(r.slug), Number(r.ts)]));
}
async function readStoredWeights(engine: BrainEngine): Promise<Map<string, number>> {
const rows = await engine.executeRaw<{ slug: string; w: string | number }>(
`SELECT slug, emotional_weight AS w
FROM pages WHERE slug LIKE 'salience/batch-%'`
);
return new Map(rows.map(r => [String(r.slug), Number(r.w)]));
}
/** Seed pages, run the first write + backdate + the MIXED batch; capture everything. */
async function runD5Fixture(engine: BrainEngine): Promise<D5Snapshot> {
for (const slug of D5_PAGES) {
await engine.putPage(slug, { type: 'note', title: slug, compiled_truth: 'body' });
}
// One active take on batch-changed so getSalienceScores exercises the
// ln(1 + take_count) term, not just weight * 5.
const page = await engine.getPage('salience/batch-changed', { sourceId: 'default' });
expect(page).not.toBeNull();
await engine.addTakesBatch([{
page_id: page!.id, row_num: 0, claim: 'd5 parity take',
kind: 'take', holder: 'tester', weight: 0.5,
}]);
// First write: all three targets exist and change (0.0 default → new value).
const firstCount = await engine.setEmotionalWeightBatch([
{ slug: 'salience/batch-changed', source_id: 'default', weight: 0.5 },
{ slug: 'salience/batch-same', source_id: 'default', weight: 0.25 },
{ slug: 'salience/batch-same-2', source_id: 'default', weight: 0.75 },
]);
// Backdate salience_touched_at on every fixture page (batch-fresh included)
// so the mixed batch's bump-vs-keep is unambiguous (~1h gap, no clock races).
await engine.executeRaw(
`UPDATE pages SET salience_touched_at = now() - interval '1 hour'
WHERE slug LIKE 'salience/batch-%'`
);
const before = await readTouchedEpochs(engine);
const xminBefore = await readXmins(engine);
// The MIXED batch: one changing row, two same-value rows, one row changing
// from the column default, one missing slug, one wrong-source ref.
const mixedCount = await engine.setEmotionalWeightBatch([
{ slug: 'salience/batch-changed', source_id: 'default', weight: 0.875 },
{ slug: 'salience/batch-same', source_id: 'default', weight: 0.25 },
{ slug: 'salience/batch-same-2', source_id: 'default', weight: 0.75 },
{ slug: 'salience/batch-fresh', source_id: 'default', weight: 0.125 },
{ slug: D5_MISSING_SLUG, source_id: 'default', weight: 0.5 },
{ slug: 'salience/batch-changed', source_id: 'no-such-source', weight: 0.99 },
]);
const after = await readTouchedEpochs(engine);
const xminAfter = await readXmins(engine);
const weights = await readStoredWeights(engine);
return { firstCount, mixedCount, before, after, weights, xminBefore, xminAfter };
}
describeBoth('D5 engine parity — setEmotionalWeightBatch + getSalienceScores', () => {
let pglite: PGLiteEngine;
let postgres: BrainEngine;
let pgliteSnap: D5Snapshot;
let postgresSnap: D5Snapshot;
beforeAll(async () => {
pglite = new PGLiteEngine();
await pglite.connect({ engine: 'pglite' } as never);
await pglite.initSchema();
pgliteSnap = await runD5Fixture(pglite);
postgres = await setupDB();
postgresSnap = await runD5Fixture(postgres);
}, 60_000);
afterAll(async () => {
if (pglite) await pglite.disconnect();
await teardownDB();
});
test('mixed batch: identical changed-row counts on both engines', () => {
// First write changed all 3 existing targets (0.0 default → new value).
expect(pgliteSnap.firstCount).toBe(3);
expect(postgresSnap.firstCount).toBe(3);
// Mixed batch: 2 CHANGED pages (batch-changed + batch-fresh); the two
// same-value rows are filtered out before the write (#4797); the missing
// slug and the wrong-source ref match nothing.
expect(pgliteSnap.mixedCount).toBe(2);
expect(postgresSnap.mixedCount).toBe(2);
});
test('mixed batch: same-value rows are not rewritten on either engine (#4797)', () => {
for (const snap of [pgliteSnap, postgresSnap]) {
// No new tuple version → the per-row BEFORE UPDATE triggers never fired.
expect(snap.xminAfter.get('salience/batch-same')).toBe(snap.xminBefore.get('salience/batch-same')!);
expect(snap.xminAfter.get('salience/batch-same-2')).toBe(snap.xminBefore.get('salience/batch-same-2')!);
// The changed rows were rewritten.
expect(snap.xminAfter.get('salience/batch-changed')).not.toBe(snap.xminBefore.get('salience/batch-changed')!);
expect(snap.xminAfter.get('salience/batch-fresh')).not.toBe(snap.xminBefore.get('salience/batch-fresh')!);
}
});
test('mixed batch: identical stored weights on both engines', () => {
const expected = new Map([
['salience/batch-changed', 0.875],
['salience/batch-same', 0.25],
['salience/batch-same-2', 0.75],
['salience/batch-fresh', 0.125],
]);
for (const snap of [pgliteSnap, postgresSnap]) {
expect(snap.weights.size).toBe(expected.size);
for (const [slug, w] of expected) {
expect(snap.weights.get(slug)).toBe(w);
}
}
// The wrong-source ref (weight 0.99) must not have fanned out onto the
// default-source page: composite (slug, source_id) key held.
expect(pgliteSnap.weights.get('salience/batch-changed')).toBe(0.875);
expect(postgresSnap.weights.get('salience/batch-changed')).toBe(0.875);
});
test('salience_touched_at bumps ONLY for rows whose weight actually changed', () => {
const changed = ['salience/batch-changed', 'salience/batch-fresh'];
const unchanged = ['salience/batch-same', 'salience/batch-same-2'];
for (const snap of [pgliteSnap, postgresSnap]) {
for (const slug of D5_PAGES) {
expect(Number.isFinite(snap.before.get(slug)!)).toBe(true);
expect(Number.isFinite(snap.after.get(slug)!)).toBe(true);
}
for (const slug of changed) {
// IS DISTINCT FROM branch fired: touched_at moved forward ~1h past
// the backdated value (allow generous slack, assert > 30 min).
expect(snap.after.get(slug)! - snap.before.get(slug)!).toBeGreaterThan(1800);
}
for (const slug of unchanged) {
// Same-value write: old timestamp preserved exactly.
expect(snap.after.get(slug)).toBe(snap.before.get(slug)!);
}
}
});
test('getSalienceScores: same source::slug → score mapping on both engines', async () => {
const refs = [
...D5_PAGES.map(slug => ({ slug, source_id: 'default' })),
{ slug: D5_MISSING_SLUG, source_id: 'default' },
{ slug: 'salience/batch-changed', source_id: 'no-such-source' },
];
const pgliteScores = await pglite.getSalienceScores(refs);
const postgresScores = await postgres.getSalienceScores(refs);
// Key shape is `${source_id}::${slug}`; unmatched refs are absent.
const expectedKeys = D5_PAGES.map(slug => `default::${slug}`).sort();
expect([...pgliteScores.keys()].sort()).toEqual(expectedKeys);
expect([...postgresScores.keys()].sort()).toEqual(expectedKeys);
expect(pgliteScores.has(`default::${D5_MISSING_SLUG}`)).toBe(false);
expect(postgresScores.has('no-such-source::salience/batch-changed')).toBe(false);
// Score = weight * 5 + ln(1 + active take count). batch-changed carries
// the one active take; the rest have zero takes.
const expectedScores = new Map([
['default::salience/batch-changed', 0.875 * 5 + Math.log(2)],
['default::salience/batch-same', 0.25 * 5],
['default::salience/batch-same-2', 0.75 * 5],
['default::salience/batch-fresh', 0.125 * 5],
]);
for (const [key, expectedScore] of expectedScores) {
const pgliteScore = pgliteScores.get(key)!;
const postgresScore = postgresScores.get(key)!;
expect(pgliteScore).toBeCloseTo(postgresScore, 6);
expect(pgliteScore).toBeCloseTo(expectedScore, 5);
}
});
});
describeBoth('v0.29 engine parity — findAnomalies', () => {
let pglite: PGLiteEngine;
let postgres: BrainEngine;
beforeAll(async () => {
pglite = new PGLiteEngine();
await pglite.connect({ engine: 'pglite' } as never);
await pglite.initSchema();
await seedFixture(pglite);
postgres = await setupDB();
await seedFixture(postgres);
}, 60_000);
afterAll(async () => {
if (pglite) await pglite.disconnect();
await teardownDB();
});
test('wedding tag cohort fires on both engines with similar counts', async () => {
const pgliteRows = await pglite.findAnomalies({ since: TODAY, lookback_days: 30, sigma: 2 });
const postgresRows = await postgres.findAnomalies({ since: TODAY, lookback_days: 30, sigma: 2 });
const pgliteWedding = pgliteRows.find(r => r.cohort_kind === 'tag' && r.cohort_value === 'wedding');
const postgresWedding = postgresRows.find(r => r.cohort_kind === 'tag' && r.cohort_value === 'wedding');
expect(pgliteWedding).toBeDefined();
expect(postgresWedding).toBeDefined();
expect(pgliteWedding!.count).toBe(5);
expect(postgresWedding!.count).toBe(5);
// baseline mean should be very small (random-tag pages don't carry "wedding").
expect(pgliteWedding!.baseline_mean).toBeLessThan(1);
expect(postgresWedding!.baseline_mean).toBeLessThan(1);
});
});