create-walle 0.1.0

package/template/wall-e/tests/channels.test.js

@@ -0,0 +1,104 @@
+'use strict';
+const { describe, it } = require('node:test');
+const assert = require('node:assert/strict');
+
+const ChannelBase = require('../channels/channel-base');
+const IMessageChannel = require('../channels/imessage-channel');
+const SlackChannel = require('../channels/slack-channel');
+
+describe('ChannelBase', () => {
+  it('stores name and defaults running to false', () => {
+    const ch = new ChannelBase('test');
+    assert.equal(ch.name, 'test');
+    assert.equal(ch.running, false);
+  });
+
+  it('start() throws not-implemented error', async () => {
+    const ch = new ChannelBase('test');
+    await assert.rejects(() => ch.start(), /test\.start\(\) not implemented/);
+  });
+
+  it('send() throws not-implemented error', async () => {
+    const ch = new ChannelBase('test');
+    await assert.rejects(() => ch.send('target', 'msg'), /test\.send\(\) not implemented/);
+  });
+
+  it('stop() sets running to false', async () => {
+    const ch = new ChannelBase('test');
+    ch.running = true;
+    await ch.stop();
+    assert.equal(ch.running, false);
+  });
+});
+
+describe('IMessageChannel', () => {
+  it('constructor sets buddyId from opts', () => {
+    const ch = new IMessageChannel({ buddyId: '+15551234567' });
+    assert.equal(ch.buddyId, '+15551234567');
+    assert.equal(ch.name, 'imessage');
+    assert.equal(ch.running, false);
+  });
+
+  it('constructor defaults buddyId to null', () => {
+    const ch = new IMessageChannel();
+    assert.equal(ch.buddyId, null);
+  });
+
+  it('constructor accepts custom pollInterval', () => {
+    const ch = new IMessageChannel({ pollInterval: 5000 });
+    assert.equal(ch.pollInterval, 5000);
+  });
+
+  it('start() with no buddyId returns without error and does not set running', async () => {
+    const ch = new IMessageChannel();
+    await ch.start(); // should not throw
+    assert.equal(ch.running, false);
+  });
+
+  it('stop() clears poll timer', async () => {
+    const ch = new IMessageChannel({ buddyId: '+15551234567' });
+    ch.running = true;
+    ch._pollTimer = setTimeout(() => {}, 100000);
+    await ch.stop();
+    assert.equal(ch.running, false);
+  });
+});
+
+describe('SlackChannel', () => {
+  it('constructor sets botToken from opts', () => {
+    const ch = new SlackChannel({ botToken: 'xoxb-test-token' });
+    assert.equal(ch.botToken, 'xoxb-test-token');
+    assert.equal(ch.name, 'slack_dm');
+    assert.equal(ch.running, false);
+  });
+
+  it('constructor defaults botToken to null when env not set', () => {
+    const orig = process.env.SLACK_BOT_TOKEN;
+    delete process.env.SLACK_BOT_TOKEN;
+    const ch = new SlackChannel();
+    assert.equal(ch.botToken, null);
+    if (orig !== undefined) process.env.SLACK_BOT_TOKEN = orig;
+  });
+
+  it('constructor accepts custom pollInterval', () => {
+    const ch = new SlackChannel({ pollInterval: 30000 });
+    assert.equal(ch.pollInterval, 30000);
+  });
+
+  it('start() with no botToken returns without error and does not set running', async () => {
+    const orig = process.env.SLACK_BOT_TOKEN;
+    delete process.env.SLACK_BOT_TOKEN;
+    const ch = new SlackChannel();
+    await ch.start(); // should not throw
+    assert.equal(ch.running, false);
+    if (orig !== undefined) process.env.SLACK_BOT_TOKEN = orig;
+  });
+
+  it('stop() clears poll timer', async () => {
+    const ch = new SlackChannel({ botToken: 'xoxb-test' });
+    ch.running = true;
+    ch._pollTimer = setTimeout(() => {}, 100000);
+    await ch.stop();
+    assert.equal(ch.running, false);
+  });
+});

package/template/wall-e/tests/chat.test.js

@@ -0,0 +1,103 @@
+'use strict';
+const { describe, it, before, after } = 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;
+
+function setupTestDb() {
+  testDir = fs.mkdtempSync(path.join(os.tmpdir(), 'wall-e-chat-test-'));
+  const testDbPath = path.join(testDir, 'test-brain.db');
+  brain.initDb(testDbPath);
+  brain.setOwner('name', 'TestUser');
+}
+
+function teardownTestDb() {
+  try { brain.closeDb(); } catch (_) {}
+  if (testDir && fs.existsSync(testDir)) {
+    fs.rmSync(testDir, { recursive: true, force: true });
+  }
+}
+
+describe('Chat Module', () => {
+  before(() => setupTestDb());
+  after(() => teardownTestDb());
+
+  it('returns a reply from mock client', async () => {
+    const chatModule = require('../chat.js');
+
+    // Inject a mock client
+    chatModule._setClient({
+      messages: {
+        async create() {
+          return {
+            content: [{ type: 'text', text: 'Hello from mock WALL-E!' }],
+          };
+        }
+      }
+    });
+
+    const result = await chatModule.chat('Hi there');
+    assert.ok(result.reply);
+    assert.equal(result.reply, 'Hello from mock WALL-E!');
+
+    // Clean up
+    chatModule._setClient(null);
+  });
+
+  it('stores inbound and outbound memories', async () => {
+    const chatModule = require('../chat.js');
+
+    chatModule._setClient({
+      messages: {
+        async create() {
+          return {
+            content: [{ type: 'text', text: 'Mock reply for memory test' }],
+          };
+        }
+      }
+    });
+
+    const beforeCount = brain.listMemories({ source: 'wall-e-chat' }).length;
+    await chatModule.chat('Remember this test message');
+    const afterMemories = brain.listMemories({ source: 'wall-e-chat' });
+
+    // Should have 2 new memories (inbound + outbound)
+    assert.equal(afterMemories.length - beforeCount, 2);
+
+    const inbound = afterMemories.find(m => m.memory_type === 'message_received' && m.content === 'Remember this test message');
+    const outbound = afterMemories.find(m => m.memory_type === 'message_sent' && m.content === 'Mock reply for memory test');
+    assert.ok(inbound, 'should have inbound memory');
+    assert.ok(outbound, 'should have outbound memory');
+    assert.equal(inbound.direction, 'inbound');
+    assert.equal(outbound.direction, 'outbound');
+
+    chatModule._setClient(null);
+  });
+
+  it('includes owner name in system prompt context', async () => {
+    const chatModule = require('../chat.js');
+    let capturedParams = null;
+
+    chatModule._setClient({
+      messages: {
+        async create(params) {
+          capturedParams = params;
+          return {
+            content: [{ type: 'text', text: 'ok' }],
+          };
+        }
+      }
+    });
+
+    await chatModule.chat('test');
+    assert.ok(capturedParams);
+    assert.ok(capturedParams.system.includes('TestUser'), 'system prompt should include owner name');
+
+    chatModule._setClient(null);
+  });
+});

package/template/wall-e/tests/confidence.test.js

@@ -0,0 +1,134 @@
+'use strict';
+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;
+
+function setupTestDb() {
+  testDir = fs.mkdtempSync(path.join(os.tmpdir(), 'wall-e-conf-test-'));
+  const testDbPath = path.join(testDir, 'test-brain.db');
+  brain.initDb(testDbPath);
+  brain.setOwner('name', 'TestUser');
+}
+
+function teardownTestDb() {
+  try { brain.closeDb(); } catch (_) {}
+  if (testDir && fs.existsSync(testDir)) {
+    fs.rmSync(testDir, { recursive: true, force: true });
+  }
+}
+
+describe('Confidence Module', () => {
+  before(() => setupTestDb());
+  after(() => teardownTestDb());
+
+  it('getDomainConfidence auto-creates domain entry', () => {
+    const confidence = require('../decision/confidence.js');
+    const dc = confidence.getDomainConfidence('slack');
+    assert.ok(dc);
+    assert.equal(dc.domain, 'slack');
+    assert.equal(dc.current_tier, 1);
+    assert.equal(dc.total_actions, 0);
+  });
+
+  it('recordAction increments counts', () => {
+    const confidence = require('../decision/confidence.js');
+    confidence.recordAction('email', true);
+    const dc = confidence.getDomainConfidence('email');
+    assert.equal(dc.total_actions, 1);
+    assert.equal(dc.approved_actions, 1);
+    assert.equal(dc.rejected_actions, 0);
+
+    confidence.recordAction('email', false);
+    const dc2 = confidence.getDomainConfidence('email');
+    assert.equal(dc2.total_actions, 2);
+    assert.equal(dc2.approved_actions, 1);
+    assert.equal(dc2.rejected_actions, 1);
+  });
+
+  it('checkGraduation promotes from tier 1 to 2 when memories > 50', () => {
+    const confidence = require('../decision/confidence.js');
+    const domain = 'calendar';
+
+    // Insert 51 memories with source = 'calendar'
+    for (let i = 0; i < 51; i++) {
+      brain.insertMemory({
+        source: domain,
+        source_id: `cal-${i}`,
+        memory_type: 'event',
+        content: `Calendar event ${i}`,
+        timestamp: new Date().toISOString(),
+      });
+    }
+
+    const result = confidence.checkGraduation(domain);
+    assert.equal(result.promoted, true);
+    assert.equal(result.from, 1);
+    assert.equal(result.to, 2);
+
+    const dc = confidence.getDomainConfidence(domain);
+    assert.equal(dc.current_tier, 2);
+  });
+
+  it('canActAutonomously returns false for tier 2, true for tier 4', () => {
+    const confidence = require('../decision/confidence.js');
+
+    // 'slack' is at tier 1
+    assert.equal(confidence.canActAutonomously('slack', false), false);
+
+    // 'calendar' is at tier 2 after previous test
+    assert.equal(confidence.canActAutonomously('calendar', false), false);
+
+    // Manually set a domain to tier 3
+    brain.getDb().prepare("UPDATE domain_confidence SET current_tier = 3 WHERE domain = 'calendar'").run();
+    assert.equal(confidence.canActAutonomously('calendar', false), true);
+    assert.equal(confidence.canActAutonomously('calendar', true), false); // high-risk blocked at tier 3
+
+    // Manually set to tier 4
+    brain.getDb().prepare("UPDATE domain_confidence SET current_tier = 4 WHERE domain = 'calendar'").run();
+    assert.equal(confidence.canActAutonomously('calendar', true), true); // even high-risk OK at tier 4
+  });
+
+  it('demotion: 3 rejections in a row drops tier', () => {
+    const confidence = require('../decision/confidence.js');
+    const domain = 'deploy';
+
+    // Set up at tier 3
+    confidence.getDomainConfidence(domain);
+    brain.getDb().prepare("UPDATE domain_confidence SET current_tier = 3 WHERE domain = ?").run(domain);
+
+    // Insert 3 rejected actions
+    for (let i = 0; i < 3; i++) {
+      brain.insertAction({
+        action_type: 'deploy',
+        tier: 3,
+        domain,
+        description: `Deploy action ${i}`,
+        confidence: 0.8,
+      });
+    }
+    // Mark all 3 as rejected
+    const actions = brain.listActions({ domain });
+    for (const a of actions.slice(0, 3)) {
+      brain.updateActionStatus(a.id, 'rejected', 'bad deploy');
+    }
+
+    // Now record another rejection -- should trigger demotion
+    confidence.recordAction(domain, false);
+
+    const dc = confidence.getDomainConfidence(domain);
+    assert.equal(dc.current_tier, 2, 'should have been demoted from tier 3 to 2');
+  });
+
+  it('listDomainConfidences returns all domains', () => {
+    const confidence = require('../decision/confidence.js');
+    const list = confidence.listDomainConfidences();
+    assert.ok(Array.isArray(list));
+    assert.ok(list.length >= 3); // slack, email, calendar, deploy
+  });
+});

package/template/wall-e/tests/contradiction.test.js

@@ -0,0 +1,217 @@
+const { describe, it, before, after } = 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');
+const { buildContradictionPrompt, parseContradictionResponse, detectContradictions } = require('../extraction/contradiction.js');
+
+let testDir;
+let testDbPath;
+
+function setupTestDb() {
+  testDir = fs.mkdtempSync(path.join(os.tmpdir(), 'wall-e-contradiction-test-'));
+  testDbPath = path.join(testDir, 'test-brain.db');
+  brain.initDb(testDbPath);
+}
+
+function teardownTestDb() {
+  try { brain.closeDb(); } catch (_) {}
+  if (testDir && fs.existsSync(testDir)) {
+    fs.rmSync(testDir, { recursive: true, force: true });
+  }
+}
+
+// ── buildContradictionPrompt ──────────────────────────────────────────────
+
+describe('buildContradictionPrompt', () => {
+  it('includes existing knowledge entries in XML blocks', () => {
+    const existing = [
+      { id: 'k1', status: 'active', subject: 'TestUser', predicate: 'prefers_editor', object: 'VSCode', confidence: 0.9 },
+    ];
+    const newEntries = [
+      { subject: 'TestUser', predicate: 'prefers_editor', object: 'Cursor' },
+    ];
+    const prompt = buildContradictionPrompt(existing, newEntries, 'TestUser');
+
+    assert.ok(prompt.includes('<existing_knowledge id="k1"'));
+    assert.ok(prompt.includes('VSCode'));
+    assert.ok(prompt.includes('<new_entry index="0"'));
+    assert.ok(prompt.includes('Cursor'));
+    assert.ok(prompt.includes('TestUser'));
+  });
+
+  it('includes owner name', () => {
+    const prompt = buildContradictionPrompt([], [], 'TestOwner');
+    assert.ok(prompt.includes('TestOwner'));
+  });
+
+  it('handles multiple existing and new entries', () => {
+    const existing = [
+      { id: 'k1', status: 'active', subject: 'A', predicate: 'p', object: 'o1', confidence: 0.5 },
+      { id: 'k2', status: 'active', subject: 'A', predicate: 'q', object: 'o2', confidence: 0.7 },
+    ];
+    const newEntries = [
+      { subject: 'A', predicate: 'p', object: 'o3' },
+      { subject: 'A', predicate: 'q', object: 'o4' },
+    ];
+    const prompt = buildContradictionPrompt(existing, newEntries, 'Owner');
+    assert.ok(prompt.includes('id="k1"'));
+    assert.ok(prompt.includes('id="k2"'));
+    assert.ok(prompt.includes('index="0"'));
+    assert.ok(prompt.includes('index="1"'));
+  });
+
+  it('escapes backtick fences in content', () => {
+    const existing = [
+      { id: 'k1', status: 'active', subject: 'test```inject', predicate: 'p', object: 'o', confidence: 0.5 },
+    ];
+    const prompt = buildContradictionPrompt(existing, [], 'Owner');
+    assert.ok(!prompt.includes('test```inject'));
+    assert.ok(prompt.includes('test` ` `inject'));
+  });
+});
+
+// ── parseContradictionResponse ────────────────────────────────────────────
+
+describe('parseContradictionResponse', () => {
+  it('parses valid JSON array', () => {
+    const input = JSON.stringify([
+      { old_id: 'k1', new_subject: 'A', new_predicate: 'p', new_object: 'o', explanation: 'contradicts' }
+    ]);
+    const result = parseContradictionResponse(input);
+    assert.equal(result.length, 1);
+    assert.equal(result[0].old_id, 'k1');
+    assert.equal(result[0].explanation, 'contradicts');
+  });
+
+  it('strips markdown fences', () => {
+    const input = '```json\n[{"old_id":"k1","new_subject":"A","new_predicate":"p","new_object":"o","explanation":"x"}]\n```';
+    const result = parseContradictionResponse(input);
+    assert.equal(result.length, 1);
+    assert.equal(result[0].old_id, 'k1');
+  });
+
+  it('returns [] for empty array', () => {
+    const result = parseContradictionResponse('[]');
+    assert.deepEqual(result, []);
+  });
+
+  it('returns [] for invalid JSON', () => {
+    const result = parseContradictionResponse('not json at all');
+    assert.deepEqual(result, []);
+  });
+
+  it('returns [] for non-array JSON', () => {
+    const result = parseContradictionResponse('{"key": "value"}');
+    assert.deepEqual(result, []);
+  });
+
+  it('filters out entries missing required fields', () => {
+    const input = JSON.stringify([
+      { old_id: 'k1', new_subject: 'A', new_predicate: 'p', new_object: 'o', explanation: 'ok' },
+      { old_id: 'k2', new_subject: 'B' }, // missing fields
+    ]);
+    const result = parseContradictionResponse(input);
+    assert.equal(result.length, 1);
+    assert.equal(result[0].old_id, 'k1');
+  });
+
+  it('returns [] for empty string', () => {
+    assert.deepEqual(parseContradictionResponse(''), []);
+  });
+});
+
+// ── detectContradictions ──────────────────────────────────────────────────
+
+describe('detectContradictions', () => {
+  before(() => setupTestDb());
+  after(() => teardownTestDb());
+
+  it('returns empty array when no new entries', async () => {
+    const result = await detectContradictions([], 'Owner');
+    assert.deepEqual(result, []);
+  });
+
+  it('returns empty array when no existing knowledge matches', async () => {
+    const mockDetectFn = () => {
+      throw new Error('Should not be called');
+    };
+    const result = await detectContradictions(
+      [{ subject: 'NonexistentSubject', predicate: 'p', object: 'o' }],
+      'Owner',
+      { detectFn: mockDetectFn }
+    );
+    assert.deepEqual(result, []);
+  });
+
+  it('detects contradictions using mockDetectFn', async () => {
+    // Insert existing knowledge
+    const existing = brain.insertKnowledge({
+      category: 'preference',
+      subject: 'TestUser',
+      predicate: 'prefers_language',
+      object: 'Python',
+    });
+
+    const mockDetectFn = (existingKnowledge, newEntries, ownerName) => {
+      assert.ok(existingKnowledge.length >= 1);
+      assert.equal(ownerName, 'TestUser');
+      return [{
+        old_id: existing.id,
+        new_subject: 'TestUser',
+        new_predicate: 'prefers_language',
+        new_object: 'Rust',
+        explanation: 'Changed preference from Python to Rust',
+      }];
+    };
+
+    const result = await detectContradictions(
+      [{ subject: 'TestUser', predicate: 'prefers_language', object: 'Rust' }],
+      'TestUser',
+      { detectFn: mockDetectFn }
+    );
+
+    assert.equal(result.length, 1);
+    assert.equal(result[0].old_id, existing.id);
+    assert.equal(result[0].new_entry.subject, 'TestUser');
+    assert.equal(result[0].new_entry.object, 'Rust');
+    assert.equal(result[0].explanation, 'Changed preference from Python to Rust');
+  });
+
+  it('handles multiple subjects with mockDetectFn', async () => {
+    brain.insertKnowledge({ category: 'preference', subject: 'SubA', predicate: 'likes', object: 'X' });
+    brain.insertKnowledge({ category: 'preference', subject: 'SubB', predicate: 'likes', object: 'Y' });
+
+    const mockDetectFn = (existingKnowledge, newEntries, ownerName) => {
+      // Return contradiction for SubA only
+      if (existingKnowledge.some(k => k.subject === 'SubA')) {
+        return [{ old_id: existingKnowledge[0].id, new_subject: 'SubA', new_predicate: 'likes', new_object: 'Z', explanation: 'changed' }];
+      }
+      return [];
+    };
+
+    const result = await detectContradictions(
+      [
+        { subject: 'SubA', predicate: 'likes', object: 'Z' },
+        { subject: 'SubB', predicate: 'likes', object: 'Y' }, // same, no contradiction
+      ],
+      'Owner',
+      { detectFn: mockDetectFn }
+    );
+
+    assert.equal(result.length, 1);
+    assert.equal(result[0].new_entry.subject, 'SubA');
+  });
+
+  it('skips entries with no subject', async () => {
+    const mockDetectFn = () => { throw new Error('Should not be called'); };
+    const result = await detectContradictions(
+      [{ predicate: 'p', object: 'o' }], // no subject
+      'Owner',
+      { detectFn: mockDetectFn }
+    );
+    assert.deepEqual(result, []);
+  });
+});

package/template/wall-e/tests/ingest.test.js

@@ -0,0 +1,113 @@
+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 brain = require('../brain');
+const CtmAdapter = require('../adapters/ctm');
+const ingest = require('../loops/ingest');
+
+describe('Ingest Loop', () => {
+  let tmpDir;
+  let dbPath;
+  let adapter;
+
+  const userMsg = {
+    type: 'user',
+    message: { role: 'user', content: 'Implement the login feature' },
+    cwd: '/home/user/project',
+    timestamp: '2026-03-22T10:00:00Z',
+    uuid: 'ingest-msg-001',
+  };
+
+  const assistantMsg = {
+    type: 'assistant',
+    message: {
+      role: 'assistant',
+      content: [{ type: 'text', text: 'Sure, creating login feature now.' }],
+    },
+    timestamp: '2026-03-22T10:01:00Z',
+    uuid: 'ingest-msg-002',
+  };
+
+  before(() => {
+    tmpDir = fs.mkdtempSync(path.join(os.tmpdir(), 'ingest-test-'));
+
+    // Init brain DB in temp dir
+    dbPath = path.join(tmpDir, 'wall-e-brain.db');
+    brain.initDb(dbPath);
+
+    // Create test session files
+    const sessionsDir = path.join(tmpDir, 'sessions');
+    const projectDir = path.join(sessionsDir, '-home-user-project');
+    fs.mkdirSync(projectDir, { recursive: true });
+
+    const sessionFile = path.join(projectDir, 'session-001.jsonl');
+    const lines = [JSON.stringify(userMsg), JSON.stringify(assistantMsg)].join('\n');
+    fs.writeFileSync(sessionFile, lines);
+
+    adapter = new CtmAdapter({ projectsDir: sessionsDir });
+  });
+
+  after(() => {
+    brain.closeDb();
+    fs.rmSync(tmpDir, { recursive: true, force: true });
+  });
+
+  it('runOnce([adapter]) returns {memoriesIngested: N} where N >= 1', async () => {
+    const result = await ingest.runOnce([adapter]);
+    assert.ok(result.memoriesIngested >= 1, `expected at least 1, got ${result.memoriesIngested}`);
+  });
+
+  it('after ingest, brain.listMemories({source:"ctm"}) contains ingested memories', () => {
+    const memories = brain.listMemories({ source: 'ctm' });
+    assert.ok(memories.length >= 1, `expected at least 1 memory, got ${memories.length}`);
+    assert.ok(memories.every(m => m.source === 'ctm'));
+  });
+
+  it('brain.getCheckpoint("ingest") has been updated', () => {
+    const checkpoint = brain.getCheckpoint('ingest');
+    assert.ok(checkpoint, 'checkpoint should exist');
+    assert.ok(checkpoint.last_run_at, 'checkpoint should have last_run_at');
+    assert.ok(checkpoint.last_memory_at, 'checkpoint should have last_memory_at');
+  });
+
+  it('running runOnce again returns {memoriesIngested: 0} (dedup)', async () => {
+    const result = await ingest.runOnce([adapter]);
+    assert.strictEqual(result.memoriesIngested, 0, 'second run should ingest 0 due to dedup');
+  });
+
+  it('if adapter throws during poll(), ingest continues with other adapters', async () => {
+    // Create a mock adapter that throws
+    const failAdapter = {
+      name: 'fail-adapter',
+      async poll() { throw new Error('Simulated adapter failure'); },
+    };
+
+    // Create a working adapter with fresh session data
+    const freshSessionsDir = path.join(tmpDir, 'sessions-fresh');
+    const freshProjectDir = path.join(freshSessionsDir, '-home-user-fresh');
+    fs.mkdirSync(freshProjectDir, { recursive: true });
+
+    const freshMsg = {
+      type: 'user',
+      message: { role: 'user', content: 'Fresh message for error test' },
+      timestamp: '2026-03-22T11:00:00Z',
+      uuid: 'ingest-fresh-001',
+    };
+    fs.writeFileSync(
+      path.join(freshProjectDir, 'session-fresh.jsonl'),
+      JSON.stringify(freshMsg)
+    );
+
+    const freshAdapter = new CtmAdapter({ projectsDir: freshSessionsDir });
+
+    const result = await ingest.runOnce([failAdapter, freshAdapter]);
+    assert.ok(result.memoriesIngested >= 1, `expected at least 1 from working adapter, got ${result.memoriesIngested}`);
+  });
+
+  it('runOnce([]) with empty adapter list returns {memoriesIngested: 0}', async () => {
+    const result = await ingest.runOnce([]);
+    assert.strictEqual(result.memoriesIngested, 0);
+  });
+});