create-walle 0.1.0

package/template/wall-e/skills/tool-executor.js

@@ -0,0 +1,188 @@
+'use strict';
+const fs = require('fs');
+const path = require('path');
+const { execFile } = require('child_process');
+const { promisify } = require('util');
+const execFileAsync = promisify(execFile);
+
+/**
+ * Execute a tool call from Claude's tool_use response.
+ * Uses execFile (not exec) to prevent shell injection.
+ * @param {string} toolName - e.g., 'http_fetch', 'read_file', 'shell_exec'
+ * @param {object} input - tool parameters from Claude
+ * @returns {Promise<{success: boolean, result: any, error?: string}>}
+ */
+async function executeTool(toolName, input) {
+  const executor = TOOL_EXECUTORS[toolName];
+  if (!executor) {
+    return { success: false, result: null, error: `Unknown tool: ${toolName}` };
+  }
+  try {
+    const result = await executor(input);
+    return { success: true, result };
+  } catch (err) {
+    return { success: false, result: null, error: err.message };
+  }
+}
+
+const TOOL_EXECUTORS = {
+  // HTTP fetch — make API requests
+  async http_fetch({ url, method, headers, body, timeout_ms }) {
+    if (!url) throw new Error('url is required');
+    // Validate URL to prevent SSRF — only allow http/https
+    const parsed = new URL(url);
+    if (!['http:', 'https:'].includes(parsed.protocol)) {
+      throw new Error('Only http/https URLs allowed');
+    }
+
+    const opts = {
+      method: method || 'GET',
+      headers: headers || {},
+      signal: AbortSignal.timeout(timeout_ms || 15000),
+    };
+    if (body) opts.body = typeof body === 'string' ? body : JSON.stringify(body);
+
+    const res = await fetch(url, opts);
+    const text = await res.text();
+    // Truncate large responses
+    const truncated = text.length > 50000 ? text.slice(0, 50000) + '...[truncated]' : text;
+    return { status: res.status, body: truncated, ok: res.ok };
+  },
+
+  // Read local file
+  async read_file({ file_path, max_bytes }) {
+    if (!file_path) throw new Error('file_path is required');
+    // Security: resolve path, prevent reading outside home or data dirs
+    const resolved = path.resolve(file_path);
+    const home = process.env.HOME;
+    if (!resolved.startsWith(home)) {
+      throw new Error('Can only read files under home directory');
+    }
+
+    const stat = fs.statSync(resolved);
+    const limit = max_bytes || 500000; // 500KB default
+    if (stat.size > limit) {
+      // Read only the first chunk
+      const fd = fs.openSync(resolved, 'r');
+      const buf = Buffer.alloc(limit);
+      fs.readSync(fd, buf, 0, limit, 0);
+      fs.closeSync(fd);
+      return buf.toString('utf8') + '...[truncated]';
+    }
+    return fs.readFileSync(resolved, 'utf8');
+  },
+
+  // Shell command — restricted via allowlist, uses execFile (no shell injection)
+  async shell_exec({ command, args, timeout_ms }) {
+    if (!command) throw new Error('command is required');
+    // Allowlist of safe commands
+    const ALLOWED = ['ls', 'cat', 'head', 'tail', 'grep', 'find', 'wc', 'date', 'echo', 'curl', 'jq'];
+    const cmd = path.basename(command);
+    if (!ALLOWED.includes(cmd)) {
+      throw new Error(`Command not allowed: ${cmd}. Allowed: ${ALLOWED.join(', ')}`);
+    }
+    // execFile is used intentionally here (not exec) to prevent shell injection
+    const { stdout, stderr } = await execFileAsync(command, args || [], {
+      timeout: timeout_ms || 10000,
+      maxBuffer: 500000,
+    });
+    return { stdout: stdout.slice(0, 50000), stderr: stderr.slice(0, 5000) };
+  },
+
+  // MCP tool call — call a tool on a connected MCP server
+  async mcp_call({ server, tool, arguments: args }) {
+    if (!server) throw new Error('server is required');
+    if (!tool) throw new Error('tool is required');
+    const { callMcpTool } = require('./mcp-client');
+    const result = await callMcpTool(server, tool, args || {});
+    // Extract text content from MCP response
+    if (result && result.content) {
+      const texts = result.content
+        .filter(c => c.type === 'text')
+        .map(c => c.text);
+      const combined = texts.join('\n');
+      return combined.length > 50000 ? combined.slice(0, 50000) + '...[truncated]' : combined;
+    }
+    return result;
+  },
+
+  // List all available MCP tools across configured servers
+  async list_mcp_tools() {
+    const { listAllTools } = require('./mcp-client');
+    const tools = await listAllTools();
+    return tools.map(t => ({
+      server: t.server,
+      name: t.name,
+      description: (t.description || '').slice(0, 200),
+    }));
+  },
+};
+
+/**
+ * Get tool definitions to pass to Claude API.
+ * These tell Claude what tools are available.
+ */
+function getToolDefinitions() {
+  return [
+    {
+      name: 'http_fetch',
+      description: 'Make an HTTP request to fetch data from an API or web service.',
+      input_schema: {
+        type: 'object',
+        properties: {
+          url: { type: 'string', description: 'The URL to fetch' },
+          method: { type: 'string', enum: ['GET', 'POST', 'PUT', 'DELETE'], default: 'GET' },
+          headers: { type: 'object', description: 'Request headers' },
+          body: { type: 'string', description: 'Request body (for POST/PUT)' },
+          timeout_ms: { type: 'number', description: 'Timeout in milliseconds', default: 15000 },
+        },
+        required: ['url'],
+      },
+    },
+    {
+      name: 'read_file',
+      description: 'Read a local file. Use for importing data exports (ChatGPT, etc.).',
+      input_schema: {
+        type: 'object',
+        properties: {
+          file_path: { type: 'string', description: 'Absolute path to the file' },
+          max_bytes: { type: 'number', description: 'Max bytes to read', default: 500000 },
+        },
+        required: ['file_path'],
+      },
+    },
+    {
+      name: 'shell_exec',
+      description: 'Run a shell command. Only safe commands allowed (ls, cat, grep, curl, etc.).',
+      input_schema: {
+        type: 'object',
+        properties: {
+          command: { type: 'string', description: 'Command to run (e.g., curl, grep)' },
+          args: { type: 'array', items: { type: 'string' }, description: 'Command arguments' },
+          timeout_ms: { type: 'number', default: 10000 },
+        },
+        required: ['command'],
+      },
+    },
+    {
+      name: 'mcp_call',
+      description: 'Call a tool on an MCP server. Available servers and tools can be discovered via list_mcp_tools.',
+      input_schema: {
+        type: 'object',
+        properties: {
+          server: { type: 'string', description: 'MCP server name (e.g., "slack", "sendgrid")' },
+          tool: { type: 'string', description: 'Tool name on the server' },
+          arguments: { type: 'object', description: 'Tool arguments' },
+        },
+        required: ['server', 'tool'],
+      },
+    },
+    {
+      name: 'list_mcp_tools',
+      description: 'List all available MCP tools across all configured servers.',
+      input_schema: { type: 'object', properties: {} },
+    },
+  ];
+}
+
+module.exports = { executeTool, getToolDefinitions, TOOL_EXECUTORS };

package/template/wall-e/tests/adapter-base.test.js

@@ -0,0 +1,20 @@
+const { describe, it } = require('node:test');
+const assert = require('node:assert');
+const AdapterBase = require('../adapters/adapter-base');
+
+describe('AdapterBase', () => {
+  it('should store name', () => {
+    const adapter = new AdapterBase('test');
+    assert.strictEqual(adapter.name, 'test');
+  });
+
+  it('poll() should throw not implemented', async () => {
+    const adapter = new AdapterBase('test');
+    await assert.rejects(() => adapter.poll(null), { message: 'test.poll() not implemented' });
+  });
+
+  it('normalize() should throw not implemented', () => {
+    const adapter = new AdapterBase('test');
+    assert.throws(() => adapter.normalize({}), { message: 'test.normalize() not implemented' });
+  });
+});

package/template/wall-e/tests/adapter-ctm.test.js

@@ -0,0 +1,122 @@
+const { describe, it, before, after } = require('node:test');
+const assert = require('node:assert');
+const fs = require('fs');
+const path = require('path');
+const os = require('os');
+const CtmAdapter = require('../adapters/ctm');
+
+describe('CtmAdapter', () => {
+  let tmpDir;
+  let projectDir;
+  let sessionFile;
+  let adapter;
+
+  const userMsg1 = {
+    type: 'user',
+    message: { role: 'user', content: 'Add a login page' },
+    cwd: '/home/user/project',
+    timestamp: '2026-03-22T10:00:00Z',
+    uuid: 'msg-001',
+  };
+
+  const assistantMsg = {
+    type: 'assistant',
+    message: {
+      role: 'assistant',
+      content: [
+        { type: 'text', text: 'Creating login page.' },
+        { type: 'tool_use', name: 'Write', input: { file_path: '/login.js' } },
+      ],
+    },
+  };
+
+  const userMsg2 = {
+    type: 'user',
+    message: {
+      role: 'user',
+      content: [{ type: 'text', text: 'Add validation too' }],
+    },
+    timestamp: '2026-03-22T10:05:00Z',
+    uuid: 'msg-002',
+  };
+
+  before(() => {
+    tmpDir = fs.mkdtempSync(path.join(os.tmpdir(), 'ctm-test-'));
+    projectDir = path.join(tmpDir, '-home-user-project');
+    fs.mkdirSync(projectDir, { recursive: true });
+
+    sessionFile = path.join(projectDir, 'session-001.jsonl');
+    const lines = [
+      JSON.stringify(userMsg1),
+      JSON.stringify(assistantMsg),
+      'not json{',
+      JSON.stringify(userMsg2),
+    ].join('\n');
+    fs.writeFileSync(sessionFile, lines);
+
+    adapter = new CtmAdapter({ projectsDir: tmpDir });
+  });
+
+  after(() => {
+    fs.rmSync(tmpDir, { recursive: true, force: true });
+  });
+
+  it('normalize() on user message with string content', () => {
+    const raw = { ...userMsg1 };
+    const result = adapter.normalize(raw);
+    assert.strictEqual(result.source, 'ctm');
+    assert.strictEqual(result.direction, 'outbound');
+    assert.strictEqual(result.memory_type, 'message_sent');
+    assert.ok(result.content.toLowerCase().includes('login page'), 'content should mention login page');
+  });
+
+  it('normalize() on assistant message with array content and tool_uses', () => {
+    const raw = { ...assistantMsg };
+    const result = adapter.normalize(raw);
+    assert.strictEqual(result.direction, 'observed');
+    assert.strictEqual(result.memory_type, 'assistant_response');
+    assert.ok(result.content.includes('Write'), 'content should include tool summary');
+    assert.ok(result.metadata, 'metadata should be present');
+    const meta = JSON.parse(result.metadata);
+    assert.ok(Array.isArray(meta.tool_uses), 'metadata should have tool_uses array');
+    assert.strictEqual(meta.tool_uses[0].name, 'Write');
+  });
+
+  it('poll(null) returns normalized memories from session files', async () => {
+    const memories = await adapter.poll(null);
+    assert.ok(memories.length >= 2, `expected at least 2 memories, got ${memories.length}`);
+    const sources = memories.map(m => m.source);
+    assert.ok(sources.every(s => s === 'ctm'));
+  });
+
+  it('poll(lastTimestamp) on second call returns 0 results (file already processed)', async () => {
+    // adapter already processed the file in the previous poll(null) call
+    const memories = await adapter.poll(null);
+    assert.strictEqual(memories.length, 0, 'second poll should return 0 since file mtime unchanged');
+  });
+
+  it('malformed JSONL lines are skipped', () => {
+    // The session file contains "not json{" which should be skipped
+    const entries = adapter._parseSessionFile(sessionFile);
+    // We wrote 3 valid JSON lines and 1 malformed
+    assert.strictEqual(entries.length, 3, 'should have 3 valid entries, skipping malformed line');
+  });
+
+  it('non-existent projectsDir returns empty from poll()', async () => {
+    const badAdapter = new CtmAdapter({ projectsDir: '/tmp/nonexistent-ctm-dir-xyz' });
+    const result = await badAdapter.poll(null);
+    assert.deepStrictEqual(result, []);
+  });
+
+  it('session with only assistant messages still returns observed memories', async () => {
+    const assistantOnlyDir = path.join(tmpDir, '-tmp-assistant-only');
+    fs.mkdirSync(assistantOnlyDir, { recursive: true });
+    const assistantOnlyFile = path.join(assistantOnlyDir, 'session-assist.jsonl');
+    fs.writeFileSync(assistantOnlyFile, JSON.stringify(assistantMsg) + '\n');
+
+    const freshAdapter = new CtmAdapter({ projectsDir: tmpDir });
+    const memories = await freshAdapter.poll(null);
+    const observed = memories.filter(m => m.direction === 'observed');
+    assert.ok(observed.length >= 1, 'should have at least one observed memory from assistant-only session');
+  });
+});

package/template/wall-e/tests/adapter-slack.test.js

@@ -0,0 +1,98 @@
+const { describe, it } = require('node:test');
+const assert = require('node:assert');
+const SlackAdapter = require('../adapters/slack');
+
+describe('SlackAdapter', () => {
+  it('normalize() inbound message from non-owner', () => {
+    const adapter = new SlackAdapter({ ownerNames: ['Bot User'] });
+    const result = adapter.normalize({
+      sender: 'Alice Chen',
+      text: 'Hello team',
+      channel: '#engineering',
+      ts: '1234567890.123456',
+      permalink: 'https://slack.com/msg/1',
+      thread_ts: null,
+      timestamp: '2026-03-22T10:00:00.000Z',
+    });
+
+    assert.strictEqual(result.source, 'slack');
+    assert.strictEqual(result.direction, 'inbound');
+    assert.strictEqual(result.memory_type, 'message_received');
+    assert.strictEqual(result.source_channel, '#engineering');
+  });
+
+  it('normalize() outbound message when sender matches ownerNames', () => {
+    const adapter = new SlackAdapter({ ownerNames: ['Alice Chen'] });
+    const result = adapter.normalize({
+      sender: 'Alice Chen',
+      text: 'Hello team',
+      channel: '#engineering',
+      ts: '1234567890.123456',
+      permalink: 'https://slack.com/msg/1',
+      thread_ts: null,
+      timestamp: '2026-03-22T10:00:00.000Z',
+    });
+
+    assert.strictEqual(result.direction, 'outbound');
+    assert.strictEqual(result.memory_type, 'message_sent');
+  });
+
+  it('normalize() returns null on empty text', () => {
+    const adapter = new SlackAdapter({ ownerNames: [] });
+    const result = adapter.normalize({
+      sender: 'Alice Chen',
+      text: '',
+      channel: '#engineering',
+      ts: '123',
+    });
+
+    assert.strictEqual(result, null);
+  });
+
+  it('normalize() handles missing sender (participants is null)', () => {
+    const adapter = new SlackAdapter({ ownerNames: [] });
+    const result = adapter.normalize({
+      text: 'System notification',
+      channel: '#alerts',
+      ts: '999',
+    });
+
+    assert.strictEqual(result.participants, null);
+    assert.strictEqual(result.content, 'System notification');
+  });
+
+  it('normalize() generates source_id when ts is missing', () => {
+    const adapter = new SlackAdapter({ ownerNames: [] });
+    const result = adapter.normalize({
+      sender: 'Alice',
+      text: 'No timestamp id',
+      channel: '#general',
+    });
+
+    assert.ok(result.source_id, 'source_id should not be null');
+    assert.ok(result.source_id.startsWith('generated-'), 'source_id should be a generated fallback');
+  });
+
+  it('feed([]) then poll() returns empty array', async () => {
+    const adapter = new SlackAdapter({ ownerNames: [] });
+    adapter.feed([]);
+    const results = await adapter.poll(null);
+    assert.deepStrictEqual(results, []);
+  });
+
+  it('feed(messages) then poll(null) returns normalized memories, second poll returns empty', async () => {
+    const adapter = new SlackAdapter({ ownerNames: ['Me'] });
+    adapter.feed([
+      { sender: 'Alice', text: 'Hi', channel: '#general', ts: '1', timestamp: '2026-03-22T10:00:00.000Z' },
+      { sender: 'Me', text: 'Hello', channel: '#general', ts: '2', timestamp: '2026-03-22T10:01:00.000Z' },
+    ]);
+
+    const first = await adapter.poll(null);
+    assert.strictEqual(first.length, 2);
+    assert.strictEqual(first[0].direction, 'inbound');
+    assert.strictEqual(first[1].direction, 'outbound');
+
+    const second = await adapter.poll(null);
+    assert.deepStrictEqual(second, []);
+  });
+});

package/template/wall-e/tests/agent-api.test.js

@@ -0,0 +1,256 @@
+const { describe, it, before, after, beforeEach } = require('node:test');
+const assert = require('node:assert/strict');
+const path = require('path');
+const fs = require('fs');
+const os = require('os');
+
+const brain = require('../brain.js');
+
+let testDir;
+let testDbPath;
+
+function setupTestDb() {
+  testDir = fs.mkdtempSync(path.join(os.tmpdir(), 'wall-e-agent-test-'));
+  testDbPath = path.join(testDir, 'test-brain.db');
+  brain.initDb(testDbPath);
+  brain.setOwner('name', 'Test Owner');
+}
+
+function teardownTestDb() {
+  try { brain.closeDb(); } catch (_) {}
+  if (testDir && fs.existsSync(testDir)) {
+    fs.rmSync(testDir, { recursive: true, force: true });
+  }
+}
+
+// We need to clear require cache between tests to reset module state
+function freshAgentApi() {
+  // Clear cached module so paired agents map is fresh
+  const modPath = require.resolve('../channels/agent-api');
+  delete require.cache[modPath];
+  const agentApi = require('../channels/agent-api');
+  agentApi._resetAgentId();
+  return agentApi;
+}
+
+describe('Agent API - Identity', () => {
+  before(() => setupTestDb());
+  after(() => teardownTestDb());
+
+  it('getAgentId() returns a string based on owner name', () => {
+    const agentApi = freshAgentApi();
+    const id = agentApi.getAgentId();
+    assert.equal(typeof id, 'string');
+    assert.ok(id.startsWith('wall-e-'));
+    assert.ok(id.includes('test-owner'), `Expected id to contain "test-owner", got "${id}"`);
+  });
+});
+
+describe('Agent API - Pairing', () => {
+  before(() => setupTestDb());
+  after(() => teardownTestDb());
+
+  it('pairAgent/listPairedAgents/unpairAgent work correctly', () => {
+    const agentApi = freshAgentApi();
+
+    // Initially empty
+    assert.deepEqual(agentApi.listPairedAgents(), []);
+
+    // Pair an agent
+    agentApi.pairAgent('wall-e-alice', 'http://localhost:4000', 'Alice');
+    const paired = agentApi.listPairedAgents();
+    assert.equal(paired.length, 1);
+    assert.equal(paired[0].id, 'wall-e-alice');
+    assert.equal(paired[0].endpoint, 'http://localhost:4000');
+    assert.equal(paired[0].owner, 'Alice');
+
+    // Pair another
+    agentApi.pairAgent('wall-e-bob', 'http://localhost:5000', 'Bob');
+    assert.equal(agentApi.listPairedAgents().length, 2);
+
+    // Unpair
+    agentApi.unpairAgent('wall-e-alice');
+    const remaining = agentApi.listPairedAgents();
+    assert.equal(remaining.length, 1);
+    assert.equal(remaining[0].id, 'wall-e-bob');
+
+    // Unpair last
+    agentApi.unpairAgent('wall-e-bob');
+    assert.deepEqual(agentApi.listPairedAgents(), []);
+  });
+});
+
+describe('Agent API - Inbound Exchange', () => {
+  before(() => setupTestDb());
+  after(() => teardownTestDb());
+
+  it('returns error for unknown agent', async () => {
+    const agentApi = freshAgentApi();
+    const result = await agentApi.handleInboundExchange({
+      from: { agent_id: 'wall-e-stranger', owner: 'Stranger' },
+      intent: 'query',
+      topic: 'test',
+      message: 'Hello?',
+    });
+    assert.ok(result.error);
+    assert.ok(result.error.includes('Not paired'));
+  });
+
+  it('returns error for missing from.agent_id', async () => {
+    const agentApi = freshAgentApi();
+    const result = await agentApi.handleInboundExchange({
+      from: {},
+      message: 'Hello?',
+    });
+    assert.ok(result.error);
+    assert.ok(result.error.includes('Missing from.agent_id'));
+  });
+
+  it('handles inbound exchange from paired agent with mock chat', async () => {
+    const agentApi = freshAgentApi();
+
+    // Insert a person matching the agent owner
+    const personResult = brain.insertPerson({
+      name: 'Alice',
+      relationship: 'colleague',
+      trust_level: 0.8,
+    });
+
+    // Insert some knowledge
+    brain.insertKnowledge({
+      category: 'work_projects',
+      subject: 'Test Owner',
+      predicate: 'works on',
+      object: 'Project Alpha',
+      confidence: 0.9,
+    });
+    brain.insertKnowledge({
+      category: 'personal_health',
+      subject: 'Test Owner',
+      predicate: 'has',
+      object: 'back pain',
+      confidence: 0.8,
+    });
+
+    // Pair the agent
+    agentApi.pairAgent('wall-e-alice', 'http://localhost:4000', 'Alice');
+
+    // Mock chat module to avoid calling real API
+    const chatMod = require('../chat');
+    const originalSetClient = chatMod._setClient;
+    chatMod._setClient({
+      messages: {
+        async create() {
+          return {
+            content: [{ type: 'text', text: 'I am working on Project Alpha currently.' }],
+          };
+        },
+      },
+    });
+
+    try {
+      const result = await agentApi.handleInboundExchange({
+        from: { agent_id: 'wall-e-alice', owner: 'Alice' },
+        intent: 'query',
+        topic: 'work',
+        message: 'What are you working on?',
+      });
+
+      // Should have a valid response
+      assert.ok(!result.error, 'Should not have error: ' + (result.error || ''));
+      assert.ok(result.from);
+      assert.equal(result.from.owner, 'Test Owner');
+      assert.equal(result.intent, 'respond');
+      assert.equal(result.topic, 'work');
+      assert.ok(typeof result.message === 'string');
+      assert.ok(result.message.length > 0);
+      assert.ok(Array.isArray(result.shared_knowledge));
+      assert.equal(typeof result.withheld, 'boolean');
+
+      // Check that the exchange was logged in the DB
+      const exchanges = brain.listExchanges({ limit: 10 });
+      assert.ok(exchanges.length > 0, 'Exchange should be logged in DB');
+      const logged = exchanges.find(e => e.remote_agent_id === 'wall-e-alice' && e.direction === 'inbound');
+      assert.ok(logged, 'Should find an inbound exchange from wall-e-alice');
+      assert.equal(logged.topic, 'work');
+      assert.ok(logged.message_in.includes('What are you working on?'));
+    } finally {
+      chatMod._setClient(null);
+    }
+  });
+});
+
+describe('Brain - Persona CRUD', () => {
+  before(() => setupTestDb());
+  after(() => teardownTestDb());
+
+  it('insertPersona and getPersonaForPerson work', () => {
+    const person = brain.insertPerson({ name: 'Bob', relationship: 'friend' });
+    const persona = brain.insertPersona({
+      person_id: person.id,
+      persona_type: 'friend',
+      sharing_rules: JSON.stringify({ shareable: ['all'], never_share: ['salary'] }),
+      tone: 'casual',
+      boundaries: JSON.stringify({ never_share: ['salary'] }),
+    });
+    assert.ok(persona.id);
+
+    const fetched = brain.getPersonaForPerson(person.id);
+    assert.ok(fetched);
+    assert.equal(fetched.person_id, person.id);
+    assert.equal(fetched.tone, 'casual');
+    assert.equal(fetched.persona_type, 'friend');
+  });
+
+  it('listPersonas returns personas with person info', () => {
+    const list = brain.listPersonas();
+    assert.ok(Array.isArray(list));
+    assert.ok(list.length > 0);
+    assert.ok(list[0].person_name);
+  });
+
+  it('updatePersona changes fields', () => {
+    const people = brain.listPeople({});
+    const bob = people.find(p => p.name === 'Bob');
+    assert.ok(bob);
+    const persona = brain.getPersonaForPerson(bob.id);
+    assert.ok(persona);
+
+    brain.updatePersona(persona.id, { tone: 'formal' });
+    const updated = brain.getPersonaForPerson(bob.id);
+    assert.equal(updated.tone, 'formal');
+  });
+
+  it('updatePersona rejects invalid fields', () => {
+    const people = brain.listPeople({});
+    const bob = people.find(p => p.name === 'Bob');
+    const persona = brain.getPersonaForPerson(bob.id);
+    assert.throws(() => {
+      brain.updatePersona(persona.id, { invalid_field: 'test' });
+    }, /Invalid update fields/);
+  });
+});
+
+describe('Brain - listExchanges', () => {
+  before(() => setupTestDb());
+  after(() => teardownTestDb());
+
+  it('returns empty array when no exchanges', () => {
+    const list = brain.listExchanges({});
+    assert.ok(Array.isArray(list));
+    assert.equal(list.length, 0);
+  });
+
+  it('returns exchanges after insert', () => {
+    const { v4: uuidv4 } = require('uuid');
+    brain.getDb().prepare(`
+      INSERT INTO agent_exchanges (id, direction, remote_agent_id, topic, message_in, message_out, created_at)
+      VALUES (?, 'outbound', 'wall-e-test', 'greeting', 'hi', 'hello', datetime('now'))
+    `).run(uuidv4());
+
+    const list = brain.listExchanges({ limit: 10 });
+    assert.equal(list.length, 1);
+    assert.equal(list[0].direction, 'outbound');
+    assert.equal(list[0].topic, 'greeting');
+  });
+});