lyra-core 0.1.1 → 0.1.10

package/src/mcp/manager.test.ts

@@ -1,97 +0,0 @@
-import { afterEach, beforeEach, describe, expect, it } from 'bun:test'
-import { mkdtemp, rm, writeFile } from 'node:fs/promises'
-import { tmpdir } from 'node:os'
-import { join } from 'node:path'
-import { ToolRegistry } from '../tools/registry'
-import type { ToolDef } from '../tools/types'
-import { McpManager } from './manager'
-
-let scratch: string
-let serverPath: string
-
-beforeEach(async () => {
-  scratch = await mkdtemp(join(tmpdir(), 'lyra-mcp-server-'))
-  serverPath = join(scratch, 'server.ts')
-  // Minimal stdio MCP server: handles initialize, tools/list, tools/call.
-  await writeFile(
-    serverPath,
-    `process.stdin.setEncoding('utf8')
-let buf = ''
-process.stdin.on('data', chunk => {
-  buf += chunk
-  let nl = buf.indexOf('\\n')
-  while (nl !== -1) {
-    const line = buf.slice(0, nl).trim()
-    buf = buf.slice(nl + 1)
-    nl = buf.indexOf('\\n')
-    if (!line) continue
-    const msg = JSON.parse(line)
-    if (msg.method === 'initialize') {
-      process.stdout.write(JSON.stringify({
-        jsonrpc: '2.0', id: msg.id,
-        result: { protocolVersion: '2024-11-05', capabilities: {}, serverInfo: { name: 'fake', version: '1.0.0' } },
-      }) + '\\n')
-    } else if (msg.method === 'tools/list') {
-      process.stdout.write(JSON.stringify({
-        jsonrpc: '2.0', id: msg.id,
-        result: { tools: [{ name: 'echo', description: 'echoes input', inputSchema: { type: 'object', properties: { text: { type: 'string' } }, required: ['text'] } }] },
-      }) + '\\n')
-    } else if (msg.method === 'tools/call') {
-      process.stdout.write(JSON.stringify({
-        jsonrpc: '2.0', id: msg.id,
-        result: { content: [{ type: 'text', text: msg.params.arguments.text }] },
-      }) + '\\n')
-    }
-  }
-})
-`,
-  )
-})
-
-afterEach(async () => {
-  await rm(scratch, { recursive: true, force: true })
-})
-
-describe('McpManager', () => {
-  it('spawns stdio server, registers tool, dispatches via registry', async () => {
-    const mgr = new McpManager([
-      { name: 'fake', type: 'stdio', command: 'bun', args: ['run', serverPath] },
-    ])
-    const reg = new ToolRegistry()
-    const result = await mgr.registerAll(def => reg.register(def))
-    expect(result.registered).toBe(1)
-    expect(result.failed).toEqual([])
-
-    const tool = reg.find('mcp.fake.echo') as ToolDef
-    expect(tool).toBeDefined()
-    expect(tool.shouldDefer).toBe(true)
-    expect(tool.parametersOverride?.properties).toEqual({ text: { type: 'string' } })
-
-    const out = await reg.dispatch({ id: '1', name: 'mcp.fake.echo', args: { text: 'hi' } })
-    expect(out.ok).toBe(true)
-    expect(out.data).toMatchObject({ content: [{ type: 'text', text: 'hi' }] })
-
-    mgr.closeAll()
-  })
-
-  it('reports failed servers without throwing', async () => {
-    const mgr = new McpManager([{ name: 'broken', type: 'stdio', command: '/does/not/exist' }])
-    const reg = new ToolRegistry()
-    const result = await mgr.registerAll(def => reg.register(def))
-    expect(result.registered).toBe(0)
-    expect(result.failed).toHaveLength(1)
-    expect(result.failed[0]!.server).toBe('broken')
-    mgr.closeAll()
-  })
-
-  it('flags http servers as not yet supported', async () => {
-    const mgr = new McpManager([
-      { name: 'http-thing', type: 'http', url: 'https://example.com/mcp' },
-    ])
-    const reg = new ToolRegistry()
-    const result = await mgr.registerAll(def => reg.register(def))
-    expect(result.registered).toBe(0)
-    expect(result.failed[0]!.error).toContain('http MCP')
-    mgr.closeAll()
-  })
-})

package/src/memory/edit.test.ts

@@ -1,41 +0,0 @@
-import { expect, test } from 'bun:test'
-import { EditError, applyEdit } from './edit'
-
-test('add on empty body inserts content', () => {
-  const out = applyEdit('', { action: 'add', newText: 'hello' })
-  expect(out).toBe('hello')
-})
-
-test('add appends with double newline on existing body', () => {
-  const out = applyEdit('first line', { action: 'add', newText: 'second line' })
-  expect(out).toBe('first line\n\nsecond line\n')
-})
-
-test('replace substring', () => {
-  const out = applyEdit('foo bar baz', {
-    action: 'replace',
-    oldText: 'bar',
-    newText: 'qux',
-  })
-  expect(out).toBe('foo qux baz')
-})
-
-test('replace throws when oldText missing', () => {
-  expect(() =>
-    applyEdit('foo bar', { action: 'replace', oldText: 'missing', newText: 'x' }),
-  ).toThrow(EditError)
-})
-
-test('replace throws when oldText is ambiguous', () => {
-  expect(() => applyEdit('foo foo', { action: 'replace', oldText: 'foo', newText: 'x' })).toThrow(
-    EditError,
-  )
-})
-
-test('remove strips matching substring', () => {
-  const out = applyEdit('leading payload trailing', {
-    action: 'remove',
-    oldText: 'payload ',
-  })
-  expect(out).toBe('leading trailing')
-})

package/src/memory/encryption.test.ts

@@ -1,68 +0,0 @@
-import { describe, expect, test } from 'bun:test'
-import { Ed25519Keypair } from '@mysten/sui/keypairs/ed25519'
-import {
-  MEMORY_BLOB_VERSION,
-  decryptMemoryBytes,
-  deriveMemoryKey,
-  encryptMemoryBytes,
-} from './encryption'
-
-const genSecret = (): string => Ed25519Keypair.generate().getSecretKey()
-
-describe('memory encryption', () => {
-  test('round-trip: encrypt + decrypt with same agent key', () => {
-    const agentPriv = genSecret()
-    const key = deriveMemoryKey(agentPriv)
-    const plaintext = new TextEncoder().encode('# identity\n\nagent-001 minted at block 42\n')
-    const blob = encryptMemoryBytes(plaintext, key)
-    expect(blob[0]).toBe(MEMORY_BLOB_VERSION)
-    const out = decryptMemoryBytes(blob, key)
-    expect(new TextDecoder().decode(out)).toBe(new TextDecoder().decode(plaintext))
-  })
-
-  test('different agent keys produce different ciphertexts (key separation)', () => {
-    const a = deriveMemoryKey(genSecret())
-    const b = deriveMemoryKey(genSecret())
-    const pt = new TextEncoder().encode('hello')
-    const ba = encryptMemoryBytes(pt, a)
-    const bb = encryptMemoryBytes(pt, b)
-    expect(Buffer.from(ba).equals(Buffer.from(bb))).toBe(false)
-    expect(() => decryptMemoryBytes(ba, b)).toThrow()
-  })
-
-  test('two encrypts of same plaintext yield different ciphertexts (random IV)', () => {
-    const key = deriveMemoryKey(genSecret())
-    const pt = new TextEncoder().encode('same plaintext')
-    const a = encryptMemoryBytes(pt, key)
-    const b = encryptMemoryBytes(pt, key)
-    expect(Buffer.from(a).equals(Buffer.from(b))).toBe(false)
-    expect(new TextDecoder().decode(decryptMemoryBytes(a, key))).toBe('same plaintext')
-    expect(new TextDecoder().decode(decryptMemoryBytes(b, key))).toBe('same plaintext')
-  })
-
-  test('tampered ciphertext fails GCM auth', () => {
-    const key = deriveMemoryKey(genSecret())
-    const blob = encryptMemoryBytes(new TextEncoder().encode('x'), key)
-    blob[blob.length - 1] = (blob[blob.length - 1] ?? 0) ^ 0xff
-    expect(() => decryptMemoryBytes(blob, key)).toThrow()
-  })
-
-  test('rejects unsupported version byte', () => {
-    const key = deriveMemoryKey(genSecret())
-    const blob = encryptMemoryBytes(new TextEncoder().encode('x'), key)
-    blob[0] = 99
-    expect(() => decryptMemoryBytes(blob, key)).toThrow(/unsupported memory blob version/)
-  })
-
-  test('rejects too-short blob', () => {
-    const key = deriveMemoryKey(genSecret())
-    expect(() => decryptMemoryBytes(new Uint8Array([1, 2, 3]), key)).toThrow(/too short/)
-  })
-
-  test('determinism: same agent privkey always derives same key', () => {
-    const priv = genSecret()
-    const k1 = deriveMemoryKey(priv)
-    const k2 = deriveMemoryKey(priv)
-    expect(k1.equals(k2)).toBe(true)
-  })
-})

package/src/memory/index-sync.test.ts

@@ -1,81 +0,0 @@
-import { afterEach, beforeEach, describe, expect, it } from 'bun:test'
-import { mkdirSync, mkdtempSync, readFileSync, rmSync, writeFileSync } from 'node:fs'
-import { tmpdir } from 'node:os'
-import { join } from 'node:path'
-import { ensureSyntheticIndexEntries } from './index-sync'
-
-describe('ensureSyntheticIndexEntries', () => {
-  let memoryDir: string
-
-  beforeEach(() => {
-    memoryDir = mkdtempSync(join(tmpdir(), 'index-sync-'))
-    mkdirSync(join(memoryDir, 'agent'), { recursive: true })
-    mkdirSync(join(memoryDir, 'user'), { recursive: true })
-    writeFileSync(join(memoryDir, 'MEMORY.md'), '# Memory\n\n', 'utf8')
-  })
-
-  afterEach(() => {
-    if (memoryDir) rmSync(memoryDir, { recursive: true, force: true })
-  })
-
-  it('adds entries for files that exist on disk with frontmatter descriptions', async () => {
-    writeFileSync(
-      join(memoryDir, 'agent', 'identity.md'),
-      '---\nname: identity\ndescription: Auto-written agent identity facts\ntype: agent-identity\n---\n# id',
-    )
-    writeFileSync(
-      join(memoryDir, 'agent', 'persona.md'),
-      '---\nname: persona\ndescription: Voice + behavior style\ntype: agent-persona\n---\nbody',
-    )
-    writeFileSync(
-      join(memoryDir, 'user', 'profile.md'),
-      '---\nname: profile\ndescription: User profile\ntype: user\n---\nbody',
-    )
-    const r = await ensureSyntheticIndexEntries(memoryDir)
-    expect(r.added).toEqual(['agent/identity.md', 'agent/persona.md', 'user/profile.md'])
-    expect(r.skipped).toEqual([])
-    const idx = readFileSync(join(memoryDir, 'MEMORY.md'), 'utf8')
-    expect(idx).toContain('agent/identity.md')
-    expect(idx).toContain('Auto-written agent identity facts')
-    expect(idx).toContain('agent/persona.md')
-    expect(idx).toContain('user/profile.md')
-  })
-
-  it('is idempotent — second call adds nothing', async () => {
-    writeFileSync(
-      join(memoryDir, 'agent', 'identity.md'),
-      '---\nname: identity\ndescription: id desc\ntype: agent-identity\n---\nbody',
-    )
-    await ensureSyntheticIndexEntries(memoryDir)
-    const r2 = await ensureSyntheticIndexEntries(memoryDir)
-    expect(r2.added).toEqual([])
-    expect(r2.skipped).toContain('agent/identity.md')
-  })
-
-  it('skips files that do not exist on disk', async () => {
-    // Only persona exists, no identity.md or profile.md.
-    writeFileSync(
-      join(memoryDir, 'agent', 'persona.md'),
-      '---\nname: persona\ndescription: voice\ntype: agent-persona\n---\nbody',
-    )
-    const r = await ensureSyntheticIndexEntries(memoryDir)
-    expect(r.added).toEqual(['agent/persona.md'])
-    expect(r.skipped).toEqual(['agent/identity.md', 'user/profile.md'])
-  })
-
-  it('falls back to filename title when frontmatter is missing', async () => {
-    writeFileSync(join(memoryDir, 'agent', 'identity.md'), 'no frontmatter here')
-    const r = await ensureSyntheticIndexEntries(memoryDir)
-    expect(r.added).toEqual(['agent/identity.md'])
-    const idx = readFileSync(join(memoryDir, 'MEMORY.md'), 'utf8')
-    expect(idx).toContain('agent/identity.md')
-    expect(idx).toContain('identity')
-  })
-
-  it('no-ops gracefully when MEMORY.md is missing', async () => {
-    rmSync(join(memoryDir, 'MEMORY.md'))
-    const r = await ensureSyntheticIndexEntries(memoryDir)
-    expect(r.added).toEqual([])
-    expect(r.skipped.length).toBe(3)
-  })
-})

package/src/memory/pack-blob.test.ts

@@ -1,90 +0,0 @@
-import { describe, expect, test } from 'bun:test'
-import { PACK_BLOB_VERSION, decodePackBlob, encodePackBlob, isV2Envelope } from './pack-blob'
-
-describe('pack-blob v2 envelope', () => {
-  test('encode + decode round-trips single root', () => {
-    const bytes = encodePackBlob({ root: '# MEMORY.md\n\nentries' })
-    expect(isV2Envelope(bytes)).toBe(true)
-    const blob = decodePackBlob(bytes)
-    expect(blob.v).toBe(PACK_BLOB_VERSION)
-    expect(blob.root).toBe('# MEMORY.md\n\nentries')
-    expect(blob.files).toEqual({})
-  })
-
-  test('encode + decode round-trips with files map', () => {
-    const bytes = encodePackBlob({
-      root: '# profile',
-      files: {
-        'operator-preferences.md': '# Operator Preferences\n\ndark mode',
-        'hackathon-deadline.md': 'May 16 2026',
-      },
-    })
-    const blob = decodePackBlob(bytes)
-    expect(blob.root).toBe('# profile')
-    expect(blob.files['operator-preferences.md']).toContain('dark mode')
-    expect(blob.files['hackathon-deadline.md']).toBe('May 16 2026')
-  })
-
-  test('encode rejects unsafe filenames', () => {
-    expect(() => encodePackBlob({ root: 'x', files: { '../etc/passwd.md': 'hax' } })).toThrow(
-      /unsafe filename/,
-    )
-    expect(() => encodePackBlob({ root: 'x', files: { 'no-dot-md': 'x' } })).toThrow(
-      /unsafe filename/,
-    )
-    expect(() => encodePackBlob({ root: 'x', files: { 'UPPERCASE.md': 'x' } })).toThrow(
-      /unsafe filename/,
-    )
-    expect(() => encodePackBlob({ root: 'x', files: { 'has spaces.md': 'x' } })).toThrow(
-      /unsafe filename/,
-    )
-    expect(() => encodePackBlob({ root: 'x', files: { '.md': 'x' } })).toThrow(/unsafe filename/)
-  })
-
-  test('isV2Envelope rejects legacy markdown', () => {
-    const md = new TextEncoder().encode('# Heading\n\ncontent')
-    expect(isV2Envelope(md)).toBe(false)
-  })
-
-  test('isV2Envelope rejects v1 JSON without v:2', () => {
-    const v1 = new TextEncoder().encode('{"version":1,"data":"x"}')
-    expect(isV2Envelope(v1)).toBe(false)
-  })
-
-  test('isV2Envelope rejects garbage', () => {
-    const junk = new Uint8Array([0xff, 0x00, 0xab, 0xcd])
-    expect(isV2Envelope(junk)).toBe(false)
-    expect(isV2Envelope(new Uint8Array(0))).toBe(false)
-  })
-
-  test('isV2Envelope tolerates leading whitespace', () => {
-    const bytes = new TextEncoder().encode('   {"v":2,"root":"x","files":{}}')
-    expect(isV2Envelope(bytes)).toBe(true)
-  })
-
-  test('decode rejects mismatched version', () => {
-    const bytes = new TextEncoder().encode('{"v":999,"root":"x"}')
-    expect(() => decodePackBlob(bytes)).toThrow(/expected v=2/)
-  })
-
-  test('decode tolerates unsafe filenames by dropping them', () => {
-    const bytes = new TextEncoder().encode(
-      '{"v":2,"root":"x","files":{"ok.md":"y","../bad.md":"hax"}}',
-    )
-    const blob = decodePackBlob(bytes)
-    expect(blob.files['ok.md']).toBe('y')
-    expect(blob.files['../bad.md']).toBeUndefined()
-  })
-
-  test('handles large blobs (~100 small files)', () => {
-    const files: Record<string, string> = {}
-    for (let i = 0; i < 100; i++) {
-      files[`learned-${i}.md`] = `fact ${i}\n`.repeat(50)
-    }
-    const bytes = encodePackBlob({ root: '# MEMORY', files })
-    expect(bytes.length).toBeGreaterThan(1000)
-    const blob = decodePackBlob(bytes)
-    expect(Object.keys(blob.files).length).toBe(100)
-    expect(blob.files['learned-50.md']).toContain('fact 50')
-  })
-})

package/src/memory/pack-gather.test.ts

@@ -1,110 +0,0 @@
-import { afterEach, beforeEach, expect, test } from 'bun:test'
-import { mkdtempSync, rmSync } from 'node:fs'
-import { mkdir, readFile, writeFile } from 'node:fs/promises'
-import { tmpdir } from 'node:os'
-import { join } from 'node:path'
-import { decodePackBlob, encodePackBlob } from './pack-blob'
-import { gatherAgentPack, gatherUserPack, writeAgentPack, writeUserPack } from './pack-gather'
-
-let tmp: string
-
-beforeEach(() => {
-  tmp = mkdtempSync(join(tmpdir(), 'pack-gather-'))
-})
-
-afterEach(() => {
-  rmSync(tmp, { recursive: true, force: true })
-})
-
-async function seed(rel: string, content: string): Promise<void> {
-  const full = join(tmp, rel)
-  await mkdir(join(full, '..'), { recursive: true })
-  await writeFile(full, content)
-}
-
-test('gatherAgentPack returns root + non-excluded files', async () => {
-  await seed('MEMORY.md', '# memory index')
-  await seed('agent/identity.md', 'identity body')
-  await seed('agent/persona.md', 'persona body')
-  await seed('agent/learned-foo.md', 'foo content')
-  await seed('agent/learned-bar.md', 'bar content')
-
-  const res = await gatherAgentPack(tmp)
-  expect(res.root).toBe('# memory index')
-  expect(res.files['learned-foo.md']).toBe('foo content')
-  expect(res.files['learned-bar.md']).toBe('bar content')
-  // Identity + persona excluded — they have their own slots
-  expect(res.files['identity.md']).toBeUndefined()
-  expect(res.files['persona.md']).toBeUndefined()
-})
-
-test('gatherUserPack returns profile.md as root + other user files', async () => {
-  await seed('user/profile.md', '# user profile')
-  await seed('user/operator-preferences.md', 'dark mode')
-  await seed('user/0g-hackathon.md', 'deadline')
-  const res = await gatherUserPack(tmp)
-  expect(res.root).toBe('# user profile')
-  expect(res.files['operator-preferences.md']).toBe('dark mode')
-  expect(res.files['0g-hackathon.md']).toBe('deadline')
-  // profile.md is the root, not in files
-  expect(res.files['profile.md']).toBeUndefined()
-})
-
-test('gather handles missing partition dir', async () => {
-  await seed('MEMORY.md', 'just an index')
-  const res = await gatherAgentPack(tmp)
-  expect(res.root).toBe('just an index')
-  expect(res.files).toEqual({})
-})
-
-test('gather handles missing root file', async () => {
-  await seed('agent/learned-x.md', 'content')
-  const res = await gatherAgentPack(tmp)
-  expect(res.root).toBe('')
-  expect(res.files['learned-x.md']).toBe('content')
-})
-
-test('gather skips non-md files + empty .md', async () => {
-  await seed('agent/learned-x.md', 'content')
-  await seed('agent/junk.txt', 'not md')
-  await seed('agent/empty.md', '')
-  const res = await gatherAgentPack(tmp)
-  expect(res.files['learned-x.md']).toBe('content')
-  expect(res.files['junk.txt']).toBeUndefined()
-  expect(res.files['empty.md']).toBeUndefined()
-})
-
-test('writeAgentPack reverses gatherAgentPack', async () => {
-  await seed('MEMORY.md', 'index v1')
-  await seed('agent/learned-a.md', 'a')
-  await seed('agent/learned-b.md', 'b')
-  const gathered = await gatherAgentPack(tmp)
-  const bytes = encodePackBlob(gathered)
-  const decoded = decodePackBlob(bytes)
-
-  const dst = mkdtempSync(join(tmpdir(), 'pack-write-'))
-  try {
-    await writeAgentPack(dst, decoded)
-    expect(await readFile(join(dst, 'MEMORY.md'), 'utf8')).toBe('index v1')
-    expect(await readFile(join(dst, 'agent', 'learned-a.md'), 'utf8')).toBe('a')
-    expect(await readFile(join(dst, 'agent', 'learned-b.md'), 'utf8')).toBe('b')
-  } finally {
-    rmSync(dst, { recursive: true, force: true })
-  }
-})
-
-test('writeUserPack creates user dir + profile + sibling files', async () => {
-  const dst = mkdtempSync(join(tmpdir(), 'pack-write-'))
-  try {
-    await writeUserPack(dst, {
-      v: 2,
-      root: '# profile',
-      files: { 'operator-preferences.md': 'prefs', 'hack-2026.md': 'deadline' },
-    })
-    expect(await readFile(join(dst, 'user', 'profile.md'), 'utf8')).toBe('# profile')
-    expect(await readFile(join(dst, 'user', 'operator-preferences.md'), 'utf8')).toBe('prefs')
-    expect(await readFile(join(dst, 'user', 'hack-2026.md'), 'utf8')).toBe('deadline')
-  } finally {
-    rmSync(dst, { recursive: true, force: true })
-  }
-})

package/src/memory/parser.test.ts

@@ -1,29 +0,0 @@
-import { expect, test } from 'bun:test'
-import { parseTopic, stringifyTopic } from './parser'
-
-const SAMPLE = `---
-name: user feedback
-description: elpabl0 prefers terse replies
-type: feedback
----
-User confirmed no wall-of-text responses in conversations.
-`
-
-test('parseTopic reads frontmatter + body', () => {
-  const topic = parseTopic('user', 'feedback-terse', SAMPLE)
-  expect(topic.frontmatter.name).toBe('user feedback')
-  expect(topic.frontmatter.type).toBe('feedback')
-  expect(topic.body.startsWith('User confirmed')).toBe(true)
-})
-
-test('stringifyTopic round-trips', () => {
-  const topic = parseTopic('user', 'feedback-terse', SAMPLE)
-  const out = stringifyTopic(topic)
-  const reparsed = parseTopic('user', 'feedback-terse', out)
-  expect(reparsed.frontmatter.name).toBe(topic.frontmatter.name)
-  expect(reparsed.body.trim()).toBe(topic.body.trim())
-})
-
-test('parseTopic throws on missing frontmatter', () => {
-  expect(() => parseTopic('user', 'broken', '# no frontmatter\ntext')).toThrow()
-})

package/src/memory/path-drift.test.ts

@@ -1,71 +0,0 @@
-import { afterAll, beforeAll, describe, expect, it } from 'bun:test'
-import { mkdirSync, mkdtempSync, readFileSync, rmSync, writeFileSync } from 'node:fs'
-import { tmpdir } from 'node:os'
-import { join } from 'node:path'
-import { makeMemoryReadTool } from './read-tool'
-import { makeMemorySaveTool } from './save-tool'
-
-// v0.23.0 Bundle A regression test.
-//
-// Gateway daemon writes restored memory under `${TMPDIR}/lyra-gateway/<id>/`
-// while `agentPaths.agent(id).memoryDir` resolves to `~/.lyra/agents/<id>/`.
-// Before the fix, memory.read / memory.save resolved against agentPaths
-// unconditionally, so files the gateway just restored to disk were invisible
-// to the brain and any new save landed in the wrong tree. The `agentDir`
-// override threads the gateway's true root through so both tools resolve
-// against the same path the runtime is using.
-describe('memory.read / memory.save honor agentDir override', () => {
-  let tmpAgentDir: string
-  const fakeAgentId = '0000000000000001'
-
-  beforeAll(() => {
-    tmpAgentDir = mkdtempSync(join(tmpdir(), 'memdrift-'))
-    mkdirSync(join(tmpAgentDir, 'memory', 'agent'), { recursive: true })
-    mkdirSync(join(tmpAgentDir, 'memory', 'user'), { recursive: true })
-    writeFileSync(
-      join(tmpAgentDir, 'memory', 'MEMORY.md'),
-      '# Memory\n\n- [identity](./agent/identity.md) seed\n',
-    )
-    writeFileSync(
-      join(tmpAgentDir, 'memory', 'agent', 'identity.md'),
-      '---\nname: identity\ntype: agent-identity\n---\nseeded from override path',
-    )
-  })
-
-  afterAll(() => {
-    if (tmpAgentDir) rmSync(tmpAgentDir, { recursive: true, force: true })
-  })
-
-  it('memory.read resolves against agentDir, not agentPaths', async () => {
-    const tool = makeMemoryReadTool({ agentId: fakeAgentId, agentDir: tmpAgentDir })
-    const r = await tool.handler({ name: 'identity' })
-    expect(r.ok).toBe(true)
-    if (r.ok) {
-      const data = r.data as { path: string; content: string }
-      expect(data.path).toBe('agent/identity.md')
-      expect(data.content).toContain('seeded from override path')
-    }
-  })
-
-  it('memory.save lands the file under agentDir', async () => {
-    const tool = makeMemorySaveTool({ agentId: fakeAgentId, agentDir: tmpAgentDir })
-    const r = await tool.handler({
-      name: 'override save test',
-      description: 'Test that save honors agentDir parameter',
-      type: 'user',
-      content: 'body content',
-    })
-    expect(r.ok).toBe(true)
-    if (r.ok) {
-      const data = r.data as { file: string }
-      expect(data.file).toBe('user/override-save-test.md')
-    }
-    const written = readFileSync(
-      join(tmpAgentDir, 'memory', 'user', 'override-save-test.md'),
-      'utf8',
-    )
-    expect(written).toContain('body content')
-    const index = readFileSync(join(tmpAgentDir, 'memory', 'MEMORY.md'), 'utf8')
-    expect(index).toContain('user/override-save-test.md')
-  })
-})

package/src/memory/read-tool-fallback.test.ts

@@ -1,54 +0,0 @@
-import { afterAll, beforeAll, describe, expect, it } from 'bun:test'
-import { mkdirSync, mkdtempSync, rmSync, writeFileSync } from 'node:fs'
-import { tmpdir } from 'node:os'
-import { join } from 'node:path'
-import { agentPaths } from '../paths'
-import { makeMemoryReadTool } from './read-tool'
-
-describe('memory.read token-overlap fallback', () => {
-  let tmpRoot: string
-  const fakeAgentId = '0000000000000001'
-
-  beforeAll(() => {
-    tmpRoot = mkdtempSync(join(tmpdir(), 'memread-fallback-'))
-    process.env.LYRA_HOME = tmpRoot
-    const paths = agentPaths.agent(fakeAgentId)
-    mkdirSync(paths.memoryDir, { recursive: true })
-    mkdirSync(join(paths.memoryDir, 'user'), { recursive: true })
-    writeFileSync(
-      paths.memoryIndex,
-      `# Memory
-
-- [Tool test session 2026-05-12](./user/tool-test-session.md) — Full tool verification
-- [Operator profile](./user/operator-profile.md) — Operator known as elpabl0
-`,
-    )
-    writeFileSync(
-      join(paths.memoryDir, 'user/tool-test-session.md'),
-      '---\nname: Tool test session\ntype: user\n---\nContent.',
-    )
-  })
-
-  afterAll(() => {
-    if (tmpRoot) rmSync(tmpRoot, { recursive: true, force: true })
-  })
-
-  it('paraphrased query finds entry via token-overlap', async () => {
-    const tool = makeMemoryReadTool({ agentId: fakeAgentId })
-    const r = await tool.handler({ name: 'tool test run' })
-    expect(r.ok).toBe(true)
-    if (r.ok) expect((r.data as { path: string }).path).toContain('tool-test-session')
-  })
-
-  it('unrelated query returns not-found', async () => {
-    const tool = makeMemoryReadTool({ agentId: fakeAgentId })
-    const r = await tool.handler({ name: 'banana cake unrelated' })
-    expect(r.ok).toBe(false)
-  })
-
-  it('exact title match still works', async () => {
-    const tool = makeMemoryReadTool({ agentId: fakeAgentId })
-    const r = await tool.handler({ name: 'Tool test session' })
-    expect(r.ok).toBe(true)
-  })
-})