@shykaruu/jarvis-brain 0.4.0

package/src/daemon/llm-settings.test.ts

@@ -0,0 +1,78 @@
+import { afterEach, beforeEach, describe, expect, mock, test } from 'bun:test';
+import { testLLMProvider } from './llm-settings.ts';
+import { DEFAULT_CONFIG, type JarvisConfig } from '../config/types.ts';
+
+function makeConfig(): JarvisConfig {
+  return structuredClone(DEFAULT_CONFIG);
+}
+
+describe('testLLMProvider', () => {
+  const originalFetch = globalThis.fetch;
+
+  beforeEach(() => {
+    globalThis.fetch = mock(async (_url: string) => {
+      return new Response(JSON.stringify({
+        id: 'cmpl_test',
+        object: 'chat.completion',
+        created: Date.now(),
+        model: 'gpt-test',
+        choices: [
+          {
+            index: 0,
+            message: { role: 'assistant', content: 'OK' },
+            finish_reason: 'stop',
+          },
+        ],
+        usage: {
+          prompt_tokens: 1,
+          completion_tokens: 1,
+          total_tokens: 2,
+        },
+      }), {
+        status: 200,
+        headers: { 'Content-Type': 'application/json' },
+      });
+    }) as unknown as typeof fetch;
+  });
+
+  afterEach(() => {
+    globalThis.fetch = originalFetch;
+  });
+
+  test('uses the official OpenAI endpoint when no base URL is configured', async () => {
+    const config = makeConfig();
+    const result = await testLLMProvider(
+      {
+        provider: 'openai',
+        api_key: 'sk-test-key',
+        model: 'gpt-5.4',
+      },
+      config,
+    );
+
+    expect(result.ok).toBe(true);
+
+    const fetchMock = globalThis.fetch as unknown as ReturnType<typeof mock>;
+    expect(fetchMock).toHaveBeenCalledTimes(1);
+    expect(fetchMock.mock.calls[0]?.[0]).toBe('https://api.openai.com/v1/chat/completions');
+  });
+
+  test('uses custom compatible base URLs without assuming an OpenAI key prefix', async () => {
+    const config = makeConfig();
+    const result = await testLLMProvider(
+      {
+        provider: 'openai',
+        api_key: 'nvapi-custom-key',
+        model: 'gpt-5.4',
+        base_url: 'https://gateway.example.com/openai',
+      },
+      config,
+    );
+
+    expect(result.ok).toBe(true);
+
+    const fetchMock = globalThis.fetch as unknown as ReturnType<typeof mock>;
+    expect(fetchMock).toHaveBeenCalledTimes(1);
+    expect(fetchMock.mock.calls[0]?.[0]).toBe('https://gateway.example.com/openai/chat/completions');
+  });
+});

package/src/daemon/llm-settings.ts

@@ -0,0 +1,450 @@
+/**
+ * LLM Settings — Bridge between DB settings, encrypted keychain, and in-memory config.
+ *
+ * Non-secret settings (provider, model, fallback) are stored in the SQLite `settings` table.
+ * API keys are stored in the encrypted secrets file via the keychain module.
+ */
+
+import { getSetting, setSetting, getSettingsByPrefix } from '../vault/settings.ts';
+import { getSecret, setSecret, deleteSecret, hasSecret } from '../vault/keychain.ts';
+import type { JarvisConfig } from '../config/types.ts';
+import { AnthropicProvider } from '../llm/anthropic.ts';
+import { OpenAIProvider } from '../llm/openai.ts';
+import { GroqProvider } from '../llm/groq.ts';
+import { GeminiProvider } from '../llm/gemini.ts';
+import { OllamaProvider } from '../llm/ollama.ts';
+import { OpenRouterProvider } from '../llm/openrouter.ts';
+import type { LLMProvider } from '../llm/provider.ts';
+import type { LLMManager } from '../llm/manager.ts';
+
+// Keychain key names
+const KEY_ANTHROPIC = 'llm.anthropic.api_key';
+const KEY_OPENAI = 'llm.openai.api_key';
+const KEY_GROQ = 'llm.groq.api_key';
+const KEY_GEMINI = 'llm.gemini.api_key';
+const KEY_OPENROUTER = 'llm.openrouter.api_key';
+
+// DB setting keys
+const SETTING_PRIMARY = 'llm.primary';
+const SETTING_FALLBACK = 'llm.fallback';
+const SETTING_ANTHROPIC_MODEL = 'llm.anthropic.model';
+const SETTING_OPENAI_MODEL = 'llm.openai.model';
+const SETTING_OPENAI_BASE_URL = 'llm.openai.base_url';
+const SETTING_GROQ_MODEL = 'llm.groq.model';
+const SETTING_GEMINI_MODEL = 'llm.gemini.model';
+const SETTING_OLLAMA_MODEL = 'llm.ollama.model';
+const SETTING_OLLAMA_BASE_URL = 'llm.ollama.base_url';
+const SETTING_OPENROUTER_MODEL = 'llm.openrouter.model';
+
+export type LLMSettingsResponse = {
+  primary: string;
+  fallback: string[];
+  anthropic: { model: string; has_api_key: boolean } | null;
+  openai: { model: string; has_api_key: boolean; base_url?: string } | null;
+  groq: { model: string; has_api_key: boolean } | null;
+  gemini: { model: string; has_api_key: boolean } | null;
+  ollama: { base_url: string; model: string } | null;
+  openrouter: { model: string; has_api_key: boolean } | null;
+};
+
+/**
+ * Read LLM settings from DB + keychain and return a dashboard-safe response.
+ * Falls back to in-memory config values for anything not yet saved to DB.
+ */
+export function getLLMSettings(config: JarvisConfig): LLMSettingsResponse {
+  const primary = getSetting(SETTING_PRIMARY) ?? config.llm.primary;
+  const fallbackRaw = getSetting(SETTING_FALLBACK);
+  const fallback = fallbackRaw ? JSON.parse(fallbackRaw) : config.llm.fallback;
+
+  const anthropicModel = getSetting(SETTING_ANTHROPIC_MODEL) ?? config.llm.anthropic?.model ?? 'claude-sonnet-4-6';
+  const openaiModel = getSetting(SETTING_OPENAI_MODEL) ?? config.llm.openai?.model ?? 'gpt-5.4';
+  const openaiBaseUrl = getSetting(SETTING_OPENAI_BASE_URL) ?? config.llm.openai?.base_url;
+  const groqModel = getSetting(SETTING_GROQ_MODEL) ?? config.llm.groq?.model ?? 'llama-3.3-70b-versatile';
+  const geminiModel = getSetting(SETTING_GEMINI_MODEL) ?? config.llm.gemini?.model ?? 'gemini-3-flash-preview';
+  const ollamaModel = getSetting(SETTING_OLLAMA_MODEL) ?? config.llm.ollama?.model ?? 'llama3';
+  const ollamaBaseUrl = getSetting(SETTING_OLLAMA_BASE_URL) ?? config.llm.ollama?.base_url ?? 'http://localhost:11434';
+
+  const openrouterModel = getSetting(SETTING_OPENROUTER_MODEL) ?? config.llm.openrouter?.model ?? 'anthropic/claude-sonnet-4';
+
+  const hasAnthropicKey = hasSecret(KEY_ANTHROPIC) || !!config.llm.anthropic?.api_key;
+  const hasOpenaiKey = hasSecret(KEY_OPENAI) || !!config.llm.openai?.api_key;
+  const hasGroqKey = hasSecret(KEY_GROQ) || !!config.llm.groq?.api_key;
+  const hasGeminiKey = hasSecret(KEY_GEMINI) || !!config.llm.gemini?.api_key;
+  const hasOpenrouterKey = hasSecret(KEY_OPENROUTER) || !!config.llm.openrouter?.api_key;
+
+  return {
+    primary,
+    fallback,
+    anthropic: { model: anthropicModel, has_api_key: hasAnthropicKey },
+    openai: { model: openaiModel, has_api_key: hasOpenaiKey, ...(openaiBaseUrl ? { base_url: openaiBaseUrl } : {}) },
+    groq: { model: groqModel, has_api_key: hasGroqKey },
+    gemini: { model: geminiModel, has_api_key: hasGeminiKey },
+    ollama: { base_url: ollamaBaseUrl, model: ollamaModel },
+    openrouter: { model: openrouterModel, has_api_key: hasOpenrouterKey },
+  };
+}
+
+/**
+ * Save LLM settings to DB + keychain and update the in-memory config.
+ */
+export function saveLLMSettings(
+  config: JarvisConfig,
+  body: {
+    primary?: string;
+    fallback?: string[];
+    anthropic?: { api_key?: string; model?: string };
+    openai?: { api_key?: string; model?: string; base_url?: string };
+    groq?: { api_key?: string; model?: string };
+    gemini?: { api_key?: string; model?: string };
+    ollama?: { base_url?: string; model?: string };
+    openrouter?: { api_key?: string; model?: string };
+  },
+): void {
+  // Save non-secret settings to DB
+  if (body.primary) {
+    setSetting(SETTING_PRIMARY, body.primary);
+    config.llm.primary = body.primary;
+  }
+  if (body.fallback) {
+    setSetting(SETTING_FALLBACK, JSON.stringify(body.fallback));
+    config.llm.fallback = body.fallback;
+  }
+
+  // Anthropic
+  if (body.anthropic) {
+    if (body.anthropic.model) {
+      setSetting(SETTING_ANTHROPIC_MODEL, body.anthropic.model);
+    }
+    if (body.anthropic.api_key) {
+      setSecret(KEY_ANTHROPIC, body.anthropic.api_key);
+    }
+    config.llm.anthropic = {
+      ...config.llm.anthropic,
+      model: body.anthropic.model ?? config.llm.anthropic?.model,
+      api_key: body.anthropic.api_key ?? getAnthropicApiKey(config) ?? '',
+    };
+  }
+
+  // OpenAI
+  if (body.openai) {
+    if (body.openai.base_url !== undefined) {
+      const trimmedBaseUrl = body.openai.base_url.trim();
+      if (trimmedBaseUrl) {
+        try {
+          new URL(trimmedBaseUrl);
+        } catch {
+          throw new Error(`Invalid OpenAI base URL: ${trimmedBaseUrl}`);
+        }
+      }
+    }
+    if (body.openai.model) {
+      setSetting(SETTING_OPENAI_MODEL, body.openai.model);
+    }
+    if (body.openai.base_url !== undefined) {
+      const trimmedBaseUrl = body.openai.base_url.trim();
+      if (trimmedBaseUrl) {
+        setSetting(SETTING_OPENAI_BASE_URL, trimmedBaseUrl);
+      } else {
+        setSetting(SETTING_OPENAI_BASE_URL, '');
+      }
+    }
+    if (body.openai.api_key) {
+      setSecret(KEY_OPENAI, body.openai.api_key);
+    }
+    config.llm.openai = {
+      ...config.llm.openai,
+      model: body.openai.model ?? config.llm.openai?.model,
+      base_url: body.openai.base_url !== undefined
+        ? (body.openai.base_url.trim() || undefined)
+        : config.llm.openai?.base_url,
+      api_key: body.openai.api_key ?? getOpenAIApiKey(config) ?? '',
+    };
+  }
+
+  // Groq
+  if (body.groq) {
+    if (body.groq.model) {
+      setSetting(SETTING_GROQ_MODEL, body.groq.model);
+    }
+    if (body.groq.api_key) {
+      setSecret(KEY_GROQ, body.groq.api_key);
+    }
+    config.llm.groq = {
+      ...config.llm.groq,
+      model: body.groq.model ?? config.llm.groq?.model,
+      api_key: body.groq.api_key ?? getGroqApiKey(config) ?? '',
+    };
+  }
+
+  // Gemini
+  if (body.gemini) {
+    if (body.gemini.model) {
+      setSetting(SETTING_GEMINI_MODEL, body.gemini.model);
+    }
+    if (body.gemini.api_key) {
+      setSecret(KEY_GEMINI, body.gemini.api_key);
+    }
+    config.llm.gemini = {
+      ...config.llm.gemini,
+      model: body.gemini.model ?? config.llm.gemini?.model,
+      api_key: body.gemini.api_key ?? getGeminiApiKey(config) ?? '',
+    };
+  }
+
+  // Ollama
+  if (body.ollama) {
+    if (body.ollama.model) {
+      setSetting(SETTING_OLLAMA_MODEL, body.ollama.model);
+    }
+    if (body.ollama.base_url) {
+      setSetting(SETTING_OLLAMA_BASE_URL, body.ollama.base_url);
+    }
+    config.llm.ollama = {
+      ...config.llm.ollama,
+      model: body.ollama.model ?? config.llm.ollama?.model,
+      base_url: body.ollama.base_url ?? config.llm.ollama?.base_url,
+    };
+  }
+
+  // OpenRouter
+  if (body.openrouter) {
+    if (body.openrouter.model) {
+      setSetting(SETTING_OPENROUTER_MODEL, body.openrouter.model);
+    }
+    if (body.openrouter.api_key) {
+      setSecret(KEY_OPENROUTER, body.openrouter.api_key);
+    }
+    config.llm.openrouter = {
+      ...config.llm.openrouter,
+      model: body.openrouter.model ?? config.llm.openrouter?.model,
+      api_key: body.openrouter.api_key ?? getOpenRouterApiKey(config) ?? '',
+    };
+  }
+}
+
+/**
+ * Resolve the Anthropic API key: keychain > config.yaml > env var.
+ */
+function getAnthropicApiKey(config: JarvisConfig): string | null {
+  return getSecret(KEY_ANTHROPIC) ?? config.llm.anthropic?.api_key ?? null;
+}
+
+/**
+ * Resolve the OpenAI API key: keychain > config.yaml > env var.
+ */
+function getOpenAIApiKey(config: JarvisConfig): string | null {
+  return getSecret(KEY_OPENAI) ?? config.llm.openai?.api_key ?? null;
+}
+
+/**
+ * Resolve the Groq API key: keychain > config.yaml > env var.
+ */
+function getGroqApiKey(config: JarvisConfig): string | null {
+  return getSecret(KEY_GROQ) ?? config.llm.groq?.api_key ?? null;
+}
+
+/**
+ * Resolve the Gemini API key: keychain > config.yaml > env var.
+ */
+function getGeminiApiKey(config: JarvisConfig): string | null {
+  return getSecret(KEY_GEMINI) ?? config.llm.gemini?.api_key ?? null;
+}
+
+/**
+ * Resolve the OpenRouter API key: keychain > config.yaml > env var.
+ */
+function getOpenRouterApiKey(config: JarvisConfig): string | null {
+  return getSecret(KEY_OPENROUTER) ?? config.llm.openrouter?.api_key ?? null;
+}
+
+/**
+ * Merge DB/keychain LLM settings into config at startup.
+ * Env vars (already applied by loadConfig) take priority over DB values.
+ */
+export function mergeLLMSettingsIntoConfig(config: JarvisConfig): void {
+  // Only override from DB if env vars are NOT set
+  const dbPrimary = getSetting(SETTING_PRIMARY);
+  if (dbPrimary) config.llm.primary = dbPrimary;
+
+  const dbFallback = getSetting(SETTING_FALLBACK);
+  if (dbFallback) config.llm.fallback = JSON.parse(dbFallback);
+
+  // Anthropic
+  const dbAnthropicModel = getSetting(SETTING_ANTHROPIC_MODEL);
+  const keychainAnthropicKey = getSecret(KEY_ANTHROPIC);
+  if (dbAnthropicModel || keychainAnthropicKey) {
+    config.llm.anthropic = {
+      ...config.llm.anthropic,
+      api_key: (!process.env.JARVIS_API_KEY && keychainAnthropicKey)
+        ? keychainAnthropicKey
+        : (config.llm.anthropic?.api_key ?? ''),
+      model: dbAnthropicModel ?? config.llm.anthropic?.model,
+    };
+  }
+
+  // OpenAI
+  const dbOpenaiModel = getSetting(SETTING_OPENAI_MODEL);
+  const dbOpenaiBaseUrl = getSetting(SETTING_OPENAI_BASE_URL);
+  const keychainOpenaiKey = getSecret(KEY_OPENAI);
+  if (dbOpenaiModel || dbOpenaiBaseUrl !== null || keychainOpenaiKey) {
+    config.llm.openai = {
+      ...config.llm.openai,
+      api_key: (!process.env.JARVIS_OPENAI_KEY && keychainOpenaiKey)
+        ? keychainOpenaiKey
+        : (config.llm.openai?.api_key ?? ''),
+      model: dbOpenaiModel ?? config.llm.openai?.model,
+      base_url: dbOpenaiBaseUrl !== null
+        ? (dbOpenaiBaseUrl || undefined)
+        : config.llm.openai?.base_url,
+    };
+  }
+
+  // Groq
+  const dbGroqModel = getSetting(SETTING_GROQ_MODEL);
+  const keychainGroqKey = getSecret(KEY_GROQ);
+  if (dbGroqModel || keychainGroqKey) {
+    config.llm.groq = {
+      ...config.llm.groq,
+      api_key: (!process.env.JARVIS_GROQ_KEY && keychainGroqKey)
+        ? keychainGroqKey
+        : (config.llm.groq?.api_key ?? ''),
+      model: dbGroqModel ?? config.llm.groq?.model,
+    };
+  }
+
+  // Gemini
+  const dbGeminiModel = getSetting(SETTING_GEMINI_MODEL);
+  const keychainGeminiKey = getSecret(KEY_GEMINI);
+  if (dbGeminiModel || keychainGeminiKey) {
+    config.llm.gemini = {
+      ...config.llm.gemini,
+      api_key: (!process.env.JARVIS_GEMINI_KEY && keychainGeminiKey)
+        ? keychainGeminiKey
+        : (config.llm.gemini?.api_key ?? ''),
+      model: dbGeminiModel ?? config.llm.gemini?.model,
+    };
+  }
+
+  // Ollama
+  const dbOllamaModel = getSetting(SETTING_OLLAMA_MODEL);
+  const dbOllamaUrl = getSetting(SETTING_OLLAMA_BASE_URL);
+  if (dbOllamaModel || dbOllamaUrl) {
+    config.llm.ollama = {
+      ...config.llm.ollama,
+      model: dbOllamaModel ?? config.llm.ollama?.model,
+      base_url: (!process.env.JARVIS_OLLAMA_URL && dbOllamaUrl)
+        ? dbOllamaUrl
+        : (config.llm.ollama?.base_url ?? 'http://localhost:11434'),
+    };
+  }
+
+  // OpenRouter
+  const dbOpenrouterModel = getSetting(SETTING_OPENROUTER_MODEL);
+  const keychainOpenrouterKey = getSecret(KEY_OPENROUTER);
+  if (dbOpenrouterModel || keychainOpenrouterKey) {
+    config.llm.openrouter = {
+      ...config.llm.openrouter,
+      api_key: (!process.env.JARVIS_OPENROUTER_KEY && keychainOpenrouterKey)
+        ? keychainOpenrouterKey
+        : (config.llm.openrouter?.api_key ?? ''),
+      model: dbOpenrouterModel ?? config.llm.openrouter?.model,
+    };
+  }
+}
+
+/**
+ * Build fresh LLM provider instances from the current config and hot-reload them
+ * into the shared LLMManager (atomic swap, safe for in-flight requests).
+ */
+export function hotReloadLLMProviders(config: JarvisConfig, llmManager: LLMManager): void {
+  const { llm } = config;
+  const providers: LLMProvider[] = [];
+
+  if (llm.anthropic?.api_key) {
+    providers.push(new AnthropicProvider(llm.anthropic.api_key, llm.anthropic.model));
+    console.log('[LLM] Hot-reloaded Anthropic provider');
+  }
+  if (llm.openai?.api_key) {
+    providers.push(new OpenAIProvider(llm.openai.api_key, llm.openai.model, llm.openai.base_url));
+    console.log('[LLM] Hot-reloaded OpenAI provider');
+  }
+  if (llm.groq?.api_key) {
+    providers.push(new GroqProvider(llm.groq.api_key, llm.groq.model));
+    console.log('[LLM] Hot-reloaded Groq provider');
+  }
+  if (llm.gemini?.api_key) {
+    providers.push(new GeminiProvider(llm.gemini.api_key, llm.gemini.model));
+    console.log('[LLM] Hot-reloaded Gemini provider');
+  }
+  if (llm.openrouter?.api_key) {
+    providers.push(new OpenRouterProvider(llm.openrouter.api_key, llm.openrouter.model));
+    console.log('[LLM] Hot-reloaded OpenRouter provider');
+  }
+  if (llm.ollama) {
+    providers.push(new OllamaProvider(llm.ollama.base_url, llm.ollama.model));
+    console.log('[LLM] Hot-reloaded Ollama provider');
+  }
+
+  const fallback = llm.fallback.filter(n => providers.some(p => p.name === n));
+  llmManager.replaceProviders(providers, llm.primary, fallback);
+  console.log(`[LLM] Providers active: ${providers.map(p => p.name).join(', ') || 'none'} (primary: ${llm.primary})`);
+}
+
+/**
+ * Test an LLM provider connection. Uses provided credentials if given,
+ * otherwise falls back to stored keys (keychain > config).
+ */
+export async function testLLMProvider(
+  opts: {
+    provider: string;
+    api_key?: string;
+    model?: string;
+    base_url?: string;
+  },
+  config: JarvisConfig,
+): Promise<{ ok: boolean; model?: string; error?: string }> {
+  try {
+    let instance: LLMProvider;
+
+    if (opts.provider === 'anthropic') {
+      const key = opts.api_key || getSecret(KEY_ANTHROPIC) || config.llm.anthropic?.api_key;
+      if (!key) return { ok: false, error: 'API key required' };
+      instance = new AnthropicProvider(key, opts.model ?? config.llm.anthropic?.model);
+    } else if (opts.provider === 'openai') {
+      const key = opts.api_key || getSecret(KEY_OPENAI) || config.llm.openai?.api_key;
+      if (!key) return { ok: false, error: 'API key required' };
+      instance = new OpenAIProvider(
+        key,
+        opts.model ?? config.llm.openai?.model,
+        opts.base_url ?? config.llm.openai?.base_url,
+      );
+    } else if (opts.provider === 'groq') {
+      const key = opts.api_key || getSecret(KEY_GROQ) || config.llm.groq?.api_key;
+      if (!key) return { ok: false, error: 'API key required' };
+      instance = new GroqProvider(key, opts.model ?? config.llm.groq?.model);
+    } else if (opts.provider === 'gemini') {
+      const key = opts.api_key || config.llm.gemini?.api_key;
+      if (!key) return { ok: false, error: 'API key required' };
+      instance = new GeminiProvider(key, opts.model ?? config.llm.gemini?.model);
+    } else if (opts.provider === 'openrouter') {
+      const key = opts.api_key || getSecret(KEY_OPENROUTER) || config.llm.openrouter?.api_key;
+      if (!key) return { ok: false, error: 'API key required' };
+      instance = new OpenRouterProvider(key, opts.model ?? config.llm.openrouter?.model);
+    } else if (opts.provider === 'ollama') {
+      instance = new OllamaProvider(
+        opts.base_url ?? config.llm.ollama?.base_url,
+        opts.model ?? config.llm.ollama?.model,
+      );
+    } else {
+      return { ok: false, error: `Unknown provider: ${opts.provider}` };
+    }
+
+    const resp = await instance.chat(
+      [{ role: 'user', content: 'Say OK' }],
+      { max_tokens: 5 },
+    );
+    return { ok: true, model: resp.model };
+  } catch (err) {
+    return { ok: false, error: err instanceof Error ? err.message : String(err) };
+  }
+}

package/src/daemon/observer-service.ts

@@ -0,0 +1,150 @@
+/**
+ * Observer Service — The Eyes
+ *
+ * Wraps ObserverManager. Registers system observers (file watcher,
+ * clipboard monitor, process monitor, email, calendar, notifications)
+ * and routes events to the vault.
+ * Also classifies events and routes them to the EventReactor (immediate)
+ * or EventCoalescer (batched for heartbeat).
+ */
+
+import type { Service, ServiceStatus } from './services.ts';
+import type { ObserverEvent } from '../observers/index.ts';
+import type { ObservationType } from '../vault/observations.ts';
+import type { EventReactor } from './event-reactor.ts';
+import type { EventCoalescer } from './event-coalescer.ts';
+import type { GoogleAuth } from '../integrations/google-auth.ts';
+
+import { homedir } from 'node:os';
+import {
+  ObserverManager,
+  FileWatcher,
+  ClipboardMonitor,
+  ProcessMonitor,
+} from '../observers/index.ts';
+import { EmailSync } from '../observers/email.ts';
+import { CalendarSync } from '../observers/calendar.ts';
+import { NotificationListener } from '../observers/notifications.ts';
+import { createObservation } from '../vault/observations.ts';
+import { classifyEvent } from './event-classifier.ts';
+
+/**
+ * Map observer event types to vault observation types.
+ */
+function mapEventType(eventType: string): ObservationType {
+  switch (eventType) {
+    case 'file_change':
+      return 'file_change';
+    case 'clipboard':
+      return 'clipboard';
+    case 'process_started':
+    case 'process_stopped':
+      return 'process';
+    case 'notification':
+      return 'notification';
+    case 'calendar':
+      return 'calendar';
+    case 'email':
+      return 'email';
+    case 'browser':
+      return 'browser';
+    case 'screen_capture':
+    case 'context_changed':
+    case 'error_detected':
+    case 'stuck_detected':
+    case 'session_started':
+    case 'session_ended':
+    case 'suggestion_ready':
+      return 'screen_capture';
+    default:
+      return 'app_activity';
+  }
+}
+
+export class ObserverService implements Service {
+  name = 'observers';
+  private _status: ServiceStatus = 'stopped';
+  private manager: ObserverManager;
+  private reactor: EventReactor | null;
+  private coalescer: EventCoalescer | null;
+  private googleAuth: GoogleAuth | null;
+
+  constructor(reactor?: EventReactor, coalescer?: EventCoalescer, googleAuth?: GoogleAuth) {
+    this.manager = new ObserverManager();
+    this.reactor = reactor ?? null;
+    this.coalescer = coalescer ?? null;
+    this.googleAuth = googleAuth ?? null;
+  }
+
+  async start(): Promise<void> {
+    this._status = 'starting';
+
+    try {
+      // Register core observers
+      this.manager.register(new FileWatcher([homedir()]));
+      this.manager.register(new ClipboardMonitor());
+      this.manager.register(new ProcessMonitor());
+
+      // Register D-Bus notification observer (Linux/WSL2)
+      this.manager.register(new NotificationListener());
+
+      // Register Gmail observer (if Google auth available)
+      this.manager.register(new EmailSync(this.googleAuth ?? undefined));
+
+      // Register Calendar observer (if Google auth available)
+      this.manager.register(new CalendarSync(this.googleAuth ?? undefined));
+
+      // Set event handler: store in vault + classify + route
+      this.manager.setEventHandler((event: ObserverEvent) => {
+        // 1. Always store in vault
+        try {
+          const obsType = mapEventType(event.type);
+          createObservation(obsType, event.data);
+        } catch (err) {
+          console.error('[ObserverService] Error storing observation:', err);
+        }
+
+        // 2. Classify and route
+        try {
+          const classified = classifyEvent(event);
+
+          if (classified.priority === 'critical' || classified.priority === 'high') {
+            // Route to reactor for immediate handling
+            if (this.reactor) {
+              this.reactor.react(classified).catch(err =>
+                console.error('[ObserverService] Reactor error:', err)
+              );
+            }
+          } else {
+            // Route to coalescer for batched delivery at heartbeat
+            if (this.coalescer) {
+              this.coalescer.addEvent(classified);
+            }
+          }
+        } catch (err) {
+          console.error('[ObserverService] Error classifying event:', err);
+        }
+      });
+
+      // Start all observers (individual failures don't crash the service)
+      await this.manager.startAll();
+
+      this._status = 'running';
+      console.log('[ObserverService] Started');
+    } catch (error) {
+      this._status = 'error';
+      throw error;
+    }
+  }
+
+  async stop(): Promise<void> {
+    this._status = 'stopping';
+    await this.manager.stopAll();
+    this._status = 'stopped';
+    console.log('[ObserverService] Stopped');
+  }
+
+  status(): ServiceStatus {
+    return this._status;
+  }
+}