Skip to content

Garry's Opinionated OpenClaw/Hermes Agent Brain

TypeScript
11.6 KB
Raw Blame
import { afterAll, beforeAll, expect, test } from 'bun:test';
import { randomUUID } from 'node:crypto';
import { mkdtempSync, readFileSync, rmSync, statSync } from 'node:fs';
import { join } from 'node:path';
import { tmpdir } from 'node:os';
import { PGLiteEngine } from '../src/core/pglite-engine.ts';
import { submitPageMutation } from '../src/core/persistence/page-mutations.ts';
import { disposePersistenceConsumer } from '../src/core/persistence/service.ts';
import type { OperationContext } from '../src/core/ops/contract.ts';
import { renderFactsTable } from '../src/core/facts-fence.ts';
import { renderTakesFence } from '../src/core/takes-fence.ts';
import { serializePageToMarkdown } from '../src/core/markdown.ts';
import { emptyFenceBlock } from '../src/core/generations/fence.ts';

let engine: PGLiteEngine;
const root = mkdtempSync(join(tmpdir(), 'gbrain-semantic-pages-'));
const sourceId = 'semantic-pages-test';
let ctx: OperationContext;
const submit = (operation: string, params: Record<string, unknown>) => submitPageMutation(ctx, { operation, params: { request_id: randomUUID(), ...params } });
beforeAll(async () => {
  engine=new PGLiteEngine();
  ctx={engine,config:{engine:'pglite'},sourceId,remote:false,dryRun:false,logger:{info(){},warn(){},error(){}}};
  await engine.connect({}); await engine.initSchema();
  await engine.executeRaw('INSERT INTO sources(id,name,local_path) VALUES($1,$1,$2)', [sourceId,root]);
  await submit('put_page', { slug: 'page', content: '---\ntype: note\ntitle: Example\n---\nStable prose\n' });
}, 120_000);
afterAll(async () => { await disposePersistenceConsumer(engine); await engine.disconnect(); rmSync(root, { recursive: true, force: true }); });

test('concurrent semantic tag mutations preserve every accepted tag and coherent file snapshot', async () => {
  const results = await Promise.all(Array.from({ length: 6 }, (_, i) => submit('add_tag', { slug: 'page', tag: `tag-${i}` })));
  expect(results.every(result => result.state === 'committed')).toBe(true);
  const snapshot = (await engine.readPageSnapshot('page', { sourceId }))!;
  expect(snapshot.tags).toEqual(Array.from({ length: 6 }, (_, i) => `tag-${i}`));
  expect(snapshot.page.compiled_truth).toContain('Stable prose');
  for (const tag of snapshot.tags) expect(readFileSync(join(root,'page.md'),'utf8')).toContain(tag);
  const revision = snapshot.revision;
  const replay = await submit('add_tag', { slug: 'page', tag: 'tag-0' });
  expect(replay.revision).toBe(revision);
});

test('#5251 a tag change defers embedding: no embedding effect is queued and chunks keep their text', async () => {
  const before = (await engine.readPageSnapshot('page', { sourceId }))!;
  const chunksBefore = (await engine.getChunks('page', { sourceId })).map(chunk => chunk.chunk_text);
  const result = await submit('add_tag', { slug: 'page', tag: 'deferred-example' }) as { state: string; embedding_state?: string; persistence?: { embedding_state?: string }; id?: string; request_id?: string };
  expect(result.state).toBe('committed');
  expect(result.embedding_state ?? result.persistence?.embedding_state).toBe('deferred');
  const [request] = await engine.executeRaw<{ id: string }>(
    "SELECT id::text AS id FROM persistence_requests WHERE source_id=$1 AND slug='page' AND operation='add_tag' ORDER BY sequence DESC LIMIT 1", [sourceId]);
  expect(await engine.executeRaw("SELECT kind FROM persistence_effects WHERE request_id=$1::uuid AND kind='embedding'", [request.id])).toEqual([]);
  const after = (await engine.readPageSnapshot('page', { sourceId }))!;
  expect(after.revision).not.toBe(before.revision);
  expect(after.tags).toContain('deferred-example');
  expect((await engine.getChunks('page', { sourceId })).map(chunk => chunk.chunk_text)).toEqual(chunksBefore);
  const removed = await submit('remove_tag', { slug: 'page', tag: 'deferred-example' }) as { embedding_state?: string; persistence?: { embedding_state?: string } };
  expect(removed.embedding_state ?? removed.persistence?.embedding_state).toBe('deferred');
});

test('timeline replay is an exact no-op in Markdown, revision, versions and structured rows', async () => {
  const params = { slug: 'page', date: '2026-09-15', summary: 'Example milestone', detail: 'Example detail', source: 'example-source' };
  await submit('add_timeline_entry', params);
  const before = (await engine.readPageSnapshot('page', { sourceId }))!;
  const file = join(root,'page.md');
  const bytes = readFileSync(file,'utf8');
  const modified = statSync(file).mtimeMs;
  const versions = await engine.executeRaw('SELECT id FROM page_versions WHERE page_id=$1', [before.page.id]);
  const replay = await submit('add_timeline_entry', params);
  expect(replay.status).toBe('skipped');
  expect((await engine.readPageSnapshot('page', { sourceId }))!.revision).toBe(before.revision);
  expect(readFileSync(file,'utf8')).toBe(bytes);
  expect(statSync(file).mtimeMs).toBe(modified);
  expect(await engine.executeRaw('SELECT id FROM page_versions WHERE page_id=$1', [before.page.id])).toEqual(versions);
  expect(await engine.getTimeline('page', { sourceId })).toHaveLength(1);
});

test('concurrent takes append, supersession and resolution publish one canonical row set', async () => {
  const added = await Promise.all(Array.from({ length: 4 }, (_, i) => submit('takes_add', {
    slug:'page',claim:`Example belief ${i}`,kind:'take',holder:'world',weight:0.6,
  })));
  expect(new Set(added.map(result=>result.row_num)).size).toBe(4);
  const superseded=await submit('takes_supersede',{slug:'page',row_num:added[0].row_num,claim:'Updated example belief'});
  const request_id=randomUUID();
  const resolve={slug:'page',row_num:superseded.new_row,quality:'correct',evidence:'Example evidence',request_id};
  const committed=await submit('takes_resolve',resolve);
  const before=(await engine.readPageSnapshot('page',{sourceId}))!;
  const result=await submit('takes_resolve',resolve);
  expect(result.revision).toBe(committed.revision);
  expect((await engine.readPageSnapshot('page',{sourceId}))!.revision).toBe(before.revision);
  const rows=await engine.executeRaw<{ row_num:number; active:boolean; resolved_quality:string|null }>('SELECT row_num,active,resolved_quality FROM takes WHERE page_id=$1 ORDER BY row_num',[before.page.id]);
  expect(rows).toHaveLength(5);
  expect(rows.find(row=>row.row_num===Number(superseded.old_row))!.active).toBe(false);
  expect(rows.find(row=>row.row_num===Number(superseded.new_row))!.resolved_quality).toBe('correct');
  expect((await engine.getChunks('page',{sourceId})).map(chunk=>chunk.chunk_text).join('\n')).not.toContain('Example belief');
});

test('canonical replacement and revert restore facts, takes and timeline from complete versions', async () => {
  const fact = (rowNum:number,claim:string) => renderFactsTable([{rowNum,claim,kind:'fact',confidence:1,
    visibility:'world',notability:'medium',active:true}]);
  const take = (rowNum:number,claim:string) => renderTakesFence([{rowNum,claim,kind:'take',holder:'world',weight:0.7,active:true}]);
  const content=`---\ntitle: Projection example\ntype: note\n---\nFirst body\n${fact(1,'First fact')}\n${take(1,'First take')}\n\n<!-- timeline -->\n\n## Timeline\n- **2026-09-15** | manual — First event\n${fact(2,'Second fact')}\n${take(2,'Second take')}`;
  await submit('put_page',{slug:'projections',content});
  const before=(await engine.readPageSnapshot('projections',{sourceId}))!;
  expect(await engine.executeRaw('SELECT id FROM facts WHERE source_id=$1 AND source_markdown_slug=$2 AND expired_at IS NULL',[sourceId,'projections'])).toHaveLength(2);
  expect(await engine.executeRaw('SELECT id FROM takes WHERE page_id=$1',[before.page.id])).toHaveLength(2);
  // GBRA-161 PR 2: a replacement without the fences holds both fence generations (fence_absent) and keeps their rows;
  // the empty fences are the proof that retires them.
  await submit('put_page',{slug:'projections',content:'---\ntitle: Replacement\ntype: note\n---\nReplacement body',expected_revision:before.revision});
  expect(await engine.executeRaw('SELECT id FROM facts WHERE source_id=$1 AND source_markdown_slug=$2 AND expired_at IS NULL',[sourceId,'projections'])).toHaveLength(2);
  expect(await engine.executeRaw('SELECT id FROM takes WHERE page_id=$1',[before.page.id])).toHaveLength(2);
  expect((await engine.executeRaw<{kind:string;held_reason:string}>("SELECT kind,held_reason FROM derived_generations WHERE source_id=$1 AND owner_key=$2 AND state='held' ORDER BY kind",
    [sourceId,'page:projections'])).map(row=>[row.kind,row.held_reason])).toEqual([['fact_fence','fence_absent'],['take_fence','fence_absent']]);
  expect(await engine.getTimeline('projections',{sourceId})).toHaveLength(0);
  const replaced=(await engine.readPageSnapshot('projections',{sourceId}))!;
  await submit('put_page',{slug:'projections',content:`---\ntitle: Replacement\ntype: note\n---\nReplacement body\n\n${emptyFenceBlock('facts')}\n${emptyFenceBlock('takes')}`,expected_revision:replaced.revision});
  expect(await engine.executeRaw('SELECT id FROM facts WHERE source_id=$1 AND source_markdown_slug=$2 AND expired_at IS NULL',[sourceId,'projections'])).toHaveLength(0);
  expect(await engine.executeRaw('SELECT id FROM takes WHERE page_id=$1',[before.page.id])).toHaveLength(0);
  expect(await engine.executeRaw("SELECT 1 FROM derived_generations WHERE source_id=$1 AND owner_key=$2 AND state='held'",[sourceId,'page:projections'])).toHaveLength(0);
  const [version]=await engine.executeRaw<{id:number}>('SELECT id FROM page_versions WHERE page_id=$1 AND knowledge_revision=$2::uuid',[before.page.id,before.revision]);
  const current=(await engine.readPageSnapshot('projections',{sourceId}))!;
  await submit('revert_version',{slug:'projections',version_id:version.id,expected_revision:current.revision});
  const restored=(await engine.readPageSnapshot('projections',{sourceId}))!;
  expect(serializePageToMarkdown(restored.page,restored.tags)).toBe(serializePageToMarkdown(before.page,before.tags));
  expect(await engine.executeRaw('SELECT id FROM facts WHERE source_id=$1 AND source_markdown_slug=$2 AND expired_at IS NULL',[sourceId,'projections'])).toHaveLength(2);
  expect(await engine.executeRaw('SELECT id FROM takes WHERE page_id=$1',[before.page.id])).toHaveLength(2);
  expect(await engine.getTimeline('projections',{sourceId})).toHaveLength(1);
  // #6188: a fence Tier 1 cannot fix exactly (a visibility no synonym maps) still refuses typed and changes nothing;
  // a duplicate row number, which Tier 1 renumbers, is covered in test/fence-write-verbs.test.ts.
  const invalid=content.replace('Second fact','Conflicting fact').replace(/(\| 2 \| Conflicting fact \| fact \| [^|]+ \| )world( \|)/,'$1nonvisible$2');
  expect(invalid).toContain('| nonvisible |');
  await expect(submit('put_page',{slug:'projections',content:invalid,expected_revision:restored.revision})).rejects.toMatchObject({code:'invalid_params',canonicalCode:'invalid_fence'});
  expect((await engine.readPageSnapshot('projections',{sourceId}))!.revision).toBe(restored.revision);
});

test('timeline detail citations remain in canonical bytes and replay without phantom events', async () => {
  const params={slug:'page',date:'2026-09-16',summary:'Cited milestone',detail:'First detail\nSee [Source: example, 2026-09-14] evidence',source:'manual'};
  await submit('add_timeline_entry',params);
  const before=(await engine.readPageSnapshot('page',{sourceId}))!;
  expect(before.page.timeline).toContain('See [Source: example, 2026-09-14] evidence');
  const rows=await engine.getTimeline('page',{sourceId});
  expect(rows.filter(row=>row.summary==='Cited milestone')).toHaveLength(1);
  expect(rows.some(row=>String(row.date).startsWith('2026-09-14'))).toBe(false);
  expect((await submit('add_timeline_entry',params)).revision).toBe(before.revision);
});