Skip to content

Garry's Opinionated OpenClaw/Hermes Agent Brain

TypeScript
6.1 KB
Raw Blame
/**
 * GST-2768 PR 3 (decision A): the conversation archive is on by default for a personal brain. An unset
 * transcripts.archive.enabled resolves on when the brain audience classifies personal, off for a shared or unknown
 * brain, a thin client and a remote caller; an explicit on or off wins; a config read failure resolves off. A keyless
 * archive run makes no network call. PGLite, synthetic sessions only.
 */
import { afterAll, beforeAll, beforeEach, describe, expect, spyOn, test } from 'bun:test';
import { PGLiteEngine } from '../src/core/pglite-engine.ts';
import type { BrainEngine } from '../src/core/engine.ts';
import { resetPgliteState } from './helpers/reset-pglite.ts';
import { ARCHIVE_ENABLED_KEY, ARCHIVE_TIMEZONE_KEY, archiveEnabled, runTranscriptArchive } from '../src/core/transcripts/archive.ts';
import { resolveArchiveEnabled } from '../src/core/transcripts/archive-default.ts';
import { conversation, staticReader } from './helpers/transcript-archive.ts';

let engine: PGLiteEngine;

beforeAll(async () => {
  engine = new PGLiteEngine();
  await engine.connect({});
  await engine.initSchema();
});

afterAll(async () => {
  await engine.disconnect();
});

beforeEach(async () => {
  await resetPgliteState(engine);
});

describe('archive default resolution', () => {
  test('a personal brain with the switch unset resolves on', async () => {
    await engine.setConfig('brain.audience', 'personal');
    const r = await resolveArchiveEnabled(engine, { config: null });
    expect(r).toMatchObject({ enabled: true, source: 'default', audience: 'personal', offered: false });
    expect(await archiveEnabled(engine)).toBe(true);
  });

  test('an undeclared brain the heuristic reads as personal resolves on', async () => {
    expect((await resolveArchiveEnabled(engine, { config: null })).enabled).toBe(true);
  });

  test('a shared brain with the switch unset resolves off and is only offered', async () => {
    await engine.setConfig('brain.audience', 'shared');
    const r = await resolveArchiveEnabled(engine, { config: null });
    expect(r).toMatchObject({ enabled: false, source: 'default', audience: 'shared', offered: true });
    expect(await archiveEnabled(engine)).toBe(false);
    expect(await engine.getConfig(ARCHIVE_ENABLED_KEY)).toBeNull();
  });

  test('an unknown audience resolves off', async () => {
    const unknown = { getConfig: async (key: string) => { if (key === 'brain.audience') throw new Error('config read failed'); return null; } } as unknown as BrainEngine;
    const r = await resolveArchiveEnabled(unknown, { config: null });
    expect(r.enabled).toBe(false);
    expect(r.audience).toBe('unknown');
  });

  test('an explicit off wins on a personal brain', async () => {
    await engine.setConfig('brain.audience', 'personal');
    await engine.setConfig(ARCHIVE_ENABLED_KEY, 'false');
    expect(await resolveArchiveEnabled(engine, { config: null })).toMatchObject({ enabled: false, source: 'explicit', offered: false });
  });

  test('an explicit on wins on a shared brain', async () => {
    await engine.setConfig('brain.audience', 'shared');
    await engine.setConfig(ARCHIVE_ENABLED_KEY, 'true');
    expect(await resolveArchiveEnabled(engine, { config: null })).toMatchObject({ enabled: true, source: 'explicit', offered: false });
  });

  test('a config read failure resolves off', async () => {
    const broken = { getConfig: async () => { throw new Error('connection lost'); } } as unknown as BrainEngine;
    expect(await resolveArchiveEnabled(broken, { config: null })).toMatchObject({ enabled: false, source: 'config_unreadable' });
    expect(await archiveEnabled(broken)).toBe(false);
  });

  test('GBRA-585: on a brain that serves several people, an explicit personal audience is not reported as unset or as switching itself off', async () => {
    await engine.setConfig('access.serves', 'several');
    const heuristic = await resolveArchiveEnabled(engine, { config: null });
    expect(heuristic).toMatchObject({ enabled: true, source: 'default', audience: 'personal', serves_several: true });
    expect(heuristic.reason).toContain('brain.audience is unset');
    expect(heuristic.reason).toContain('turns off');
    expect(heuristic.reason).toContain('gbrain config set brain.audience shared');

    await engine.setConfig('brain.audience', 'personal');
    const declared = await resolveArchiveEnabled(engine, { config: null });
    expect(declared).toMatchObject({ enabled: true, source: 'default', audience: 'personal', serves_several: true });
    expect(declared.reason).toContain('brain.audience is set to personal');
    expect(declared.reason).not.toContain('unset');
    expect(declared.reason).not.toContain('turns off');
    expect(declared.reason).toContain('gbrain config set brain.audience shared');
  });

  test('a thin client and a remote caller resolve off, even with the switch on', async () => {
    await engine.setConfig('brain.audience', 'personal');
    await engine.setConfig(ARCHIVE_ENABLED_KEY, 'true');
    expect(await resolveArchiveEnabled(engine, { config: { remote_mcp: { issuer_url: 'https://brain.example.invalid' } } as never })).toMatchObject({ enabled: false, source: 'thin_client' });
    expect(await resolveArchiveEnabled(engine, { config: null, remote: true })).toMatchObject({ enabled: false, source: 'remote' });
  });
});

describe('a keyless default-on run', () => {
  test('writes the day and makes no network call', async () => {
    await engine.setConfig('brain.audience', 'personal');
    await engine.setConfig(ARCHIVE_TIMEZONE_KEY, 'UTC');
    const fetchSpy = spyOn(globalThis, 'fetch').mockImplementation((() => { throw new Error('network call from a keyless archive run'); }) as never);
    try {
      const result = await runTranscriptArchive(engine, {
        mode: 'run', now: new Date('2026-11-10T09:00:00Z'),
        readers: [staticReader('codex', [conversation('codex', 'codex-session-default', [['user', '2026-11-10T08:00:00.000Z', 'hello from alice-example']])])],
      });
      expect(result.enabled).toBe(true);
      expect(result.written).toBe(1);
      expect(fetchSpy).toHaveBeenCalledTimes(0);
    } finally {
      fetchSpy.mockRestore();
    }
  }, 60_000);
});