import { describe, it, expect, vi, afterEach } from 'vitest';
import { AgentRouter } from '../agents/router.js';
import { AgentConfigRegistry } from '../agents/registry.js';
import type { ModelTier } from '../models/router.js';
import { createMessageRouter } from './routing.js';
import { AgentOrchestrator } from '../backends/index.js';
import { CommandRegistry, registerBuiltinCommands } from '../commands/index.js';
import { ComponentRegistry } from '../intents/index.js';
import { RoutingPolicy } from '../routing/index.js';
import type { OutboundMessage } from '../channels/index.js';
import { initAuditLogger } from '../audit/index.js';

type MessageRouterDeps = Parameters<typeof createMessageRouter>[0];
type MessageRouterInput = Parameters<ReturnType<typeof createMessageRouter>['handler']>[0];

describe('daemon agent routing integration', () => {
  it('resolves agent config for channel messages', () => {
    const registry = new AgentConfigRegistry();
    registry.loadFromConfig({
      assistant: { system_prompt: 'Be helpful.', model_tier: 'default', tool_profile: 'messaging', sandbox: false },
      coder: { system_prompt: 'Write code.', model_tier: 'complex', tool_profile: 'coding', sandbox: true },
    });

    const router = new AgentRouter({
      default_agent: 'assistant',
      channels: { discord: 'coder' },
      senders: { 'telegram:admin': 'coder' },
    });

    // Discord user gets coder
    const discordAgent = router.resolve('discord', 'user123');
    expect(discordAgent).toBe('coder');
    expect(discordAgent).toBeDefined();
    const discordAgentConfig = discordAgent ? registry.get(discordAgent) : undefined;
    expect(discordAgentConfig?.systemPrompt).toBe('Write code.');

    // Telegram admin gets coder
    const telegramAdmin = router.resolve('telegram', 'admin');
    expect(telegramAdmin).toBe('coder');

    // Random telegram user gets assistant
    const telegramUser = router.resolve('telegram', 'random');
    expect(telegramUser).toBe('assistant');
    expect(telegramUser).toBeDefined();
    const telegramUserConfig = telegramUser ? registry.get(telegramUser) : undefined;
    expect(telegramUserConfig?.systemPrompt).toBe('Be helpful.');
  });

  it('uses default agent when no routing configured', () => {
    const router = new AgentRouter({ channels: {}, senders: {} });
    expect(router.resolve('telegram', '123')).toBeUndefined();
  });

  it('model tier precedence: metadata > metadata modelFor > agent config > global default', () => {
    // This test documents the tier resolution precedence used by createMessageRouter.
    // The actual resolution logic:
    // tierFromMetadata ?? tierFromMetadataModelFor ?? agentConfig?.modelTier ?? primary_tier ?? 'default'
    function resolveTier(
      metadataTier: ModelTier | undefined,
      metadataForTier: ModelTier | undefined,
      agentTier: ModelTier | undefined,
      globalTier: ModelTier | undefined,
    ): ModelTier {
      return metadataTier ?? metadataForTier ?? agentTier ?? globalTier ?? 'default';
    }

    // With all three set, metadata wins
    expect(resolveTier('fast', 'default', 'complex', 'default')).toBe('fast');

    // Without explicit metadata tier, modelFor-resolved tier wins
    expect(resolveTier(undefined, 'complex', 'default', 'fast')).toBe('complex');

    // Without metadata, agent config wins
    expect(resolveTier(undefined, undefined, 'complex', 'default')).toBe('complex');

    // Without metadata or agent config, global wins
    expect(resolveTier(undefined, undefined, undefined, 'default')).toBe('default');

    // Without anything, falls back to 'default'
    expect(resolveTier(undefined, undefined, undefined, undefined)).toBe('default');
  });

  it('uses metadata.modelFor tags to select tier', async () => {
    const processSpy = vi.spyOn(AgentOrchestrator.prototype, 'process').mockResolvedValue('ok');
    const session = {
      id: 'telegram:model-for',
      addMessage: vi.fn(),
      getHistory: vi.fn(() => []),
      clear: vi.fn(),
      replaceHistory: vi.fn(),
      getConfig: vi.fn(() => undefined),
      setConfig: vi.fn(),
      deleteConfig: vi.fn(),
    };

    const router = createMessageRouter({
      sessionManager: {
        getSession: vi.fn(() => session),
      } as unknown as MessageRouterDeps['sessionManager'],
      modelRouter: {
        getAvailableTiers: () => ['fast', 'default', 'complex', 'local'],
        getAllLabels: () => ({ fast: 'fast', default: 'default', complex: 'complex', local: 'local' }),
        getLabel: (tier: string) => tier,
      } as unknown as MessageRouterDeps['modelRouter'],
      systemPrompt: 'test prompt',
      toolRegistry: {
        clone() { return this; },
        register: vi.fn(),
      } as unknown as MessageRouterDeps['toolRegistry'],
      toolExecutor: {} as unknown as MessageRouterDeps['toolExecutor'],
      config: {
        agents: {
          primary_tier: 'default',
          delegation: {
            compaction: 'fast',
            memory_extraction: 'fast',
            classification: 'fast',
            tool_summarisation: 'fast',
            complex_reasoning: 'complex',
          },
          max_delegation_depth: 3,
          max_iterations: 10,
        },
        compaction: { enabled: false },
        models: {
          default: { provider: 'anthropic', model: 'claude', for: ['chat'] },
          fast: { provider: 'anthropic', model: 'haiku', for: ['search'] },
        },
      } as unknown as MessageRouterDeps['config'],
    });

    await router.handler({
      id: 'm-model-for',
      channel: 'telegram',
      senderId: 'model-for',
      text: 'find this quickly',
      timestamp: Date.now(),
      metadata: { modelFor: 'search' },
    } as MessageRouterInput, vi.fn(async () => {}));

    const keys = Array.from(router.agents.keys());
    expect(keys.some((key) => key.endsWith(':fast'))).toBe(true);
    expect(processSpy).toHaveBeenCalled();
  });
});

describe('daemon command fast-path integration', () => {
  afterEach(() => {
    vi.restoreAllMocks();
  });

  it('handles known reset command without calling agent.process', async () => {
    const processSpy = vi.spyOn(AgentOrchestrator.prototype, 'process');
    const session = {
      id: 'telegram:user-1',
      addMessage: vi.fn(),
      getHistory: vi.fn(() => []),
      clear: vi.fn(),
      replaceHistory: vi.fn(),
      getConfig: vi.fn(() => undefined),
      setConfig: vi.fn(),
      deleteConfig: vi.fn(),
    };

    const commandRegistry = new CommandRegistry();
    registerBuiltinCommands(commandRegistry);

    const router = createMessageRouter({
      sessionManager: {
        getSession: vi.fn(() => session),
      } as unknown as MessageRouterDeps['sessionManager'],
      modelRouter: {
        getAvailableTiers: () => ['fast', 'default', 'complex', 'local'],
        getAllLabels: () => ({ fast: 'fast', default: 'default', complex: 'complex', local: 'local' }),
        getLabel: (tier: string) => tier,
      } as unknown as MessageRouterDeps['modelRouter'],
      systemPrompt: 'test prompt',
      toolRegistry: {
        clone() { return this; },
        register: vi.fn(),
      } as unknown as MessageRouterDeps['toolRegistry'],
      toolExecutor: {} as unknown as MessageRouterDeps['toolExecutor'],
      config: {
        agents: {
          primary_tier: 'default',
          delegation: {
            compaction: 'fast',
            memory_extraction: 'fast',
            classification: 'fast',
            tool_summarisation: 'fast',
            complex_reasoning: 'complex',
          },
          max_delegation_depth: 3,
          max_iterations: 10,
        },
        compaction: { enabled: false },
        models: { default: { provider: 'anthropic', model: 'claude' } },
      } as unknown as MessageRouterDeps['config'],
      commandRegistry,
    });

    const reply = vi.fn(async (_message: OutboundMessage) => {});
    await router.handler({
      id: 'm1',
      channel: 'telegram',
      senderId: 'user-1',
      text: '/reset',
      timestamp: Date.now(),
      metadata: { isCommand: true, command: 'reset' },
    } as MessageRouterInput, reply);

    expect(processSpy).not.toHaveBeenCalled();
    expect(session.deleteConfig).toHaveBeenCalledWith('modelTier');
  });

  it('emits user.action audit events for channel messages', async () => {
    const mockAuditLogger = {
      userAction: vi.fn(),
    };
    initAuditLogger(mockAuditLogger as any);

    const session = {
      id: 'telegram:user-audit',
      addMessage: vi.fn(),
      getHistory: vi.fn(() => []),
      clear: vi.fn(),
      replaceHistory: vi.fn(),
      getConfig: vi.fn(() => undefined),
      setConfig: vi.fn(),
      deleteConfig: vi.fn(),
    };

    const commandRegistry = new CommandRegistry();
    registerBuiltinCommands(commandRegistry);

    const router = createMessageRouter({
      sessionManager: {
        getSession: vi.fn(() => session),
      } as unknown as MessageRouterDeps['sessionManager'],
      modelRouter: {
        getAvailableTiers: () => ['fast', 'default', 'complex', 'local'],
        getAllLabels: () => ({ fast: 'fast', default: 'default', complex: 'complex', local: 'local' }),
        getLabel: (tier: string) => tier,
      } as unknown as MessageRouterDeps['modelRouter'],
      systemPrompt: 'test prompt',
      toolRegistry: {
        clone() { return this; },
        register: vi.fn(),
      } as unknown as MessageRouterDeps['toolRegistry'],
      toolExecutor: {} as unknown as MessageRouterDeps['toolExecutor'],
      config: {
        agents: {
          primary_tier: 'default',
          delegation: {
            compaction: 'fast',
            memory_extraction: 'fast',
            classification: 'fast',
            tool_summarisation: 'fast',
            complex_reasoning: 'complex',
          },
          max_delegation_depth: 3,
          max_iterations: 10,
        },
        compaction: { enabled: false },
        models: { default: { provider: 'anthropic', model: 'claude' } },
      } as unknown as MessageRouterDeps['config'],
      commandRegistry,
    });

    await router.handler({
      id: 'm-audit',
      channel: 'telegram',
      senderId: 'user-audit',
      text: '/reset',
      metadata: { isCommand: true, command: 'reset' },
    } as unknown as MessageRouterInput, vi.fn(async (_: OutboundMessage) => {}));

    expect(mockAuditLogger.userAction).toHaveBeenCalledWith(
      expect.objectContaining({
        source: 'channel',
        action_type: 'command',
        channel: 'telegram',
      }),
    );
  });

  it('handles model command via fast-path and persists tier override', async () => {
    const processSpy = vi.spyOn(AgentOrchestrator.prototype, 'process');
    const setModelTierSpy = vi.spyOn(AgentOrchestrator.prototype, 'setModelTier');
    const session = {
      id: 'telegram:user-4',
      addMessage: vi.fn(),
      getHistory: vi.fn(() => []),
      clear: vi.fn(),
      replaceHistory: vi.fn(),
      getConfig: vi.fn(() => undefined),
      setConfig: vi.fn(),
      deleteConfig: vi.fn(),
    };

    const commandRegistry = new CommandRegistry();
    registerBuiltinCommands(commandRegistry);

    const router = createMessageRouter({
      sessionManager: {
        getSession: vi.fn(() => session),
      } as unknown as MessageRouterDeps['sessionManager'],
      modelRouter: {
        getAvailableTiers: () => ['fast', 'default', 'complex', 'local'],
        getAllLabels: () => ({ fast: 'fast', default: 'default', complex: 'complex', local: 'local' }),
        getLabel: (tier: string) => tier,
      } as unknown as MessageRouterDeps['modelRouter'],
      systemPrompt: 'test prompt',
      toolRegistry: {
        clone() { return this; },
        register: vi.fn(),
      } as unknown as MessageRouterDeps['toolRegistry'],
      toolExecutor: {} as unknown as MessageRouterDeps['toolExecutor'],
      config: {
        agents: {
          primary_tier: 'default',
          delegation: {
            compaction: 'fast',
            memory_extraction: 'fast',
            classification: 'fast',
            tool_summarisation: 'fast',
            complex_reasoning: 'complex',
          },
          max_delegation_depth: 3,
          max_iterations: 10,
        },
        compaction: { enabled: false },
        models: { default: { provider: 'anthropic', model: 'claude' } },
      } as unknown as MessageRouterDeps['config'],
      commandRegistry,
    });

    const reply = vi.fn(async (_message: OutboundMessage) => {});
    await router.handler({
      id: 'm4',
      channel: 'telegram',
      senderId: 'user-4',
      text: '/model fast',
      timestamp: Date.now(),
      metadata: { isCommand: true, command: 'model', commandArgs: 'fast' },
    } as MessageRouterInput, reply);

    expect(processSpy).not.toHaveBeenCalled();
    expect(setModelTierSpy).toHaveBeenCalledWith('fast');
    expect(session.setConfig).toHaveBeenCalledWith('modelTier', 'fast');
  });

  it('handles queue command via fast-path and persists queue override', async () => {
    const processSpy = vi.spyOn(AgentOrchestrator.prototype, 'process');
    const session = {
      id: 'telegram:user-queue',
      addMessage: vi.fn(),
      getHistory: vi.fn(() => []),
      clear: vi.fn(),
      replaceHistory: vi.fn(),
      getConfig: vi.fn(() => undefined),
      setConfig: vi.fn(),
      deleteConfig: vi.fn(),
    };

    const commandRegistry = new CommandRegistry();
    registerBuiltinCommands(commandRegistry);

    const router = createMessageRouter({
      sessionManager: {
        getSession: vi.fn(() => session),
      } as unknown as MessageRouterDeps['sessionManager'],
      modelRouter: {
        getAvailableTiers: () => ['fast', 'default', 'complex', 'local'],
        getAllLabels: () => ({ fast: 'fast', default: 'default', complex: 'complex', local: 'local' }),
        getLabel: (tier: string) => tier,
      } as unknown as MessageRouterDeps['modelRouter'],
      systemPrompt: 'test prompt',
      toolRegistry: {
        clone() { return this; },
        register: vi.fn(),
      } as unknown as MessageRouterDeps['toolRegistry'],
      toolExecutor: {} as unknown as MessageRouterDeps['toolExecutor'],
      config: {
        agents: {
          primary_tier: 'default',
          delegation: {
            compaction: 'fast',
            memory_extraction: 'fast',
            classification: 'fast',
            tool_summarisation: 'fast',
            complex_reasoning: 'complex',
          },
          max_delegation_depth: 3,
          max_iterations: 10,
        },
        server: {
          queue: {
            mode: 'collect',
            cap: 50,
            overflow: 'drop_old',
            debounce_ms: 0,
            summarize_overflow: true,
          },
        },
        compaction: { enabled: false },
        models: { default: { provider: 'anthropic', model: 'claude' } },
      } as unknown as MessageRouterDeps['config'],
      commandRegistry,
    });

    const reply = vi.fn(async (_message: OutboundMessage) => {});
    await router.handler({
      id: 'q1',
      channel: 'telegram',
      senderId: 'user-queue',
      text: '/queue set mode followup',
      timestamp: Date.now(),
      metadata: { isCommand: true, command: 'queue', commandArgs: 'set mode followup' },
    } as MessageRouterInput, reply);

    expect(processSpy).not.toHaveBeenCalled();
    expect(session.setConfig).toHaveBeenCalledWith('queue.mode', 'followup');
  });

  it('uses intent match to override agent target', async () => {
    const session = {
      id: 'telegram:user-2',
      addMessage: vi.fn(),
      getHistory: vi.fn(() => []),
      clear: vi.fn(),
      replaceHistory: vi.fn(),
      getConfig: vi.fn(() => undefined),
      setConfig: vi.fn(),
      deleteConfig: vi.fn(),
    };

    const commandRegistry = new CommandRegistry();
    registerBuiltinCommands(commandRegistry);

    const intentRegistry = new ComponentRegistry({ matchThreshold: 0.5 });
    intentRegistry.register({
      name: 'deploy-route',
      patterns: ['deploy *'],
      target: { type: 'agent', name: 'coder' },
      priority: 10,
      enabled: true,
    });

    const agentConfigRegistry = new AgentConfigRegistry();
    agentConfigRegistry.loadFromConfig({
      assistant: { model_tier: 'default', sandbox: false },
      coder: { model_tier: 'complex', sandbox: false },
    });

    const agentRouter = new AgentRouter({
      default_agent: 'assistant',
      channels: {},
      senders: {},
    });

    const router = createMessageRouter({
      sessionManager: {
        getSession: vi.fn(() => session),
      } as unknown as MessageRouterDeps['sessionManager'],
      modelRouter: {
        getAvailableTiers: () => ['fast', 'default', 'complex', 'local'],
        getAllLabels: () => ({ fast: 'fast', default: 'default', complex: 'complex', local: 'local' }),
        getLabel: (tier: string) => tier,
      } as unknown as MessageRouterDeps['modelRouter'],
      systemPrompt: 'test prompt',
      toolRegistry: {
        clone() { return this; },
        register: vi.fn(),
      } as unknown as MessageRouterDeps['toolRegistry'],
      toolExecutor: {} as unknown as MessageRouterDeps['toolExecutor'],
      config: {
        intents: { enabled: true },
        agents: {
          primary_tier: 'default',
          delegation: {
            compaction: 'fast',
            memory_extraction: 'fast',
            classification: 'fast',
            tool_summarisation: 'fast',
            complex_reasoning: 'complex',
          },
          max_delegation_depth: 3,
          max_iterations: 10,
        },
        compaction: { enabled: false },
        models: { default: { provider: 'anthropic', model: 'claude' } },
      } as unknown as MessageRouterDeps['config'],
      commandRegistry,
      intentRegistry,
      agentConfigRegistry,
      agentRouter,
    });

    await router.handler({
      id: 'm2',
      channel: 'telegram',
      senderId: 'user-2',
      text: 'deploy backend now',
      timestamp: Date.now(),
      metadata: { isCommand: true, command: 'reset' },
    } as MessageRouterInput, vi.fn(async () => {}));

    const keys = Array.from(router.agents.keys());
    expect(keys.some(key => key.includes(':coder'))).toBe(true);
  });

  it('auto-routes research-prefixed messages to research agent when configured', async () => {
    const processSpy = vi.spyOn(AgentOrchestrator.prototype, 'process').mockResolvedValue('ok');
    const session = {
      id: 'telegram:user-research',
      addMessage: vi.fn(),
      getHistory: vi.fn(() => []),
      clear: vi.fn(),
      replaceHistory: vi.fn(),
      getConfig: vi.fn(() => undefined),
      setConfig: vi.fn(),
      deleteConfig: vi.fn(),
    };

    const commandRegistry = new CommandRegistry();
    registerBuiltinCommands(commandRegistry);

    const agentConfigRegistry = new AgentConfigRegistry();
    agentConfigRegistry.loadFromConfig({
      assistant: { model_tier: 'default', sandbox: false },
      research: { model_tier: 'complex', sandbox: false },
    });

    const agentRouter = new AgentRouter({
      default_agent: 'assistant',
      channels: {},
      senders: {},
    });

    const router = createMessageRouter({
      sessionManager: {
        getSession: vi.fn(() => session),
      } as unknown as MessageRouterDeps['sessionManager'],
      modelRouter: {
        getAvailableTiers: () => ['fast', 'default', 'complex', 'local'],
        getAllLabels: () => ({ fast: 'fast', default: 'default', complex: 'complex', local: 'local' }),
        getLabel: (tier: string) => tier,
      } as unknown as MessageRouterDeps['modelRouter'],
      systemPrompt: 'test prompt',
      toolRegistry: {
        clone() { return this; },
        register: vi.fn(),
      } as unknown as MessageRouterDeps['toolRegistry'],
      toolExecutor: {} as unknown as MessageRouterDeps['toolExecutor'],
      config: {
        intents: { enabled: false },
        agents: {
          primary_tier: 'default',
          delegation: {
            compaction: 'fast',
            memory_extraction: 'fast',
            classification: 'fast',
            tool_summarisation: 'fast',
            complex_reasoning: 'complex',
          },
          max_delegation_depth: 3,
          max_iterations: 10,
        },
        compaction: { enabled: false },
        models: { default: { provider: 'anthropic', model: 'claude' } },
      } as unknown as MessageRouterDeps['config'],
      commandRegistry,
      agentConfigRegistry,
      agentRouter,
    });

    await router.handler({
      id: 'm-research',
      channel: 'telegram',
      senderId: 'user-research',
      text: 'research compare k0s vs k3s for a homelab',
      timestamp: Date.now(),
    } as MessageRouterInput, vi.fn(async () => {}));

    const keys = Array.from(router.agents.keys());
    expect(keys.some(key => key.includes(':research'))).toBe(true);
    expect(processSpy).toHaveBeenCalledWith('compare k0s vs k3s for a homelab', undefined);
  });

  it('falls back to llm path when confidence is below fast threshold', async () => {
    const session = {
      id: 'telegram:user-3',
      addMessage: vi.fn(),
      getHistory: vi.fn(() => []),
      clear: vi.fn(),
      replaceHistory: vi.fn(),
      getConfig: vi.fn(() => undefined),
      setConfig: vi.fn(),
      deleteConfig: vi.fn(),
    };

    const commandRegistry = new CommandRegistry();
    registerBuiltinCommands(commandRegistry);

    const intentRegistry = new ComponentRegistry({ matchThreshold: 0.5 });
    intentRegistry.register({
      name: 'deploy-route',
      patterns: ['deploy *'],
      target: { type: 'agent', name: 'coder' },
      priority: 10,
      enabled: true,
    });

    const routingPolicy = new RoutingPolicy({
      enabled: true,
      fastPathThreshold: 0.99,
      llmThreshold: 0.2,
      defaultPath: 'llm',
    });

    const agentConfigRegistry = new AgentConfigRegistry();
    agentConfigRegistry.loadFromConfig({
      assistant: { model_tier: 'default', sandbox: false },
      coder: { model_tier: 'complex', sandbox: false },
    });

    const agentRouter = new AgentRouter({
      default_agent: 'assistant',
      channels: {},
      senders: {},
    });

    const router = createMessageRouter({
      sessionManager: {
        getSession: vi.fn(() => session),
      } as unknown as MessageRouterDeps['sessionManager'],
      modelRouter: {
        getAvailableTiers: () => ['fast', 'default', 'complex', 'local'],
        getAllLabels: () => ({ fast: 'fast', default: 'default', complex: 'complex', local: 'local' }),
        getLabel: (tier: string) => tier,
      } as unknown as MessageRouterDeps['modelRouter'],
      systemPrompt: 'test prompt',
      toolRegistry: {
        clone() { return this; },
        register: vi.fn(),
      } as unknown as MessageRouterDeps['toolRegistry'],
      toolExecutor: {} as unknown as MessageRouterDeps['toolExecutor'],
      config: {
        intents: { enabled: true },
        agents: {
          primary_tier: 'default',
          delegation: {
            compaction: 'fast',
            memory_extraction: 'fast',
            classification: 'fast',
            tool_summarisation: 'fast',
            complex_reasoning: 'complex',
          },
          max_delegation_depth: 3,
          max_iterations: 10,
        },
        compaction: { enabled: false },
        models: { default: { provider: 'anthropic', model: 'claude' } },
      } as unknown as MessageRouterDeps['config'],
      commandRegistry,
      intentRegistry,
      routingPolicy,
      agentConfigRegistry,
      agentRouter,
    });

    await router.handler({
      id: 'm3',
      channel: 'telegram',
      senderId: 'user-3',
      text: 'deploy backend now',
      timestamp: Date.now(),
      metadata: { isCommand: true, command: 'reset' },
    } as MessageRouterInput, vi.fn(async () => {}));

    const keys = Array.from(router.agents.keys());
    expect(keys.some(key => key.includes(':assistant'))).toBe(true);
  });

  it('includes selected backend in status output', async () => {
    const session = {
      id: 'telegram:user-status',
      addMessage: vi.fn(),
      getHistory: vi.fn(() => []),
      clear: vi.fn(),
      replaceHistory: vi.fn(),
      getConfig: vi.fn(() => undefined),
      setConfig: vi.fn(),
      deleteConfig: vi.fn(),
    };

    const commandRegistry = new CommandRegistry();
    registerBuiltinCommands(commandRegistry);

    const router = createMessageRouter({
      sessionManager: {
        getSession: vi.fn(() => session),
      } as unknown as MessageRouterDeps['sessionManager'],
      modelRouter: {
        getAvailableTiers: () => ['fast', 'default', 'complex', 'local'],
        getAllLabels: () => ({ fast: 'fast', default: 'default', complex: 'complex', local: 'local' }),
        getLabel: (tier: string) => tier,
      } as unknown as MessageRouterDeps['modelRouter'],
      systemPrompt: 'test prompt',
      toolRegistry: {
        clone() { return this; },
        register: vi.fn(),
      } as unknown as MessageRouterDeps['toolRegistry'],
      toolExecutor: {} as unknown as MessageRouterDeps['toolExecutor'],
      config: {
        agents: {
          primary_tier: 'default',
          delegation: {
            compaction: 'fast',
            memory_extraction: 'fast',
            classification: 'fast',
            tool_summarisation: 'fast',
            complex_reasoning: 'complex',
          },
          max_delegation_depth: 3,
          max_iterations: 10,
        },
        compaction: { enabled: false },
        models: { default: { provider: 'anthropic', model: 'claude' } },
      } as unknown as MessageRouterDeps['config'],
      commandRegistry,
      externalBackends: { codex: { name: 'codex', process: vi.fn(async () => 'unused') } } as unknown as MessageRouterDeps['externalBackends'],
      defaultName: 'codex',
    });

    const reply = vi.fn(async (_message: OutboundMessage) => {});
    await router.handler({
      id: 'm-status',
      channel: 'telegram',
      senderId: 'user-status',
      text: '/status',
      timestamp: Date.now(),
      metadata: { isCommand: true, command: 'status' },
    } as MessageRouterInput, reply);

    const outbound = reply.mock.calls[0]?.[0] as OutboundMessage | undefined;
    expect(outbound?.text).toContain('Backend: codex');
  });
});

describe('daemon external backend integration', () => {
  afterEach(() => {
    vi.restoreAllMocks();
  });

  it('uses configured external backend for non-command messages', async () => {
    const processSpy = vi.spyOn(AgentOrchestrator.prototype, 'process');
    const history: Array<{ role: 'user' | 'assistant'; content: string }> = [];
    const session = {
      id: 'telegram:external-user',
      addMessage: vi.fn((msg: { role: 'user' | 'assistant'; content: string }) => {
        history.push(msg);
        return msg;
      }),
      getHistory: vi.fn(() => [...history]),
      clear: vi.fn(),
      replaceHistory: vi.fn(),
      getConfig: vi.fn(() => undefined),
      setConfig: vi.fn(),
      deleteConfig: vi.fn(),
    };

    const externalBackend = {
      name: 'codex',
      process: vi.fn(async () => 'external backend response'),
    };

    const router = createMessageRouter({
      sessionManager: {
        getSession: vi.fn(() => session),
      } as unknown as MessageRouterDeps['sessionManager'],
      modelRouter: {
        getAvailableTiers: () => ['fast', 'default', 'complex', 'local'],
        getAllLabels: () => ({ fast: 'fast', default: 'default', complex: 'complex', local: 'local' }),
        getLabel: (tier: string) => tier,
      } as unknown as MessageRouterDeps['modelRouter'],
      systemPrompt: 'test prompt',
      toolRegistry: {
        clone() { return this; },
        register: vi.fn(),
      } as unknown as MessageRouterDeps['toolRegistry'],
      toolExecutor: {} as unknown as MessageRouterDeps['toolExecutor'],
      config: {
        agents: {
          primary_tier: 'default',
          delegation: {
            compaction: 'fast',
            memory_extraction: 'fast',
            classification: 'fast',
            tool_summarisation: 'fast',
            complex_reasoning: 'complex',
          },
          max_delegation_depth: 3,
          max_iterations: 10,
        },
        compaction: { enabled: false },
        models: { default: { provider: 'anthropic', model: 'claude' } },
      } as unknown as MessageRouterDeps['config'],
      externalBackends: { codex: externalBackend } as unknown as MessageRouterDeps['externalBackends'],
      defaultName: 'codex',
    });

    const reply = vi.fn(async (_message: OutboundMessage) => {});
    await router.handler({
      id: 'm-external',
      channel: 'telegram',
      senderId: 'external-user',
      text: 'hello from external path',
      timestamp: Date.now(),
    } as MessageRouterInput, reply);

    expect(externalBackend.process).toHaveBeenCalled();
    expect(processSpy).not.toHaveBeenCalled();
    expect(reply).toHaveBeenCalledWith(expect.objectContaining({ text: 'external backend response' }));
  });

  it('falls back to native processing when external backend fails', async () => {
    const processSpy = vi.spyOn(AgentOrchestrator.prototype, 'process')
      .mockResolvedValue('native fallback response');
    const history: Array<{ role: 'user' | 'assistant'; content: string }> = [];
    const session = {
      id: 'telegram:external-fail',
      addMessage: vi.fn((msg: { role: 'user' | 'assistant'; content: string }) => {
        history.push(msg);
        return msg;
      }),
      getHistory: vi.fn(() => [...history]),
      clear: vi.fn(),
      replaceHistory: vi.fn(),
      getConfig: vi.fn(() => undefined),
      setConfig: vi.fn(),
      deleteConfig: vi.fn(),
    };

    const externalBackend = {
      name: 'codex',
      process: vi.fn(async () => {
        throw new Error('external failed');
      }),
    };

    const router = createMessageRouter({
      sessionManager: {
        getSession: vi.fn(() => session),
      } as unknown as MessageRouterDeps['sessionManager'],
      modelRouter: {
        getAvailableTiers: () => ['fast', 'default', 'complex', 'local'],
        getAllLabels: () => ({ fast: 'fast', default: 'default', complex: 'complex', local: 'local' }),
        getLabel: (tier: string) => tier,
      } as unknown as MessageRouterDeps['modelRouter'],
      systemPrompt: 'test prompt',
      toolRegistry: {
        clone() { return this; },
        register: vi.fn(),
      } as unknown as MessageRouterDeps['toolRegistry'],
      toolExecutor: {} as unknown as MessageRouterDeps['toolExecutor'],
      config: {
        agents: {
          primary_tier: 'default',
          delegation: {
            compaction: 'fast',
            memory_extraction: 'fast',
            classification: 'fast',
            tool_summarisation: 'fast',
            complex_reasoning: 'complex',
          },
          max_delegation_depth: 3,
          max_iterations: 10,
        },
        compaction: { enabled: false },
        models: { default: { provider: 'anthropic', model: 'claude' } },
      } as unknown as MessageRouterDeps['config'],
      externalBackends: { codex: externalBackend } as unknown as MessageRouterDeps['externalBackends'],
      defaultName: 'codex',
    });

    const reply = vi.fn(async (_message: OutboundMessage) => {});
    await router.handler({
      id: 'm-external-fail',
      channel: 'telegram',
      senderId: 'external-fail',
      text: 'hello fallback',
      timestamp: Date.now(),
    } as MessageRouterInput, reply);

    expect(externalBackend.process).toHaveBeenCalled();
    expect(processSpy).toHaveBeenCalled();
    expect(reply).toHaveBeenCalledWith(expect.objectContaining({ text: 'native fallback response' }));
  });
});

describe('daemon audio routing integration', () => {
  afterEach(() => {
    vi.restoreAllMocks();
  });

  it('fast-path replies for voice attachments when transcription is not configured and model does not support audio', async () => {
    const processSpy = vi.spyOn(AgentOrchestrator.prototype, 'process');

    const session = {
      id: 'telegram:user-voice-1',
      addMessage: vi.fn(),
      getHistory: vi.fn(() => []),
      clear: vi.fn(),
      replaceHistory: vi.fn(),
      getConfig: vi.fn(() => undefined),
      setConfig: vi.fn(),
      deleteConfig: vi.fn(),
    };

    const commandRegistry = new CommandRegistry();
    registerBuiltinCommands(commandRegistry);

    const router = createMessageRouter({
      sessionManager: { getSession: vi.fn(() => session) } as unknown as MessageRouterDeps['sessionManager'],
      modelRouter: {
        getAvailableTiers: () => ['default'],
        getAllLabels: () => ({ default: 'default' }),
        getLabel: (tier: string) => tier,
      } as unknown as MessageRouterDeps['modelRouter'],
      systemPrompt: 'test prompt',
      toolRegistry: { clone() { return this; }, register: vi.fn() } as unknown as MessageRouterDeps['toolRegistry'],
      toolExecutor: {} as unknown as MessageRouterDeps['toolExecutor'],
      config: {
        agents: {
          primary_tier: 'default',
          delegation: {
            compaction: 'default',
            memory_extraction: 'default',
            classification: 'default',
            tool_summarisation: 'default',
            complex_reasoning: 'default',
          },
          max_delegation_depth: 1,
          max_iterations: 3,
        },
        compaction: { enabled: false },
        // Anthropic doesn't support native audio; ensures routing hits the non-audio path.
        models: { default: { provider: 'anthropic', model: 'claude' } },
        audio: { enabled: false },
      } as unknown as MessageRouterDeps['config'],
      commandRegistry,
    });

    const reply = vi.fn(async (_message: OutboundMessage) => {});
    await router.handler({
      id: 'v1',
      channel: 'telegram',
      senderId: 'user-voice-1',
      text: '',
      attachments: [{ mimeType: 'audio/ogg', data: 'ZGF0YQ==', filename: 'voice.ogg' }],
      timestamp: Date.now(),
    } as MessageRouterInput, reply);

    expect(processSpy).not.toHaveBeenCalled();
    expect(reply).toHaveBeenCalledTimes(1);
    const firstReply = reply.mock.calls[0]?.[0] as OutboundMessage | undefined;
    const msg = firstReply as { text?: string };
    expect(String(msg.text)).toContain('audio transcription is not configured');
  });

  it('transcribes voice attachments when transcription is configured, then strips audio before calling agent.process', async () => {
    const processSpy = vi.spyOn(AgentOrchestrator.prototype, 'process').mockResolvedValue('ok');

    // Mock transcription endpoint call.
    const fetchSpy = vi.spyOn(globalThis, 'fetch').mockResolvedValue({
      ok: true,
      status: 200,
      statusText: 'OK',
      json: async () => ({ text: 'hello world' }),
    } as Response);

    const session = {
      id: 'telegram:user-voice-2',
      addMessage: vi.fn(),
      getHistory: vi.fn(() => []),
      clear: vi.fn(),
      replaceHistory: vi.fn(),
      getConfig: vi.fn(() => undefined),
      setConfig: vi.fn(),
      deleteConfig: vi.fn(),
    };

    const commandRegistry = new CommandRegistry();
    registerBuiltinCommands(commandRegistry);

    const router = createMessageRouter({
      sessionManager: { getSession: vi.fn(() => session) } as unknown as MessageRouterDeps['sessionManager'],
      modelRouter: {
        getAvailableTiers: () => ['default'],
        getAllLabels: () => ({ default: 'default' }),
        getLabel: (tier: string) => tier,
      } as unknown as MessageRouterDeps['modelRouter'],
      systemPrompt: 'test prompt',
      toolRegistry: { clone() { return this; }, register: vi.fn() } as unknown as MessageRouterDeps['toolRegistry'],
      toolExecutor: {} as unknown as MessageRouterDeps['toolExecutor'],
      config: {
        agents: {
          primary_tier: 'default',
          delegation: {
            compaction: 'default',
            memory_extraction: 'default',
            classification: 'default',
            tool_summarisation: 'default',
            complex_reasoning: 'default',
          },
          max_delegation_depth: 1,
          max_iterations: 3,
        },
        compaction: { enabled: false },
        models: { default: { provider: 'anthropic', model: 'claude' } },
        audio: {
          enabled: true,
          provider: { type: 'openai', endpoint: 'https://example.com/v1/audio/transcriptions', api_key: 'sk-test', model: 'whisper-1' },
        },
      } as unknown as MessageRouterDeps['config'],
      commandRegistry,
    });

    const reply = vi.fn(async (_message: OutboundMessage) => {});
    await router.handler({
      id: 'v2',
      channel: 'telegram',
      senderId: 'user-voice-2',
      text: 'caption',
      attachments: [
        { mimeType: 'audio/ogg', data: 'ZGF0YQ==', filename: 'voice.ogg' },
        { mimeType: 'image/jpeg', data: 'aW1n', filename: 'img.jpg' },
      ],
      timestamp: Date.now(),
    } as MessageRouterInput, reply);

    expect(fetchSpy).toHaveBeenCalled();
    expect(processSpy).toHaveBeenCalledTimes(1);
    const [calledText, calledAttachments] = processSpy.mock.calls[0] ?? [];
    expect(String(calledText)).toContain('[Voice message]: hello world');
    expect(String(calledText)).toContain('caption');
    const atts = calledAttachments as Array<{ mimeType: string }> | undefined;
    expect(atts?.some(a => a.mimeType === 'audio/ogg')).toBe(false);
    expect(atts?.some(a => a.mimeType === 'image/jpeg')).toBe(true);
  });
});

describe('daemon auto-escalate integration', () => {
  afterEach(() => {
    vi.restoreAllMocks();
  });

  it('retries on complex tier when auto_escalate is enabled', async () => {
    const processSpy = vi.spyOn(AgentOrchestrator.prototype, 'process')
      .mockRejectedValueOnce(new Error('primary tier failed'))
      .mockResolvedValueOnce('complex-tier response');
    const setModelTierSpy = vi.spyOn(AgentOrchestrator.prototype, 'setModelTier');

    const session = {
      id: 'telegram:auto-escalate',
      addMessage: vi.fn(),
      getHistory: vi.fn(() => []),
      clear: vi.fn(),
      replaceHistory: vi.fn(),
      getConfig: vi.fn(() => undefined),
      setConfig: vi.fn(),
      deleteConfig: vi.fn(),
    };

    const router = createMessageRouter({
      sessionManager: {
        getSession: vi.fn(() => session),
      } as unknown as MessageRouterDeps['sessionManager'],
      modelRouter: {
        getAvailableTiers: () => ['fast', 'default', 'complex', 'local'],
        getAllLabels: () => ({ fast: 'fast', default: 'default', complex: 'complex', local: 'local' }),
        getLabel: (tier: string) => tier,
      } as unknown as MessageRouterDeps['modelRouter'],
      systemPrompt: 'test prompt',
      toolRegistry: {
        clone() { return this; },
        register: vi.fn(),
      } as unknown as MessageRouterDeps['toolRegistry'],
      toolExecutor: {} as unknown as MessageRouterDeps['toolExecutor'],
      config: {
        agents: {
          primary_tier: 'default',
          auto_escalate: true,
          delegation: {
            compaction: 'fast',
            memory_extraction: 'fast',
            classification: 'fast',
            tool_summarisation: 'fast',
            complex_reasoning: 'complex',
          },
          max_delegation_depth: 3,
          max_iterations: 10,
        },
        compaction: { enabled: false },
        models: { default: { provider: 'anthropic', model: 'claude' } },
      } as unknown as MessageRouterDeps['config'],
    });

    const reply = vi.fn(async (_message: OutboundMessage) => {});
    await router.handler({
      id: 'm-auto-escalate',
      channel: 'telegram',
      senderId: 'auto-escalate',
      text: 'do something hard',
      timestamp: Date.now(),
    } as MessageRouterInput, reply);

    expect(processSpy).toHaveBeenCalledTimes(2);
    expect(setModelTierSpy).toHaveBeenCalledWith('complex');
    expect(reply).toHaveBeenCalledWith(expect.objectContaining({ text: 'complex-tier response' }));
  });
});

describe('daemon talk mode (voice wake) integration', () => {
  afterEach(() => {
    vi.restoreAllMocks();
  });

  it('ignores messages until wake phrase is used', async () => {
    const processSpy = vi.spyOn(AgentOrchestrator.prototype, 'process').mockResolvedValue('ok');
    const session = {
      id: 'telegram:user-talk-1',
      addMessage: vi.fn(),
      getHistory: vi.fn(() => []),
      clear: vi.fn(),
      replaceHistory: vi.fn(),
      getConfig: vi.fn(() => undefined),
      setConfig: vi.fn(),
      deleteConfig: vi.fn(),
    };

    const router = createMessageRouter({
      sessionManager: { getSession: vi.fn(() => session) } as unknown as MessageRouterDeps['sessionManager'],
      modelRouter: {
        getAvailableTiers: () => ['fast', 'default', 'complex', 'local'],
        getAllLabels: () => ({ fast: 'fast', default: 'default', complex: 'complex', local: 'local' }),
        getLabel: (tier: string) => tier,
      } as unknown as MessageRouterDeps['modelRouter'],
      systemPrompt: 'test prompt',
      toolRegistry: { clone() { return this; }, register: vi.fn() } as unknown as MessageRouterDeps['toolRegistry'],
      toolExecutor: {} as unknown as MessageRouterDeps['toolExecutor'],
      config: {
        agents: {
          primary_tier: 'default',
          delegation: { compaction: 'fast', memory_extraction: 'fast', classification: 'fast', tool_summarisation: 'fast', complex_reasoning: 'complex' },
          max_delegation_depth: 3,
          max_iterations: 10,
        },
        compaction: { enabled: false },
        models: { default: { provider: 'anthropic', model: 'claude' } },
        audio: { talk_mode: { enabled: true, wake_phrase: 'hey flynn', timeout_ms: 120000, allow_manual_toggle: true } },
      } as unknown as MessageRouterDeps['config'],
    });

    const reply = vi.fn(async (_message: OutboundMessage) => {});

    await router.handler({
      id: 'm-talk-1',
      channel: 'telegram',
      senderId: 'user-talk-1',
      text: 'hello there',
      timestamp: Date.now(),
    } as MessageRouterInput, reply);
    expect(processSpy).not.toHaveBeenCalled();

    await router.handler({
      id: 'm-talk-2',
      channel: 'telegram',
      senderId: 'user-talk-1',
      text: 'hey flynn what time is it?',
      timestamp: Date.now(),
    } as MessageRouterInput, reply);
    expect(processSpy).toHaveBeenCalledOnce();
    expect(processSpy).toHaveBeenCalledWith('what time is it?', undefined);
  });
});
