lyra-core 0.1.2 → 0.1.11

package/src/sandbox/sandbox.test.ts

@@ -1,386 +0,0 @@
-import { describe, expect, test } from 'bun:test'
-import { makeSandboxBackend } from './factory'
-import { buildBwrapArgs } from './linux'
-import { LocalBackend } from './local'
-import { MacOSSandboxExecBackend } from './macos'
-import { buildSeatbeltProfile } from './seatbelt-profile'
-
-describe('LocalBackend (passthrough)', () => {
-  test('returns spawn request unchanged', async () => {
-    const b = new LocalBackend()
-    const req = {
-      command: '/bin/sh',
-      args: ['-c', 'echo ok'],
-      options: { cwd: '/tmp' },
-    }
-    const out = await b.wrapSpawn(req)
-    expect(out.command).toBe('/bin/sh')
-    expect(out.args).toEqual(['-c', 'echo ok'])
-    expect(out.options).toEqual({ cwd: '/tmp' })
-  })
-
-  test('mode + label expose correct identifiers', () => {
-    const b = new LocalBackend()
-    expect(b.mode).toBe('none')
-    expect(b.label).toBe('none')
-  })
-})
-
-describe('buildSeatbeltProfile', () => {
-  test('emits a deny-default profile that explicitly allows agentDir + workspaceRoot', () => {
-    const profile = buildSeatbeltProfile({
-      agentDir: '/Users/test/.lyra/agents/abc',
-      workspaceRoot: '/Users/test/Documents/proj',
-      homedir: '/Users/test',
-    })
-    expect(profile).toContain('(deny default)')
-    expect(profile).toContain('(allow file-write* (subpath "/Users/test/.lyra/agents/abc"))')
-    expect(profile).toContain('(allow file-write* (subpath "/Users/test/Documents/proj"))')
-  })
-
-  test('explicitly denies credential paths for both reads and writes', () => {
-    const profile = buildSeatbeltProfile({
-      agentDir: '/Users/test/.lyra/agents/abc',
-      workspaceRoot: '/Users/test/work',
-      homedir: '/Users/test',
-    })
-    expect(profile).toContain('(deny file-write* (subpath "/Users/test/.ssh"))')
-    expect(profile).toContain('(deny file-write* (subpath "/Users/test/.aws"))')
-    expect(profile).toContain('(deny file-write* (subpath "/Users/test/Library/Keychains"))')
-    expect(profile).toContain('(deny file-write* (subpath "/Users/test/.config/gcloud"))')
-    expect(profile).toContain('(deny file-write* (subpath "/Users/test/.lyra"))')
-    // Reads of credential dirs blocked too — `cat ~/.ssh/id_rsa` should fail
-    expect(profile).toContain('(deny file-read* (subpath "/Users/test/.ssh"))')
-    expect(profile).toContain('(deny file-read* (subpath "/Users/test/.aws"))')
-    expect(profile).toContain('(deny file-read* (subpath "/Users/test/Library/Keychains"))')
-    expect(profile).toContain('(deny file-read* (subpath "/Users/test/.config/gcloud"))')
-  })
-
-  test('allows process-fork + process-exec + network', () => {
-    const profile = buildSeatbeltProfile({
-      agentDir: '/a',
-      workspaceRoot: '/b',
-      homedir: '/h',
-    })
-    expect(profile).toContain('(allow process-fork)')
-    expect(profile).toContain('(allow process-exec)')
-    expect(profile).toContain('(allow network*)')
-    expect(profile).toContain('(allow file-read*)')
-  })
-
-  test('allows /tmp/lyra-* + /var/folders for temp dirs', () => {
-    const profile = buildSeatbeltProfile({
-      agentDir: '/a',
-      workspaceRoot: '/b',
-      homedir: '/h',
-    })
-    expect(profile).toContain('(allow file-write* (regex #"^/tmp/lyra-"))')
-    expect(profile).toContain('(allow file-write* (regex #"^/private/tmp/lyra-"))')
-    expect(profile).toContain('(allow file-write* (subpath "/var/folders"))')
-  })
-
-  test('respects extraWriteAllow + extraWriteDeny', () => {
-    const profile = buildSeatbeltProfile({
-      agentDir: '/a',
-      workspaceRoot: '/b',
-      homedir: '/h',
-      extraWriteAllow: ['/tmp/lyra-test-sandbox-XYZ'],
-      extraWriteDeny: ['/Users/h/Documents/sensitive'],
-    })
-    expect(profile).toContain('(allow file-write* (subpath "/tmp/lyra-test-sandbox-XYZ"))')
-    expect(profile).toContain('(deny file-write* (subpath "/Users/h/Documents/sensitive"))')
-  })
-
-  test('escapes embedded double quotes + backslashes in paths', () => {
-    const profile = buildSeatbeltProfile({
-      agentDir: '/path/with"quote',
-      workspaceRoot: '/path\\with\\backslash',
-      homedir: '/h',
-    })
-    expect(profile).toContain('/path/with\\"quote')
-    expect(profile).toContain('/path\\\\with\\\\backslash')
-  })
-
-  // Property-style fuzz of the escape function: every input must produce a
-  // syntactically valid (subpath "X") string — no unescaped backslashes/quotes/
-  // newlines that would prematurely close the literal or break SBPL parsing.
-  // The actual exploit risk is near-zero (operators don't trick themselves) but
-  // the cost of a clean test is one regex check per scenario.
-  test('escapes pathological inputs cleanly: nested quotes, sbpl operators, unicode', () => {
-    const cases: Array<[string, string]> = [
-      // Bare close-paren that could escape an SBPL form (must remain inside the literal)
-      ['/tmp/test)', '/tmp/test)'],
-      // Embedded "(allow file-write*" attempt to inject a new rule
-      [
-        '/tmp/" (allow file-write* (subpath "/etc"))',
-        '/tmp/\\" (allow file-write* (subpath \\"/etc\\"))',
-      ],
-      // Nested quotes
-      ['/path"with"many"quotes', '/path\\"with\\"many\\"quotes'],
-      // Backslash-quote pair
-      ['/x\\"y', '/x\\\\\\"y'],
-      // Carriage return / form feed
-      ['/x\ny', '/x y'], // newline becomes space
-      // Unicode emoji (valid path component on macOS)
-      ['/Users/alice/\u{1F600}-projects', '/Users/alice/\u{1F600}-projects'],
-      // SBPL pattern delimiters embedded
-      ['/path/#(literal)', '/path/#(literal)'],
-    ]
-    for (const [input, expectedFragment] of cases) {
-      const profile = buildSeatbeltProfile({
-        agentDir: input,
-        workspaceRoot: '/w',
-        homedir: '/h',
-      })
-      expect(profile).toContain(`(subpath "${expectedFragment}")`)
-      // After escape + concat, no unbalanced double quote inside (subpath "..."):
-      // every non-escaped " inside the literal would prematurely close it.
-      const subpathPattern = /\(subpath\s+"((?:\\.|[^"\\])*)"\)/g
-      // Strip well-formed (subpath "...") instances; remaining text shouldn't
-      // contain a stray (subpath ".. " missing its terminator.
-      const stripped = profile.replace(subpathPattern, '<<subpath>>')
-      expect(stripped).not.toContain('(subpath "')
-    }
-  })
-
-  test('re-allows agentDir AFTER the broad ~/.lyra deny so lyra state stays writable', () => {
-    const profile = buildSeatbeltProfile({
-      agentDir: '/Users/test/.lyra/agents/abc',
-      workspaceRoot: '/w',
-      homedir: '/Users/test',
-    })
-    const agentAllowIdx = profile.lastIndexOf(
-      '(allow file-write* (subpath "/Users/test/.lyra/agents/abc"))',
-    )
-    const lyraDenyIdx = profile.indexOf('(deny file-write* (subpath "/Users/test/.lyra"))')
-    expect(agentAllowIdx).toBeGreaterThan(-1)
-    expect(lyraDenyIdx).toBeGreaterThan(-1)
-    expect(agentAllowIdx).toBeGreaterThan(lyraDenyIdx)
-  })
-})
-
-describe('MacOSSandboxExecBackend', () => {
-  // sandbox-exec is macOS-only; skip these on Linux CI but assert constructor
-  // there too.
-  if (process.platform !== 'darwin') {
-    test('skipped on non-darwin', () => {
-      expect(true).toBe(true)
-    })
-    return
-  }
-
-  test('constructs with valid opts on darwin', () => {
-    const b = new MacOSSandboxExecBackend({
-      agentDir: '/tmp/lyra-test-agent',
-      workspaceRoot: '/tmp',
-      homedir: process.env.HOME ?? '/tmp',
-    })
-    expect(b.mode).toBe('os')
-    expect(b.label).toBe('os:darwin')
-    const profile = b.getProfile()
-    expect(profile).toContain('(deny default)')
-    expect(profile).toContain('(allow file-write* (subpath "/tmp/lyra-test-agent"))')
-  })
-
-  test('wrapSpawn prepends sandbox-exec + profile to argv', async () => {
-    const b = new MacOSSandboxExecBackend({
-      agentDir: '/tmp/lyra-test-agent',
-      workspaceRoot: '/tmp',
-      homedir: process.env.HOME ?? '/tmp',
-    })
-    const out = await b.wrapSpawn({
-      command: '/bin/sh',
-      args: ['-c', 'echo hi'],
-      options: { cwd: '/tmp' },
-    })
-    expect(out.command).toBe('/usr/bin/sandbox-exec')
-    expect(out.args[0]).toBe('-p')
-    expect(typeof out.args[1]).toBe('string')
-    expect(out.args[1]?.includes('(deny default)')).toBe(true)
-    expect(out.args.slice(2)).toEqual(['/bin/sh', '-c', 'echo hi'])
-    expect(out.options).toEqual({ cwd: '/tmp' })
-  })
-})
-
-describe('makeSandboxBackend factory', () => {
-  test('mode=none returns LocalBackend on any platform', () => {
-    const b = makeSandboxBackend({
-      mode: 'none',
-      agentDir: '/a',
-      workspaceRoot: '/w',
-      homedir: '/h',
-      platform: 'darwin',
-    })
-    expect(b.mode).toBe('none')
-    const b2 = makeSandboxBackend({
-      mode: 'none',
-      agentDir: '/a',
-      workspaceRoot: '/w',
-      homedir: '/h',
-      platform: 'linux',
-    })
-    expect(b2.mode).toBe('none')
-  })
-
-  test('mode=docker constructs DockerBackend if a runtime exists, else falls back', () => {
-    let warned = ''
-    const b = makeSandboxBackend({
-      mode: 'docker',
-      agentDir: '/a',
-      workspaceRoot: '/w',
-      homedir: '/h',
-      platform: 'darwin',
-      warn: m => {
-        warned = m
-      },
-    })
-    // On a developer machine with docker/podman installed, mode === 'docker'.
-    // On a stripped CI box with neither, factory falls back to LocalBackend
-    // and emits a warning. Either is acceptable for this test.
-    if (b.mode === 'docker') {
-      expect(b.label.startsWith('docker:') || b.label.startsWith('podman:')).toBe(true)
-    } else {
-      expect(b.mode).toBe('none')
-      expect(warned).toContain('docker')
-    }
-  })
-
-  test('mode=docker accepts resource caps + network/runtime overrides without crashing', () => {
-    // Wide-input smoke test: factory should accept all DockerBackend opts and
-    // construct (or fall back) without throwing, regardless of runtime presence.
-    let warned = ''
-    const b = makeSandboxBackend({
-      mode: 'docker',
-      agentDir: '/a',
-      workspaceRoot: '/w',
-      homedir: '/h',
-      platform: 'darwin',
-      dockerCpu: 1.5,
-      dockerMemoryMb: 4096,
-      dockerDiskMb: 51200,
-      dockerNoNetwork: true,
-      dockerMountWorkspace: false,
-      warn: m => {
-        warned = m
-      },
-    })
-    if (b.mode === 'docker') {
-      expect(b.label.startsWith('docker:') || b.label.startsWith('podman:')).toBe(true)
-    } else {
-      expect(b.mode).toBe('none')
-      expect(warned).toContain('docker')
-    }
-  })
-
-  test('mode=os on linux constructs bubblewrap backend if bwrap exists, else falls back', () => {
-    let warned = ''
-    const b = makeSandboxBackend({
-      mode: 'os',
-      agentDir: '/tmp/lyra-agent',
-      workspaceRoot: '/tmp',
-      homedir: '/root',
-      platform: 'linux',
-      warn: m => {
-        warned = m
-      },
-    })
-    // On a Linux machine with bubblewrap installed (apt install bubblewrap),
-    // mode === 'os' + label 'os:linux'. On macOS or stripped Linux without
-    // bwrap, factory falls back to LocalBackend with a warning. Either is
-    // acceptable; this test pins the contract, not the platform.
-    if (b.mode === 'os') {
-      expect(b.label).toBe('os:linux')
-    } else {
-      expect(b.mode).toBe('none')
-      expect(warned).toContain('bubblewrap')
-    }
-  })
-
-  test('mode=os on unknown platform falls back to LocalBackend with warning', () => {
-    let warned = ''
-    const b = makeSandboxBackend({
-      mode: 'os',
-      agentDir: '/a',
-      workspaceRoot: '/w',
-      homedir: '/h',
-      platform: 'aix',
-      warn: m => {
-        warned = m
-      },
-    })
-    expect(b.mode).toBe('none')
-    expect(warned).toContain('aix')
-  })
-
-  if (process.platform === 'darwin') {
-    test('mode=os on darwin returns MacOSSandboxExecBackend', () => {
-      const b = makeSandboxBackend({
-        mode: 'os',
-        agentDir: '/tmp/lyra-test-agent',
-        workspaceRoot: '/tmp',
-        homedir: process.env.HOME ?? '/tmp',
-      })
-      expect(b.mode).toBe('os')
-      expect(b.label).toBe('os:darwin')
-    })
-  }
-})
-
-describe('buildBwrapArgs (Linux profile)', () => {
-  test('binds agentDir + workspaceRoot writable', () => {
-    const args = buildBwrapArgs({
-      agentDir: '/home/u/.lyra/agents/abc',
-      workspaceRoot: '/home/u/proj',
-      homedir: '/home/u',
-    })
-    expect(args).toContain('--bind')
-    expect(args.join(' ')).toContain('/home/u/.lyra/agents/abc /home/u/.lyra/agents/abc')
-    expect(args.join(' ')).toContain('/home/u/proj /home/u/proj')
-  })
-
-  test('blocks credential dirs via tmpfs overlay', () => {
-    const args = buildBwrapArgs({
-      agentDir: '/a',
-      workspaceRoot: '/w',
-      homedir: '/home/u',
-    })
-    const argString = args.join(' ')
-    expect(argString).toContain('--tmpfs /home/u/.ssh')
-    expect(argString).toContain('--tmpfs /home/u/.aws')
-    expect(argString).toContain('--tmpfs /home/u/.config/gcloud')
-    expect(argString).toContain('--tmpfs /home/u/.gnupg')
-  })
-
-  test('reads of root are allowed via --ro-bind', () => {
-    const args = buildBwrapArgs({ agentDir: '/a', workspaceRoot: '/w', homedir: '/h' })
-    expect(args.slice(0, 3)).toEqual(['--ro-bind', '/', '/'])
-  })
-
-  test('shares network but unshares everything else', () => {
-    const args = buildBwrapArgs({ agentDir: '/a', workspaceRoot: '/w', homedir: '/h' })
-    expect(args).toContain('--unshare-all')
-    expect(args).toContain('--share-net')
-    expect(args).toContain('--die-with-parent')
-    expect(args).toContain('--new-session')
-  })
-
-  test('respects extraWriteAllow for sandbox dirs', () => {
-    const args = buildBwrapArgs({
-      agentDir: '/a',
-      workspaceRoot: '/w',
-      homedir: '/h',
-      extraWriteAllow: ['/tmp/lyra-test-sandbox-XYZ'],
-    })
-    expect(args.join(' ')).toContain('--bind /tmp/lyra-test-sandbox-XYZ /tmp/lyra-test-sandbox-XYZ')
-  })
-
-  test('respects extraWriteDeny via tmpfs', () => {
-    const args = buildBwrapArgs({
-      agentDir: '/a',
-      workspaceRoot: '/w',
-      homedir: '/h',
-      extraWriteDeny: ['/home/u/secrets'],
-    })
-    expect(args.join(' ')).toContain('--tmpfs /home/u/secrets')
-  })
-})

package/src/skills/scanner.test.ts

@@ -1,137 +0,0 @@
-import { afterEach, beforeEach, describe, expect, it } from 'bun:test'
-import { mkdir, mkdtemp, rm, writeFile } from 'node:fs/promises'
-import { tmpdir } from 'node:os'
-import { join } from 'node:path'
-import { parseFrontmatter, scanSkills } from './scanner'
-
-let scratch: string
-
-beforeEach(async () => {
-  scratch = await mkdtemp(join(tmpdir(), 'lyra-skills-scanner-'))
-})
-
-afterEach(async () => {
-  await rm(scratch, { recursive: true, force: true })
-})
-
-async function plant(absDir: string, fm: string, body = '# body\n'): Promise<void> {
-  await mkdir(absDir, { recursive: true })
-  await writeFile(join(absDir, 'SKILL.md'), `${fm}\n\n${body}`)
-}
-
-describe('parseFrontmatter', () => {
-  it('parses top-level fields', () => {
-    const fm = parseFrontmatter('---\nname: foo\ndescription: hi\nversion: 1.0.0\n---\n\nbody')
-    expect(fm.name).toBe('foo')
-    expect(fm.description).toBe('hi')
-    expect(fm.version).toBe('1.0.0')
-  })
-
-  it('parses metadata.filePattern + metadata.bashPattern', () => {
-    const raw =
-      '---\nname: dogfood\ndescription: tests\nmetadata:\n  filePattern: "*.test.ts,*.spec.ts"\n  bashPattern: "playwright|jest"\n---\n\nbody'
-    const fm = parseFrontmatter(raw)
-    expect(fm.filePattern).toBe('*.test.ts,*.spec.ts')
-    expect(fm.bashPattern).toBe('playwright|jest')
-  })
-
-  it('parses argument-hint as argumentHint', () => {
-    const fm = parseFrontmatter('---\nname: c\nargument-hint: <message>\n---\n\nbody')
-    expect(fm.argumentHint).toBe('<message>')
-  })
-
-  it('returns empty object for non-frontmatter content', () => {
-    expect(parseFrontmatter('# just a heading\nblah')).toEqual({})
-  })
-})
-
-describe('scanSkills', () => {
-  it('finds lyra + claude-code skills + claude plugin cache layouts', async () => {
-    const lyraSkillsRoot = join(scratch, '.lyra', 'skills')
-    const claudeSkillsRoot = join(scratch, '.claude', 'skills')
-    const claudePluginsCacheRoot = join(scratch, '.claude', 'plugins', 'cache')
-
-    await plant(join(lyraSkillsRoot, 'dogfood'), '---\nname: dogfood\ndescription: lyra skill\n---')
-    await plant(
-      join(claudeSkillsRoot, 'commit'),
-      '---\nname: commit\ndescription: claude skill\n---',
-    )
-    await plant(
-      join(claudePluginsCacheRoot, 'awesome', 'pdf', '1.0.0', 'skills', 'extract'),
-      '---\nname: extract\ndescription: pdf skill\n---',
-    )
-    // Plugin with direct SKILL.md (no skills/ subdir)
-    await plant(
-      join(claudePluginsCacheRoot, 'awesome', 'docx', '1.0.0'),
-      '---\nname: docx\ndescription: docx skill\n---',
-    )
-
-    const skills = await scanSkills({
-      lyraSkillsRoot,
-      lyraPluginsRoot: join(scratch, '.lyra', 'plugins'),
-      claudeSkillsRoot,
-      claudePluginsCacheRoot,
-      importsClaudeCode: true,
-    })
-    const ids = skills.map(s => s.id).sort()
-    expect(ids).toContain('lyra:dogfood')
-    expect(ids).toContain('claude-code:commit')
-    expect(ids).toContain('claude-plugin:awesome:pdf:extract')
-    expect(ids).toContain('claude-plugin:awesome:docx')
-    const pdf = skills.find(s => s.id === 'claude-plugin:awesome:pdf:extract')
-    expect(pdf?.pluginCoord?.marketplace).toBe('awesome')
-    expect(pdf?.pluginCoord?.plugin).toBe('pdf')
-    expect(pdf?.pluginCoord?.version).toBe('1.0.0')
-  })
-
-  it('skips claude paths when imports.claudeCode is false', async () => {
-    const claudeSkillsRoot = join(scratch, '.claude', 'skills')
-    await plant(join(claudeSkillsRoot, 'foo'), '---\nname: foo\ndescription: x\n---')
-    const skills = await scanSkills({
-      lyraSkillsRoot: join(scratch, 'doesnotexist'),
-      lyraPluginsRoot: join(scratch, 'doesnotexist'),
-      claudeSkillsRoot,
-      claudePluginsCacheRoot: join(scratch, 'doesnotexist'),
-      importsClaudeCode: false,
-    })
-    expect(skills).toEqual([])
-  })
-
-  it('discovers lyra-plugin skills', async () => {
-    const lyraPluginsRoot = join(scratch, '.lyra', 'plugins')
-    await plant(
-      join(lyraPluginsRoot, 'system', 'skills', 'sweep'),
-      '---\nname: sweep\ndescription: plugin-sourced skill\n---',
-    )
-    const skills = await scanSkills({
-      lyraSkillsRoot: join(scratch, 'doesnotexist'),
-      lyraPluginsRoot,
-      claudeSkillsRoot: join(scratch, 'doesnotexist'),
-      claudePluginsCacheRoot: join(scratch, 'doesnotexist'),
-      importsClaudeCode: false,
-    })
-    expect(skills.map(s => s.id)).toEqual(['lyra-plugin:system:sweep'])
-  })
-})
-
-describe('skills without YAML frontmatter', () => {
-  it('still surfaces skills whose SKILL.md has no frontmatter (fallback to dir name + first body line)', async () => {
-    const lyraSkillsRoot = join(scratch, '.lyra', 'skills')
-    await mkdir(join(lyraSkillsRoot, 'no-fm'), { recursive: true })
-    await writeFile(
-      join(lyraSkillsRoot, 'no-fm', 'SKILL.md'),
-      '# no-fm skill\n\nA skill without yaml frontmatter that should still be discoverable.\n',
-    )
-    const skills = await scanSkills({
-      lyraSkillsRoot,
-      lyraPluginsRoot: join(scratch, 'doesnotexist'),
-      claudeSkillsRoot: join(scratch, 'doesnotexist'),
-      claudePluginsCacheRoot: join(scratch, 'doesnotexist'),
-      importsClaudeCode: false,
-    })
-    const found = skills.find(s => s.id === 'lyra:no-fm')
-    expect(found).toBeDefined()
-    expect(found!.name).toBe('no-fm')
-    expect(found!.description).toContain('A skill without yaml frontmatter')
-  })
-})

package/src/skills/triggers.test.ts

@@ -1,77 +0,0 @@
-import { describe, expect, it } from 'bun:test'
-import { matchBashPattern, matchFilePattern, matchTriggers } from './triggers'
-import type { SkillRef } from './types'
-
-describe('matchFilePattern', () => {
-  it('matches single glob against basename', () => {
-    expect(matchFilePattern('*.test.ts', '/tmp/foo.test.ts')).toBe(true)
-    expect(matchFilePattern('*.test.ts', '/tmp/foo.ts')).toBe(false)
-  })
-  it('matches comma-separated globs', () => {
-    expect(matchFilePattern('*.test.ts,*.spec.ts', '/tmp/foo.spec.ts')).toBe(true)
-    expect(matchFilePattern('*.test.ts,*.spec.ts', '/tmp/foo.md')).toBe(false)
-  })
-})
-
-describe('matchBashPattern', () => {
-  it('matches regex anywhere in command', () => {
-    expect(matchBashPattern('playwright|jest', 'bun run jest tests/')).toBe(true)
-    expect(matchBashPattern('playwright|jest', 'go test ./...')).toBe(false)
-  })
-  it('returns false on invalid regex', () => {
-    expect(matchBashPattern('[invalid', 'foo')).toBe(false)
-  })
-})
-
-function ref(filePattern?: string, bashPattern?: string): SkillRef {
-  return {
-    id: 'lyra:t',
-    name: 't',
-    description: '',
-    path: '/tmp/SKILL.md',
-    source: 'lyra',
-    frontmatter: {
-      name: 't',
-      description: '',
-      ...(filePattern ? { filePattern } : {}),
-      ...(bashPattern ? { bashPattern } : {}),
-    },
-  }
-}
-
-describe('matchTriggers', () => {
-  it('matches fs.write paths against filePattern', () => {
-    const skills = [ref('*.test.ts')]
-    const out = matchTriggers(
-      { name: 'fs.write', args: { path: '/tmp/foo.test.ts', text: 'x' } },
-      skills,
-    )
-    expect(out).toHaveLength(1)
-    expect(out[0]!.reason).toBe('filePattern')
-  })
-
-  it('matches shell.run commands against bashPattern', () => {
-    const skills = [ref(undefined, 'jest')]
-    const out = matchTriggers(
-      { name: 'shell.run', args: { command: 'bun run jest tests/' } },
-      skills,
-    )
-    expect(out).toHaveLength(1)
-    expect(out[0]!.reason).toBe('bashPattern')
-  })
-
-  it('returns empty when nothing matches', () => {
-    const skills = [ref('*.spec.ts'), ref(undefined, 'rspec')]
-    const out = matchTriggers(
-      { name: 'fs.write', args: { path: '/tmp/foo.md', text: 'x' } },
-      skills,
-    )
-    expect(out).toEqual([])
-  })
-
-  it('ignores non-matching tool names', () => {
-    const skills = [ref('*.md')]
-    const out = matchTriggers({ name: 'memory.save', args: { path: '/tmp/foo.md' } }, skills)
-    expect(out).toEqual([])
-  })
-})

package/src/storage/encryption.test.ts

@@ -1,30 +0,0 @@
-import { describe, expect, test } from 'bun:test'
-import { decrypt, encrypt, packEnvelope, unpackEnvelope } from './encryption'
-
-describe('encryption', () => {
-  test('round-trips a short message', () => {
-    const plaintext = new TextEncoder().encode('hello lyra')
-    const env = encrypt(plaintext, 'testpass1234')
-    const out = decrypt(env, 'testpass1234')
-    expect(new TextDecoder().decode(out)).toBe('hello lyra')
-  })
-
-  test('wrong passphrase fails', () => {
-    const env = encrypt(new TextEncoder().encode('secret'), 'right-password')
-    expect(() => decrypt(env, 'wrong-password')).toThrow()
-  })
-
-  test('packs + unpacks round-trip', () => {
-    const env = encrypt(new TextEncoder().encode('pack me'), 'pw')
-    const packed = packEnvelope(env)
-    const unpacked = unpackEnvelope(packed)
-    expect(Array.from(unpacked.salt)).toEqual(Array.from(env.salt))
-    expect(Array.from(unpacked.iv)).toEqual(Array.from(env.iv))
-    expect(Array.from(unpacked.tag)).toEqual(Array.from(env.tag))
-    expect(Array.from(unpacked.ciphertext)).toEqual(Array.from(env.ciphertext))
-  })
-
-  test('unpack throws on truncated input', () => {
-    expect(() => unpackEnvelope(new Uint8Array(20))).toThrow('envelope shorter than header')
-  })
-})

package/src/storage/sqlite.test.ts

@@ -1,29 +0,0 @@
-import { describe, expect, it } from 'bun:test'
-import { SqliteStorage } from './sqlite'
-
-const enc = (s: string) => new TextEncoder().encode(s)
-const dec = (b: Uint8Array | null) => (b ? new TextDecoder().decode(b) : null)
-
-describe('SqliteStorage', () => {
-  it('round-trips a content-addressed blob', async () => {
-    const s = new SqliteStorage(':memory:')
-    const cid = await s.putBlob(enc('hello sui'))
-    expect(cid).toMatch(/^0x[0-9a-f]{64}$/)
-    // Same bytes -> same CID (content addressed, idempotent).
-    expect(await s.putBlob(enc('hello sui'))).toBe(cid)
-    expect(dec(await s.getBlob(cid))).toBe('hello sui')
-    expect(await s.getBlob('0xdeadbeef')).toBeNull()
-    s.close()
-  })
-
-  it('stores + overwrites KV and appends to the log', async () => {
-    const s = new SqliteStorage(':memory:')
-    await s.putKV('stream1', 'k', enc('v1'))
-    await s.putKV('stream1', 'k', enc('v2'))
-    expect(dec(await s.getKV('stream1', 'k'))).toBe('v2')
-    expect(await s.getKV('stream1', 'missing')).toBeNull()
-    const cid = await s.appendLog('stream1', enc('entry'))
-    expect(cid).toMatch(/^0x[0-9a-f]{64}$/)
-    s.close()
-  })
-})