bazilion 0.0.0 → 0.1.0

package/apps/daemon/test/runtime/retry.test.ts

@@ -1,191 +0,0 @@
-import { describe, expect, test, vi } from 'vitest'
-import { isRetryableError, withRetry } from '../../src/runtime/providers/retry.ts'
-import type {
-  Provider,
-  ProviderRequest,
-  ProviderResponse,
-} from '../../src/runtime/providers/types.ts'
-
-function okResponse(text = 'ok'): ProviderResponse {
-  return { content: text, toolCalls: [], stopReason: 'stop' }
-}
-
-function scripted(outcomes: Array<() => Promise<ProviderResponse>>): Provider {
-  let i = 0
-  return {
-    name: 'mock',
-    async chat(_req: ProviderRequest) {
-      const fn = outcomes[i++]
-      if (!fn) throw new Error('scripted provider: out of outcomes')
-      return await fn()
-    },
-  }
-}
-
-const baseReq: ProviderRequest = { model: 'm', messages: [] }
-
-describe('isRetryableError', () => {
-  test('allows transient 5xx / rate-limit / socket markers', () => {
-    expect(isRetryableError(new Error('Codex error: {"type":"server_error"}'))).toBe(true)
-    expect(isRetryableError(new Error('rate_limit_exceeded'))).toBe(true)
-    expect(isRetryableError(new Error('overloaded_error: too many requests'))).toBe(true)
-    expect(isRetryableError(new Error('fetch failed'))).toBe(true)
-    expect(isRetryableError(new Error('ECONNRESET'))).toBe(true)
-    expect(isRetryableError(new Error('status 503 service_unavailable'))).toBe(true)
-  })
-
-  test('blocks auth / invalid-request / context-overflow / 4xx', () => {
-    expect(isRetryableError(new Error('invalid_api_key'))).toBe(false)
-    expect(isRetryableError(new Error('authentication failed'))).toBe(false)
-    expect(isRetryableError(new Error('status 401 unauthorized'))).toBe(false)
-    expect(isRetryableError(new Error('context_length_exceeded'))).toBe(false)
-    expect(isRetryableError(new Error('model_not_found'))).toBe(false)
-    expect(isRetryableError(new Error('insufficient_quota'))).toBe(false)
-  })
-
-  test('deny-list wins when both markers appear', () => {
-    // A 429 that also mentions authentication: don't retry — the auth
-    // failure is the load-bearing signal.
-    expect(isRetryableError(new Error('status 429 after authentication failure'))).toBe(false)
-  })
-
-  test('unknown errors are not retried by default', () => {
-    expect(isRetryableError(new Error('random client bug'))).toBe(false)
-    expect(isRetryableError(new Error(''))).toBe(false)
-  })
-})
-
-describe('withRetry', () => {
-  test('passes through on first-try success', async () => {
-    const p = withRetry(scripted([() => Promise.resolve(okResponse('hi'))]))
-    const res = await p.chat(baseReq)
-    expect(res.content).toBe('hi')
-  })
-
-  test('recovers after a transient server_error', async () => {
-    const onRetry = vi.fn()
-    const p = withRetry(
-      scripted([
-        () => Promise.reject(new Error('Codex error: server_error')),
-        () => Promise.resolve(okResponse('recovered')),
-      ]),
-      { initialDelayMs: 1, onRetry },
-    )
-    const res = await p.chat(baseReq)
-    expect(res.content).toBe('recovered')
-    expect(onRetry).toHaveBeenCalledTimes(1)
-    expect(onRetry.mock.calls[0]?.[0]?.attempt).toBe(1)
-  })
-
-  test('gives up after maxRetries + 1 attempts', async () => {
-    let calls = 0
-    const p = withRetry(
-      {
-        name: 'mock',
-        async chat() {
-          calls++
-          throw new Error('rate_limit')
-        },
-      },
-      { maxRetries: 2, initialDelayMs: 1 },
-    )
-    await expect(p.chat(baseReq)).rejects.toThrow(/rate_limit/)
-    expect(calls).toBe(3)
-  })
-
-  test('does not retry non-retryable errors', async () => {
-    let calls = 0
-    const p = withRetry(
-      {
-        name: 'mock',
-        async chat() {
-          calls++
-          throw new Error('invalid_api_key')
-        },
-      },
-      { maxRetries: 5, initialDelayMs: 1 },
-    )
-    await expect(p.chat(baseReq)).rejects.toThrow(/invalid_api_key/)
-    expect(calls).toBe(1)
-  })
-
-  test('does not retry after text has streamed', async () => {
-    // First attempt streams a token, then errors — retry would duplicate the
-    // token in the UI, so the wrapper must surface the error as-is.
-    let calls = 0
-    const p = withRetry(
-      {
-        name: 'mock',
-        async chat(req) {
-          calls++
-          req.onDelta?.('partial...')
-          throw new Error('server_error: stream broke mid-way')
-        },
-      },
-      { maxRetries: 3, initialDelayMs: 1 },
-    )
-    const deltas: string[] = []
-    await expect(p.chat({ ...baseReq, onDelta: (d) => deltas.push(d) })).rejects.toThrow(
-      /server_error/,
-    )
-    expect(calls).toBe(1)
-    expect(deltas).toEqual(['partial...'])
-  })
-
-  test('aborts immediately if the caller signal is already aborted', async () => {
-    const ac = new AbortController()
-    ac.abort()
-    let calls = 0
-    const p = withRetry(
-      {
-        name: 'mock',
-        async chat() {
-          calls++
-          throw new Error('server_error')
-        },
-      },
-      { initialDelayMs: 1 },
-    )
-    await expect(p.chat({ ...baseReq, signal: ac.signal })).rejects.toThrow()
-    expect(calls).toBe(1) // one attempt, then abort check skips the retry
-  })
-
-  test('abort during backoff surfaces the original error', async () => {
-    const ac = new AbortController()
-    const p = withRetry(
-      {
-        name: 'mock',
-        async chat() {
-          throw new Error('server_error: upstream blew up')
-        },
-      },
-      { maxRetries: 3, initialDelayMs: 100 },
-    )
-    // Abort 10ms into the 100ms backoff.
-    setTimeout(() => ac.abort(), 10)
-    await expect(p.chat({ ...baseReq, signal: ac.signal })).rejects.toThrow(
-      /server_error: upstream blew up/,
-    )
-  })
-
-  test('backoff grows exponentially up to maxDelayMs', async () => {
-    const delays: number[] = []
-    const p = withRetry(
-      {
-        name: 'mock',
-        async chat() {
-          throw new Error('server_error')
-        },
-      },
-      {
-        maxRetries: 3,
-        initialDelayMs: 100,
-        maxDelayMs: 250,
-        onRetry: (info) => delays.push(info.delayMs),
-      },
-    )
-    await expect(p.chat(baseReq)).rejects.toThrow()
-    // 100, 200, min(400, 250) = 250
-    expect(delays).toEqual([100, 200, 250])
-  })
-})

package/apps/daemon/test/runtime/session-head.test.ts

@@ -1,90 +0,0 @@
-import { mkdirSync, mkdtempSync, rmSync, utimesSync, writeFileSync } from 'node:fs'
-import { tmpdir } from 'node:os'
-import { join } from 'node:path'
-import { afterEach, beforeEach, expect, test } from 'vitest'
-import { resolvePaths } from '../../src/core/index.ts'
-import { loadSessionHead } from '../../src/runtime/pi/session.ts'
-
-// Minimal ResolvedAgent shape loadSessionHead actually reads — we don't need
-// a real spawn + provider wiring for this unit test, only the agent.id (used
-// to resolve the session dir). loadSessionHead itself doesn't touch the
-// group, but the type still requires it.
-function fakeAgent(id: string, dir: string) {
-  return {
-    agent: { id, dir, name: id, status: 'idle' as const },
-    group: { id: 'g', name: 'g', path: dir, userMd: '', createdAt: 0 },
-    skills: [],
-  } as unknown as Parameters<typeof loadSessionHead>[0]
-}
-
-let home: string
-beforeEach(() => {
-  home = mkdtempSync(join(tmpdir(), 'bazilion-session-head-'))
-})
-afterEach(() => rmSync(home, { recursive: true, force: true }))
-
-test('returns {file:null, size:0} when no sessions dir exists (fresh agent)', () => {
-  const paths = resolvePaths(home)
-  mkdirSync(paths.agentsDir, { recursive: true })
-  mkdirSync(join(paths.agentsDir, 'agent-a'), { recursive: true })
-
-  const head = loadSessionHead(fakeAgent('agent-a', join(paths.agentsDir, 'agent-a')), paths)
-  expect(head).toEqual({ file: null, size: 0 })
-})
-
-test('returns {file:null, size:0} when sessions dir is empty', () => {
-  const paths = resolvePaths(home)
-  mkdirSync(join(paths.agentsDir, 'agent-b', 'sessions'), { recursive: true })
-
-  const head = loadSessionHead(fakeAgent('agent-b', join(paths.agentsDir, 'agent-b')), paths)
-  expect(head).toEqual({ file: null, size: 0 })
-})
-
-test('returns the newest .jsonl basename + its byte size', () => {
-  const paths = resolvePaths(home)
-  const sessionDir = join(paths.agentsDir, 'agent-c', 'sessions')
-  mkdirSync(sessionDir, { recursive: true })
-
-  writeFileSync(join(sessionDir, 'old.jsonl'), 'old entry\n', 'utf8')
-  const now = Date.now() / 1000
-  // Backdate 'old' so 'newer' is unambiguously most-recent regardless of the
-  // order mkdir stamps mtime.
-  utimesSync(join(sessionDir, 'old.jsonl'), now - 60, now - 60)
-
-  const newerContent = '{"type":"session"}\n{"type":"message"}\n'
-  writeFileSync(join(sessionDir, 'newer.jsonl'), newerContent, 'utf8')
-
-  const head = loadSessionHead(fakeAgent('agent-c', join(paths.agentsDir, 'agent-c')), paths)
-  expect(head.file).toBe('newer.jsonl')
-  expect(head.size).toBe(Buffer.byteLength(newerContent, 'utf8'))
-})
-
-test('ignores non-jsonl files in the sessions dir', () => {
-  const paths = resolvePaths(home)
-  const sessionDir = join(paths.agentsDir, 'agent-d', 'sessions')
-  mkdirSync(sessionDir, { recursive: true })
-
-  writeFileSync(join(sessionDir, 'README.md'), 'not a session\n', 'utf8')
-  writeFileSync(join(sessionDir, '.DS_Store'), 'mac junk', 'utf8')
-  writeFileSync(join(sessionDir, 'real.jsonl'), 'entry\n', 'utf8')
-
-  const head = loadSessionHead(fakeAgent('agent-d', join(paths.agentsDir, 'agent-d')), paths)
-  expect(head.file).toBe('real.jsonl')
-})
-
-test('size grows monotonically as entries are appended — matches poll signal', () => {
-  const paths = resolvePaths(home)
-  const sessionDir = join(paths.agentsDir, 'agent-e', 'sessions')
-  mkdirSync(sessionDir, { recursive: true })
-  const file = join(sessionDir, 'session.jsonl')
-  writeFileSync(file, 'a\n', 'utf8')
-
-  const head1 = loadSessionHead(fakeAgent('agent-e', join(paths.agentsDir, 'agent-e')), paths)
-  // simulate pi appending another entry — ordinary append, no rename
-  writeFileSync(file, 'a\nb\n', 'utf8')
-  const head2 = loadSessionHead(fakeAgent('agent-e', join(paths.agentsDir, 'agent-e')), paths)
-
-  expect(head1.file).toBe('session.jsonl')
-  expect(head2.file).toBe('session.jsonl')
-  expect(head2.size).toBeGreaterThan(head1.size)
-})

package/apps/daemon/test/runtime/tools-home.test.ts

@@ -1,102 +0,0 @@
-import { mkdtempSync, readFileSync, rmSync, writeFileSync } from 'node:fs'
-import { tmpdir } from 'node:os'
-import { join } from 'node:path'
-import { afterEach, beforeEach, expect, test } from 'vitest'
-import { homeTools } from '../../src/runtime/tools/home.ts'
-import { createToolRegistry } from '../../src/runtime/tools/registry.ts'
-
-let agentDir: string
-
-beforeEach(() => {
-  agentDir = mkdtempSync(join(tmpdir(), 'bazilion-home-'))
-  writeFileSync(join(agentDir, 'IDENTITY.md'), '# IDENTITY\n\n- Name:\n', 'utf8')
-  writeFileSync(join(agentDir, 'SOUL.md'), '# SOUL\n\nhelpful and honest.\n', 'utf8')
-  writeFileSync(join(agentDir, 'BOOTSTRAP.md'), '# BOOTSTRAP\n\nfirst run.\n', 'utf8')
-})
-afterEach(() => rmSync(agentDir, { recursive: true, force: true }))
-
-test('home_read returns the file contents', async () => {
-  const tools = createToolRegistry(homeTools(agentDir))
-  const out = await tools.invoke('home_read', JSON.stringify({ file: 'IDENTITY.md' }))
-  expect(out).toContain('# IDENTITY')
-})
-
-test('home_read rejects files outside the whitelist', async () => {
-  const tools = createToolRegistry(homeTools(agentDir))
-  await expect(
-    tools.invoke('home_read', JSON.stringify({ file: '../etc/passwd' })),
-  ).rejects.toThrow(/must be one of/)
-  await expect(
-    tools.invoke('home_read', JSON.stringify({ file: 'memory/notes.md' })),
-  ).rejects.toThrow(/must be one of/)
-})
-
-test('home_read surfaces a helpful error if the file is missing', async () => {
-  const tools = createToolRegistry(homeTools(agentDir))
-  // TOOLS.md is whitelisted but not seeded in beforeEach — should raise a read error
-  await expect(tools.invoke('home_read', JSON.stringify({ file: 'TOOLS.md' }))).rejects.toThrow(
-    /could not read TOOLS\.md/,
-  )
-})
-
-test('home_write replaces file contents and is readable back', async () => {
-  const tools = createToolRegistry(homeTools(agentDir))
-  const body = '# IDENTITY\n\n- Name: Molty\n- Emoji: 🦞\n'
-  const w = await tools.invoke('home_write', JSON.stringify({ file: 'IDENTITY.md', content: body }))
-  expect(w).toMatch(/wrote IDENTITY\.md/)
-  expect(readFileSync(join(agentDir, 'IDENTITY.md'), 'utf8')).toBe(body)
-  const r = await tools.invoke('home_read', JSON.stringify({ file: 'IDENTITY.md' }))
-  expect(r).toBe(body)
-})
-
-test('home_write refuses to touch BOOTSTRAP.md (lifecycle belongs to bootstrap_done)', async () => {
-  const tools = createToolRegistry(homeTools(agentDir))
-  await expect(
-    tools.invoke('home_write', JSON.stringify({ file: 'BOOTSTRAP.md', content: 'nope' })),
-  ).rejects.toThrow(/must be one of/)
-  // Seeded BOOTSTRAP.md content is intact
-  expect(readFileSync(join(agentDir, 'BOOTSTRAP.md'), 'utf8')).toContain('first run')
-})
-
-test('home_write rejects files outside the whitelist', async () => {
-  const tools = createToolRegistry(homeTools(agentDir))
-  await expect(
-    tools.invoke(
-      'home_write',
-      JSON.stringify({ file: '../escape.md', content: 'should not leak' }),
-    ),
-  ).rejects.toThrow(/must be one of/)
-})
-
-test('home_list reports seeded files with byte sizes', async () => {
-  const tools = createToolRegistry(homeTools(agentDir))
-  const out = await tools.invoke('home_list', '{}')
-  expect(out).toMatch(/IDENTITY\.md \(\d+b\)/)
-  expect(out).toMatch(/SOUL\.md \(\d+b\)/)
-  expect(out).toMatch(/BOOTSTRAP\.md \(\d+b\)/)
-  // files we never created should not appear
-  expect(out).not.toMatch(/AGENTS\.md/)
-})
-
-test('home tools are scoped to the provided agentDir — sibling agents do not collide', async () => {
-  const other = mkdtempSync(join(tmpdir(), 'bazilion-home-other-'))
-  try {
-    writeFileSync(join(other, 'IDENTITY.md'), 'sibling original\n', 'utf8')
-
-    const a = createToolRegistry(homeTools(agentDir))
-    const b = createToolRegistry(homeTools(other))
-
-    await a.invoke(
-      'home_write',
-      JSON.stringify({ file: 'IDENTITY.md', content: 'agent-a writes its own\n' }),
-    )
-
-    expect(readFileSync(join(agentDir, 'IDENTITY.md'), 'utf8')).toBe('agent-a writes its own\n')
-    expect(readFileSync(join(other, 'IDENTITY.md'), 'utf8')).toBe('sibling original\n')
-
-    const bRead = await b.invoke('home_read', JSON.stringify({ file: 'IDENTITY.md' }))
-    expect(bRead).toBe('sibling original\n')
-  } finally {
-    rmSync(other, { recursive: true, force: true })
-  }
-})

package/apps/daemon/test/runtime/tools-web.test.ts

@@ -1,206 +0,0 @@
-import { afterEach, expect, test } from 'vitest'
-import { createToolRegistry } from '../../src/runtime/tools/registry.ts'
-import { webTools } from '../../src/runtime/tools/web.ts'
-import { type MockServer, startMockServer } from './mock-server.ts'
-
-let server: MockServer | null = null
-afterEach(async () => {
-  await server?.stop()
-  server = null
-})
-
-async function startMock(handler: (req: Request) => Response | Promise<Response>): Promise<string> {
-  server = await startMockServer(handler)
-  return server.url
-}
-
-test('web_fetch fetches a plain text URL', async () => {
-  const base = await startMock(
-    () => new Response('hello plain', { headers: { 'content-type': 'text/plain' } }),
-  )
-  const tools = createToolRegistry(webTools({ fetchImpl: fetch, allowPrivate: true }))
-  const result = await tools.invoke('web_fetch', JSON.stringify({ url: `${base}/doc` }))
-  expect(result).toContain('hello plain')
-})
-
-test('web_fetch extracts readable content from HTML (strips scripts/nav/footer)', async () => {
-  const html = `<html><head><title>Test Doc</title><script>evil()</script><style>.x{}</style></head>
-    <body>
-      <nav>skip nav</nav>
-      <article>
-        <h1>The Real Article</h1>
-        <p>This is the primary body of the article and it is long enough to give Readability something to score. The fox jumps over the lazy dog. Repeat repeat repeat.</p>
-        <p>A second paragraph of genuine content to satisfy any content-length thresholds.</p>
-      </article>
-      <footer>skip footer</footer>
-    </body></html>`
-  const base = await startMock(
-    () => new Response(html, { headers: { 'content-type': 'text/html' } }),
-  )
-  const tools = createToolRegistry(webTools({ fetchImpl: fetch, allowPrivate: true }))
-  const result = await tools.invoke('web_fetch', JSON.stringify({ url: `${base}/page` }))
-  expect(result).toContain('primary body of the article')
-  expect(result).not.toContain('evil()')
-  expect(result).not.toContain('<script')
-  expect(result).not.toContain('skip nav')
-  expect(result).not.toContain('skip footer')
-})
-
-test('web_fetch includes title as markdown heading', async () => {
-  const html = `<html><head><title>My Awesome Post</title></head>
-    <body><article><h1>My Awesome Post</h1>
-      <p>Body text that is long enough to trigger Readability scoring here, filler filler filler filler.</p>
-      <p>Another solid paragraph so Readability has plenty to work with.</p>
-    </article></body></html>`
-  const base = await startMock(
-    () => new Response(html, { headers: { 'content-type': 'text/html' } }),
-  )
-  const tools = createToolRegistry(webTools({ fetchImpl: fetch, allowPrivate: true }))
-  const result = await tools.invoke('web_fetch', JSON.stringify({ url: `${base}/post` }))
-  expect(result).toMatch(/^#\s+My Awesome Post/)
-})
-
-test('web_fetch pretty-prints JSON responses', async () => {
-  const base = await startMock(
-    () => new Response('{"a":1,"b":[2,3]}', { headers: { 'content-type': 'application/json' } }),
-  )
-  const tools = createToolRegistry(webTools({ fetchImpl: fetch, allowPrivate: true }))
-  const result = await tools.invoke('web_fetch', JSON.stringify({ url: `${base}/data.json` }))
-  expect(result).toContain('"a": 1')
-  expect(result).toContain('"b": [')
-})
-
-test('web_fetch truncates at max_length', async () => {
-  const base = await startMock(
-    () => new Response('a'.repeat(500), { headers: { 'content-type': 'text/plain' } }),
-  )
-  const tools = createToolRegistry(webTools({ fetchImpl: fetch, allowPrivate: true }))
-  const result = await tools.invoke(
-    'web_fetch',
-    JSON.stringify({ url: `${base}/big`, max_length: 100 }),
-  )
-  expect(result).toContain('[truncated at 100 chars]')
-  expect(result.length).toBeLessThan(200)
-})
-
-test('web_fetch throws on non-2xx', async () => {
-  const base = await startMock(() => new Response('nope', { status: 404 }))
-  const tools = createToolRegistry(webTools({ fetchImpl: fetch, allowPrivate: true }))
-  await expect(
-    tools.invoke('web_fetch', JSON.stringify({ url: `${base}/missing` })),
-  ).rejects.toThrow(/404/)
-})
-
-test('web_fetch caches results per (url, extract_mode)', async () => {
-  let hits = 0
-  const base = await startMock(() => {
-    hits += 1
-    return new Response(
-      '<html><body><article><p>Cached content here, enough words to pass threshold filler filler.</p></article></body></html>',
-      {
-        headers: { 'content-type': 'text/html' },
-      },
-    )
-  })
-  const tools = createToolRegistry(webTools({ fetchImpl: fetch, allowPrivate: true }))
-  const first = await tools.invoke('web_fetch', JSON.stringify({ url: `${base}/cached` }))
-  const second = await tools.invoke('web_fetch', JSON.stringify({ url: `${base}/cached` }))
-  expect(first).toBe(second)
-  expect(hits).toBe(1)
-})
-
-test('web_fetch blocks private IP literals by default', async () => {
-  const tools = createToolRegistry(webTools())
-  await expect(
-    tools.invoke('web_fetch', JSON.stringify({ url: 'http://127.0.0.1/' })),
-  ).rejects.toThrow(/private/i)
-})
-
-test('web_fetch blocks localhost by default', async () => {
-  const tools = createToolRegistry(webTools())
-  await expect(
-    tools.invoke('web_fetch', JSON.stringify({ url: 'http://localhost/' })),
-  ).rejects.toThrow(/Blocked hostname/i)
-})
-
-test('web_fetch blocks non-http(s) schemes', async () => {
-  const tools = createToolRegistry(webTools({ allowPrivate: true }))
-  await expect(
-    tools.invoke('web_fetch', JSON.stringify({ url: 'file:///etc/passwd' })),
-  ).rejects.toThrow(/http or https/i)
-})
-
-test('web_search tools are registered', () => {
-  const tools = createToolRegistry(webTools())
-  expect(tools.has('web_search')).toBe(true)
-  expect(tools.has('web_fetch')).toBe(true)
-})
-
-test('web_search rejects empty query', async () => {
-  const tools = createToolRegistry(webTools())
-  await expect(tools.invoke('web_search', JSON.stringify({ query: '' }))).rejects.toThrow(
-    /query is required/,
-  )
-})
-
-test('web_search errors when no backend is configured', async () => {
-  const tools = createToolRegistry(webTools({ env: {} }))
-  await expect(tools.invoke('web_search', JSON.stringify({ query: 'test' }))).rejects.toThrow(
-    /no search backend configured/,
-  )
-})
-
-test('web_search uses Brave when BRAVE_API_KEY is set', async () => {
-  let capturedHeaders = null as Headers | null
-  const base = await startMock((req) => {
-    capturedHeaders = req.headers
-    return new Response(
-      JSON.stringify({
-        web: {
-          results: [
-            {
-              title: 'Weather Krakow',
-              url: 'https://weather.example.com/krakow',
-              description: 'Sunny, 22°C',
-            },
-          ],
-        },
-      }),
-      { headers: { 'content-type': 'application/json' } },
-    )
-  })
-  const tools = createToolRegistry(
-    webTools({
-      fetchImpl: async (input, init) => {
-        const url =
-          typeof input === 'string' ? input : input instanceof URL ? input.href : input.url
-        const redirected = url.replace('https://api.search.brave.com', base)
-        return fetch(redirected, init)
-      },
-      env: { BRAVE_API_KEY: 'test-key' },
-    }),
-  )
-  const result = await tools.invoke('web_search', JSON.stringify({ query: 'weather krakow' }))
-  expect(result).toContain('Weather Krakow')
-  expect(result).toContain('Sunny')
-  expect(result).toContain('weather.example.com')
-  expect(capturedHeaders?.get('x-subscription-token')).toBe('test-key')
-})
-
-test('web_search uses SearXNG when SEARXNG_URL is set', async () => {
-  const base = await startMock(
-    () =>
-      new Response(
-        JSON.stringify({
-          results: [
-            { title: 'News', url: 'https://news.example.com', content: 'Latest headlines' },
-          ],
-        }),
-        { headers: { 'content-type': 'application/json' } },
-      ),
-  )
-  const tools = createToolRegistry(webTools({ env: { SEARXNG_URL: base } }))
-  const result = await tools.invoke('web_search', JSON.stringify({ query: 'news' }))
-  expect(result).toContain('News')
-  expect(result).toContain('Latest headlines')
-})

package/apps/daemon/tsconfig.json

@@ -1,4 +0,0 @@
-{
-  "extends": "../../tsconfig.base.json",
-  "include": ["src/**/*"]
-}

package/apps/mobile/README.md

@@ -1,60 +0,0 @@
-# @bazilion/mobile
-
-Expo (SDK 54) + Expo Router 6 + React 19 + RN 0.81 + new architecture. Pairs to a running `bazilion` daemon over LAN/Tailscale/VPN via a QR code minted on the server.
-
-## First run
-
-1. **On the server**: expose the daemon on your LAN.
-   ```sh
-   bazilion serve --host 0.0.0.0
-   ```
-   The daemon binds `127.0.0.1:4321` by default and prints a loud warning when
-   you bind it beyond loopback — TLS is your responsibility (Tailscale handles
-   it for personal networks; reverse-proxy with TLS for anything else).
-2. **On the server**: mint a pairing token.
-   ```sh
-   bazilion token create phone --qr
-   ```
-   A QR encoding `bazilion://pair?server=<url>&token=<t>` prints in the terminal.
-3. **On the phone**: install [Expo Go](https://expo.dev/go) and make sure it's on the same network as the server (or Tailscale, etc.).
-4. **On your dev machine**:
-   ```sh
-   pnpm --filter @bazilion/mobile start
-   ```
-   Scan the QR the Expo CLI prints with Expo Go → the app loads → grant camera access → point the camera at the **pairing** QR from step 2.
-5. The app verifies the token against `/api/health`, saves `server` + `token` into `expo-secure-store`, and lands on the agents list.
-
-## Manual pairing
-
-If the camera flow doesn't work (remote testing, wrong Expo Go version, etc.), tap "Paste URL instead" and paste the `bazilion://pair?…` URL the CLI printed. Same verification path.
-
-## Commands
-
-- `pnpm --filter @bazilion/mobile start` — Expo dev server (reads the Metro/Babel config).
-- `pnpm --filter @bazilion/mobile typecheck` — TypeScript check over the mobile tree only.
-- Root `pnpm test` picks up `apps/mobile/test/**/*.test.ts` — currently the `pair-url` parser suite.
-
-## Layout
-
-```
-app/
-  _layout.tsx        root stack + StatusBar
-  index.tsx          loads SecureStore → redirects /pair or /agents
-  pair.tsx           camera QR scan + manual-paste fallback + verify + save
-  settings.tsx       server URL + unpair
-  agents/
-    index.tsx        FlatList of agents (pull-to-refresh, unpair header, 401 → /pair)
-    [id]/
-      index.tsx      detail: name, status, model, profile, group, skills
-      chat.tsx       NDJSON streaming chat screen
-src/
-  auth.ts            SecureStore wrapper + verifyCredentials + clientFor()
-  pair-url.ts        pure TS URL parser (vitest-tested)
-  theme.ts           Baziu palette + spacing tokens
-test/
-  pair-url.test.ts
-```
-
-## Status
-
-Pairing, agents list, chat (NDJSON streaming), and settings ship end-to-end. Inbox + triggers screens are the next mobile work — paused for now while focus is on the web app.