bazilion 0.0.0

package/apps/cli/test/config-page.test.ts

@@ -0,0 +1,151 @@
+import { afterAll, beforeAll, beforeEach, expect, test } from 'vitest'
+import { startTestServer, type TestServer } from './server-fixture.ts'
+
+// End-to-end coverage for the /config page's HTTP surface — provider
+// enable/disable toggle and per-field storage dispatch.
+//
+// The server fixture enables `lmstudio` + `ollama` by default (see
+// `initHome` in server-fixture.ts). These tests explicitly toggle them to
+// verify the switch flows through the API, the DB, and back out via the
+// `/api/config/providers` endpoint the web UI + CLI both consume.
+
+let server: TestServer
+
+beforeAll(async () => {
+  server = await startTestServer()
+})
+afterAll(async () => {
+  await server.stop()
+})
+beforeEach(() => server.reset())
+
+interface ProviderEntry {
+  id: string
+  enabled: boolean
+  curated: string[]
+  fields: { envVar: string; kind: 'secret' | 'config'; set: boolean }[]
+}
+
+async function fetchProviders(): Promise<ProviderEntry[]> {
+  const res = await fetch(`${server.url}/api/config/providers`, {
+    headers: { cookie: `bz_token=${server.token}` },
+  })
+  expect(res.ok).toBe(true)
+  const body = (await res.json()) as { providers: ProviderEntry[] }
+  return body.providers
+}
+
+async function findProvider(id: string): Promise<ProviderEntry> {
+  const providers = await fetchProviders()
+  const p = providers.find((x) => x.id === id)
+  if (!p) throw new Error(`provider ${id} missing from /api/config/providers response`)
+  return p
+}
+
+test('provider toggle defaults respect the test fixture seed (lmstudio enabled)', async () => {
+  const lmstudio = await findProvider('lmstudio')
+  expect(lmstudio.enabled).toBe(true)
+  const anthropic = await findProvider('anthropic')
+  expect(anthropic.enabled).toBe(false)
+})
+
+test('bazilion provider disable + enable round-trip via CLI', async () => {
+  const before = await findProvider('lmstudio')
+  expect(before.enabled).toBe(true)
+
+  const off = await server.cli(['provider', 'disable', 'lmstudio'])
+  expect(off.exitCode).toBe(0)
+  expect(off.stdout).toContain('disabled')
+
+  const mid = await findProvider('lmstudio')
+  expect(mid.enabled).toBe(false)
+
+  const on = await server.cli(['provider', 'enable', 'lmstudio'])
+  expect(on.exitCode).toBe(0)
+  expect(on.stdout).toContain('enabled')
+
+  const after = await findProvider('lmstudio')
+  expect(after.enabled).toBe(true)
+})
+
+test('provider enable via API accepts {enabled: boolean} and round-trips state', async () => {
+  const res = await fetch(`${server.url}/api/config/providers/anthropic/enabled`, {
+    method: 'PUT',
+    headers: {
+      cookie: `bz_token=${server.token}`,
+      origin: server.url,
+      'content-type': 'application/json',
+    },
+    body: JSON.stringify({ enabled: true }),
+  })
+  expect(res.status).toBe(200)
+  const body = (await res.json()) as { name: string; enabled: boolean }
+  expect(body).toEqual({ name: 'anthropic', enabled: true })
+  const anthropic = await findProvider('anthropic')
+  expect(anthropic.enabled).toBe(true)
+})
+
+test('toggling an unknown provider returns 404', async () => {
+  const res = await fetch(`${server.url}/api/config/providers/martian/enabled`, {
+    method: 'PUT',
+    headers: {
+      cookie: `bz_token=${server.token}`,
+      origin: server.url,
+      'content-type': 'application/json',
+    },
+    body: JSON.stringify({ enabled: true }),
+  })
+  expect(res.status).toBe(404)
+})
+
+test('bazilion config set routes config-kind fields to plaintext store', async () => {
+  const set = await server.cli(['config', 'set', 'LMSTUDIO_URL', 'http://127.0.0.1:9999/v1'])
+  expect(set.exitCode).toBe(0)
+  // CLI echoes "(config)" for the kind.
+  expect(set.stdout).toMatch(/LMSTUDIO_URL.*\(config\)/)
+  expect(set.stdout).toContain('http://127.0.0.1:9999/v1')
+
+  // Verify it lands in the provider fields state.
+  const lmstudio = await findProvider('lmstudio')
+  const url = lmstudio.fields.find((f) => f.envVar === 'LMSTUDIO_URL')
+  expect(url?.set).toBe(true)
+})
+
+test('bazilion config set routes secret-kind fields to encrypted store', async () => {
+  const set = await server.cli(['config', 'set', 'ANTHROPIC_API_KEY', 'sk-ant-testing-1234567890'])
+  expect(set.exitCode).toBe(0)
+  expect(set.stdout).toMatch(/ANTHROPIC_API_KEY.*\(secret\)/)
+  // Secret should be displayed as a masked preview, not the full value.
+  expect(set.stdout).not.toContain('sk-ant-testing-1234567890')
+
+  const anthropic = await findProvider('anthropic')
+  const key = anthropic.fields.find((f) => f.envVar === 'ANTHROPIC_API_KEY')
+  expect(key?.set).toBe(true)
+})
+
+test('bazilion config rm clears both kinds', async () => {
+  await server.cli(['config', 'set', 'LMSTUDIO_URL', 'http://example.com/v1'])
+  await server.cli(['config', 'set', 'OPENAI_API_KEY', 'sk-test-key-abcdefgh'])
+
+  const rmUrl = await server.cli(['config', 'rm', 'LMSTUDIO_URL'])
+  expect(rmUrl.exitCode).toBe(0)
+  const rmKey = await server.cli(['config', 'rm', 'OPENAI_API_KEY'])
+  expect(rmKey.exitCode).toBe(0)
+
+  const lmstudio = await findProvider('lmstudio')
+  expect(lmstudio.fields.find((f) => f.envVar === 'LMSTUDIO_URL')?.set).toBe(false)
+  const openai = await findProvider('openai')
+  expect(openai.fields.find((f) => f.envVar === 'OPENAI_API_KEY')?.set).toBe(false)
+})
+
+test('bazilion config set rejects unknown envVars', async () => {
+  const r = await server.cli(['config', 'set', 'TOTALLY_MADE_UP_KEY', 'x'])
+  expect(r.exitCode).not.toBe(0)
+  expect(r.stderr + r.stdout).toMatch(/unknown envVar/i)
+})
+
+// SSR-regression coverage that previously asserted the rendered /config HTML
+// matched provider_state lived here. After the daemon split, the test fixture
+// boots only the daemon (the canonical /api/* surface). The SSR page now
+// renders exclusively from the same `/api/config/providers` response we
+// already exercise above — those API checks are the load-bearing assertions.

package/apps/cli/test/group.test.ts

@@ -0,0 +1,74 @@
+import { existsSync, lstatSync, mkdtempSync } from 'node:fs'
+import { tmpdir } from 'node:os'
+import { join } from 'node:path'
+import { afterAll, beforeAll, beforeEach, expect, test } from 'vitest'
+import { startTestServer, type TestServer } from './server-fixture.ts'
+
+let server: TestServer
+beforeAll(async () => {
+  server = await startTestServer()
+})
+afterAll(() => server.stop())
+beforeEach(() => server.reset())
+
+test('group add + list + rm (slug-only, real dir under groups/)', async () => {
+  let r = await server.cli(['group', 'add', 'shared1'])
+  expect(r.exitCode).toBe(0)
+  expect(r.stdout).toContain('registered group shared1')
+
+  // Real dir created at ~/.bazilion/groups/shared1/
+  const slot = join(server.home, 'groups', 'shared1')
+  expect(existsSync(slot)).toBe(true)
+  expect(lstatSync(slot).isSymbolicLink()).toBe(false)
+  expect(existsSync(join(slot, 'memory'))).toBe(true)
+
+  r = await server.cli(['group', 'list'])
+  expect(r.stdout).toContain('shared1')
+  expect(r.stdout).toContain(slot)
+
+  r = await server.cli(['group', 'rm', 'shared1'])
+  expect(r.exitCode).toBe(0)
+
+  r = await server.cli(['group', 'list'])
+  // Auto-seeded 'default' group from the fixture stays; only the removed one is gone.
+  expect(r.stdout).not.toContain('shared1')
+  expect(r.stdout).toContain('default')
+})
+
+test('group add --link materializes the slot as a symlink', async () => {
+  const target = mkdtempSync(join(tmpdir(), 'bazilion-cli-link-'))
+  const r = await server.cli(['group', 'add', 'linked', '--link', target])
+  expect(r.exitCode).toBe(0)
+  const slot = join(server.home, 'groups', 'linked')
+  expect(lstatSync(slot).isSymbolicLink()).toBe(true)
+})
+
+test('group add --link fails when target does not exist', async () => {
+  const r = await server.cli([
+    'group',
+    'add',
+    'ghost',
+    '--link',
+    '/tmp/bazilion-test-no-such-path-xyz',
+  ])
+  expect(r.exitCode).not.toBe(0)
+  expect(r.stderr + r.stdout).toContain('does not exist')
+})
+
+test('group user-md set + show + clear round-trip', async () => {
+  let r = await server.cli(['group', 'user-md', 'show', 'default'])
+  expect(r.exitCode).toBe(0)
+  expect(r.stdout.trim()).toBe('')
+
+  r = await server.cli(['group', 'user-md', 'set', 'default', '--text', 'call me Pat'])
+  expect(r.exitCode).toBe(0)
+
+  r = await server.cli(['group', 'user-md', 'show', 'default'])
+  expect(r.stdout).toContain('call me Pat')
+
+  r = await server.cli(['group', 'user-md', 'clear', 'default'])
+  expect(r.exitCode).toBe(0)
+
+  r = await server.cli(['group', 'user-md', 'show', 'default'])
+  expect(r.stdout.trim()).toBe('')
+})

package/apps/cli/test/helpers.ts

@@ -0,0 +1,70 @@
+import { spawn } from 'node:child_process'
+import { mkdtempSync, rmSync } from 'node:fs'
+import { tmpdir } from 'node:os'
+import { join } from 'node:path'
+
+const cliEntry = join(import.meta.dirname, '..', 'src', 'index.ts')
+
+export interface CliResult {
+  stdout: string
+  stderr: string
+  exitCode: number
+}
+
+// Test CLI spawns use Node 22.12+'s built-in `--experimental-strip-types`
+// instead of `tsx`. Startup drops from ~1.5s (tsx's transform cost) to
+// ~140ms (node loading .ts via native strip). Across a full suite with
+// hundreds of CLI invocations that's ~60s saved wall-clock. The project
+// already requires Node 22.12 (engines in root package.json), and no code
+// uses enums/namespaces — the only TS forms strip-types can't handle.
+//
+// `--no-warnings` silences the "ExperimentalWarning: Type Stripping is an
+// experimental feature" banner that would otherwise land on stderr and
+// upset tests that assert clean stderr. On Node 25+ the flag is
+// effectively stable but the warning still fires.
+const STRIP_TYPES_ARGS = ['--experimental-strip-types', '--no-warnings']
+
+export function runCli(
+  args: string[],
+  home: string,
+  extraEnv: NodeJS.ProcessEnv = {},
+): Promise<CliResult> {
+  return new Promise((resolve, reject) => {
+    const proc = spawn(process.execPath, [...STRIP_TYPES_ARGS, cliEntry, ...args], {
+      env: { ...process.env, BAZILION_HOME: home, ...extraEnv },
+    })
+    const stdoutChunks: Buffer[] = []
+    const stderrChunks: Buffer[] = []
+    proc.stdout.on('data', (c: Buffer) => stdoutChunks.push(c))
+    proc.stderr.on('data', (c: Buffer) => stderrChunks.push(c))
+    proc.on('error', reject)
+    proc.on('close', (code) => {
+      resolve({
+        stdout: Buffer.concat(stdoutChunks).toString('utf8'),
+        stderr: Buffer.concat(stderrChunks).toString('utf8'),
+        exitCode: code ?? 0,
+      })
+    })
+  })
+}
+
+export interface TestHome {
+  home: string
+  cleanup: () => void
+}
+
+export function makeHome(): TestHome {
+  const home = mkdtempSync(join(tmpdir(), 'bazilion-cli-test-'))
+  return {
+    home,
+    cleanup() {
+      rmSync(home, { recursive: true, force: true })
+    },
+  }
+}
+
+export function extractAgentId(stdout: string): string {
+  const m = stdout.match(/spawned agent ([\w-]+)/)
+  if (!m?.[1]) throw new Error(`could not extract agent id from: ${stdout}`)
+  return m[1]
+}

package/apps/cli/test/inbox-autodeliver.test.ts

@@ -0,0 +1,143 @@
+// Integration test for scheduler-driven inbox auto-delivery.
+//
+// Exercises the end-to-end flow: a message is inserted into agent B's inbox
+// (via the `/api/agents/:id/messages` POST, same path the CLI's `bazilion
+// send` uses), the scheduler tick should drain B's unread mail within one
+// tick interval and fire a turn for B with the messages embedded in the
+// prompt. We verify that by watching for a run row against B and matching
+// the mock LLM's received system prompt would be overkill — the presence
+// of a fresh run is sufficient signal the wake loop fired.
+
+import { createServer, type ServerResponse } from 'node:http'
+import { afterAll, beforeAll, beforeEach, expect, test } from 'vitest'
+import { extractAgentId } from './helpers.ts'
+import { startTestServer, type TestServer } from './server-fixture.ts'
+
+interface MockLlm {
+  url: string
+  push(responses: unknown[]): void
+  reset(): void
+  stop(): Promise<void>
+  callCount(): number
+}
+
+interface Canned {
+  choices: Array<{
+    message: { role?: string; content?: string | null }
+    finish_reason?: string
+  }>
+}
+
+function writeSse(res: ServerResponse, canned: Canned): void {
+  res.writeHead(200, {
+    'content-type': 'text/event-stream',
+    'cache-control': 'no-cache',
+    connection: 'keep-alive',
+  })
+  const msg = canned.choices[0]?.message ?? {}
+  const finish = canned.choices[0]?.finish_reason ?? 'stop'
+  res.write(
+    `data: ${JSON.stringify({
+      id: 'mock',
+      object: 'chat.completion.chunk',
+      choices: [{ index: 0, delta: { role: 'assistant' }, finish_reason: null }],
+    })}\n\n`,
+  )
+  if (typeof msg.content === 'string' && msg.content.length > 0) {
+    res.write(
+      `data: ${JSON.stringify({
+        id: 'mock',
+        object: 'chat.completion.chunk',
+        choices: [{ index: 0, delta: { content: msg.content }, finish_reason: null }],
+      })}\n\n`,
+    )
+  }
+  res.write(
+    `data: ${JSON.stringify({
+      id: 'mock',
+      object: 'chat.completion.chunk',
+      choices: [{ index: 0, delta: {}, finish_reason: finish }],
+    })}\n\n`,
+  )
+  res.write('data: [DONE]\n\n')
+  res.end()
+}
+
+function startMock(): Promise<MockLlm> {
+  const queue: unknown[] = []
+  let calls = 0
+  const server = createServer((_req, res) => {
+    calls++
+    const item = queue.shift() ?? {
+      choices: [{ message: { role: 'assistant', content: 'ok' }, finish_reason: 'stop' }],
+    }
+    writeSse(res, item as Canned)
+  })
+  return new Promise((resolve) => {
+    server.listen(0, () => {
+      const addr = server.address()
+      if (!addr || typeof addr === 'string') throw new Error('unexpected address')
+      resolve({
+        url: `http://localhost:${addr.port}/v1`,
+        push(items) {
+          queue.push(...items)
+        },
+        reset() {
+          queue.length = 0
+          calls = 0
+        },
+        stop: () => new Promise((r) => server.close(() => r())),
+        callCount() {
+          return calls
+        },
+      })
+    })
+  })
+}
+
+let mock: MockLlm
+let server: TestServer
+
+beforeAll(async () => {
+  mock = await startMock()
+  server = await startTestServer({
+    LMSTUDIO_URL: mock.url,
+    // Fast scheduler ticks so the test doesn't wait 5s per auto-deliver.
+    BAZILION_SCHEDULER_TICK_MS: '200',
+  })
+})
+afterAll(async () => {
+  await server.stop()
+  await mock.stop()
+})
+beforeEach(() => {
+  server.reset()
+  mock.reset()
+})
+
+async function spawnAgent(name: string): Promise<string> {
+  const r = await server.cli(['agent', 'spawn', '--profile', 'p', '--name', name])
+  return extractAgentId(r.stdout)
+}
+
+test('unread message to an idle agent triggers an auto-delivered turn', async () => {
+  await server.cli(['profile', 'create', 'p', '--model', 'lmstudio:test-model'])
+  const a = await spawnAgent('alice')
+  const b = await spawnAgent('bob')
+
+  // Post a message from A to B through the HTTP API (same code path `bazilion
+  // send` uses).
+  const send = await server.cli(['send', a, b, 'hello bob, please reply'])
+  expect(send.exitCode).toBe(0)
+
+  // Wait up to 10s for B's auto-wake turn to hit the mock LLM.
+  let llmHit = false
+  for (let i = 0; i < 100; i++) {
+    if (mock.callCount() > 0) {
+      llmHit = true
+      break
+    }
+    await new Promise((r) => setTimeout(r, 100))
+  }
+  expect(llmHit).toBe(true)
+})

package/apps/cli/test/inbox.test.ts

@@ -0,0 +1,147 @@
+import { afterAll, beforeAll, beforeEach, expect, test } from 'vitest'
+import { extractAgentId } from './helpers.ts'
+import { startTestServer, type TestServer } from './server-fixture.ts'
+
+// This suite tests the inbox CLI / HTTP surface (list / show / read / replyTo)
+// in isolation. Bazilion's scheduler runs inbox auto-delivery every tick,
+// which would drain these tests' seeded messages and mark them read before
+// the assertions run. We disable the scheduler for this fixture; the
+// auto-delivery flow is covered end-to-end by `inbox-autodeliver.test.ts`.
+let server: TestServer
+beforeAll(async () => {
+  server = await startTestServer({ BAZILION_SCHEDULER: 'off' })
+})
+afterAll(() => server.stop())
+beforeEach(() => server.reset())
+
+async function spawnTwoAgents(): Promise<{ a: string; b: string }> {
+  await server.cli(['profile', 'create', 'p', '--model', 'm'])
+  let r = await server.cli(['agent', 'spawn', '--profile', 'p'])
+  const a = extractAgentId(r.stdout)
+  r = await server.cli(['agent', 'spawn', '--profile', 'p'])
+  const b = extractAgentId(r.stdout)
+  return { a, b }
+}
+
+function firstIdFromSend(stdout: string): string {
+  const m = stdout.match(/sent message ([\w-]+)/)
+  if (!m?.[1]) throw new Error(`no message id in: ${stdout}`)
+  return m[1]
+}
+
+function parseInboxIds(stdout: string): string[] {
+  return stdout
+    .split('\n')
+    .map((l) => l.trim())
+    .filter((l) => l.length > 0 && !l.startsWith('('))
+    .map((l) => l.split(/\s+/)[0] ?? '')
+    .filter((x) => x.length > 0)
+}
+
+test('inbox list shows sent messages', async () => {
+  const { a, b } = await spawnTwoAgents()
+  const send = await server.cli(['send', a, b, 'first'])
+  const id = firstIdFromSend(send.stdout)
+
+  const r = await server.cli(['inbox', 'list', b])
+  expect(r.exitCode).toBe(0)
+  expect(parseInboxIds(r.stdout)).toContain(id)
+  expect(r.stdout).toContain('first')
+  expect(r.stdout).toContain('NEW')
+})
+
+test('inbox list --unread filters out read messages', async () => {
+  const { a, b } = await spawnTwoAgents()
+  const s1 = await server.cli(['send', a, b, 'one'])
+  const id1 = firstIdFromSend(s1.stdout)
+  await server.cli(['send', a, b, 'two'])
+
+  await server.cli(['inbox', 'read', id1])
+
+  const all = await server.cli(['inbox', 'list', b])
+  expect(parseInboxIds(all.stdout).length).toBe(2)
+
+  const unread = await server.cli(['inbox', 'list', b, '--unread'])
+  const unreadIds = parseInboxIds(unread.stdout)
+  expect(unreadIds).not.toContain(id1)
+  expect(unreadIds.length).toBe(1)
+})
+
+test('inbox show prints message body', async () => {
+  const { a, b } = await spawnTwoAgents()
+  const s = await server.cli(['send', a, b, 'hello body'])
+  const id = firstIdFromSend(s.stdout)
+
+  const r = await server.cli(['inbox', 'show', id])
+  expect(r.exitCode).toBe(0)
+  expect(r.stdout).toContain('hello body')
+  expect(r.stdout).toContain(`id:        ${id}`)
+  expect(r.stdout).toContain(`from:      ${a}`)
+})
+
+test('inbox read marks a message read', async () => {
+  const { a, b } = await spawnTwoAgents()
+  const s = await server.cli(['send', a, b, 'mark me'])
+  const id = firstIdFromSend(s.stdout)
+
+  const before = await server.cli(['inbox', 'show', id])
+  expect(before.stdout).toContain('read:      (unread)')
+
+  const r = await server.cli(['inbox', 'read', id])
+  expect(r.exitCode).toBe(0)
+  expect(r.stdout).toContain(`marked read: ${id}`)
+
+  const after = await server.cli(['inbox', 'show', id])
+  expect(after.stdout).not.toContain('(unread)')
+})
+
+test('inbox show fails for unknown message id', async () => {
+  await server.cli(['profile', 'create', 'p', '--model', 'm'])
+  const r = await server.cli(['inbox', 'show', 'nope-not-real'])
+  expect(r.exitCode).not.toBe(0)
+  expect(r.stderr + r.stdout).toContain('message not found')
+})
+
+test('POST with replyTo links the messages', async () => {
+  const { a, b } = await spawnTwoAgents()
+  const first = await server.cli(['send', a, b, 'please reply'])
+  const firstId = firstIdFromSend(first.stdout)
+
+  const res = await fetch(`${server.url}/api/agents/${a}/messages`, {
+    method: 'POST',
+    headers: {
+      'content-type': 'application/json',
+      cookie: `bz_token=${server.token}`,
+    },
+    body: JSON.stringify({
+      from: b,
+      payload: { text: 'here is a reply' },
+      replyTo: firstId,
+    }),
+  })
+  expect(res.status).toBe(201)
+  const msg = (await res.json()) as { id: string; replyTo: string | null }
+  expect(msg.replyTo).toBe(firstId)
+
+  const show = await server.cli(['inbox', 'show', msg.id])
+  expect(show.stdout).toContain(`reply_to:  ${firstId}`)
+})
+
+test('POST replyTo to missing message is rejected', async () => {
+  const { a, b } = await spawnTwoAgents()
+  const res = await fetch(`${server.url}/api/agents/${b}/messages`, {
+    method: 'POST',
+    headers: {
+      'content-type': 'application/json',
+      cookie: `bz_token=${server.token}`,
+    },
+    body: JSON.stringify({
+      from: a,
+      payload: { text: 'ghost reply' },
+      replyTo: 'not-a-real-id',
+    }),
+  })
+  expect(res.status).toBe(404)
+  const err = (await res.json()) as { error: string }
+  expect(err.error).toContain('reply target not found')
+})

package/apps/cli/test/memory.test.ts

@@ -0,0 +1,69 @@
+import { afterAll, beforeAll, beforeEach, expect, test } from 'vitest'
+import { startTestServer, type TestServer } from './server-fixture.ts'
+
+// The fixture seeds a `default` group on every reset — that's our scope.
+const GROUP = 'default'
+
+let server: TestServer
+beforeAll(async () => {
+  server = await startTestServer()
+})
+afterAll(() => server.stop())
+beforeEach(() => server.reset())
+
+test('memory write + read round-trip', async () => {
+  let r = await server.cli(['memory', 'write', GROUP, 'colors.md', 'My favorite color is blue.'])
+  expect(r.exitCode).toBe(0)
+  expect(r.stdout).toContain('wrote colors.md')
+
+  r = await server.cli(['memory', 'read', GROUP, 'colors.md'])
+  expect(r.exitCode).toBe(0)
+  expect(r.stdout).toContain('My favorite color is blue')
+})
+
+test('memory search finds written entries', async () => {
+  await server.cli(['memory', 'write', GROUP, 'a.md', 'I like pasta'])
+  await server.cli(['memory', 'write', GROUP, 'b.md', 'I like pizza'])
+  await server.cli(['memory', 'write', GROUP, 'c.md', 'I like cars'])
+
+  const r = await server.cli(['memory', 'search', GROUP, 'pizza'])
+  expect(r.exitCode).toBe(0)
+  expect(r.stdout).toContain('b.md')
+  expect(r.stdout).not.toContain('a.md')
+})
+
+test('memory list shows all entries', async () => {
+  await server.cli(['memory', 'write', GROUP, 'one.md', 'one'])
+  await server.cli(['memory', 'write', GROUP, 'two.md', 'two'])
+
+  const r = await server.cli(['memory', 'list', GROUP])
+  expect(r.stdout).toContain('one.md')
+  expect(r.stdout).toContain('two.md')
+})
+
+test('memory rm deletes the entry', async () => {
+  await server.cli(['memory', 'write', GROUP, 'tmp.md', 'temporary'])
+  await server.cli(['memory', 'rm', GROUP, 'tmp.md'])
+  const r = await server.cli(['memory', 'read', GROUP, 'tmp.md'])
+  expect(r.exitCode).not.toBe(0)
+  expect(r.stderr + r.stdout).toContain('not found')
+})
+
+test('memory persists across CLI invocations under the group dir', async () => {
+  await server.cli(['memory', 'write', GROUP, 'persist.md', 'survives restart'])
+  // New CLI invocation = new subprocess; state lives server-side.
+  const r = await server.cli(['memory', 'read', GROUP, 'persist.md'])
+  expect(r.stdout).toContain('survives restart')
+})
+
+test('memory is shared across every agent in the group', async () => {
+  // Spawn two agents both implicitly placed in `default`. They must see
+  // the same entry — the whole point of moving memory to the group level.
+  await server.cli(['profile', 'create', 'p', '--model', 'm'])
+  await server.cli(['agent', 'spawn', '--profile', 'p'])
+  await server.cli(['agent', 'spawn', '--profile', 'p'])
+
+  await server.cli(['memory', 'write', GROUP, 'shared.md', 'visible to all'])
+  const r = await server.cli(['memory', 'read', GROUP, 'shared.md'])
+  expect(r.stdout).toContain('visible to all')
+})