@onmars/lunar-core 0.1.0

package/src/__tests__/router.test.ts

@@ -0,0 +1,1246 @@
+/**
+ * # Router — Functional Specification
+ *
+ * The Router is the central orchestrator of the message flow:
+ *
+ *     Incoming Message → Auth → Session → [Memory Recall] → Agent Query → [Redaction] → Response
+ *
+ * ## Responsibilities:
+ * 1. **Auth gating**: only allowed sender IDs can trigger agent queries
+ * 2. **Session management**: maps channel:chatId → agentSessionId for conversation resumption
+ * 3. **Moon resolution**: selects the right persona (SOUL.md) per channel
+ * 4. **Auto-recall** (optional): calls MemoryProvider.recall() before each query and
+ *    injects relevant memories into the system prompt as `## Memory Context`
+ * 5. **Memory instructions** (optional): injects brain/memory API usage instructions
+ *    into system prompt with 3-level priority cascade:
+ *      1. `config.yaml memory.instructionsFile` (explicit path)
+ *      2. `prompts/{provider}.md` in workspace (convention-based)
+ *      3. Provider's built-in `agentInstructions()` (fallback)
+ * 6. **Output redaction**: scrubs known secret patterns before sending to channel
+ * 7. **Typing indicator**: sends Discord-style typing signals during processing
+ * 8. **Error handling**: agent failures are caught and surfaced as user-friendly messages
+ */
+import { afterEach, beforeEach, describe, expect, it, mock } from 'bun:test'
+import { mkdirSync, rmSync, writeFileSync } from 'node:fs'
+import { resolve } from 'node:path'
+import type { LunarConfig } from '../lib/config'
+import type { MemoryConfig, RecallConfig, SecurityConfig } from '../lib/config-loader'
+import { MoonLoader } from '../lib/moon-loader'
+import { PluginRegistry } from '../lib/plugin'
+import { Router } from '../lib/router'
+import { SessionStore } from '../lib/session'
+import type { Agent, AgentEvent } from '../types/agent'
+import type { Channel, IncomingMessage } from '../types/channel'
+import type { MemoryProvider, MemoryResult } from '../types/memory'
+
+// ─── Test infrastructure ───────────────────────────────────────────
+
+const TMP = resolve(import.meta.dir, '.tmp-router-test')
+const DB_PATH = resolve(TMP, 'test.db')
+
+function setupWorkspace(extraFiles?: Record<string, string>): string {
+  rmSync(TMP, { recursive: true, force: true })
+  mkdirSync(resolve(TMP, 'prompts'), { recursive: true })
+  writeFileSync(resolve(TMP, 'SOUL.md'), '# Test Moon\nI am a test assistant.')
+  writeFileSync(resolve(TMP, 'AGENTS.md'), 'Be helpful.')
+  writeFileSync(resolve(TMP, 'IDENTITY.md'), '- **Name:** TestMoon\n- **Emoji:** 🧪')
+
+  if (extraFiles) {
+    for (const [path, content] of Object.entries(extraFiles)) {
+      const fullPath = resolve(TMP, path)
+      mkdirSync(resolve(fullPath, '..'), { recursive: true })
+      writeFileSync(fullPath, content)
+    }
+  }
+  return TMP
+}
+
+function cleanup(): void {
+  rmSync(TMP, { recursive: true, force: true })
+}
+
+const mockConfig: LunarConfig = {
+  discordToken: 'test-token',
+  discordGuildId: 'test-guild',
+  discordAllowedUsers: ['user-123'],
+  rootDir: TMP,
+  moonWorkspace: TMP,
+  dataDir: resolve(TMP, 'store'),
+  agentBackend: 'claude',
+  logLevel: 'info',
+  dev: false,
+}
+
+function createChannel(): Channel & {
+  lastSent: { target: string; msg: any } | null
+  typingCount: number
+} {
+  const ch = {
+    id: 'discord',
+    name: 'Mock Discord',
+    lastSent: null as { target: string; msg: any } | null,
+    typingCount: 0,
+    connect: async () => {},
+    disconnect: async () => {},
+    isConnected: () => true,
+    send: async (target: string, msg: any) => {
+      ch.lastSent = { target, msg }
+      return undefined
+    },
+    sendTyping: async () => {
+      ch.typingCount++
+    },
+    onMessage: () => {},
+  }
+  return ch as typeof ch & Channel
+}
+
+function createAgent(response = 'Hello!'): Agent {
+  return {
+    id: 'claude',
+    name: 'Mock Claude',
+    init: async () => {},
+    destroy: async () => {},
+    query: async function* (input) {
+      yield { type: 'text' as const, content: response }
+      yield { type: 'done' as const, sessionId: 'session-1' }
+    },
+    health: async () => ({ ok: true }),
+  }
+}
+
+/** Spy agent: captures the AgentInput so tests can inspect systemPrompt */
+function createSpyAgent(): Agent & { capturedInput: any } {
+  const spy: Agent & { capturedInput: any } = {
+    id: 'claude',
+    name: 'Spy Claude',
+    capturedInput: null,
+    init: async () => {},
+    destroy: async () => {},
+    query: async function* (input) {
+      spy.capturedInput = input
+      yield { type: 'text' as const, content: 'ok' }
+      yield { type: 'done' as const, sessionId: 's1' }
+    },
+    health: async () => ({ ok: true }),
+  }
+  return spy
+}
+
+function createMemory(
+  recallResults: MemoryResult[] = [],
+): MemoryProvider & { lastRecallQuery: string | null } {
+  const mem: MemoryProvider & { lastRecallQuery: string | null } = {
+    id: 'brain',
+    name: 'Test Brain',
+    lastRecallQuery: null,
+    init: async () => {},
+    destroy: async () => {},
+    recall: async (query: string) => {
+      mem.lastRecallQuery = query
+      return recallResults
+    },
+    save: async () => {},
+    health: async () => ({ ok: true }),
+    agentInstructions: () => '## Test Brain Instructions\nUse curl to query the brain.',
+  }
+  return mem
+}
+
+function msg(text: string, senderId = 'user-123'): IncomingMessage {
+  return {
+    id: 'msg-1',
+    channelId: 'chan-1',
+    text,
+    sender: { id: senderId, name: 'Test User' },
+    timestamp: new Date(),
+  }
+}
+
+// ═══════════════════════════════════════════════════════════════════
+
+describe('Router', () => {
+  let registry: PluginRegistry
+  let sessions: SessionStore
+  let moonLoader: MoonLoader
+  let channel: ReturnType<typeof createChannel>
+
+  beforeEach(async () => {
+    setupWorkspace()
+    registry = new PluginRegistry()
+    sessions = new SessionStore(DB_PATH)
+    moonLoader = new MoonLoader()
+    await moonLoader.loadAll(TMP)
+    channel = createChannel()
+    registry.registerChannel(channel)
+  })
+
+  afterEach(() => {
+    sessions.close()
+    cleanup()
+  })
+
+  // ─── Core message flow ─────────────────────────────────────────
+
+  describe('basic message flow', () => {
+    it('routes message → agent → channel response', async () => {
+      registry.registerAgent(createAgent('Hello from agent!'), true)
+      const router = new Router(registry, sessions, mockConfig, moonLoader, [])
+
+      await router.route('discord', msg('Hi'))
+
+      expect(channel.lastSent).not.toBeNull()
+      expect(channel.lastSent!.msg.text).toBe('Hello from agent!')
+    })
+
+    it('sends typing indicator while processing', async () => {
+      registry.registerAgent(createAgent(), true)
+      const router = new Router(registry, sessions, mockConfig, moonLoader, [])
+
+      await router.route('discord', msg('Hello'))
+
+      expect(channel.typingCount).toBeGreaterThan(0)
+    })
+
+    it('creates persistent session on first message', async () => {
+      registry.registerAgent(createAgent(), true)
+      const router = new Router(registry, sessions, mockConfig, moonLoader, [])
+
+      await router.route('discord', msg('Hello'))
+
+      const session = sessions.get('claude:discord:chan-1')
+      expect(session).not.toBeNull()
+      expect(session!.agentSessionId).toBe('session-1')
+    })
+  })
+
+  // ─── Authorization ─────────────────────────────────────────────
+
+  describe('auth — sender allowlist', () => {
+    it('rejects messages from unauthorized senders (silent drop)', async () => {
+      registry.registerAgent(createAgent(), true)
+      const router = new Router(registry, sessions, mockConfig, moonLoader, [])
+
+      await router.route('discord', msg('Hello', 'unauthorized-user'))
+
+      expect(channel.lastSent).toBeNull()
+    })
+
+    it('allows all senders when allowlist is empty (open mode)', async () => {
+      const openConfig = { ...mockConfig, discordAllowedUsers: [] }
+      registry.registerAgent(createAgent(), true)
+      const router = new Router(registry, sessions, openConfig, moonLoader, [])
+
+      await router.route('discord', msg('Hello', 'anyone'))
+
+      expect(channel.lastSent).not.toBeNull()
+    })
+  })
+
+  // ─── Auto-recall ───────────────────────────────────────────────
+
+  describe('auto-recall — inject relevant memories before query', () => {
+    const autoRecall: RecallConfig = { enabled: true, limit: 5, minScore: 0.3, budget: 800 }
+
+    it('calls memory.recall() with user message as query', async () => {
+      const memory = createMemory([
+        { content: 'Alice likes TypeScript', score: 0.8, metadata: { type: 'fact' } },
+      ])
+      const spy = createSpyAgent()
+      registry.registerAgent(spy, true)
+
+      const router = new Router(
+        registry,
+        sessions,
+        mockConfig,
+        moonLoader,
+        [],
+        undefined,
+        memory,
+        autoRecall,
+      )
+
+      await router.route('discord', msg('What do I like?'))
+
+      expect(memory.lastRecallQuery).toBe('What do I like?')
+    })
+
+    it('injects recalled memories into system prompt', async () => {
+      const spy = createSpyAgent()
+      registry.registerAgent(spy, true)
+
+      const memory = createMemory([
+        { content: 'Important fact', score: 0.85, metadata: { type: 'fact' } },
+      ])
+
+      const router = new Router(
+        registry,
+        sessions,
+        mockConfig,
+        moonLoader,
+        [],
+        undefined,
+        memory,
+        autoRecall,
+      )
+
+      await router.route('discord', msg('test'))
+
+      // System prompt should contain the memory context section
+      expect(spy.capturedInput.systemPrompt).toContain('Memory Context')
+      expect(spy.capturedInput.systemPrompt).toContain('Important fact')
+      expect(spy.capturedInput.systemPrompt).toContain('85%')
+    })
+
+    it('skips recall entirely when autoRecall.enabled=false', async () => {
+      const memory = createMemory()
+      registry.registerAgent(createAgent(), true)
+
+      const router = new Router(registry, sessions, mockConfig, moonLoader, [], undefined, memory, {
+        ...autoRecall,
+        enabled: false,
+      })
+
+      await router.route('discord', msg('test'))
+
+      expect(memory.lastRecallQuery).toBeNull()
+    })
+
+    it('does not inject memory section when recall returns empty', async () => {
+      const spy = createSpyAgent()
+      registry.registerAgent(spy, true)
+
+      const memory = createMemory([]) // empty results
+      const router = new Router(
+        registry,
+        sessions,
+        mockConfig,
+        moonLoader,
+        [],
+        undefined,
+        memory,
+        autoRecall,
+      )
+
+      await router.route('discord', msg('test'))
+
+      expect(spy.capturedInput.systemPrompt).not.toContain('Memory Context')
+    })
+
+    it('continues gracefully when recall throws (no crash)', async () => {
+      const failingMemory = createMemory()
+      failingMemory.recall = async () => {
+        throw new Error('Brain is down')
+      }
+      registry.registerAgent(createAgent(), true)
+
+      const router = new Router(
+        registry,
+        sessions,
+        mockConfig,
+        moonLoader,
+        [],
+        undefined,
+        failingMemory,
+        autoRecall,
+      )
+
+      await router.route('discord', msg('test'))
+
+      // Should still get a response — recall failure is non-fatal
+      expect(channel.lastSent).not.toBeNull()
+      expect(channel.lastSent!.msg.text).toBe('Hello!')
+    })
+  })
+
+  // ─── Memory instructions cascade ──────────────────────────────
+
+  describe('memory instructions — 3-level priority cascade', () => {
+    const autoRecall: RecallConfig = { enabled: true, limit: 5, minScore: 0.3, budget: 800 }
+    const baseMemConfig: MemoryConfig = {
+      recall: { enabled: true, limit: 5, minScore: 0.3, budget: 800 },
+      dedup: { strategy: 'adaptive', threshold: 0.85 },
+      providers: { brain: { url: 'http://localhost:8082' } },
+    }
+
+    it('Level 3 (lowest): uses provider built-in agentInstructions()', async () => {
+      const spy = createSpyAgent()
+      registry.registerAgent(spy, true)
+
+      const router = new Router(
+        registry,
+        sessions,
+        mockConfig,
+        moonLoader,
+        [],
+        undefined,
+        createMemory(),
+        autoRecall,
+        TMP,
+        baseMemConfig,
+      )
+
+      await router.route('discord', msg('test'))
+
+      expect(spy.capturedInput.systemPrompt).toContain('Test Brain Instructions')
+    })
+
+    it('Level 2: prompts/{provider}.md overrides built-in', async () => {
+      setupWorkspace({
+        'prompts/brain.md': '## Custom Brain Prompt\nDo custom things with the brain.',
+      })
+      await moonLoader.loadAll(TMP)
+
+      const spy = createSpyAgent()
+      registry = new PluginRegistry()
+      registry.registerChannel(channel)
+      registry.registerAgent(spy, true)
+
+      const router = new Router(
+        registry,
+        sessions,
+        mockConfig,
+        moonLoader,
+        [],
+        undefined,
+        createMemory(),
+        autoRecall,
+        TMP,
+        baseMemConfig,
+      )
+
+      await router.route('discord', msg('test'))
+
+      expect(spy.capturedInput.systemPrompt).toContain('Custom Brain Prompt')
+      expect(spy.capturedInput.systemPrompt).not.toContain('Test Brain Instructions')
+    })
+
+    it('Level 1 (highest): config.instructionsFile overrides everything', async () => {
+      setupWorkspace({
+        'prompts/brain.md': 'Convention prompt',
+        'custom/my-brain-prompt.md': '## Override Prompt\nExplicit override.',
+      })
+      await moonLoader.loadAll(TMP)
+
+      const spy = createSpyAgent()
+      registry = new PluginRegistry()
+      registry.registerChannel(channel)
+      registry.registerAgent(spy, true)
+
+      const memConfig = {
+        ...baseMemConfig,
+        providers: {
+          brain: { url: 'http://localhost:8082', instructions: 'custom/my-brain-prompt.md' },
+        },
+      }
+      const router = new Router(
+        registry,
+        sessions,
+        mockConfig,
+        moonLoader,
+        [],
+        undefined,
+        createMemory(),
+        autoRecall,
+        TMP,
+        memConfig,
+      )
+
+      await router.route('discord', msg('test'))
+
+      expect(spy.capturedInput.systemPrompt).toContain('Override Prompt')
+      expect(spy.capturedInput.systemPrompt).not.toContain('Convention prompt')
+      expect(spy.capturedInput.systemPrompt).not.toContain('Test Brain Instructions')
+    })
+
+    it('no instructions when provider lacks agentInstructions()', async () => {
+      const spy = createSpyAgent()
+      registry.registerAgent(spy, true)
+
+      const memory = createMemory()
+      delete (memory as any).agentInstructions
+
+      const router = new Router(
+        registry,
+        sessions,
+        mockConfig,
+        moonLoader,
+        [],
+        undefined,
+        memory,
+        autoRecall,
+      )
+
+      await router.route('discord', msg('test'))
+
+      expect(spy.capturedInput.systemPrompt).not.toContain('Brain')
+    })
+  })
+
+  // ─── Output redaction ──────────────────────────────────────────
+
+  describe('output redaction — scrub secrets before sending', () => {
+    it('redacts known secret patterns from agent output', async () => {
+      const leakyAgent: Agent = {
+        id: 'claude',
+        name: 'Leaky Claude',
+        init: async () => {},
+        destroy: async () => {},
+        query: async function* () {
+          yield { type: 'text' as const, content: 'Key is sk-abcdefghijklmnopqrstuvwx' }
+          yield { type: 'done' as const, sessionId: 's1' }
+        },
+        health: async () => ({ ok: true }),
+      }
+      registry.registerAgent(leakyAgent, true)
+
+      const security: SecurityConfig = {
+        isolation: 'process',
+        envDefaults: ['HOME', 'PATH'],
+        envPassthrough: [],
+        envPassthroughAll: false,
+        outputRedactPatterns: [],
+        inputSanitization: {
+          enabled: true,
+          stripMarkers: true,
+          logSuspicious: false,
+          notifyAgent: false,
+          customPatterns: [],
+        },
+      }
+
+      const router = new Router(registry, sessions, mockConfig, moonLoader, [], security)
+      await router.route('discord', msg('test'))
+
+      expect(channel.lastSent!.msg.text).toContain('[REDACTED]')
+      expect(channel.lastSent!.msg.text).not.toContain('sk-abcdef')
+    })
+  })
+
+  // ─── Error handling ────────────────────────────────────────────
+
+  describe('error handling — graceful degradation', () => {
+    it('sends user-friendly error when agent throws', async () => {
+      const failingAgent: Agent = {
+        id: 'claude',
+        name: 'Failing Claude',
+        init: async () => {},
+        destroy: async () => {},
+        query: async function* () {
+          yield { type: 'error' as const, error: 'Agent exploded', recoverable: false }
+          throw new Error('Agent exploded')
+        },
+        health: async () => ({ ok: false }),
+      }
+      registry.registerAgent(failingAgent, true)
+
+      const router = new Router(registry, sessions, mockConfig, moonLoader, [])
+      await router.route('discord', msg('test'))
+
+      expect(channel.lastSent!.msg.text).toContain('Something went wrong')
+    })
+
+    it('surfaces non-recoverable agent errors to user', async () => {
+      const errorAgent: Agent = {
+        id: 'claude',
+        name: 'Error Claude',
+        init: async () => {},
+        destroy: async () => {},
+        query: async function* () {
+          yield { type: 'error' as const, error: 'fatal', recoverable: false }
+          yield { type: 'done' as const, sessionId: 's1' }
+        },
+        health: async () => ({ ok: true }),
+      }
+      registry.registerAgent(errorAgent, true)
+
+      const router = new Router(registry, sessions, mockConfig, moonLoader, [])
+      await router.route('discord', msg('test'))
+
+      expect(channel.lastSent!.msg.text).toContain('error occurred')
+    })
+  })
+
+  // ─── Session lifecycle — graceful close ────────────────────────
+
+  describe('session lifecycle — graceful close', () => {
+    it('tracks message history during route()', async () => {
+      registry.registerAgent(createAgent('Response'), true)
+      const router = new Router(registry, sessions, mockConfig, moonLoader, [])
+
+      await router.route('discord', msg('Hello'))
+
+      expect(router.getSessionMessageCount('claude:discord:chan-1')).toBe(2) // user + assistant
+    })
+
+    it('tracks multiple exchanges in same session', async () => {
+      registry.registerAgent(createAgent('Response'), true)
+      const router = new Router(registry, sessions, mockConfig, moonLoader, [])
+
+      await router.route('discord', msg('Hello'))
+      await router.route('discord', msg('How are you?'))
+      await router.route('discord', msg('Thanks'))
+
+      expect(router.getSessionMessageCount('claude:discord:chan-1')).toBe(6) // 3 user + 3 assistant
+    })
+
+    it('reports activeSessionCount', async () => {
+      registry.registerAgent(createAgent('ok'), true)
+      const router = new Router(registry, sessions, mockConfig, moonLoader, [])
+
+      expect(router.activeSessionCount).toBe(0)
+
+      await router.route('discord', msg('Hello'))
+
+      expect(router.activeSessionCount).toBe(1)
+    })
+
+    it('closeAllSessions calls memory.onSessionEnd with history', async () => {
+      let capturedContext: any = null
+      const memory = createMemory()
+      memory.onSessionEnd = async (ctx) => {
+        capturedContext = ctx
+      }
+      registry.registerAgent(createAgent('Response'), true)
+
+      const autoRecall = { enabled: false, limit: 5, minScore: 0.3, budget: 800 }
+      const router = new Router(
+        registry,
+        sessions,
+        mockConfig,
+        moonLoader,
+        [],
+        undefined,
+        memory,
+        autoRecall,
+      )
+
+      await router.route('discord', msg('Hello'))
+      await router.route('discord', msg('World'))
+
+      await router.closeAllSessions()
+
+      expect(capturedContext).not.toBeNull()
+      expect(capturedContext.messages).toHaveLength(4) // 2 user + 2 assistant
+      expect(capturedContext.messages[0].role).toBe('user')
+      expect(capturedContext.messages[0].content).toBe('Hello')
+      expect(capturedContext.messages[1].role).toBe('assistant')
+    })
+
+    it('closeAllSessions extracts topics from messages', async () => {
+      let capturedContext: any = null
+      const memory = createMemory()
+      memory.onSessionEnd = async (ctx) => {
+        capturedContext = ctx
+      }
+      registry.registerAgent(createAgent('Response'), true)
+
+      const autoRecall = { enabled: false, limit: 5, minScore: 0.3, budget: 800 }
+      const router = new Router(
+        registry,
+        sessions,
+        mockConfig,
+        moonLoader,
+        [],
+        undefined,
+        memory,
+        autoRecall,
+      )
+
+      await router.route('discord', msg('Tell me about hooks and memory architecture'))
+
+      await router.closeAllSessions()
+
+      expect(capturedContext.topics).toBeDefined()
+      expect(Array.isArray(capturedContext.topics)).toBe(true)
+    })
+
+    it('closeAllSessions clears history after closing', async () => {
+      const memory = createMemory()
+      memory.onSessionEnd = async () => {}
+      registry.registerAgent(createAgent('ok'), true)
+
+      const autoRecall = { enabled: false, limit: 5, minScore: 0.3, budget: 800 }
+      const router = new Router(
+        registry,
+        sessions,
+        mockConfig,
+        moonLoader,
+        [],
+        undefined,
+        memory,
+        autoRecall,
+      )
+
+      await router.route('discord', msg('test'))
+      expect(router.activeSessionCount).toBe(1)
+
+      await router.closeAllSessions()
+      expect(router.activeSessionCount).toBe(0)
+    })
+
+    it('closeAllSessions is no-op without memory provider', async () => {
+      registry.registerAgent(createAgent('ok'), true)
+      const router = new Router(registry, sessions, mockConfig, moonLoader, [])
+
+      await router.route('discord', msg('test'))
+
+      // Should not throw even without memory
+      await router.closeAllSessions()
+      expect(router.activeSessionCount).toBe(1) // not cleared since no memory
+    })
+
+    it('closeAllSessions handles provider errors gracefully', async () => {
+      const memory = createMemory()
+      memory.onSessionEnd = async () => {
+        throw new Error('Provider crashed')
+      }
+      registry.registerAgent(createAgent('ok'), true)
+
+      const autoRecall = { enabled: false, limit: 5, minScore: 0.3, budget: 800 }
+      const router = new Router(
+        registry,
+        sessions,
+        mockConfig,
+        moonLoader,
+        [],
+        undefined,
+        memory,
+        autoRecall,
+      )
+
+      await router.route('discord', msg('test'))
+
+      // Should not throw
+      await router.closeAllSessions()
+      // History should still be cleared even if provider failed
+      expect(router.activeSessionCount).toBe(0)
+    })
+  })
+
+  // ─── dispatchScheduled — scheduled/cron dispatch ────────────
+
+  describe('dispatchScheduled — scheduled/cron dispatch', () => {
+    const channels: import('../types/moon').ChannelPersona[] = [
+      { id: 'chan-1', name: 'orbit', platform: 'discord' },
+      { id: 'chan-2', name: 'research', platform: 'discord', moon: 'researcher' },
+    ]
+
+    it('sends static message directly to channel (kind=message)', async () => {
+      registry.registerAgent(createAgent(), true)
+      const router = new Router(registry, sessions, mockConfig, moonLoader, channels)
+
+      await router.dispatchScheduled('orbit', { kind: 'message', text: 'Good morning!' })
+
+      expect(channel.lastSent).not.toBeNull()
+      expect(channel.lastSent!.target).toBe('chan-1')
+      expect(channel.lastSent!.msg.text).toBe('Good morning!')
+    })
+
+    it('dispatches query to agent and sends response (kind=query)', async () => {
+      registry.registerAgent(createAgent('Scheduled response'), true)
+      const router = new Router(registry, sessions, mockConfig, moonLoader, channels)
+
+      await router.dispatchScheduled('orbit', { kind: 'query', prompt: 'Summarize the day' })
+
+      expect(channel.lastSent).not.toBeNull()
+      expect(channel.lastSent!.msg.text).toBe('Scheduled response')
+    })
+
+    it('bypasses auth — no allowedUsers check for scheduled dispatch', async () => {
+      // Config with strict allowedUsers — normal route would reject non-listed senders
+      const strictConfig = { ...mockConfig, discordAllowedUsers: ['only-this-user'] }
+      registry.registerAgent(createAgent('Cron response'), true)
+      const router = new Router(registry, sessions, strictConfig, moonLoader, channels)
+
+      // dispatchScheduled has sender.id = 'scheduler' which is NOT in allowedUsers,
+      // but it should still succeed because scheduled queries bypass auth
+      await router.dispatchScheduled('orbit', { kind: 'query', prompt: 'health check' })
+
+      expect(channel.lastSent).not.toBeNull()
+      expect(channel.lastSent!.msg.text).toBe('Cron response')
+    })
+
+    it('looks up channel by name from channelIndex', async () => {
+      registry.registerAgent(createAgent('Research result'), true)
+      const router = new Router(registry, sessions, mockConfig, moonLoader, channels)
+
+      await router.dispatchScheduled('research', { kind: 'query', prompt: 'Analyze data' })
+
+      // Should target chan-2 (the 'research' channel)
+      expect(channel.lastSent!.target).toBe('chan-2')
+    })
+
+    it('returns early (no crash) when channel name not found', async () => {
+      registry.registerAgent(createAgent(), true)
+      const router = new Router(registry, sessions, mockConfig, moonLoader, channels)
+
+      // Should not throw — just logs error and returns
+      await router.dispatchScheduled('nonexistent-channel', { kind: 'query', prompt: 'test' })
+
+      expect(channel.lastSent).toBeNull()
+    })
+
+    it('returns early when channel adapter not found in registry', async () => {
+      // Channel persona references platform 'telegram' but only 'discord' adapter is registered
+      const telegramChannels: import('../types/moon').ChannelPersona[] = [
+        { id: 'tg-1', name: 'tg-hub', platform: 'telegram' },
+      ]
+      registry.registerAgent(createAgent(), true)
+      const router = new Router(registry, sessions, mockConfig, moonLoader, telegramChannels)
+
+      await router.dispatchScheduled('tg-hub', { kind: 'query', prompt: 'test' })
+
+      // Discord channel should not receive anything — telegram adapter is missing
+      expect(channel.lastSent).toBeNull()
+    })
+
+    it('returns early when no agent is available for query dispatch', async () => {
+      // Do NOT register any agent
+      const router = new Router(registry, sessions, mockConfig, moonLoader, channels)
+
+      await router.dispatchScheduled('orbit', { kind: 'query', prompt: 'test' })
+
+      expect(channel.lastSent).toBeNull()
+    })
+
+    it('agent receives the scheduled prompt text as input', async () => {
+      const spy = createSpyAgent()
+      registry.registerAgent(spy, true)
+      const router = new Router(registry, sessions, mockConfig, moonLoader, channels)
+
+      await router.dispatchScheduled('orbit', { kind: 'query', prompt: 'What is the weather?' })
+
+      expect(spy.capturedInput).not.toBeNull()
+      expect(spy.capturedInput.prompt).toBe('What is the weather?')
+    })
+
+    it('agent input metadata includes scheduled=true and sender=Scheduler', async () => {
+      const spy = createSpyAgent()
+      registry.registerAgent(spy, true)
+      const router = new Router(registry, sessions, mockConfig, moonLoader, channels)
+
+      await router.dispatchScheduled(
+        'orbit',
+        { kind: 'query', prompt: 'test' },
+        {
+          jobId: 'job-123',
+          jobName: 'morning-check',
+        },
+      )
+
+      expect(spy.capturedInput.metadata.scheduled).toBe(true)
+      expect(spy.capturedInput.metadata.sender.id).toBe('scheduler')
+      expect(spy.capturedInput.metadata.jobId).toBe('job-123')
+      expect(spy.capturedInput.metadata.jobName).toBe('morning-check')
+    })
+  })
+
+  // ─── recallContext — memory context formatting ────────────────
+
+  describe('recallContext — memory context formatting', () => {
+    const autoRecall: RecallConfig = { enabled: true, limit: 5, minScore: 0.3, budget: 800 }
+
+    it('formats recall results as "## Memory Context" section with scores', async () => {
+      const spy = createSpyAgent()
+      registry.registerAgent(spy, true)
+
+      const memory = createMemory([
+        { content: 'Mars likes TypeScript', score: 0.92, metadata: { type: 'fact' } },
+        { content: 'Project uses Bun runtime', score: 0.75, metadata: { type: 'tech' } },
+      ])
+
+      const router = new Router(
+        registry,
+        sessions,
+        mockConfig,
+        moonLoader,
+        [],
+        undefined,
+        memory,
+        autoRecall,
+      )
+
+      await router.route('discord', msg('Tell me about the project'))
+
+      const prompt = spy.capturedInput.systemPrompt
+      expect(prompt).toContain('## Memory Context (auto-recalled)')
+      expect(prompt).toContain('Mars likes TypeScript')
+      expect(prompt).toContain('92%')
+      expect(prompt).toContain('Project uses Bun runtime')
+      expect(prompt).toContain('75%')
+    })
+
+    it('returns no memory context when recall returns empty array', async () => {
+      const spy = createSpyAgent()
+      registry.registerAgent(spy, true)
+
+      const memory = createMemory([]) // empty
+      const router = new Router(
+        registry,
+        sessions,
+        mockConfig,
+        moonLoader,
+        [],
+        undefined,
+        memory,
+        autoRecall,
+      )
+
+      await router.route('discord', msg('test'))
+
+      // System prompt should NOT contain memory context
+      const prompt = spy.capturedInput.systemPrompt ?? ''
+      expect(prompt).not.toContain('Memory Context')
+    })
+
+    it('continues without memory context when recall throws', async () => {
+      const failingMemory = createMemory()
+      failingMemory.recall = async () => {
+        throw new Error('Brain offline')
+      }
+
+      registry.registerAgent(createAgent('Still works'), true)
+      const router = new Router(
+        registry,
+        sessions,
+        mockConfig,
+        moonLoader,
+        [],
+        undefined,
+        failingMemory,
+        autoRecall,
+      )
+
+      await router.route('discord', msg('test'))
+
+      // Should still get a response — recall failure is non-fatal
+      expect(channel.lastSent).not.toBeNull()
+      expect(channel.lastSent!.msg.text).toBe('Still works')
+    })
+
+    it('includes relevance scores in formatted output', async () => {
+      const spy = createSpyAgent()
+      registry.registerAgent(spy, true)
+
+      const memory = createMemory([
+        { content: 'Exact match fact', score: 0.99, metadata: { type: 'fact' } },
+      ])
+
+      const router = new Router(
+        registry,
+        sessions,
+        mockConfig,
+        moonLoader,
+        [],
+        undefined,
+        memory,
+        autoRecall,
+      )
+
+      await router.route('discord', msg('test'))
+
+      expect(spy.capturedInput.systemPrompt).toContain('relevance: 99%')
+    })
+
+    it('separates diary entries from semantic results', async () => {
+      const spy = createSpyAgent()
+      registry.registerAgent(spy, true)
+
+      const memory = createMemory([
+        {
+          content: 'Diary entry from today',
+          score: 0.9,
+          source: 'brain:diary',
+          metadata: { category: 'daily' },
+        },
+        { content: 'Semantic fact', score: 0.8, metadata: { type: 'fact' } },
+      ])
+
+      const router = new Router(
+        registry,
+        sessions,
+        mockConfig,
+        moonLoader,
+        [],
+        undefined,
+        memory,
+        autoRecall,
+      )
+
+      await router.route('discord', msg('test'))
+
+      const prompt = spy.capturedInput.systemPrompt
+      expect(prompt).toContain('### Session Diary (today)')
+      expect(prompt).toContain('[daily]')
+      expect(prompt).toContain('Diary entry from today')
+      expect(prompt).toContain('### Relevant Memories')
+      expect(prompt).toContain('Semantic fact')
+    })
+
+    it('respects budget limit — truncates semantic results when over budget', async () => {
+      const spy = createSpyAgent()
+      registry.registerAgent(spy, true)
+
+      // Very small budget (10 tokens = ~40 chars) with long results
+      const tinyBudget: RecallConfig = { enabled: true, limit: 10, minScore: 0.1, budget: 10 }
+
+      const longContent = 'A'.repeat(200)
+      const memory = createMemory([
+        { content: 'Short fact', score: 0.9, metadata: { type: 'fact' } },
+        { content: longContent, score: 0.7, metadata: { type: 'detail' } },
+      ])
+
+      const router = new Router(
+        registry,
+        sessions,
+        mockConfig,
+        moonLoader,
+        [],
+        undefined,
+        memory,
+        tinyBudget,
+      )
+
+      await router.route('discord', msg('test'))
+
+      const prompt = spy.capturedInput.systemPrompt
+      // First result should be included (fits budget)
+      expect(prompt).toContain('Short fact')
+      // Second result (200 chars) should be truncated by budget
+      expect(prompt).not.toContain(longContent)
+    })
+  })
+
+  // ─── Per-channel model override ──────────────────────────────
+
+  describe('per-channel model override — channel > moon > global', () => {
+    it('channel model takes priority over moon model', async () => {
+      const spy = createSpyAgent()
+      registry.registerAgent(spy, true)
+
+      // Load moon with model override
+      await moonLoader.loadAll(TMP, {}, { model: 'sonnet' })
+
+      const channels: import('../types/moon').ChannelPersona[] = [
+        { id: 'chan-1', name: 'research', platform: 'discord', model: 'opus' },
+      ]
+      const router = new Router(registry, sessions, mockConfig, moonLoader, channels)
+
+      await router.route('discord', msg('Hello'))
+
+      expect(spy.capturedInput.model).toBe('opus')
+    })
+
+    it('falls back to moon model when channel has no model', async () => {
+      const spy = createSpyAgent()
+      registry.registerAgent(spy, true)
+
+      await moonLoader.loadAll(TMP, {}, { model: 'haiku' })
+
+      const channels: import('../types/moon').ChannelPersona[] = [
+        { id: 'chan-1', name: 'orbit', platform: 'discord' },
+      ]
+      const router = new Router(registry, sessions, mockConfig, moonLoader, channels)
+
+      await router.route('discord', msg('Hello'))
+
+      expect(spy.capturedInput.model).toBe('haiku')
+    })
+
+    it('model is undefined when neither channel nor moon specifies one', async () => {
+      const spy = createSpyAgent()
+      registry.registerAgent(spy, true)
+
+      // Default loadAll — no model overrides
+      await moonLoader.loadAll(TMP)
+
+      const channels: import('../types/moon').ChannelPersona[] = [
+        { id: 'chan-1', name: 'orbit', platform: 'discord' },
+      ]
+      const router = new Router(registry, sessions, mockConfig, moonLoader, channels)
+
+      await router.route('discord', msg('Hello'))
+
+      expect(spy.capturedInput.model).toBeUndefined()
+    })
+  })
+
+  // ─── Multi-agent routing (Phase B) ────────────────────────
+
+  describe('multi-agent routing — channelPersona.agentId directs to correct agent', () => {
+    function createNamedAgent(id: string, response = 'ok'): Agent {
+      return {
+        id,
+        name: `Agent ${id}`,
+        init: async () => {},
+        destroy: async () => {},
+        query: async function* () {
+          yield { type: 'text' as const, content: response }
+          yield { type: 'done' as const, sessionId: `session-${id}` }
+        },
+        health: async () => ({ ok: true }),
+      }
+    }
+
+    it('channel with agentId routes to the named agent', async () => {
+      const hermes = createNamedAgent('hermes', 'Hermes response')
+      const defaultAgent = createNamedAgent('deimos', 'Deimos response')
+      registry.registerAgent(defaultAgent, true)
+      registry.registerAgent(hermes, false)
+
+      const channels: import('../types/moon').ChannelPersona[] = [
+        { id: 'chan-1', name: 'notifications', platform: 'discord', agentId: 'hermes' },
+      ]
+      const router = new Router(registry, sessions, mockConfig, moonLoader, channels)
+
+      await router.route('discord', msg('Hello'))
+
+      expect(channel.lastSent).not.toBeNull()
+      expect(channel.lastSent!.msg.text).toBe('Hermes response')
+    })
+
+    it('channel without agentId uses default agent', async () => {
+      const hermes = createNamedAgent('hermes', 'Hermes response')
+      const defaultAgent = createNamedAgent('deimos', 'Deimos response')
+      registry.registerAgent(defaultAgent, true)
+      registry.registerAgent(hermes, false)
+
+      const channels: import('../types/moon').ChannelPersona[] = [
+        { id: 'chan-1', name: 'orbit', platform: 'discord' },
+      ]
+      const router = new Router(registry, sessions, mockConfig, moonLoader, channels)
+
+      await router.route('discord', msg('Hello'))
+
+      expect(channel.lastSent).not.toBeNull()
+      expect(channel.lastSent!.msg.text).toBe('Deimos response')
+    })
+
+    it('RouteOptions.agentId takes priority over channelPersona.agentId', async () => {
+      const hermes = createNamedAgent('hermes', 'Hermes response')
+      const deimos = createNamedAgent('deimos', 'Deimos response')
+      registry.registerAgent(deimos, true)
+      registry.registerAgent(hermes, false)
+
+      // Channel says hermes, but RouteOptions says deimos
+      const channels: import('../types/moon').ChannelPersona[] = [
+        { id: 'chan-1', name: 'notifications', platform: 'discord', agentId: 'hermes' },
+      ]
+      const router = new Router(registry, sessions, mockConfig, moonLoader, channels)
+
+      await router.route('discord', msg('Hello'), { agentId: 'deimos' })
+
+      expect(channel.lastSent!.msg.text).toBe('Deimos response')
+    })
+
+    it('session key includes agent ID: agentId:channelId:messageChannelId', async () => {
+      const hermes = createNamedAgent('hermes')
+      registry.registerAgent(hermes, true)
+
+      const channels: import('../types/moon').ChannelPersona[] = [
+        { id: 'chan-1', name: 'notifications', platform: 'discord', agentId: 'hermes' },
+      ]
+      const router = new Router(registry, sessions, mockConfig, moonLoader, channels)
+
+      await router.route('discord', msg('Hello'))
+
+      // Session key should be hermes:discord:chan-1
+      const session = sessions.get('hermes:discord:chan-1')
+      expect(session).not.toBeNull()
+      expect(session!.agentSessionId).toBe('session-hermes')
+    })
+
+    it('two channels with different agentIds get different session namespaces', async () => {
+      const hermes = createNamedAgent('hermes')
+      const deimos = createNamedAgent('deimos')
+      registry.registerAgent(deimos, true)
+      registry.registerAgent(hermes, false)
+
+      const channels: import('../types/moon').ChannelPersona[] = [
+        { id: 'chan-orbit', name: 'orbit', platform: 'discord', agentId: 'deimos' },
+        { id: 'chan-notify', name: 'notifications', platform: 'discord', agentId: 'hermes' },
+      ]
+      const router = new Router(registry, sessions, mockConfig, moonLoader, channels)
+
+      // Route to deimos channel (chan-orbit)
+      const deimosMsg: IncomingMessage = {
+        id: 'msg-1',
+        channelId: 'chan-orbit',
+        text: 'Hello',
+        sender: { id: 'user-123', name: 'Test User' },
+        timestamp: new Date(),
+      }
+      await router.route('discord', deimosMsg)
+
+      // Route to hermes channel (chan-notify)
+      const hermesMsg: IncomingMessage = {
+        id: 'msg-2',
+        channelId: 'chan-notify',
+        text: 'Notification check',
+        sender: { id: 'user-123', name: 'Test User' },
+        timestamp: new Date(),
+      }
+      await router.route('discord', hermesMsg)
+
+      // Both sessions exist with different namespaces
+      const deimosSession = sessions.get('deimos:discord:chan-orbit')
+      expect(deimosSession).not.toBeNull()
+      expect(deimosSession!.agentSessionId).toBe('session-deimos')
+
+      const hermesSession = sessions.get('hermes:discord:chan-notify')
+      expect(hermesSession).not.toBeNull()
+      expect(hermesSession!.agentSessionId).toBe('session-hermes')
+    })
+  })
+
+  // ─── dispatchScheduled — multi-agent session key ──────────
+
+  describe('dispatchScheduled — multi-agent session key', () => {
+    function createNamedAgent(id: string, response = 'ok'): Agent {
+      return {
+        id,
+        name: `Agent ${id}`,
+        init: async () => {},
+        destroy: async () => {},
+        query: async function* () {
+          yield { type: 'text' as const, content: response }
+          yield { type: 'done' as const, sessionId: `session-${id}` }
+        },
+        health: async () => ({ ok: true }),
+      }
+    }
+
+    it('dispatchScheduled uses channelPersona.agentId for agent selection', async () => {
+      const hermes = createNamedAgent('hermes', 'Hermes scheduled')
+      const deimos = createNamedAgent('deimos', 'Deimos scheduled')
+      registry.registerAgent(deimos, true)
+      registry.registerAgent(hermes, false)
+
+      const channels: import('../types/moon').ChannelPersona[] = [
+        { id: 'chan-notify', name: 'notifications', platform: 'discord', agentId: 'hermes' },
+      ]
+      const router = new Router(registry, sessions, mockConfig, moonLoader, channels)
+
+      await router.dispatchScheduled('notifications', { kind: 'query', prompt: 'test' })
+
+      expect(channel.lastSent).not.toBeNull()
+      expect(channel.lastSent!.msg.text).toBe('Hermes scheduled')
+    })
+
+    it('dispatchScheduled session key includes agent ID', async () => {
+      const hermes = createNamedAgent('hermes')
+      registry.registerAgent(hermes, true)
+
+      const channels: import('../types/moon').ChannelPersona[] = [
+        { id: 'chan-notify', name: 'notifications', platform: 'discord', agentId: 'hermes' },
+      ]
+      const router = new Router(registry, sessions, mockConfig, moonLoader, channels)
+
+      await router.dispatchScheduled('notifications', { kind: 'query', prompt: 'test' })
+
+      const session = sessions.get('hermes:discord:chan-notify')
+      expect(session).not.toBeNull()
+    })
+  })
+})