Garry's Opinionated OpenClaw/Hermes Agent Brain
TypeScript
/**
* Verify: weight normalization at engine layer.
*
* Cross-modal eval over 100K takes flagged false precision (e.g. 0.74, 0.82)
* as calibration accuracy that doesn't exist. The engine layer rounds to a
* 0.05 grid on every write — addTakesBatch + updateTake in both engines.
*
* Imports the real helper (single source of truth) so the test cannot drift
* from the engine path. Both engines call `normalizeWeightForStorage(raw)`
* at all 4 takes write sites.
*/
import { describe, it, expect } from 'bun:test';
import { normalizeWeightForStorage } from '../src/core/takes-fence.ts';
// Convenience: extract the numeric weight for the existing positive-path tests.
function roundWeight(w: number | null | undefined): number {
return normalizeWeightForStorage(w).weight;
}
describe('takes weight normalization (v0.32+ Codex #8 hardening)', () => {
describe('rounding to 0.05 grid', () => {
it('rounds 0.74 to 0.75', () => {
expect(roundWeight(0.74)).toBe(0.75);
});
it('rounds 0.82 to 0.80', () => {
expect(roundWeight(0.82)).toBe(0.80);
});
it('preserves exact 0.05 boundaries', () => {
for (const w of [0, 0.05, 0.10, 0.25, 0.50, 0.75, 0.85, 0.95, 1.0]) {
expect(roundWeight(w)).toBe(w);
}
});
it('rounds up at midpoint (0.025 → 0.05, 0.075 → 0.10)', () => {
expect(roundWeight(0.025)).toBe(0.05);
expect(roundWeight(0.075)).toBe(0.10);
});
it('handles edge near 0.5', () => {
expect(roundWeight(0.47)).toBe(0.45);
expect(roundWeight(0.48)).toBe(0.50);
expect(roundWeight(0.52)).toBe(0.50);
expect(roundWeight(0.53)).toBe(0.55);
});
});
describe('clamping out-of-range', () => {
it('clamps below zero', () => {
const r = normalizeWeightForStorage(-0.1);
expect(r.weight).toBe(0);
expect(r.clamped).toBe(true);
});
it('clamps above one', () => {
const r = normalizeWeightForStorage(1.3);
expect(r.weight).toBe(1.0);
expect(r.clamped).toBe(true);
});
it('does not flag in-range values as clamped', () => {
expect(normalizeWeightForStorage(0.5).clamped).toBe(false);
expect(normalizeWeightForStorage(0.0).clamped).toBe(false);
expect(normalizeWeightForStorage(1.0).clamped).toBe(false);
});
it('does not flag mere rounding as clamped', () => {
// 0.74 rounds to 0.75 but is NOT out of range; clamped must stay false.
expect(normalizeWeightForStorage(0.74).clamped).toBe(false);
expect(normalizeWeightForStorage(0.82).clamped).toBe(false);
});
});
describe('NaN + Infinity guards (Codex #8)', () => {
it('NaN → 0.5 + clamped=true', () => {
const r = normalizeWeightForStorage(NaN);
expect(r.weight).toBe(0.5);
expect(r.clamped).toBe(true);
});
it('Infinity → 1.0 (via clamp) — guarded as not-finite first, falls to default 0.5', () => {
const r = normalizeWeightForStorage(Infinity);
// Codex #8 contract: !Number.isFinite catches Infinity AND NaN; both
// route to 0.5. This is the safe default; 1.0 would lie about the
// input being "maximum confidence."
expect(r.weight).toBe(0.5);
expect(r.clamped).toBe(true);
});
it('-Infinity → 0.5 (same not-finite path)', () => {
const r = normalizeWeightForStorage(-Infinity);
expect(r.weight).toBe(0.5);
expect(r.clamped).toBe(true);
});
it('regression: pre-v0.32 code did Math.round(NaN * 20) / 20 = NaN, which would write NaN to the DB', () => {
// The bug this guard fixes: without Number.isFinite check, NaN survives
// the (w < 0 || w > 1) check (NaN comparisons are always false) and
// becomes Math.round(NaN * 20) / 20 = NaN, written through to the DB.
expect(Number.isFinite(normalizeWeightForStorage(NaN).weight)).toBe(true);
expect(Number.isFinite(normalizeWeightForStorage(Infinity).weight)).toBe(true);
});
});
describe('null/undefined handling', () => {
it('undefined → 0.5 with clamped=false (default fence weight)', () => {
const r = normalizeWeightForStorage(undefined);
expect(r.weight).toBe(0.5);
expect(r.clamped).toBe(false);
});
it('null → 0.5 with clamped=false', () => {
const r = normalizeWeightForStorage(null);
expect(r.weight).toBe(0.5);
expect(r.clamped).toBe(false);
});
});
describe('updateTake site coverage (Codex #8 — was unhardened in original PR)', () => {
// The plan caught that updateTake() in both engines had the same NaN hole
// as addTakesBatch(). Now both call normalizeWeightForStorage. These cases
// assert the contract is identical at every write site.
it('updateTake: NaN input → 0.5, clamped=true', () => {
const r = normalizeWeightForStorage(NaN);
expect(r.weight).toBe(0.5);
expect(r.clamped).toBe(true);
});
it('updateTake: 0.74 input → 0.75 (rounds, not clamped)', () => {
const r = normalizeWeightForStorage(0.74);
expect(r.weight).toBe(0.75);
expect(r.clamped).toBe(false);
});
it('updateTake: out-of-range input gets the same treatment as addTakesBatch', () => {
expect(normalizeWeightForStorage(2.5).weight).toBe(1.0);
expect(normalizeWeightForStorage(-3).weight).toBe(0.0);
});
});
});