lyra-core 0.1.2 → 0.1.10

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "lyra-core",
-  "version": "0.1.2",
+  "version": "0.1.10",
   "type": "module",
   "description": "The SDK for lyra, a Sui-native policy-aware AI treasury assistant: brain, local memory + storage, the policy/approval engine, and the Sui agent keypair + chain helpers",
   "license": "MIT",
@@ -13,26 +13,14 @@
   "bugs": {
     "url": "https://github.com/rifkyeasy/lyra/issues"
   },
-  "keywords": [
-    "lyra",
-    "ai",
-    "agent",
-    "sui",
-    "treasury",
-    "defi",
-    "policy"
-  ],
+  "keywords": ["lyra", "ai", "agent", "sui", "treasury", "defi", "policy"],
   "publishConfig": {
     "access": "public"
   },
   "engines": {
     "bun": ">=1.1"
   },
-  "files": [
-    "src",
-    "!src/**/*.test.ts",
-    "README.md"
-  ],
+  "files": ["src", "!src/**/*.test.ts", "README.md"],
   "main": "./src/index.ts",
   "types": "./src/index.ts",
   "exports": {

package/src/brain/compaction.test.ts

@@ -1,156 +0,0 @@
-import { describe, expect, it } from 'bun:test'
-import {
-  DEFAULT_COMPACTION_OPTS,
-  SUMMARY_SYSTEM_PROMPT,
-  compactHistory,
-  estimateTokens,
-  shouldCompact,
-} from './compaction'
-import type { BrainMessage } from './types'
-
-const u = (content: string): BrainMessage => ({ role: 'user', content })
-const a = (content: string): BrainMessage => ({ role: 'assistant', content })
-
-describe('estimateTokens', () => {
-  it('returns 0 for empty', () => {
-    expect(estimateTokens([])).toBe(0)
-  })
-
-  it('rounds up content length / 3.5', () => {
-    // 7 chars / 3.5 = 2 tokens
-    expect(estimateTokens([u('1234567')])).toBe(2)
-  })
-
-  it('sums across messages', () => {
-    expect(estimateTokens([u('hello'), a('world!')])).toBeGreaterThan(0)
-    expect(estimateTokens([u('hello'), a('world!')])).toBe(Math.ceil(5 / 3.5) + Math.ceil(6 / 3.5))
-  })
-
-  it('counts tool_calls overhead', () => {
-    const withTools: BrainMessage = {
-      role: 'assistant',
-      content: '',
-      toolCalls: [{ id: 'x', name: 'shell.run', args: { command: 'ls' } }],
-    }
-    expect(estimateTokens([withTools])).toBeGreaterThan(0)
-  })
-})
-
-describe('shouldCompact', () => {
-  // Trigger tokens = threshold * contextWindow = 0.5 * 1000 = 500.
-  // Min history length to consider = keepRecent * 2 + 4 = 8 messages.
-  const opts = { threshold: 0.5, contextWindow: 1000, keepRecent: 2 }
-
-  it('returns null when history too short to compact', () => {
-    expect(shouldCompact([], null, opts)).toBeNull()
-    expect(shouldCompact([u('a'), a('b')], null, opts)).toBeNull()
-  })
-
-  it('returns null when token count below threshold', () => {
-    const tiny: BrainMessage[] = []
-    for (let i = 0; i < 20; i++) tiny.push(u('x'))
-    // 20 single-char messages → ~20 tokens, threshold = 500
-    expect(shouldCompact(tiny, null, opts)).toBeNull()
-  })
-
-  it('returns trigger tokens when estimate exceeds threshold', () => {
-    const big: BrainMessage[] = []
-    for (let i = 0; i < 20; i++) big.push(u('x'.repeat(100)))
-    // 20 × ~29 tokens = ~580 tokens; threshold = 500
-    const r = shouldCompact(big, null, opts)
-    expect(r).not.toBeNull()
-    expect(r!).toBeGreaterThan(500)
-  })
-
-  it('uses lastTurnPromptTokens when larger than estimate', () => {
-    const small: BrainMessage[] = []
-    for (let i = 0; i < 20; i++) small.push(u('x'))
-    const r = shouldCompact(small, 999, opts)
-    expect(r).toBe(999)
-  })
-
-  it('uses estimate when larger than lastTurnPromptTokens', () => {
-    const big: BrainMessage[] = []
-    for (let i = 0; i < 20; i++) big.push(u('x'.repeat(100)))
-    const est = estimateTokens(big)
-    const r = shouldCompact(big, 50, opts)
-    expect(r).toBe(est)
-  })
-
-  it('respects keepRecent cutoff', () => {
-    // keepRecent=100 → min 204 messages required
-    const opts2 = { threshold: 0.001, contextWindow: 100, keepRecent: 100 }
-    const ten: BrainMessage[] = []
-    for (let i = 0; i < 50; i++) ten.push(u('x'.repeat(1000)))
-    expect(shouldCompact(ten, null, opts2)).toBeNull()
-  })
-})
-
-describe('compactHistory', () => {
-  it('returns unchanged when history shorter than keepRecent*2', async () => {
-    const opts = { ...DEFAULT_COMPACTION_OPTS, keepRecent: 4 }
-    const h = [u('1'), a('2'), u('3'), a('4')]
-    const result = await compactHistory(h, opts, async () => 'summary')
-    expect(result).toEqual(h)
-  })
-
-  it('folds older into a summary message', async () => {
-    const opts = { ...DEFAULT_COMPACTION_OPTS, keepRecent: 2 }
-    const h: BrainMessage[] = []
-    for (let i = 0; i < 10; i++) h.push(u(`msg ${i}`))
-    const result = await compactHistory(h, opts, async older => {
-      expect(older.length).toBe(6) // 10 - keepRecent*2
-      return 'OLDER SUMMARY'
-    })
-    // Expected: [summary, ...last 4 messages]
-    expect(result.length).toBe(5)
-    expect(result[0]?.role).toBe('user')
-    expect(result[0]?.content).toContain('<previous-context-summary>')
-    expect(result[0]?.content).toContain('OLDER SUMMARY')
-    expect(result[1]?.content).toBe('msg 6')
-    expect(result[4]?.content).toBe('msg 9')
-  })
-
-  it('wraps summary in tag', async () => {
-    const opts = { ...DEFAULT_COMPACTION_OPTS, keepRecent: 2 }
-    const h: BrainMessage[] = []
-    for (let i = 0; i < 10; i++) h.push(u(`msg ${i}`))
-    const result = await compactHistory(h, opts, async () => 'X')
-    expect(result[0]?.content).toMatch(
-      /^<previous-context-summary>\nX\n<\/previous-context-summary>$/,
-    )
-  })
-
-  it('propagates summarize errors', async () => {
-    const opts = { ...DEFAULT_COMPACTION_OPTS, keepRecent: 1 }
-    const h: BrainMessage[] = []
-    for (let i = 0; i < 10; i++) h.push(u(`msg ${i}`))
-    await expect(
-      compactHistory(h, opts, async () => {
-        throw new Error('summarize fail')
-      }),
-    ).rejects.toThrow('summarize fail')
-  })
-})
-
-describe('SUMMARY_SYSTEM_PROMPT', () => {
-  it('mentions key elements to preserve', () => {
-    const lower = SUMMARY_SYSTEM_PROMPT.toLowerCase()
-    expect(lower).toContain('facts')
-    expect(lower).toContain('decisions')
-    expect(lower).toContain('tool outputs')
-  })
-
-  it('forbids preamble', () => {
-    expect(SUMMARY_SYSTEM_PROMPT).toMatch(/preamble/i)
-  })
-})
-
-describe('DEFAULT_COMPACTION_OPTS', () => {
-  it('targets Qwen 1M with conservative threshold', () => {
-    expect(DEFAULT_COMPACTION_OPTS.contextWindow).toBe(1_000_000)
-    expect(DEFAULT_COMPACTION_OPTS.threshold).toBeGreaterThan(0)
-    expect(DEFAULT_COMPACTION_OPTS.threshold).toBeLessThan(1)
-    expect(DEFAULT_COMPACTION_OPTS.keepRecent).toBeGreaterThan(0)
-  })
-})

package/src/brain/frozen-prefix.test.ts

@@ -1,235 +0,0 @@
-import { expect, test } from 'bun:test'
-import { buildFrozenPrefix, renderFrozenPrefix, renderUserContext } from './frozen-prefix'
-
-test('buildFrozenPrefix without memory index returns system prompt + session', () => {
-  const p = buildFrozenPrefix({ memoryIndex: null, timestamp: null })
-  expect(p.memoryIndexText).toBeNull()
-  expect(p.systemPrompt.length).toBeGreaterThan(0)
-  expect(renderFrozenPrefix(p)).toBe(`${p.systemPrompt}\n`)
-})
-
-test('buildFrozenPrefix with memory index puts it in renderUserContext, NOT system prompt', () => {
-  const memoryIndex = {
-    lines: ['# agent-id — Memory Index', '', '## Memories', '', '- [foo](agent/foo.md) — hello'],
-    entries: new Map(),
-  }
-  const p = buildFrozenPrefix({ memoryIndex, timestamp: null })
-  const sys = renderFrozenPrefix(p)
-  expect(sys).not.toContain('MEMORY.md (index)')
-  const ctx = renderUserContext(p)
-  expect(ctx).not.toBeNull()
-  expect(ctx!).toContain('MEMORY.md (index)')
-  expect(ctx!).toContain('foo')
-  expect(ctx!).toContain('<system-reminder>')
-})
-
-test('buildFrozenPrefix accepts custom system prompt', () => {
-  const p = buildFrozenPrefix({ systemPrompt: 'custom.', memoryIndex: null, timestamp: null })
-  expect(renderFrozenPrefix(p)).toBe('custom.\n')
-})
-
-test('buildFrozenPrefix loads identity + persona content into prefix', () => {
-  const p = buildFrozenPrefix({
-    memoryIndex: null,
-    identity: '# I am agent #42',
-    persona: '# I am terse',
-    timestamp: null,
-  })
-  const rendered = renderFrozenPrefix(p)
-  expect(rendered).toContain('Identity (canonical')
-  expect(rendered).toContain('I am agent #42')
-  expect(rendered).toContain('Persona (voice')
-  expect(rendered).toContain('I am terse')
-})
-
-test('buildFrozenPrefix appends per-tool guidance for loaded tools only', () => {
-  const p = buildFrozenPrefix({
-    memoryIndex: null,
-    loadedToolNames: ['memory.save', 'memory.read'],
-    timestamp: null,
-  })
-  const rendered = renderFrozenPrefix(p)
-  expect(rendered).toContain('Save durable facts using `memory.save` proactively')
-  expect(rendered).toContain('call `memory.read`')
-  // No guidance for unknown tools
-  const p2 = buildFrozenPrefix({
-    memoryIndex: null,
-    loadedToolNames: ['unknown.tool'],
-    timestamp: null,
-  })
-  expect(p2.toolGuidance).toEqual([])
-})
-
-test('buildFrozenPrefix includes session timestamp by default', () => {
-  const p = buildFrozenPrefix({ memoryIndex: null })
-  expect(p.timestamp).toMatch(/^\d{4}-\d{2}-\d{2}T/)
-  expect(renderFrozenPrefix(p)).toContain('Session started:')
-})
-
-test('renderUserContext returns null when nothing to inject', () => {
-  const p = buildFrozenPrefix({ memoryIndex: null, timestamp: null })
-  expect(renderUserContext(p)).toBeNull()
-})
-
-test('buildFrozenPrefix filters claude-code agent-browser skill out of the index', () => {
-  const skills = [
-    {
-      id: 'claude-code:agent-browser',
-      name: 'agent-browser',
-      description: 'Automates browser interactions',
-      path: '/x/SKILL.md',
-      source: 'claude-code' as const,
-      frontmatter: { name: 'agent-browser', description: 'Automates browser interactions' },
-    },
-    {
-      id: 'claude-code:hakr',
-      name: 'hakr',
-      description: 'Hacker News CLI',
-      path: '/y/SKILL.md',
-      source: 'claude-code' as const,
-      frontmatter: { name: 'hakr', description: 'Hacker News CLI' },
-    },
-  ]
-  const p = buildFrozenPrefix({ memoryIndex: null, timestamp: null, skills })
-  expect(p.skillIndexText).toContain('hakr')
-  expect(p.skillIndexText).not.toContain('agent-browser')
-  expect(p.skillIndexText).not.toContain('claude-code:agent-browser')
-})
-
-test('default system prompt includes browser guidance always-on (not conditional)', () => {
-  const p = buildFrozenPrefix({ memoryIndex: null, timestamp: null })
-  const rendered = renderFrozenPrefix(p)
-  expect(rendered).toContain('browser.navigate')
-  expect(rendered).toContain('headless Chromium')
-  expect(rendered).toContain('agent-browser')
-})
-
-test('default system prompt forbids pre-flight environment probes for browser', () => {
-  // v0.19.18 regression guard: brain was hitting `shell.run "which chromium ..."`
-  // before browser.navigate, blocking forever on the resulting approval and
-  // then hallucinating "browser tools aren't available in this sandbox" when
-  // the probe was denied. The guidance must explicitly forbid those probes.
-  const p = buildFrozenPrefix({ memoryIndex: null, timestamp: null })
-  const rendered = renderFrozenPrefix(p)
-  expect(rendered).toContain('Do NOT pre-probe the environment')
-  expect(rendered).toContain('which chromium')
-  expect(rendered).toContain('self-contained')
-})
-
-test('default system prompt includes tool-use enforcement', () => {
-  const p = buildFrozenPrefix({ memoryIndex: null, timestamp: null })
-  const rendered = renderFrozenPrefix(p)
-  expect(rendered).toContain('You MUST use your tools')
-  expect(rendered).toContain('NEVER answer these from memory')
-})
-
-test('buildFrozenPrefix appends operator promptAppend under # Operator instructions', () => {
-  const p = buildFrozenPrefix({
-    memoryIndex: null,
-    timestamp: null,
-    promptAppend: 'Always reply in Indonesian.',
-  })
-  expect(p.appendText).toBe('Always reply in Indonesian.')
-  const rendered = renderFrozenPrefix(p)
-  expect(rendered).toContain('# Operator instructions')
-  expect(rendered).toContain('Always reply in Indonesian.')
-})
-
-test('buildFrozenPrefix renders envInfo cwd + platform', () => {
-  const p = buildFrozenPrefix({
-    memoryIndex: null,
-    timestamp: null,
-    envInfo: { cwd: '/tmp/x', platform: 'darwin' },
-  })
-  const rendered = renderFrozenPrefix(p)
-  expect(rendered).toContain('# Environment')
-  expect(rendered).toContain('cwd: /tmp/x')
-  expect(rendered).toContain('platform: darwin')
-})
-
-test('envInfo with sandbox=docker surfaces inner OS + workspace mount + scope', () => {
-  const p = buildFrozenPrefix({
-    memoryIndex: null,
-    timestamp: null,
-    envInfo: {
-      cwd: '/tmp/x',
-      platform: 'darwin',
-      sandbox: {
-        mode: 'docker',
-        label: 'podman:nikolaik/python-nodejs:python3.11-nodejs20+workspace',
-        innerOs: 'linux',
-        workspaceMount: '/workspace',
-        scope: 'shell.run, code.execute, shell.process_start run inside the container',
-      },
-    },
-  })
-  const rendered = renderFrozenPrefix(p)
-  expect(rendered).toContain('sandbox: docker (podman:')
-  expect(rendered).toContain('inner os: linux')
-  expect(rendered).toContain('workspace mount: host cwd is bind-mounted at /workspace')
-  expect(rendered).toContain('scope: shell.run, code.execute')
-})
-
-test('envInfo with sandbox.mode=none does NOT add the sandbox section', () => {
-  const p = buildFrozenPrefix({
-    memoryIndex: null,
-    timestamp: null,
-    envInfo: {
-      cwd: '/tmp/x',
-      platform: 'darwin',
-      sandbox: { mode: 'none', label: 'none' },
-    },
-  })
-  const rendered = renderFrozenPrefix(p)
-  expect(rendered).toContain('cwd: /tmp/x')
-  expect(rendered).not.toContain('sandbox:')
-})
-
-test('envInfo with sandbox=os surfaces label + scope under # Environment', () => {
-  const p = buildFrozenPrefix({
-    memoryIndex: null,
-    timestamp: null,
-    envInfo: {
-      cwd: '/tmp/x',
-      platform: 'darwin',
-      sandbox: {
-        mode: 'os',
-        label: 'os:darwin',
-        innerOs: 'darwin',
-        workspaceMount: null,
-        scope: 'spawns wrapped in sandbox-exec; writes outside agentDir + cwd denied',
-      },
-    },
-  })
-  const rendered = renderFrozenPrefix(p)
-  expect(rendered).toContain('sandbox: os (os:darwin)')
-  expect(rendered).toContain('scope: spawns wrapped in sandbox-exec')
-  expect(rendered).not.toContain('workspace mount:')
-})
-
-test('skill-shadow filter keeps lyra-source skills with the same name', () => {
-  const skills = [
-    {
-      id: 'lyra:browser',
-      name: 'browser',
-      description: 'Lyra native browser playbook',
-      path: '/z/SKILL.md',
-      source: 'lyra' as const,
-      frontmatter: { name: 'browser', description: 'Lyra native browser playbook' },
-    },
-  ]
-  const p = buildFrozenPrefix({ memoryIndex: null, timestamp: null, skills })
-  expect(p.skillIndexText).toContain('lyra:browser')
-})
-
-// v0.22.0: brain emitted em-dashes in prose + table separators, violating the
-// project hard rule (global CLAUDE.md). The system prompt now carries an
-// explicit ASCII-hyphen rule in the Tone and style section.
-test('system prompt instructs brain to use ASCII hyphens, not em-dashes', () => {
-  const p = buildFrozenPrefix({ memoryIndex: null, timestamp: null })
-  const rendered = renderFrozenPrefix(p)
-  expect(rendered).toMatch(/ASCII hyphens/)
-  expect(rendered).toMatch(/em-dashes/)
-  // Reference U+2014 explicitly so the brain knows the exact codepoint
-  expect(rendered).toMatch(/U\+2014/)
-})

package/src/brain/history-persist.test.ts

@@ -1,129 +0,0 @@
-import { describe, expect, it } from 'bun:test'
-import { mkdtempSync, readFileSync } from 'node:fs'
-import { tmpdir } from 'node:os'
-import { join } from 'node:path'
-import { createFsHistoryPersist, sanitizeChannelKey } from './history-persist'
-import type { BrainMessage } from './types'
-
-const u = (content: string): BrainMessage => ({ role: 'user', content })
-const a = (content: string): BrainMessage => ({ role: 'assistant', content })
-
-function makeTmpDir(): string {
-  return mkdtempSync(join(tmpdir(), 'lyra-history-test-'))
-}
-
-describe('sanitizeChannelKey', () => {
-  it('passes safe keys through', () => {
-    expect(sanitizeChannelKey('default')).toBe('default')
-    expect(sanitizeChannelKey('tui:stdin')).toBe('tui_stdin')
-    expect(sanitizeChannelKey('a-b_c.d')).toBe('a-b_c.d')
-  })
-
-  it('replaces unsafe chars', () => {
-    expect(sanitizeChannelKey('agent:specter:telegram:dm:12345')).toBe(
-      'agent_specter_telegram_dm_12345',
-    )
-    expect(sanitizeChannelKey('a/b\\c')).toBe('a_b_c')
-  })
-
-  it('caps length', () => {
-    const long = 'x'.repeat(500)
-    const out = sanitizeChannelKey(long)
-    expect(out.length).toBeLessThanOrEqual(200)
-  })
-
-  it('falls back to default on empty/all-unsafe', () => {
-    expect(sanitizeChannelKey('')).toBe('default')
-    // 250 unsafe chars → all replaced with _, then sliced to 200, still non-empty so kept
-    expect(sanitizeChannelKey('/'.repeat(250)).length).toBe(200)
-  })
-})
-
-describe('createFsHistoryPersist', () => {
-  it('roundtrips a single channel', async () => {
-    const dir = makeTmpDir()
-    const persist = createFsHistoryPersist({ dir })
-    await persist.appendTurn('default', u('hi'), a('hello'))
-    const loaded = await persist.loadAll()
-    expect(loaded.get('default')).toEqual([u('hi'), a('hello')])
-  })
-
-  it('partitions per channel', async () => {
-    const dir = makeTmpDir()
-    const persist = createFsHistoryPersist({ dir })
-    await persist.appendTurn('tui:stdin', u('A'), a('B'))
-    await persist.appendTurn('agent:foo:tg:dm:1', u('C'), a('D'))
-    const loaded = await persist.loadAll()
-    expect(loaded.get('tui:stdin')).toEqual([u('A'), a('B')])
-    expect(loaded.get('agent:foo:tg:dm:1')).toEqual([u('C'), a('D')])
-  })
-
-  it('appends append onto existing file', async () => {
-    const dir = makeTmpDir()
-    const persist = createFsHistoryPersist({ dir })
-    await persist.appendTurn('default', u('1'), a('2'))
-    await persist.appendTurn('default', u('3'), a('4'))
-    const loaded = await persist.loadAll()
-    expect(loaded.get('default')).toEqual([u('1'), a('2'), u('3'), a('4')])
-  })
-
-  it('clearChannel removes the file', async () => {
-    const dir = makeTmpDir()
-    const persist = createFsHistoryPersist({ dir })
-    await persist.appendTurn('default', u('x'), a('y'))
-    await persist.clearChannel('default')
-    const loaded = await persist.loadAll()
-    expect(loaded.get('default')).toBeUndefined()
-  })
-
-  it('clearChannel is idempotent on missing file', async () => {
-    const dir = makeTmpDir()
-    const persist = createFsHistoryPersist({ dir })
-    await persist.clearChannel('never-existed')
-    // No throw
-    expect(true).toBe(true)
-  })
-
-  it('rewriteChannel atomically replaces history', async () => {
-    const dir = makeTmpDir()
-    const persist = createFsHistoryPersist({ dir })
-    await persist.appendTurn('default', u('old1'), a('old2'))
-    await persist.appendTurn('default', u('old3'), a('old4'))
-    await persist.rewriteChannel('default', [u('SUMMARY'), u('new'), a('reply')])
-    const loaded = await persist.loadAll()
-    expect(loaded.get('default')).toEqual([u('SUMMARY'), u('new'), a('reply')])
-  })
-
-  it('loadAll returns empty Map when dir does not exist', async () => {
-    const persist = createFsHistoryPersist({ dir: '/nonexistent/path/lyra-test' })
-    const loaded = await persist.loadAll()
-    expect(loaded.size).toBe(0)
-  })
-
-  it('loadAll skips malformed lines', async () => {
-    const dir = makeTmpDir()
-    const persist = createFsHistoryPersist({ dir })
-    await persist.appendTurn('default', u('good'), a('reply'))
-    // Append a bad line manually
-    const path = join(dir, 'default.jsonl')
-    const { writeFileSync } = await import('node:fs')
-    const existing = readFileSync(path, 'utf8')
-    writeFileSync(path, `${existing}not-json\n`)
-    const loaded = await persist.loadAll()
-    expect(loaded.get('default')).toEqual([u('good'), a('reply')])
-  })
-
-  it('loadAll skips records with wrong version', async () => {
-    const dir = makeTmpDir()
-    const path = join(dir, 'default.jsonl')
-    const { mkdirSync, writeFileSync } = await import('node:fs')
-    mkdirSync(dir, { recursive: true })
-    writeFileSync(
-      path,
-      `${JSON.stringify({ v: 999, channelKey: 'default', message: u('x'), ts: 1 })}\n`,
-    )
-    const persist = createFsHistoryPersist({ dir })
-    const loaded = await persist.loadAll()
-    expect(loaded.get('default')).toBeUndefined()
-  })
-})

package/src/brain/openai-brain.test.ts

@@ -1,61 +0,0 @@
-import { afterEach, describe, expect, it } from 'bun:test'
-import type { LyraEvent } from '../events/types'
-import { buildFrozenPrefix } from './frozen-prefix'
-import { OpenAIBrain } from './openai-brain'
-
-const origFetch = globalThis.fetch
-
-/** Replace global fetch with a canned OpenAI-compatible /chat/completions response. */
-function mockFetch(body: unknown): void {
-  globalThis.fetch = (async () =>
-    new Response(JSON.stringify(body), {
-      status: 200,
-      headers: { 'content-type': 'application/json' },
-    })) as unknown as typeof fetch
-}
-
-function makeEvent(text: string): LyraEvent {
-  return { id: 'evt-1', source: 'stdin', payload: { label: 'user', data: text }, ts: 0 }
-}
-
-const prefix = buildFrozenPrefix({
-  systemPrompt: 'You are a test agent.',
-  memoryIndex: null,
-  identity: null,
-  persona: null,
-  loadedToolNames: [],
-  skills: [],
-  timestamp: null,
-})
-
-describe('OpenAIBrain', () => {
-  afterEach(() => {
-    globalThis.fetch = origFetch
-  })
-
-  it('returns assistant content from an OpenAI-compatible response', async () => {
-    mockFetch({
-      choices: [{ message: { content: 'hello from lyra' }, finish_reason: 'stop' }],
-      usage: { prompt_tokens: 10, completion_tokens: 3, total_tokens: 13 },
-    })
-    const brain = new OpenAIBrain({ apiKey: 'test-key', model: 'gpt-4o-mini', tools: [], prefix })
-    const turn = await brain.infer({ event: makeEvent('hi') })
-    expect(turn.content).toBe('hello from lyra')
-    expect(turn.toolCalls).toHaveLength(0)
-    expect(turn.usage?.totalTokens).toBe(13)
-  })
-
-  it('falls back to reasoning_content when content is empty', async () => {
-    mockFetch({
-      choices: [
-        {
-          message: { content: null, reasoning_content: '<think>x</think>the answer' },
-          finish_reason: 'stop',
-        },
-      ],
-    })
-    const brain = new OpenAIBrain({ apiKey: 'k', tools: [], prefix })
-    const turn = await brain.infer({ event: makeEvent('q') })
-    expect(turn.content).toBe('the answer')
-  })
-})

package/src/brain/sanitize.test.ts

@@ -1,27 +0,0 @@
-import { describe, expect, it } from 'bun:test'
-import { sanitizeDashes } from './sanitize'
-
-describe('sanitizeDashes (v0.22.2 backstop)', () => {
-  it('replaces em-dash with comma+space (preserving surrounding spaces)', () => {
-    expect(sanitizeDashes('Denied — rm -rf blocked')).toBe('Denied ,  rm -rf blocked')
-    expect(sanitizeDashes('text—more')).toBe('text, more')
-  })
-  it('replaces en-dash with ASCII hyphen', () => {
-    expect(sanitizeDashes('range 3–5')).toBe('range 3-5')
-    expect(sanitizeDashes('2026–2027')).toBe('2026-2027')
-  })
-  it('passes plain ASCII text untouched', () => {
-    expect(sanitizeDashes('hello world')).toBe('hello world')
-    expect(sanitizeDashes('use rm -rf carefully')).toBe('use rm -rf carefully')
-  })
-  it('handles empty + null-ish', () => {
-    expect(sanitizeDashes('')).toBe('')
-  })
-  it('strips all em-dashes and en-dashes from prose-heavy input', () => {
-    const result = sanitizeDashes('A — B – C — D')
-    expect(result).not.toMatch(/[—–]/)
-    expect(result.startsWith('A')).toBe(true)
-    expect(result.endsWith('D')).toBe(true)
-    expect(result).toContain('B - C')
-  })
-})