cowork-os 0.3.21

package/dist/electron/electron/ipc/handlers.js

@@ -0,0 +1,3138 @@
+"use strict";
+var __createBinding = (this && this.__createBinding) || (Object.create ? (function(o, m, k, k2) {
+    if (k2 === undefined) k2 = k;
+    var desc = Object.getOwnPropertyDescriptor(m, k);
+    if (!desc || ("get" in desc ? !m.__esModule : desc.writable || desc.configurable)) {
+      desc = { enumerable: true, get: function() { return m[k]; } };
+    }
+    Object.defineProperty(o, k2, desc);
+}) : (function(o, m, k, k2) {
+    if (k2 === undefined) k2 = k;
+    o[k2] = m[k];
+}));
+var __setModuleDefault = (this && this.__setModuleDefault) || (Object.create ? (function(o, v) {
+    Object.defineProperty(o, "default", { enumerable: true, value: v });
+}) : function(o, v) {
+    o["default"] = v;
+});
+var __importStar = (this && this.__importStar) || (function () {
+    var ownKeys = function(o) {
+        ownKeys = Object.getOwnPropertyNames || function (o) {
+            var ar = [];
+            for (var k in o) if (Object.prototype.hasOwnProperty.call(o, k)) ar[ar.length] = k;
+            return ar;
+        };
+        return ownKeys(o);
+    };
+    return function (mod) {
+        if (mod && mod.__esModule) return mod;
+        var result = {};
+        if (mod != null) for (var k = ownKeys(mod), i = 0; i < k.length; i++) if (k[i] !== "default") __createBinding(result, mod, k[i]);
+        __setModuleDefault(result, mod);
+        return result;
+    };
+})();
+var __importDefault = (this && this.__importDefault) || function (mod) {
+    return (mod && mod.__esModule) ? mod : { "default": mod };
+};
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.getNotificationService = getNotificationService;
+exports.setupIpcHandlers = setupIpcHandlers;
+exports.getHooksServer = getHooksServer;
+const electron_1 = require("electron");
+const path = __importStar(require("path"));
+const fs = __importStar(require("fs/promises"));
+const fsSync = __importStar(require("fs"));
+const mammoth_1 = __importDefault(require("mammoth"));
+// eslint-disable-next-line @typescript-eslint/no-require-imports
+const pdfParseModule = require('pdf-parse');
+// Handle both ESM default export and CommonJS module.exports
+const pdfParse = (typeof pdfParseModule === 'function' ? pdfParseModule : pdfParseModule.default);
+const schema_1 = require("../database/schema");
+const repositories_1 = require("../database/repositories");
+const AgentRoleRepository_1 = require("../agents/AgentRoleRepository");
+const ActivityRepository_1 = require("../activity/ActivityRepository");
+const MentionRepository_1 = require("../agents/MentionRepository");
+const TaskLabelRepository_1 = require("../database/TaskLabelRepository");
+const WorkingStateRepository_1 = require("../agents/WorkingStateRepository");
+const context_policy_1 = require("../gateway/context-policy");
+const types_1 = require("../../shared/types");
+const os = __importStar(require("os"));
+const llm_1 = require("../agent/llm");
+const search_1 = require("../agent/search");
+const updater_1 = require("../updater");
+const rate_limiter_1 = require("../utils/rate-limiter");
+const validation_1 = require("../utils/validation");
+const guardrail_manager_1 = require("../guardrails/guardrail-manager");
+const appearance_manager_1 = require("../settings/appearance-manager");
+const personality_manager_1 = require("../settings/personality-manager");
+const normalizeMentionToken = (value) => value.toLowerCase().replace(/[^a-z0-9]/g, '');
+const buildAgentMentionIndex = (roles) => {
+    const index = new Map();
+    roles.forEach((role) => {
+        const baseTokens = [
+            role.name,
+            role.displayName,
+            role.name.replace(/[_-]+/g, ''),
+            role.displayName.replace(/\s+/g, ''),
+            role.displayName.replace(/\s+/g, '_'),
+            role.displayName.replace(/\s+/g, '-'),
+        ];
+        baseTokens.forEach((token) => {
+            const normalized = normalizeMentionToken(token);
+            if (normalized) {
+                index.set(normalized, role);
+            }
+        });
+    });
+    return index;
+};
+const CAPABILITY_KEYWORDS = {
+    code: ['code', 'implement', 'build', 'develop', 'feature', 'api', 'backend', 'frontend', 'refactor', 'bug', 'fix'],
+    review: ['review', 'audit', 'best practices', 'quality', 'lint'],
+    test: ['test', 'testing', 'qa', 'unit', 'integration', 'e2e', 'regression', 'coverage'],
+    design: ['design', 'ui', 'ux', 'wireframe', 'mockup', 'figma', 'layout', 'visual', 'brand'],
+    ops: ['deploy', 'ci', 'cd', 'devops', 'infra', 'infrastructure', 'docker', 'kubernetes', 'pipeline', 'monitor'],
+    security: ['security', 'vulnerability', 'threat', 'audit', 'compliance', 'encryption'],
+    research: ['research', 'investigate', 'compare', 'comparison', 'competitive', 'competitor', 'benchmark', 'study'],
+    analyze: ['analyze', 'analysis', 'data', 'metrics', 'insights', 'report', 'trend', 'dashboard'],
+    plan: ['plan', 'strategy', 'roadmap', 'architecture', 'outline', 'spec'],
+    document: ['document', 'documentation', 'docs', 'guide', 'manual', 'readme', 'spec'],
+    write: ['write', 'draft', 'copy', 'blog', 'post', 'article', 'content', 'summary'],
+    communicate: ['email', 'support', 'customer', 'communication', 'outreach', 'reply', 'respond'],
+    market: ['marketing', 'growth', 'campaign', 'social', 'seo', 'launch', 'newsletter', 'ads'],
+    manage: ['manage', 'project', 'timeline', 'milestone', 'coordination', 'sprint', 'backlog'],
+    product: ['product', 'feature', 'user story', 'requirements', 'prioritize', 'mvp'],
+};
+const scoreAgentForTask = (role, text) => {
+    const lowerText = text.toLowerCase();
+    let score = 0;
+    const roleText = `${role.name} ${role.displayName} ${role.description ?? ''}`.toLowerCase();
+    const tokens = roleText.split(/[^a-z0-9]+/).filter((token) => token.length > 2);
+    tokens.forEach((token) => {
+        if (lowerText.includes(token)) {
+            score += 1;
+        }
+    });
+    if (role.capabilities) {
+        role.capabilities.forEach((capability) => {
+            const keywords = CAPABILITY_KEYWORDS[capability];
+            if (keywords && keywords.some((keyword) => lowerText.includes(keyword))) {
+                score += 3;
+            }
+        });
+    }
+    return score;
+};
+const selectBestAgentsForTask = (text, roles) => {
+    if (roles.length === 0)
+        return roles;
+    const scored = roles
+        .map((role) => ({ role, score: scoreAgentForTask(role, text) }))
+        .sort((a, b) => {
+        if (b.score !== a.score)
+            return b.score - a.score;
+        return (a.role.sortOrder ?? 0) - (b.role.sortOrder ?? 0);
+    });
+    const withScore = scored.filter((entry) => entry.score > 0);
+    if (withScore.length > 0) {
+        const maxScore = withScore[0].score;
+        const threshold = Math.max(1, maxScore - 2);
+        const selected = withScore
+            .filter((entry) => entry.score >= threshold)
+            .slice(0, 4)
+            .map((entry) => entry.role);
+        return selected.length > 0 ? selected : withScore.slice(0, 3).map((entry) => entry.role);
+    }
+    const leads = roles
+        .filter((role) => role.autonomyLevel === 'lead')
+        .sort((a, b) => (a.sortOrder ?? 0) - (b.sortOrder ?? 0));
+    if (leads.length > 0) {
+        return leads.slice(0, 3);
+    }
+    return roles.slice(0, Math.min(3, roles.length));
+};
+const extractMentionedRoles = (text, roles) => {
+    const normalizedText = text.toLowerCase();
+    const useSmartSelection = /\B@everybody\b/.test(normalizedText);
+    if (/\B@all\b/.test(normalizedText) || /\B@everyone\b/.test(normalizedText)) {
+        return roles;
+    }
+    const index = buildAgentMentionIndex(roles);
+    const matches = new Map();
+    const regex = /@([a-zA-Z0-9][a-zA-Z0-9 _-]{0,50})/g;
+    let match;
+    while ((match = regex.exec(text)) !== null) {
+        const raw = match[1].replace(/[.,:;!?)]*$/, '').trim();
+        const token = normalizeMentionToken(raw);
+        const role = index.get(token);
+        if (role) {
+            matches.set(role.id, role);
+        }
+    }
+    if (matches.size > 0) {
+        if (useSmartSelection) {
+            const selected = selectBestAgentsForTask(text, roles);
+            const merged = new Map();
+            selected.forEach((role) => merged.set(role.id, role));
+            matches.forEach((role) => merged.set(role.id, role));
+            return Array.from(merged.values());
+        }
+        return Array.from(matches.values());
+    }
+    const normalizedWithAt = text
+        .toLowerCase()
+        .replace(/[^a-z0-9@]/g, '');
+    index.forEach((role, token) => {
+        if (normalizedWithAt.includes(`@${token}`)) {
+            matches.set(role.id, role);
+        }
+    });
+    if (useSmartSelection) {
+        return selectBestAgentsForTask(text, roles);
+    }
+    return Array.from(matches.values());
+};
+const buildSoulSummary = (soul) => {
+    if (!soul)
+        return null;
+    try {
+        const parsed = JSON.parse(soul);
+        const parts = [];
+        if (typeof parsed.name === 'string')
+            parts.push(`Name: ${parsed.name}`);
+        if (typeof parsed.role === 'string')
+            parts.push(`Role: ${parsed.role}`);
+        if (typeof parsed.personality === 'string')
+            parts.push(`Personality: ${parsed.personality}`);
+        if (typeof parsed.communicationStyle === 'string')
+            parts.push(`Style: ${parsed.communicationStyle}`);
+        if (Array.isArray(parsed.focusAreas))
+            parts.push(`Focus: ${parsed.focusAreas.join(', ')}`);
+        if (Array.isArray(parsed.strengths))
+            parts.push(`Strengths: ${parsed.strengths.join(', ')}`);
+        if (parts.length === 0) {
+            return null;
+        }
+        return parts.join('\n');
+    }
+    catch {
+        return soul;
+    }
+};
+const buildAgentDispatchPrompt = (role, parentTask) => {
+    const lines = [
+        `You are ${role.displayName}${role.description ? ` — ${role.description}` : ''}.`,
+    ];
+    if (role.capabilities && role.capabilities.length > 0) {
+        lines.push(`Capabilities: ${role.capabilities.join(', ')}`);
+    }
+    if (role.systemPrompt) {
+        lines.push('System guidance:');
+        lines.push(role.systemPrompt);
+    }
+    const soulSummary = buildSoulSummary(role.soul || undefined);
+    if (soulSummary) {
+        lines.push('Role notes:');
+        lines.push(soulSummary);
+    }
+    lines.push('');
+    lines.push(`Parent task: ${parentTask.title}`);
+    lines.push('Request:');
+    lines.push(parentTask.prompt);
+    lines.push('');
+    lines.push('Deliverables:');
+    lines.push('- Provide a concise summary of your findings.');
+    lines.push('- Call out risks or open questions.');
+    lines.push('- Recommend next steps.');
+    return lines.join('\n');
+};
+const x_manager_1 = require("../settings/x-manager");
+const x_cli_1 = require("../utils/x-cli");
+const custom_skill_loader_1 = require("../agent/custom-skill-loader");
+const settings_1 = require("../mcp/settings");
+const MCPClientManager_1 = require("../mcp/client/MCPClientManager");
+const MCPRegistryManager_1 = require("../mcp/registry/MCPRegistryManager");
+const MCPHostServer_1 = require("../mcp/host/MCPHostServer");
+const builtin_settings_1 = require("../agent/tools/builtin-settings");
+const validation_2 = require("../utils/validation");
+const notifications_1 = require("../notifications");
+const hooks_1 = require("../hooks");
+const MemoryService_1 = require("../memory/MemoryService");
+const voice_settings_manager_1 = require("../voice/voice-settings-manager");
+const VoiceService_1 = require("../voice/VoiceService");
+// Global notification service instance
+let notificationService = null;
+/**
+ * Get the notification service instance
+ */
+function getNotificationService() {
+    return notificationService;
+}
+// Helper to check rate limit and throw if exceeded
+function checkRateLimit(channel, config = rate_limiter_1.RATE_LIMIT_CONFIGS.standard) {
+    if (!rate_limiter_1.rateLimiter.check(channel)) {
+        const resetMs = rate_limiter_1.rateLimiter.getResetTime(channel);
+        const resetSec = Math.ceil(resetMs / 1000);
+        throw new Error(`Rate limit exceeded. Try again in ${resetSec} seconds.`);
+    }
+}
+// Configure rate limits for sensitive channels
+rate_limiter_1.rateLimiter.configure(types_1.IPC_CHANNELS.TASK_CREATE, rate_limiter_1.RATE_LIMIT_CONFIGS.expensive);
+rate_limiter_1.rateLimiter.configure(types_1.IPC_CHANNELS.TASK_SEND_MESSAGE, rate_limiter_1.RATE_LIMIT_CONFIGS.expensive);
+rate_limiter_1.rateLimiter.configure(types_1.IPC_CHANNELS.LLM_SAVE_SETTINGS, rate_limiter_1.RATE_LIMIT_CONFIGS.limited);
+rate_limiter_1.rateLimiter.configure(types_1.IPC_CHANNELS.LLM_TEST_PROVIDER, rate_limiter_1.RATE_LIMIT_CONFIGS.expensive);
+rate_limiter_1.rateLimiter.configure(types_1.IPC_CHANNELS.LLM_GET_OLLAMA_MODELS, rate_limiter_1.RATE_LIMIT_CONFIGS.standard);
+rate_limiter_1.rateLimiter.configure(types_1.IPC_CHANNELS.LLM_GET_GEMINI_MODELS, rate_limiter_1.RATE_LIMIT_CONFIGS.standard);
+rate_limiter_1.rateLimiter.configure(types_1.IPC_CHANNELS.LLM_GET_OPENROUTER_MODELS, rate_limiter_1.RATE_LIMIT_CONFIGS.standard);
+rate_limiter_1.rateLimiter.configure(types_1.IPC_CHANNELS.LLM_GET_BEDROCK_MODELS, rate_limiter_1.RATE_LIMIT_CONFIGS.standard);
+rate_limiter_1.rateLimiter.configure(types_1.IPC_CHANNELS.SEARCH_SAVE_SETTINGS, rate_limiter_1.RATE_LIMIT_CONFIGS.limited);
+rate_limiter_1.rateLimiter.configure(types_1.IPC_CHANNELS.SEARCH_TEST_PROVIDER, rate_limiter_1.RATE_LIMIT_CONFIGS.expensive);
+rate_limiter_1.rateLimiter.configure(types_1.IPC_CHANNELS.GATEWAY_ADD_CHANNEL, rate_limiter_1.RATE_LIMIT_CONFIGS.limited);
+rate_limiter_1.rateLimiter.configure(types_1.IPC_CHANNELS.GATEWAY_TEST_CHANNEL, rate_limiter_1.RATE_LIMIT_CONFIGS.expensive);
+rate_limiter_1.rateLimiter.configure(types_1.IPC_CHANNELS.GUARDRAIL_SAVE_SETTINGS, rate_limiter_1.RATE_LIMIT_CONFIGS.limited);
+// Helper function to get the main window
+function getMainWindow() {
+    const windows = electron_1.BrowserWindow.getAllWindows();
+    return windows.length > 0 ? windows[0] : null;
+}
+async function setupIpcHandlers(dbManager, agentDaemon, gateway) {
+    const db = dbManager.getDatabase();
+    const workspaceRepo = new repositories_1.WorkspaceRepository(db);
+    const taskRepo = new repositories_1.TaskRepository(db);
+    const taskEventRepo = new repositories_1.TaskEventRepository(db);
+    const artifactRepo = new repositories_1.ArtifactRepository(db);
+    const skillRepo = new repositories_1.SkillRepository(db);
+    const llmModelRepo = new repositories_1.LLMModelRepository(db);
+    const agentRoleRepo = new AgentRoleRepository_1.AgentRoleRepository(db);
+    const activityRepo = new ActivityRepository_1.ActivityRepository(db);
+    const mentionRepo = new MentionRepository_1.MentionRepository(db);
+    const taskLabelRepo = new TaskLabelRepository_1.TaskLabelRepository(db);
+    const workingStateRepo = new WorkingStateRepository_1.WorkingStateRepository(db);
+    const contextPolicyManager = new context_policy_1.ContextPolicyManager(db);
+    // Seed default agent roles if none exist
+    agentRoleRepo.seedDefaults();
+    // Helper to validate path is within workspace (prevent path traversal attacks)
+    const isPathWithinWorkspace = (filePath, workspacePath) => {
+        const normalizedWorkspace = path.resolve(workspacePath);
+        const normalizedFile = path.resolve(normalizedWorkspace, filePath);
+        const relative = path.relative(normalizedWorkspace, normalizedFile);
+        // If relative path starts with '..' or is absolute, it's outside workspace
+        return !relative.startsWith('..') && !path.isAbsolute(relative);
+    };
+    // Temp workspace management
+    // The temp workspace is created on-demand and stored in the database with a special ID
+    // It uses the system's temp directory and is filtered from the workspace list shown to users
+    const getOrCreateTempWorkspace = async () => {
+        // Check if temp workspace already exists in database
+        const existing = workspaceRepo.findById(types_1.TEMP_WORKSPACE_ID);
+        if (existing) {
+            const updatedPermissions = {
+                ...existing.permissions,
+                read: true,
+                write: true,
+                delete: true,
+                network: true,
+                shell: existing.permissions.shell ?? false,
+                unrestrictedFileAccess: true,
+            };
+            if (!existing.permissions.unrestrictedFileAccess) {
+                workspaceRepo.updatePermissions(existing.id, updatedPermissions);
+            }
+            // Verify the temp directory still exists, recreate if not
+            try {
+                await fs.access(existing.path);
+                return { ...existing, permissions: updatedPermissions, isTemp: true };
+            }
+            catch {
+                // Directory was deleted, delete the workspace record and recreate
+                workspaceRepo.delete(types_1.TEMP_WORKSPACE_ID);
+            }
+        }
+        // Create temp directory
+        const tempDir = path.join(os.tmpdir(), 'cowork-os-temp');
+        await fs.mkdir(tempDir, { recursive: true });
+        // Create the temp workspace with a known ID
+        const tempWorkspace = {
+            id: types_1.TEMP_WORKSPACE_ID,
+            name: types_1.TEMP_WORKSPACE_NAME,
+            path: tempDir,
+            createdAt: Date.now(),
+            permissions: {
+                read: true,
+                write: true,
+                delete: true,
+                network: true,
+                shell: false,
+                unrestrictedFileAccess: true,
+            },
+            isTemp: true,
+        };
+        // Insert directly using raw SQL to use our specific ID
+        const stmt = db.prepare(`
+      INSERT OR REPLACE INTO workspaces (id, name, path, created_at, permissions)
+      VALUES (?, ?, ?, ?, ?)
+    `);
+        stmt.run(tempWorkspace.id, tempWorkspace.name, tempWorkspace.path, tempWorkspace.createdAt, JSON.stringify(tempWorkspace.permissions));
+        return tempWorkspace;
+    };
+    // File handlers - open files and show in Finder
+    electron_1.ipcMain.handle('file:open', async (_, filePath, workspacePath) => {
+        // Security: require workspacePath and validate path is within it
+        if (!workspacePath) {
+            throw new Error('Workspace path is required for file operations');
+        }
+        // Resolve the path relative to workspace
+        const resolvedPath = path.isAbsolute(filePath)
+            ? filePath
+            : path.resolve(workspacePath, filePath);
+        // Validate path is within workspace (prevent path traversal)
+        if (!isPathWithinWorkspace(resolvedPath, workspacePath)) {
+            throw new Error('Access denied: file path is outside the workspace');
+        }
+        return electron_1.shell.openPath(resolvedPath);
+    });
+    electron_1.ipcMain.handle('file:showInFinder', async (_, filePath, workspacePath) => {
+        // Security: require workspacePath and validate path is within it
+        if (!workspacePath) {
+            throw new Error('Workspace path is required for file operations');
+        }
+        // Resolve the path relative to workspace
+        const resolvedPath = path.isAbsolute(filePath)
+            ? filePath
+            : path.resolve(workspacePath, filePath);
+        // Validate path is within workspace (prevent path traversal)
+        if (!isPathWithinWorkspace(resolvedPath, workspacePath)) {
+            throw new Error('Access denied: file path is outside the workspace');
+        }
+        electron_1.shell.showItemInFolder(resolvedPath);
+    });
+    // Open external URL in system browser
+    electron_1.ipcMain.handle('shell:openExternal', async (_, url) => {
+        // Validate URL to prevent security issues
+        try {
+            const parsedUrl = new URL(url);
+            if (!['http:', 'https:'].includes(parsedUrl.protocol)) {
+                throw new Error('Only http and https URLs are allowed');
+            }
+            await electron_1.shell.openExternal(url);
+        }
+        catch (error) {
+            throw new Error(`Failed to open URL: ${error.message}`);
+        }
+    });
+    // File viewer handler - read file content for in-app preview
+    // Note: This handler allows viewing any file on the system for convenience.
+    // File operations like open/showInFinder remain workspace-restricted.
+    electron_1.ipcMain.handle('file:readForViewer', async (_, data) => {
+        const { filePath, workspacePath } = data;
+        // Resolve the path - if absolute use directly, otherwise resolve relative to workspace or cwd
+        const resolvedPath = path.isAbsolute(filePath)
+            ? filePath
+            : workspacePath
+                ? path.resolve(workspacePath, filePath)
+                : path.resolve(filePath);
+        // Check if file exists
+        try {
+            await fs.access(resolvedPath);
+        }
+        catch {
+            return { success: false, error: 'File not found' };
+        }
+        // Get file stats
+        const stats = await fs.stat(resolvedPath);
+        const extension = path.extname(resolvedPath).toLowerCase();
+        const fileName = path.basename(resolvedPath);
+        // Determine file type
+        const getFileType = (ext) => {
+            const codeExtensions = ['.js', '.ts', '.tsx', '.jsx', '.py', '.java', '.go', '.rs', '.c', '.cpp', '.h', '.css', '.scss', '.xml', '.json', '.yaml', '.yml', '.toml', '.sh', '.bash', '.zsh', '.sql', '.graphql', '.vue', '.svelte', '.rb', '.php', '.swift', '.kt', '.scala'];
+            const textExtensions = ['.txt', '.log', '.csv', '.env', '.gitignore', '.dockerignore', '.editorconfig', '.prettierrc', '.eslintrc'];
+            const imageExtensions = ['.png', '.jpg', '.jpeg', '.gif', '.webp', '.svg', '.bmp', '.ico'];
+            if (ext === '.md' || ext === '.markdown')
+                return 'markdown';
+            if (ext === '.html' || ext === '.htm')
+                return 'html';
+            if (ext === '.docx')
+                return 'docx';
+            if (ext === '.pdf')
+                return 'pdf';
+            if (ext === '.pptx')
+                return 'pptx';
+            if (imageExtensions.includes(ext))
+                return 'image';
+            if (codeExtensions.includes(ext))
+                return 'code';
+            if (textExtensions.includes(ext))
+                return 'text';
+            return 'unsupported';
+        };
+        const fileType = getFileType(extension);
+        // Size limits
+        const MAX_TEXT_SIZE = 5 * 1024 * 1024; // 5MB
+        const MAX_IMAGE_SIZE = 10 * 1024 * 1024; // 10MB
+        if (fileType === 'image' && stats.size > MAX_IMAGE_SIZE) {
+            return { success: false, error: 'File too large for preview (max 10MB for images)' };
+        }
+        if (fileType !== 'image' && fileType !== 'unsupported' && stats.size > MAX_TEXT_SIZE) {
+            return { success: false, error: 'File too large for preview (max 5MB for text files)' };
+        }
+        try {
+            let content = null;
+            let htmlContent;
+            switch (fileType) {
+                case 'markdown':
+                case 'code':
+                case 'text': {
+                    content = await fs.readFile(resolvedPath, 'utf-8');
+                    break;
+                }
+                case 'docx': {
+                    const buffer = await fs.readFile(resolvedPath);
+                    const result = await mammoth_1.default.convertToHtml({ buffer });
+                    htmlContent = result.value;
+                    content = null; // HTML content is in htmlContent
+                    break;
+                }
+                case 'pdf': {
+                    const buffer = await fs.readFile(resolvedPath);
+                    const pdfData = await pdfParse(buffer);
+                    content = pdfData.text;
+                    break;
+                }
+                case 'image': {
+                    const buffer = await fs.readFile(resolvedPath);
+                    const mimeTypes = {
+                        '.png': 'image/png',
+                        '.jpg': 'image/jpeg',
+                        '.jpeg': 'image/jpeg',
+                        '.gif': 'image/gif',
+                        '.webp': 'image/webp',
+                        '.svg': 'image/svg+xml',
+                        '.bmp': 'image/bmp',
+                        '.ico': 'image/x-icon',
+                    };
+                    const mimeType = mimeTypes[extension] || 'image/png';
+                    content = `data:${mimeType};base64,${buffer.toString('base64')}`;
+                    break;
+                }
+                case 'html': {
+                    htmlContent = await fs.readFile(resolvedPath, 'utf-8');
+                    content = null; // HTML content is in htmlContent
+                    break;
+                }
+                case 'pptx':
+                    // PowerPoint files are complex to render, return placeholder
+                    content = null;
+                    break;
+                default:
+                    return { success: false, error: 'Unsupported file type', fileType: 'unsupported' };
+            }
+            return {
+                success: true,
+                data: {
+                    path: resolvedPath,
+                    fileName,
+                    fileType,
+                    content,
+                    htmlContent,
+                    size: stats.size,
+                },
+            };
+        }
+        catch (error) {
+            return { success: false, error: `Failed to read file: ${error.message}` };
+        }
+    });
+    // Workspace handlers
+    electron_1.ipcMain.handle(types_1.IPC_CHANNELS.WORKSPACE_CREATE, async (_, data) => {
+        const validated = (0, validation_1.validateInput)(validation_1.WorkspaceCreateSchema, data, 'workspace');
+        const { name, path, permissions } = validated;
+        // Check if workspace with this path already exists
+        if (workspaceRepo.existsByPath(path)) {
+            throw new Error(`A workspace with path "${path}" already exists. Please choose a different folder.`);
+        }
+        // Provide default permissions if not specified
+        // Note: network is enabled by default for browser tools (web access)
+        const defaultPermissions = {
+            read: true,
+            write: true,
+            delete: false,
+            network: true,
+            shell: false,
+        };
+        return workspaceRepo.create(name, path, permissions ?? defaultPermissions);
+    });
+    electron_1.ipcMain.handle(types_1.IPC_CHANNELS.WORKSPACE_LIST, async () => {
+        // Filter out the temp workspace from the list - users shouldn't see it in their workspaces
+        const allWorkspaces = workspaceRepo.findAll();
+        return allWorkspaces.filter(w => w.id !== types_1.TEMP_WORKSPACE_ID);
+    });
+    // Get or create the temp workspace (used when no workspace is selected)
+    electron_1.ipcMain.handle(types_1.IPC_CHANNELS.WORKSPACE_GET_TEMP, async () => {
+        return getOrCreateTempWorkspace();
+    });
+    electron_1.ipcMain.handle(types_1.IPC_CHANNELS.WORKSPACE_SELECT, async (_, id) => {
+        return workspaceRepo.findById(id);
+    });
+    electron_1.ipcMain.handle(types_1.IPC_CHANNELS.WORKSPACE_UPDATE_PERMISSIONS, async (_, id, permissions) => {
+        const workspace = workspaceRepo.findById(id);
+        if (!workspace) {
+            throw new Error(`Workspace not found: ${id}`);
+        }
+        const updatedPermissions = { ...workspace.permissions, ...permissions };
+        workspaceRepo.updatePermissions(id, updatedPermissions);
+        return workspaceRepo.findById(id);
+    });
+    // Task handlers
+    electron_1.ipcMain.handle(types_1.IPC_CHANNELS.TASK_CREATE, async (_, data) => {
+        checkRateLimit(types_1.IPC_CHANNELS.TASK_CREATE);
+        const validated = (0, validation_1.validateInput)(validation_1.TaskCreateSchema, data, 'task');
+        const { title, prompt, workspaceId, budgetTokens, budgetCost } = validated;
+        const task = taskRepo.create({
+            title,
+            prompt,
+            status: 'pending',
+            workspaceId,
+            budgetTokens,
+            budgetCost,
+        });
+        // Start task execution in agent daemon
+        try {
+            await agentDaemon.startTask(task);
+        }
+        catch (error) {
+            // Update task status to failed if we can't start it
+            taskRepo.update(task.id, {
+                status: 'failed',
+                error: error.message || 'Failed to start task',
+            });
+            throw new Error(error.message || 'Failed to start task. Please check your LLM provider settings.');
+        }
+        // Dispatch to mentioned agents (e.g., "Please review @Vision @Loki")
+        try {
+            const activeRoles = agentRoleRepo.findAll(false).filter((role) => role.isActive);
+            const mentionedRoles = extractMentionedRoles(`${title}\n${prompt}`, activeRoles);
+            const dispatchRoles = mentionedRoles.length > 0 ? mentionedRoles : activeRoles;
+            if (dispatchRoles.length > 0) {
+                taskRepo.update(task.id, {
+                    mentionedAgentRoleIds: dispatchRoles.map((role) => role.id),
+                });
+                for (const role of dispatchRoles) {
+                    const childPrompt = buildAgentDispatchPrompt(role, task);
+                    const childTask = await agentDaemon.createChildTask({
+                        title: `@${role.displayName}: ${task.title}`,
+                        prompt: childPrompt,
+                        workspaceId: task.workspaceId,
+                        parentTaskId: task.id,
+                        agentType: 'sub',
+                        agentConfig: {
+                            ...(role.modelKey ? { modelKey: role.modelKey } : {}),
+                            ...(role.personalityId ? { personalityId: role.personalityId } : {}),
+                            retainMemory: false,
+                        },
+                    });
+                    taskRepo.update(childTask.id, {
+                        assignedAgentRoleId: role.id,
+                        boardColumn: 'todo',
+                    });
+                    const dispatchActivity = activityRepo.create({
+                        workspaceId: task.workspaceId,
+                        taskId: task.id,
+                        agentRoleId: role.id,
+                        actorType: 'system',
+                        activityType: 'agent_assigned',
+                        title: `Dispatched to ${role.displayName}`,
+                        description: childTask.title,
+                    });
+                    getMainWindow()?.webContents.send(types_1.IPC_CHANNELS.ACTIVITY_EVENT, { type: 'created', activity: dispatchActivity });
+                    const mention = mentionRepo.create({
+                        workspaceId: task.workspaceId,
+                        taskId: task.id,
+                        toAgentRoleId: role.id,
+                        mentionType: 'request',
+                        context: `New task: ${task.title}`,
+                    });
+                    getMainWindow()?.webContents.send(types_1.IPC_CHANNELS.MENTION_EVENT, { type: 'created', mention });
+                    const mentionActivity = activityRepo.create({
+                        workspaceId: task.workspaceId,
+                        taskId: task.id,
+                        agentRoleId: role.id,
+                        actorType: 'user',
+                        activityType: 'mention',
+                        title: `@${role.displayName} mentioned`,
+                        description: mention.context,
+                        metadata: { mentionId: mention.id, mentionType: mention.mentionType },
+                    });
+                    getMainWindow()?.webContents.send(types_1.IPC_CHANNELS.ACTIVITY_EVENT, { type: 'created', activity: mentionActivity });
+                }
+            }
+        }
+        catch (error) {
+            console.error('Failed to dispatch to mentioned agents:', error);
+        }
+        return task;
+    });
+    electron_1.ipcMain.handle(types_1.IPC_CHANNELS.TASK_GET, async (_, id) => {
+        return taskRepo.findById(id);
+    });
+    electron_1.ipcMain.handle(types_1.IPC_CHANNELS.TASK_LIST, async () => {
+        return taskRepo.findAll();
+    });
+    electron_1.ipcMain.handle(types_1.IPC_CHANNELS.TASK_CANCEL, async (_, id) => {
+        try {
+            await agentDaemon.cancelTask(id);
+        }
+        finally {
+            // Always update status even if daemon cancel fails
+            taskRepo.update(id, { status: 'cancelled' });
+        }
+    });
+    electron_1.ipcMain.handle(types_1.IPC_CHANNELS.TASK_PAUSE, async (_, id) => {
+        // Pause daemon first - if it fails, exception propagates and status won't be updated
+        await agentDaemon.pauseTask(id);
+        taskRepo.update(id, { status: 'paused' });
+    });
+    electron_1.ipcMain.handle(types_1.IPC_CHANNELS.TASK_RESUME, async (_, id) => {
+        // Resume daemon first - if it fails, exception propagates and status won't be updated
+        await agentDaemon.resumeTask(id);
+        taskRepo.update(id, { status: 'executing' });
+    });
+    electron_1.ipcMain.handle(types_1.IPC_CHANNELS.TASK_SEND_STDIN, async (_, data) => {
+        return agentDaemon.sendStdinToTask(data.taskId, data.input);
+    });
+    electron_1.ipcMain.handle(types_1.IPC_CHANNELS.TASK_KILL_COMMAND, async (_, data) => {
+        return agentDaemon.killCommandInTask(data.taskId, data.force);
+    });
+    electron_1.ipcMain.handle(types_1.IPC_CHANNELS.TASK_RENAME, async (_, data) => {
+        const validated = (0, validation_1.validateInput)(validation_1.TaskRenameSchema, data, 'task rename');
+        taskRepo.update(validated.id, { title: validated.title });
+    });
+    electron_1.ipcMain.handle(types_1.IPC_CHANNELS.TASK_DELETE, async (_, id) => {
+        // Cancel the task if it's running
+        await agentDaemon.cancelTask(id);
+        // Delete from database
+        taskRepo.delete(id);
+    });
+    // ============ Sub-Agent / Parallel Agent Handlers ============
+    // Get child tasks for a parent task
+    electron_1.ipcMain.handle(types_1.IPC_CHANNELS.AGENT_GET_CHILDREN, async (_, parentTaskId) => {
+        return agentDaemon.getChildTasks(parentTaskId);
+    });
+    // Get status of specific agents
+    electron_1.ipcMain.handle(types_1.IPC_CHANNELS.AGENT_GET_STATUS, async (_, taskIds) => {
+        const tasks = [];
+        for (const id of taskIds) {
+            const task = await agentDaemon.getTaskById(id);
+            if (task) {
+                tasks.push({
+                    taskId: id,
+                    status: task.status,
+                    title: task.title,
+                    agentType: task.agentType,
+                    resultSummary: task.resultSummary,
+                    error: task.error,
+                });
+            }
+        }
+        return tasks;
+    });
+    // Task events handler - get historical events from database
+    electron_1.ipcMain.handle(types_1.IPC_CHANNELS.TASK_EVENTS, async (_, taskId) => {
+        return taskEventRepo.findByTaskId(taskId);
+    });
+    // Send follow-up message to a task
+    electron_1.ipcMain.handle(types_1.IPC_CHANNELS.TASK_SEND_MESSAGE, async (_, data) => {
+        checkRateLimit(types_1.IPC_CHANNELS.TASK_SEND_MESSAGE);
+        const validated = (0, validation_1.validateInput)(validation_1.TaskMessageSchema, data, 'task message');
+        await agentDaemon.sendMessage(validated.taskId, validated.message);
+    });
+    // Approval handlers
+    electron_1.ipcMain.handle(types_1.IPC_CHANNELS.APPROVAL_RESPOND, async (_, data) => {
+        const validated = (0, validation_1.validateInput)(validation_1.ApprovalResponseSchema, data, 'approval response');
+        await agentDaemon.respondToApproval(validated.approvalId, validated.approved);
+    });
+    // Artifact handlers
+    electron_1.ipcMain.handle(types_1.IPC_CHANNELS.ARTIFACT_LIST, async (_, taskId) => {
+        return artifactRepo.findByTaskId(taskId);
+    });
+    electron_1.ipcMain.handle(types_1.IPC_CHANNELS.ARTIFACT_PREVIEW, async (_, id) => {
+        // TODO: Implement artifact preview
+        return null;
+    });
+    // Skill handlers
+    electron_1.ipcMain.handle(types_1.IPC_CHANNELS.SKILL_LIST, async () => {
+        return skillRepo.findAll();
+    });
+    electron_1.ipcMain.handle(types_1.IPC_CHANNELS.SKILL_GET, async (_, id) => {
+        return skillRepo.findById(id);
+    });
+    // Custom User Skills handlers
+    const customSkillLoader = (0, custom_skill_loader_1.getCustomSkillLoader)();
+    // Initialize custom skill loader
+    customSkillLoader.initialize().catch(error => {
+        console.error('[IPC] Failed to initialize custom skill loader:', error);
+    });
+    electron_1.ipcMain.handle(types_1.IPC_CHANNELS.CUSTOM_SKILL_LIST, async () => {
+        return customSkillLoader.listSkills();
+    });
+    electron_1.ipcMain.handle(types_1.IPC_CHANNELS.CUSTOM_SKILL_LIST_TASKS, async () => {
+        return customSkillLoader.listTaskSkills();
+    });
+    electron_1.ipcMain.handle(types_1.IPC_CHANNELS.CUSTOM_SKILL_LIST_GUIDELINES, async () => {
+        return customSkillLoader.listGuidelineSkills();
+    });
+    electron_1.ipcMain.handle(types_1.IPC_CHANNELS.CUSTOM_SKILL_GET, async (_, id) => {
+        return customSkillLoader.getSkill(id);
+    });
+    electron_1.ipcMain.handle(types_1.IPC_CHANNELS.CUSTOM_SKILL_CREATE, async (_, skillData) => {
+        return customSkillLoader.createSkill(skillData);
+    });
+    electron_1.ipcMain.handle(types_1.IPC_CHANNELS.CUSTOM_SKILL_UPDATE, async (_, id, updates) => {
+        return customSkillLoader.updateSkill(id, updates);
+    });
+    electron_1.ipcMain.handle(types_1.IPC_CHANNELS.CUSTOM_SKILL_DELETE, async (_, id) => {
+        return customSkillLoader.deleteSkill(id);
+    });
+    electron_1.ipcMain.handle(types_1.IPC_CHANNELS.CUSTOM_SKILL_RELOAD, async () => {
+        return customSkillLoader.reloadSkills();
+    });
+    electron_1.ipcMain.handle(types_1.IPC_CHANNELS.CUSTOM_SKILL_OPEN_FOLDER, async () => {
+        return customSkillLoader.openSkillsFolder();
+    });
+    // Skill Registry (SkillHub) handlers
+    const { getSkillRegistry } = await Promise.resolve().then(() => __importStar(require('../agent/skill-registry')));
+    const skillRegistry = getSkillRegistry();
+    electron_1.ipcMain.handle(types_1.IPC_CHANNELS.SKILL_REGISTRY_SEARCH, async (_, query, options) => {
+        return skillRegistry.search(query, options);
+    });
+    electron_1.ipcMain.handle(types_1.IPC_CHANNELS.SKILL_REGISTRY_GET_DETAILS, async (_, skillId) => {
+        return skillRegistry.getSkillDetails(skillId);
+    });
+    electron_1.ipcMain.handle(types_1.IPC_CHANNELS.SKILL_REGISTRY_INSTALL, async (_, skillId, version) => {
+        const result = await skillRegistry.install(skillId, version);
+        if (result.success) {
+            // Reload skills to pick up the new one
+            await customSkillLoader.reloadSkills();
+            // Clear eligibility cache in case new dependencies were installed
+            customSkillLoader.clearEligibilityCache();
+        }
+        return result;
+    });
+    electron_1.ipcMain.handle(types_1.IPC_CHANNELS.SKILL_REGISTRY_UPDATE, async (_, skillId, version) => {
+        const result = await skillRegistry.update(skillId, version);
+        if (result.success) {
+            await customSkillLoader.reloadSkills();
+            customSkillLoader.clearEligibilityCache();
+        }
+        return result;
+    });
+    electron_1.ipcMain.handle(types_1.IPC_CHANNELS.SKILL_REGISTRY_UPDATE_ALL, async () => {
+        const result = await skillRegistry.updateAll();
+        await customSkillLoader.reloadSkills();
+        customSkillLoader.clearEligibilityCache();
+        return result;
+    });
+    electron_1.ipcMain.handle(types_1.IPC_CHANNELS.SKILL_REGISTRY_UNINSTALL, async (_, skillId) => {
+        const result = skillRegistry.uninstall(skillId);
+        if (result.success) {
+            await customSkillLoader.reloadSkills();
+        }
+        return result;
+    });
+    electron_1.ipcMain.handle(types_1.IPC_CHANNELS.SKILL_REGISTRY_LIST_MANAGED, async () => {
+        return skillRegistry.listManagedSkills();
+    });
+    electron_1.ipcMain.handle(types_1.IPC_CHANNELS.SKILL_REGISTRY_CHECK_UPDATES, async (_, skillId) => {
+        return skillRegistry.checkForUpdates(skillId);
+    });
+    electron_1.ipcMain.handle(types_1.IPC_CHANNELS.SKILL_REGISTRY_GET_STATUS, async () => {
+        return customSkillLoader.getSkillStatus();
+    });
+    electron_1.ipcMain.handle(types_1.IPC_CHANNELS.SKILL_REGISTRY_GET_ELIGIBLE, async () => {
+        return customSkillLoader.getEligibleSkills();
+    });
+    // LLM Settings handlers
+    electron_1.ipcMain.handle(types_1.IPC_CHANNELS.LLM_GET_SETTINGS, async () => {
+        return llm_1.LLMProviderFactory.loadSettings();
+    });
+    electron_1.ipcMain.handle(types_1.IPC_CHANNELS.LLM_SAVE_SETTINGS, async (_, settings) => {
+        checkRateLimit(types_1.IPC_CHANNELS.LLM_SAVE_SETTINGS);
+        const validated = (0, validation_1.validateInput)(validation_1.LLMSettingsSchema, settings, 'LLM settings');
+        // Load existing settings to preserve cached models and OAuth tokens
+        const existingSettings = llm_1.LLMProviderFactory.loadSettings();
+        // Build OpenAI settings, preserving OAuth tokens from existing settings
+        let openaiSettings = validated.openai;
+        if (existingSettings.openai?.authMethod === 'oauth') {
+            // Preserve OAuth tokens when saving settings
+            openaiSettings = {
+                ...validated.openai,
+                accessToken: existingSettings.openai.accessToken,
+                refreshToken: existingSettings.openai.refreshToken,
+                tokenExpiresAt: existingSettings.openai.tokenExpiresAt,
+                authMethod: existingSettings.openai.authMethod,
+            };
+        }
+        llm_1.LLMProviderFactory.saveSettings({
+            providerType: validated.providerType,
+            modelKey: validated.modelKey,
+            anthropic: validated.anthropic,
+            bedrock: validated.bedrock,
+            ollama: validated.ollama,
+            gemini: validated.gemini,
+            openrouter: validated.openrouter,
+            openai: openaiSettings,
+            // Preserve cached models from existing settings
+            cachedGeminiModels: existingSettings.cachedGeminiModels,
+            cachedOpenRouterModels: existingSettings.cachedOpenRouterModels,
+            cachedOllamaModels: existingSettings.cachedOllamaModels,
+            cachedBedrockModels: existingSettings.cachedBedrockModels,
+            cachedOpenAIModels: existingSettings.cachedOpenAIModels,
+        });
+        // Clear cache so next task uses new settings
+        llm_1.LLMProviderFactory.clearCache();
+        return { success: true };
+    });
+    electron_1.ipcMain.handle(types_1.IPC_CHANNELS.LLM_TEST_PROVIDER, async (_, config) => {
+        checkRateLimit(types_1.IPC_CHANNELS.LLM_TEST_PROVIDER);
+        // For OpenAI OAuth, get tokens from stored settings if authMethod is 'oauth'
+        let openaiAccessToken;
+        let openaiRefreshToken;
+        if (config.providerType === 'openai' && config.openai?.authMethod === 'oauth') {
+            const settings = llm_1.LLMProviderFactory.loadSettings();
+            openaiAccessToken = settings.openai?.accessToken;
+            openaiRefreshToken = settings.openai?.refreshToken;
+        }
+        const providerConfig = {
+            type: config.providerType,
+            model: llm_1.LLMProviderFactory.getModelId(config.modelKey, config.providerType, config.ollama?.model, config.gemini?.model, config.openrouter?.model, config.openai?.model),
+            anthropicApiKey: config.anthropic?.apiKey,
+            awsRegion: config.bedrock?.region,
+            awsAccessKeyId: config.bedrock?.accessKeyId,
+            awsSecretAccessKey: config.bedrock?.secretAccessKey,
+            awsSessionToken: config.bedrock?.sessionToken,
+            awsProfile: config.bedrock?.profile,
+            ollamaBaseUrl: config.ollama?.baseUrl,
+            ollamaApiKey: config.ollama?.apiKey,
+            geminiApiKey: config.gemini?.apiKey,
+            openrouterApiKey: config.openrouter?.apiKey,
+            openaiApiKey: config.openai?.apiKey,
+            openaiAccessToken: openaiAccessToken,
+            openaiRefreshToken: openaiRefreshToken,
+        };
+        return llm_1.LLMProviderFactory.testProvider(providerConfig);
+    });
+    electron_1.ipcMain.handle(types_1.IPC_CHANNELS.LLM_GET_MODELS, async () => {
+        // Get models from database
+        const dbModels = llmModelRepo.findAll();
+        return dbModels.map(m => ({
+            key: m.key,
+            displayName: m.displayName,
+            description: m.description,
+        }));
+    });
+    electron_1.ipcMain.handle(types_1.IPC_CHANNELS.LLM_GET_CONFIG_STATUS, async () => {
+        const settings = llm_1.LLMProviderFactory.loadSettings();
+        const providers = llm_1.LLMProviderFactory.getAvailableProviders();
+        // Get models based on the current provider type
+        let models = [];
+        let currentModel = settings.modelKey;
+        switch (settings.providerType) {
+            case 'anthropic':
+            case 'bedrock':
+                // Use Anthropic/Bedrock models from MODELS
+                models = Object.entries(llm_1.MODELS).map(([key, value]) => ({
+                    key,
+                    displayName: value.displayName,
+                    description: key.includes('opus') ? 'Most capable for complex work' :
+                        key.includes('sonnet') ? 'Balanced performance and speed' :
+                            'Fast and efficient',
+                }));
+                break;
+            case 'gemini': {
+                // For Gemini, use the specific model from settings (full model ID)
+                currentModel = settings.gemini?.model || 'gemini-2.0-flash';
+                // Use cached models if available, otherwise fall back to static list
+                const cachedGemini = llm_1.LLMProviderFactory.getCachedModels('gemini');
+                if (cachedGemini && cachedGemini.length > 0) {
+                    models = cachedGemini;
+                }
+                else {
+                    // Fall back to static models
+                    models = Object.values(llm_1.GEMINI_MODELS).map((value) => ({
+                        key: value.id,
+                        displayName: value.displayName,
+                        description: value.description,
+                    }));
+                }
+                // Ensure the currently selected model is in the list
+                if (currentModel && !models.some(m => m.key === currentModel)) {
+                    models.unshift({
+                        key: currentModel,
+                        displayName: currentModel,
+                        description: 'Selected model',
+                    });
+                }
+                break;
+            }
+            case 'openrouter': {
+                // For OpenRouter, use the specific model from settings (full model ID)
+                currentModel = settings.openrouter?.model || 'anthropic/claude-3.5-sonnet';
+                // Use cached models if available, otherwise fall back to static list
+                const cachedOpenRouter = llm_1.LLMProviderFactory.getCachedModels('openrouter');
+                if (cachedOpenRouter && cachedOpenRouter.length > 0) {
+                    models = cachedOpenRouter;
+                }
+                else {
+                    // Fall back to static models
+                    models = Object.values(llm_1.OPENROUTER_MODELS).map((value) => ({
+                        key: value.id,
+                        displayName: value.displayName,
+                        description: value.description,
+                    }));
+                }
+                // Ensure the currently selected model is in the list
+                if (currentModel && !models.some(m => m.key === currentModel)) {
+                    models.unshift({
+                        key: currentModel,
+                        displayName: currentModel,
+                        description: 'Selected model',
+                    });
+                }
+                break;
+            }
+            case 'ollama': {
+                // For Ollama, use the specific model from settings
+                currentModel = settings.ollama?.model || 'llama3.2';
+                // Use cached models if available, otherwise fall back to static list
+                const cachedOllama = llm_1.LLMProviderFactory.getCachedModels('ollama');
+                if (cachedOllama && cachedOllama.length > 0) {
+                    models = cachedOllama;
+                }
+                else {
+                    // Fall back to static models
+                    models = Object.entries(llm_1.OLLAMA_MODELS).map(([key, value]) => ({
+                        key,
+                        displayName: value.displayName,
+                        description: `${value.size} parameter model`,
+                    }));
+                }
+                // Ensure the currently selected model is in the list
+                if (currentModel && !models.some(m => m.key === currentModel)) {
+                    models.unshift({
+                        key: currentModel,
+                        displayName: currentModel,
+                        description: 'Selected model',
+                    });
+                }
+                break;
+            }
+            case 'openai': {
+                // For OpenAI, use the specific model from settings
+                currentModel = settings.openai?.model || 'gpt-4o-mini';
+                // Use cached models if available, otherwise fall back to static list
+                const cachedOpenAI = llm_1.LLMProviderFactory.getCachedModels('openai');
+                if (cachedOpenAI && cachedOpenAI.length > 0) {
+                    models = cachedOpenAI;
+                }
+                else {
+                    // Fall back to static models
+                    models = [
+                        { key: 'gpt-4o', displayName: 'GPT-4o', description: 'Most capable model for complex tasks' },
+                        { key: 'gpt-4o-mini', displayName: 'GPT-4o Mini', description: 'Fast and affordable for most tasks' },
+                        { key: 'gpt-4-turbo', displayName: 'GPT-4 Turbo', description: 'Previous generation flagship' },
+                        { key: 'gpt-3.5-turbo', displayName: 'GPT-3.5 Turbo', description: 'Fast and cost-effective' },
+                        { key: 'o1', displayName: 'o1', description: 'Advanced reasoning model' },
+                        { key: 'o1-mini', displayName: 'o1 Mini', description: 'Fast reasoning model' },
+                    ];
+                }
+                // Ensure the currently selected model is in the list
+                if (currentModel && !models.some(m => m.key === currentModel)) {
+                    models.unshift({
+                        key: currentModel,
+                        displayName: currentModel,
+                        description: 'Selected model',
+                    });
+                }
+                break;
+            }
+            default:
+                // Fallback to Anthropic models
+                models = Object.entries(llm_1.MODELS).map(([key, value]) => ({
+                    key,
+                    displayName: value.displayName,
+                    description: 'Claude model',
+                }));
+        }
+        return {
+            currentProvider: settings.providerType,
+            currentModel,
+            providers,
+            models,
+        };
+    });
+    // Set the current model (persists selection across sessions)
+    electron_1.ipcMain.handle(types_1.IPC_CHANNELS.LLM_SET_MODEL, async (_, modelKey) => {
+        const settings = llm_1.LLMProviderFactory.loadSettings();
+        // Update the model key based on the current provider
+        switch (settings.providerType) {
+            case 'gemini':
+                settings.gemini = { ...settings.gemini, model: modelKey };
+                break;
+            case 'openrouter':
+                settings.openrouter = { ...settings.openrouter, model: modelKey };
+                break;
+            case 'ollama':
+                settings.ollama = { ...settings.ollama, model: modelKey };
+                break;
+            case 'openai':
+                settings.openai = { ...settings.openai, model: modelKey };
+                break;
+            case 'anthropic':
+            case 'bedrock':
+            default:
+                // For Anthropic/Bedrock, use the modelKey field
+                settings.modelKey = modelKey;
+                break;
+        }
+        llm_1.LLMProviderFactory.saveSettings(settings);
+        return { success: true };
+    });
+    electron_1.ipcMain.handle(types_1.IPC_CHANNELS.LLM_GET_OLLAMA_MODELS, async (_, baseUrl) => {
+        checkRateLimit(types_1.IPC_CHANNELS.LLM_GET_OLLAMA_MODELS);
+        console.log('[IPC] Handling LLM_GET_OLLAMA_MODELS request');
+        const models = await llm_1.LLMProviderFactory.getOllamaModels(baseUrl);
+        // Cache the models for use in config status
+        const cachedModels = models.map(m => ({
+            key: m.name,
+            displayName: m.name,
+            description: `${Math.round(m.size / 1e9)}B parameter model`,
+            size: m.size,
+        }));
+        llm_1.LLMProviderFactory.saveCachedModels('ollama', cachedModels);
+        return models;
+    });
+    electron_1.ipcMain.handle(types_1.IPC_CHANNELS.LLM_GET_GEMINI_MODELS, async (_, apiKey) => {
+        checkRateLimit(types_1.IPC_CHANNELS.LLM_GET_GEMINI_MODELS);
+        const models = await llm_1.LLMProviderFactory.getGeminiModels(apiKey);
+        // Cache the models for use in config status
+        const cachedModels = models.map(m => ({
+            key: m.name,
+            displayName: m.displayName,
+            description: m.description,
+        }));
+        llm_1.LLMProviderFactory.saveCachedModels('gemini', cachedModels);
+        return models;
+    });
+    electron_1.ipcMain.handle(types_1.IPC_CHANNELS.LLM_GET_OPENROUTER_MODELS, async (_, apiKey) => {
+        checkRateLimit(types_1.IPC_CHANNELS.LLM_GET_OPENROUTER_MODELS);
+        const models = await llm_1.LLMProviderFactory.getOpenRouterModels(apiKey);
+        // Cache the models for use in config status
+        const cachedModels = models.map(m => ({
+            key: m.id,
+            displayName: m.name,
+            description: `Context: ${Math.round(m.context_length / 1000)}k tokens`,
+            contextLength: m.context_length,
+        }));
+        llm_1.LLMProviderFactory.saveCachedModels('openrouter', cachedModels);
+        return models;
+    });
+    electron_1.ipcMain.handle(types_1.IPC_CHANNELS.LLM_GET_OPENAI_MODELS, async (_, apiKey) => {
+        checkRateLimit(types_1.IPC_CHANNELS.LLM_GET_OPENAI_MODELS);
+        const models = await llm_1.LLMProviderFactory.getOpenAIModels(apiKey);
+        // Cache the models for use in config status
+        const cachedModels = models.map(m => ({
+            key: m.id,
+            displayName: m.name,
+            description: m.description,
+        }));
+        llm_1.LLMProviderFactory.saveCachedModels('openai', cachedModels);
+        return models;
+    });
+    // OpenAI OAuth handlers
+    electron_1.ipcMain.handle(types_1.IPC_CHANNELS.LLM_OPENAI_OAUTH_START, async () => {
+        checkRateLimit(types_1.IPC_CHANNELS.LLM_OPENAI_OAUTH_START);
+        console.log('[IPC] Starting OpenAI OAuth flow with pi-ai SDK...');
+        try {
+            const oauth = new llm_1.OpenAIOAuth();
+            const tokens = await oauth.authenticate();
+            // Save tokens to settings
+            const settings = llm_1.LLMProviderFactory.loadSettings();
+            settings.openai = {
+                ...settings.openai,
+                accessToken: tokens.access_token,
+                refreshToken: tokens.refresh_token,
+                tokenExpiresAt: tokens.expires_at,
+                authMethod: 'oauth',
+                // Clear API key when using OAuth
+                apiKey: undefined,
+            };
+            llm_1.LLMProviderFactory.saveSettings(settings);
+            llm_1.LLMProviderFactory.clearCache();
+            console.log('[IPC] OpenAI OAuth successful!');
+            if (tokens.email) {
+                console.log('[IPC] Logged in as:', tokens.email);
+            }
+            return { success: true, email: tokens.email };
+        }
+        catch (error) {
+            console.error('[IPC] OpenAI OAuth failed:', error.message);
+            return { success: false, error: error.message };
+        }
+    });
+    electron_1.ipcMain.handle(types_1.IPC_CHANNELS.LLM_OPENAI_OAUTH_LOGOUT, async () => {
+        checkRateLimit(types_1.IPC_CHANNELS.LLM_OPENAI_OAUTH_LOGOUT);
+        console.log('[IPC] Logging out of OpenAI OAuth...');
+        // Clear OAuth tokens from settings
+        const settings = llm_1.LLMProviderFactory.loadSettings();
+        if (settings.openai) {
+            settings.openai = {
+                ...settings.openai,
+                accessToken: undefined,
+                refreshToken: undefined,
+                tokenExpiresAt: undefined,
+                authMethod: undefined,
+            };
+            llm_1.LLMProviderFactory.saveSettings(settings);
+        }
+        return { success: true };
+    });
+    electron_1.ipcMain.handle(types_1.IPC_CHANNELS.LLM_GET_BEDROCK_MODELS, async (_, config) => {
+        checkRateLimit(types_1.IPC_CHANNELS.LLM_GET_BEDROCK_MODELS);
+        const models = await llm_1.LLMProviderFactory.getBedrockModels(config);
+        // Cache the models for use in config status
+        const cachedModels = models.map(m => ({
+            key: m.id,
+            displayName: m.name,
+            description: m.description,
+        }));
+        llm_1.LLMProviderFactory.saveCachedModels('bedrock', cachedModels);
+        return models;
+    });
+    // Search Settings handlers
+    electron_1.ipcMain.handle(types_1.IPC_CHANNELS.SEARCH_GET_SETTINGS, async () => {
+        return search_1.SearchProviderFactory.loadSettings();
+    });
+    electron_1.ipcMain.handle(types_1.IPC_CHANNELS.SEARCH_SAVE_SETTINGS, async (_, settings) => {
+        checkRateLimit(types_1.IPC_CHANNELS.SEARCH_SAVE_SETTINGS);
+        const validated = (0, validation_1.validateInput)(validation_1.SearchSettingsSchema, settings, 'search settings');
+        search_1.SearchProviderFactory.saveSettings(validated);
+        search_1.SearchProviderFactory.clearCache();
+        return { success: true };
+    });
+    electron_1.ipcMain.handle(types_1.IPC_CHANNELS.SEARCH_GET_CONFIG_STATUS, async () => {
+        return search_1.SearchProviderFactory.getConfigStatus();
+    });
+    electron_1.ipcMain.handle(types_1.IPC_CHANNELS.SEARCH_TEST_PROVIDER, async (_, providerType) => {
+        checkRateLimit(types_1.IPC_CHANNELS.SEARCH_TEST_PROVIDER);
+        return search_1.SearchProviderFactory.testProvider(providerType);
+    });
+    // X/Twitter Settings handlers
+    electron_1.ipcMain.handle(types_1.IPC_CHANNELS.X_GET_SETTINGS, async () => {
+        return x_manager_1.XSettingsManager.loadSettings();
+    });
+    electron_1.ipcMain.handle(types_1.IPC_CHANNELS.X_SAVE_SETTINGS, async (_, settings) => {
+        checkRateLimit(types_1.IPC_CHANNELS.X_SAVE_SETTINGS);
+        const validated = (0, validation_1.validateInput)(validation_1.XSettingsSchema, settings, 'x settings');
+        x_manager_1.XSettingsManager.saveSettings(validated);
+        x_manager_1.XSettingsManager.clearCache();
+        return { success: true };
+    });
+    electron_1.ipcMain.handle(types_1.IPC_CHANNELS.X_TEST_CONNECTION, async () => {
+        checkRateLimit(types_1.IPC_CHANNELS.X_TEST_CONNECTION);
+        const settings = x_manager_1.XSettingsManager.loadSettings();
+        return (0, x_cli_1.testXConnection)(settings);
+    });
+    electron_1.ipcMain.handle(types_1.IPC_CHANNELS.X_GET_STATUS, async () => {
+        checkRateLimit(types_1.IPC_CHANNELS.X_GET_STATUS);
+        const installStatus = await (0, x_cli_1.checkBirdInstalled)();
+        if (!installStatus.installed) {
+            return { installed: false, connected: false };
+        }
+        const settings = x_manager_1.XSettingsManager.loadSettings();
+        if (!settings.enabled) {
+            return { installed: true, connected: false };
+        }
+        const result = await (0, x_cli_1.testXConnection)(settings);
+        return {
+            installed: true,
+            connected: result.success,
+            username: result.username,
+            error: result.success ? undefined : result.error,
+        };
+    });
+    // Gateway / Channel handlers
+    electron_1.ipcMain.handle(types_1.IPC_CHANNELS.GATEWAY_GET_CHANNELS, async () => {
+        if (!gateway)
+            return [];
+        return gateway.getChannels().map(ch => ({
+            id: ch.id,
+            type: ch.type,
+            name: ch.name,
+            enabled: ch.enabled,
+            status: ch.status,
+            botUsername: ch.botUsername,
+            securityMode: ch.securityConfig.mode,
+            createdAt: ch.createdAt,
+            config: ch.config,
+        }));
+    });
+    electron_1.ipcMain.handle(types_1.IPC_CHANNELS.GATEWAY_ADD_CHANNEL, async (_, data) => {
+        checkRateLimit(types_1.IPC_CHANNELS.GATEWAY_ADD_CHANNEL);
+        if (!gateway)
+            throw new Error('Gateway not initialized');
+        const validated = (0, validation_1.validateInput)(validation_1.AddChannelSchema, data, 'channel');
+        if (validated.type === 'telegram') {
+            const channel = await gateway.addTelegramChannel(validated.name, validated.botToken, validated.securityMode || 'pairing');
+            return {
+                id: channel.id,
+                type: channel.type,
+                name: channel.name,
+                enabled: channel.enabled,
+                status: channel.status,
+                securityMode: channel.securityConfig.mode,
+                createdAt: channel.createdAt,
+            };
+        }
+        if (validated.type === 'discord') {
+            const channel = await gateway.addDiscordChannel(validated.name, validated.botToken, validated.applicationId, validated.guildIds, validated.securityMode || 'pairing');
+            return {
+                id: channel.id,
+                type: channel.type,
+                name: channel.name,
+                enabled: channel.enabled,
+                status: channel.status,
+                securityMode: channel.securityConfig.mode,
+                createdAt: channel.createdAt,
+            };
+        }
+        if (validated.type === 'slack') {
+            const channel = await gateway.addSlackChannel(validated.name, validated.botToken, validated.appToken, validated.signingSecret, validated.securityMode || 'pairing');
+            return {
+                id: channel.id,
+                type: channel.type,
+                name: channel.name,
+                enabled: channel.enabled,
+                status: channel.status,
+                securityMode: channel.securityConfig.mode,
+                createdAt: channel.createdAt,
+            };
+        }
+        if (validated.type === 'whatsapp') {
+            const channel = await gateway.addWhatsAppChannel(validated.name, validated.allowedNumbers, validated.securityMode || 'pairing', validated.selfChatMode ?? true, validated.responsePrefix ?? '🤖');
+            // Automatically enable and connect WhatsApp to start QR code generation
+            // This is done asynchronously to not block the response
+            gateway.enableWhatsAppWithQRForwarding(channel.id).catch((err) => {
+                console.error('Failed to enable WhatsApp channel:', err);
+            });
+            return {
+                id: channel.id,
+                type: channel.type,
+                name: channel.name,
+                enabled: channel.enabled,
+                status: 'connecting', // Indicate we're connecting
+                securityMode: channel.securityConfig.mode,
+                createdAt: channel.createdAt,
+                config: channel.config,
+            };
+        }
+        if (validated.type === 'imessage') {
+            const channel = await gateway.addImessageChannel(validated.name, validated.cliPath, validated.dbPath, validated.allowedContacts, validated.securityMode || 'pairing', validated.dmPolicy || 'pairing', validated.groupPolicy || 'allowlist');
+            // Automatically enable and connect iMessage
+            gateway.enableChannel(channel.id).catch((err) => {
+                console.error('Failed to enable iMessage channel:', err);
+            });
+            return {
+                id: channel.id,
+                type: channel.type,
+                name: channel.name,
+                enabled: channel.enabled,
+                status: 'connecting', // Indicate we're connecting
+                securityMode: channel.securityConfig.mode,
+                createdAt: channel.createdAt,
+                config: channel.config,
+            };
+        }
+        if (validated.type === 'signal') {
+            const channel = await gateway.addSignalChannel(validated.name, validated.phoneNumber, validated.dataDir, validated.securityMode || 'pairing', validated.mode || 'native', validated.trustMode || 'tofu', validated.dmPolicy || 'pairing', validated.groupPolicy || 'allowlist', validated.sendReadReceipts ?? true, validated.sendTypingIndicators ?? true);
+            // Automatically enable and connect Signal
+            gateway.enableChannel(channel.id).catch((err) => {
+                console.error('Failed to enable Signal channel:', err);
+            });
+            return {
+                id: channel.id,
+                type: channel.type,
+                name: channel.name,
+                enabled: channel.enabled,
+                status: 'connecting', // Indicate we're connecting
+                securityMode: channel.securityConfig.mode,
+                createdAt: channel.createdAt,
+                config: channel.config,
+            };
+        }
+        if (validated.type === 'mattermost') {
+            const channel = await gateway.addMattermostChannel(validated.name, validated.mattermostServerUrl, validated.mattermostToken, validated.mattermostTeamId, validated.securityMode || 'pairing');
+            // Automatically enable and connect Mattermost
+            gateway.enableChannel(channel.id).catch((err) => {
+                console.error('Failed to enable Mattermost channel:', err);
+            });
+            return {
+                id: channel.id,
+                type: channel.type,
+                name: channel.name,
+                enabled: channel.enabled,
+                status: 'connecting',
+                securityMode: channel.securityConfig.mode,
+                createdAt: channel.createdAt,
+                config: channel.config,
+            };
+        }
+        if (validated.type === 'matrix') {
+            const channel = await gateway.addMatrixChannel(validated.name, validated.matrixHomeserver, validated.matrixUserId, validated.matrixAccessToken, validated.matrixDeviceId, validated.matrixRoomIds, validated.securityMode || 'pairing');
+            // Automatically enable and connect Matrix
+            gateway.enableChannel(channel.id).catch((err) => {
+                console.error('Failed to enable Matrix channel:', err);
+            });
+            return {
+                id: channel.id,
+                type: channel.type,
+                name: channel.name,
+                enabled: channel.enabled,
+                status: 'connecting',
+                securityMode: channel.securityConfig.mode,
+                createdAt: channel.createdAt,
+                config: channel.config,
+            };
+        }
+        if (validated.type === 'twitch') {
+            const channel = await gateway.addTwitchChannel(validated.name, validated.twitchUsername, validated.twitchOauthToken, validated.twitchChannels || [], validated.twitchAllowWhispers ?? false, validated.securityMode || 'pairing');
+            // Automatically enable and connect Twitch
+            gateway.enableChannel(channel.id).catch((err) => {
+                console.error('Failed to enable Twitch channel:', err);
+            });
+            return {
+                id: channel.id,
+                type: channel.type,
+                name: channel.name,
+                enabled: channel.enabled,
+                status: 'connecting',
+                securityMode: channel.securityConfig.mode,
+                createdAt: channel.createdAt,
+                config: channel.config,
+            };
+        }
+        if (validated.type === 'line') {
+            const channel = await gateway.addLineChannel(validated.name, validated.lineChannelAccessToken, validated.lineChannelSecret, validated.lineWebhookPort ?? 3100, validated.securityMode || 'pairing');
+            // Automatically enable and connect LINE
+            gateway.enableChannel(channel.id).catch((err) => {
+                console.error('Failed to enable LINE channel:', err);
+            });
+            return {
+                id: channel.id,
+                type: channel.type,
+                name: channel.name,
+                enabled: channel.enabled,
+                status: 'connecting',
+                securityMode: channel.securityConfig.mode,
+                createdAt: channel.createdAt,
+                config: channel.config,
+            };
+        }
+        if (validated.type === 'bluebubbles') {
+            const channel = await gateway.addBlueBubblesChannel(validated.name, validated.blueBubblesServerUrl, validated.blueBubblesPassword, validated.blueBubblesWebhookPort ?? 3101, validated.blueBubblesAllowedContacts, validated.securityMode || 'pairing');
+            // Automatically enable and connect BlueBubbles
+            gateway.enableChannel(channel.id).catch((err) => {
+                console.error('Failed to enable BlueBubbles channel:', err);
+            });
+            return {
+                id: channel.id,
+                type: channel.type,
+                name: channel.name,
+                enabled: channel.enabled,
+                status: 'connecting',
+                securityMode: channel.securityConfig.mode,
+                createdAt: channel.createdAt,
+                config: channel.config,
+            };
+        }
+        if (validated.type === 'email') {
+            const channel = await gateway.addEmailChannel(validated.name, validated.emailAddress, validated.emailPassword, validated.emailImapHost, validated.emailSmtpHost, validated.emailDisplayName, validated.emailAllowedSenders, validated.emailSubjectFilter, validated.securityMode || 'pairing');
+            // Automatically enable and connect Email
+            gateway.enableChannel(channel.id).catch((err) => {
+                console.error('Failed to enable Email channel:', err);
+            });
+            return {
+                id: channel.id,
+                type: channel.type,
+                name: channel.name,
+                enabled: channel.enabled,
+                status: 'connecting',
+                securityMode: channel.securityConfig.mode,
+                createdAt: channel.createdAt,
+                config: channel.config,
+            };
+        }
+        // TypeScript exhaustiveness check - should never reach here due to discriminated union
+        throw new Error(`Unsupported channel type`);
+    });
+    electron_1.ipcMain.handle(types_1.IPC_CHANNELS.GATEWAY_UPDATE_CHANNEL, async (_, data) => {
+        if (!gateway)
+            throw new Error('Gateway not initialized');
+        const validated = (0, validation_1.validateInput)(validation_1.UpdateChannelSchema, data, 'channel update');
+        const channel = gateway.getChannel(validated.id);
+        if (!channel)
+            throw new Error('Channel not found');
+        const updates = {};
+        if (validated.name !== undefined)
+            updates.name = validated.name;
+        if (validated.securityMode !== undefined) {
+            updates.securityConfig = { ...channel.securityConfig, mode: validated.securityMode };
+        }
+        if (validated.config !== undefined) {
+            updates.config = { ...channel.config, ...validated.config };
+        }
+        gateway.updateChannel(validated.id, updates);
+    });
+    electron_1.ipcMain.handle(types_1.IPC_CHANNELS.GATEWAY_REMOVE_CHANNEL, async (_, id) => {
+        if (!gateway)
+            throw new Error('Gateway not initialized');
+        await gateway.removeChannel(id);
+    });
+    electron_1.ipcMain.handle(types_1.IPC_CHANNELS.GATEWAY_ENABLE_CHANNEL, async (_, id) => {
+        if (!gateway)
+            throw new Error('Gateway not initialized');
+        await gateway.enableChannel(id);
+    });
+    electron_1.ipcMain.handle(types_1.IPC_CHANNELS.GATEWAY_DISABLE_CHANNEL, async (_, id) => {
+        if (!gateway)
+            throw new Error('Gateway not initialized');
+        await gateway.disableChannel(id);
+    });
+    electron_1.ipcMain.handle(types_1.IPC_CHANNELS.GATEWAY_TEST_CHANNEL, async (_, id) => {
+        checkRateLimit(types_1.IPC_CHANNELS.GATEWAY_TEST_CHANNEL);
+        if (!gateway)
+            return { success: false, error: 'Gateway not initialized' };
+        return gateway.testChannel(id);
+    });
+    electron_1.ipcMain.handle(types_1.IPC_CHANNELS.GATEWAY_GET_USERS, async (_, channelId) => {
+        if (!gateway)
+            return [];
+        return gateway.getChannelUsers(channelId).map(u => ({
+            id: u.id,
+            channelId: u.channelId,
+            channelUserId: u.channelUserId,
+            displayName: u.displayName,
+            username: u.username,
+            allowed: u.allowed,
+            lastSeenAt: u.lastSeenAt,
+        }));
+    });
+    electron_1.ipcMain.handle(types_1.IPC_CHANNELS.GATEWAY_GRANT_ACCESS, async (_, data) => {
+        if (!gateway)
+            throw new Error('Gateway not initialized');
+        const validated = (0, validation_1.validateInput)(validation_1.GrantAccessSchema, data, 'grant access');
+        gateway.grantUserAccess(validated.channelId, validated.userId, validated.displayName);
+    });
+    electron_1.ipcMain.handle(types_1.IPC_CHANNELS.GATEWAY_REVOKE_ACCESS, async (_, data) => {
+        if (!gateway)
+            throw new Error('Gateway not initialized');
+        const validated = (0, validation_1.validateInput)(validation_1.RevokeAccessSchema, data, 'revoke access');
+        gateway.revokeUserAccess(validated.channelId, validated.userId);
+    });
+    electron_1.ipcMain.handle(types_1.IPC_CHANNELS.GATEWAY_GENERATE_PAIRING, async (_, data) => {
+        if (!gateway)
+            throw new Error('Gateway not initialized');
+        const validated = (0, validation_1.validateInput)(validation_1.GeneratePairingSchema, data, 'generate pairing');
+        return gateway.generatePairingCode(validated.channelId, validated.userId, validated.displayName);
+    });
+    // WhatsApp-specific handlers
+    electron_1.ipcMain.handle('whatsapp:get-info', async () => {
+        if (!gateway)
+            return {};
+        return gateway.getWhatsAppInfo();
+    });
+    electron_1.ipcMain.handle('whatsapp:logout', async () => {
+        if (!gateway)
+            throw new Error('Gateway not initialized');
+        await gateway.whatsAppLogout();
+    });
+    // App Update handlers
+    electron_1.ipcMain.handle(types_1.IPC_CHANNELS.APP_GET_VERSION, async () => {
+        return updater_1.updateManager.getVersionInfo();
+    });
+    electron_1.ipcMain.handle(types_1.IPC_CHANNELS.APP_CHECK_UPDATES, async () => {
+        return updater_1.updateManager.checkForUpdates();
+    });
+    electron_1.ipcMain.handle(types_1.IPC_CHANNELS.APP_DOWNLOAD_UPDATE, async (_, updateInfo) => {
+        await updater_1.updateManager.downloadAndInstallUpdate(updateInfo);
+        return { success: true };
+    });
+    electron_1.ipcMain.handle(types_1.IPC_CHANNELS.APP_INSTALL_UPDATE, async () => {
+        await updater_1.updateManager.installUpdateAndRestart();
+        return { success: true };
+    });
+    // Guardrail Settings handlers
+    electron_1.ipcMain.handle(types_1.IPC_CHANNELS.GUARDRAIL_GET_SETTINGS, async () => {
+        return guardrail_manager_1.GuardrailManager.loadSettings();
+    });
+    electron_1.ipcMain.handle(types_1.IPC_CHANNELS.GUARDRAIL_SAVE_SETTINGS, async (_, settings) => {
+        checkRateLimit(types_1.IPC_CHANNELS.GUARDRAIL_SAVE_SETTINGS);
+        const validated = (0, validation_1.validateInput)(validation_1.GuardrailSettingsSchema, settings, 'guardrail settings');
+        guardrail_manager_1.GuardrailManager.saveSettings(validated);
+        guardrail_manager_1.GuardrailManager.clearCache();
+        return { success: true };
+    });
+    electron_1.ipcMain.handle(types_1.IPC_CHANNELS.GUARDRAIL_GET_DEFAULTS, async () => {
+        return guardrail_manager_1.GuardrailManager.getDefaults();
+    });
+    // Appearance Settings handlers
+    electron_1.ipcMain.handle(types_1.IPC_CHANNELS.APPEARANCE_GET_SETTINGS, async () => {
+        return appearance_manager_1.AppearanceManager.loadSettings();
+    });
+    electron_1.ipcMain.handle(types_1.IPC_CHANNELS.APPEARANCE_SAVE_SETTINGS, async (_, settings) => {
+        appearance_manager_1.AppearanceManager.saveSettings(settings);
+        return { success: true };
+    });
+    // Personality Settings handlers
+    // Subscribe to PersonalityManager events to broadcast changes to UI
+    // This handles both IPC changes and tool-based changes
+    personality_manager_1.PersonalityManager.onSettingsChanged((settings) => {
+        broadcastPersonalitySettingsChanged(settings);
+    });
+    electron_1.ipcMain.handle(types_1.IPC_CHANNELS.PERSONALITY_GET_SETTINGS, async () => {
+        return personality_manager_1.PersonalityManager.loadSettings();
+    });
+    electron_1.ipcMain.handle(types_1.IPC_CHANNELS.PERSONALITY_SAVE_SETTINGS, async (_, settings) => {
+        personality_manager_1.PersonalityManager.saveSettings(settings);
+        // Event emission is handled by PersonalityManager.saveSettings()
+        return { success: true };
+    });
+    electron_1.ipcMain.handle(types_1.IPC_CHANNELS.PERSONALITY_GET_DEFINITIONS, async () => {
+        return personality_manager_1.PersonalityManager.getDefinitions();
+    });
+    electron_1.ipcMain.handle(types_1.IPC_CHANNELS.PERSONALITY_GET_PERSONAS, async () => {
+        return personality_manager_1.PersonalityManager.getPersonaDefinitions();
+    });
+    electron_1.ipcMain.handle(types_1.IPC_CHANNELS.PERSONALITY_GET_RELATIONSHIP_STATS, async () => {
+        return personality_manager_1.PersonalityManager.getRelationshipStats();
+    });
+    electron_1.ipcMain.handle(types_1.IPC_CHANNELS.PERSONALITY_SET_ACTIVE, async (_, personalityId) => {
+        personality_manager_1.PersonalityManager.setActivePersonality(personalityId);
+        // Event emission is handled by PersonalityManager.saveSettings()
+        return { success: true };
+    });
+    electron_1.ipcMain.handle(types_1.IPC_CHANNELS.PERSONALITY_SET_PERSONA, async (_, personaId) => {
+        personality_manager_1.PersonalityManager.setActivePersona(personaId);
+        // Event emission is handled by PersonalityManager.saveSettings()
+        return { success: true };
+    });
+    electron_1.ipcMain.handle(types_1.IPC_CHANNELS.PERSONALITY_RESET, async (_, preserveRelationship) => {
+        checkRateLimit(types_1.IPC_CHANNELS.PERSONALITY_RESET);
+        personality_manager_1.PersonalityManager.resetToDefaults(preserveRelationship);
+        // Event emission is handled by PersonalityManager.resetToDefaults()
+        return { success: true };
+    });
+    // Agent Role / Squad handlers
+    electron_1.ipcMain.handle(types_1.IPC_CHANNELS.AGENT_ROLE_LIST, async (_, includeInactive) => {
+        return agentRoleRepo.findAll(includeInactive ?? false);
+    });
+    electron_1.ipcMain.handle(types_1.IPC_CHANNELS.AGENT_ROLE_GET, async (_, id) => {
+        const validated = (0, validation_1.validateInput)(validation_1.UUIDSchema, id, 'agent role ID');
+        return agentRoleRepo.findById(validated);
+    });
+    electron_1.ipcMain.handle(types_1.IPC_CHANNELS.AGENT_ROLE_CREATE, async (_, request) => {
+        checkRateLimit(types_1.IPC_CHANNELS.AGENT_ROLE_CREATE);
+        // Validate name format (lowercase, alphanumeric, hyphens)
+        if (!/^[a-z0-9-]+$/.test(request.name)) {
+            throw new Error('Agent role name must be lowercase alphanumeric with hyphens only');
+        }
+        // Check for duplicate name
+        if (agentRoleRepo.findByName(request.name)) {
+            throw new Error(`Agent role with name "${request.name}" already exists`);
+        }
+        return agentRoleRepo.create(request);
+    });
+    electron_1.ipcMain.handle(types_1.IPC_CHANNELS.AGENT_ROLE_UPDATE, async (_, request) => {
+        checkRateLimit(types_1.IPC_CHANNELS.AGENT_ROLE_UPDATE);
+        const validated = (0, validation_1.validateInput)(validation_1.UUIDSchema, request.id, 'agent role ID');
+        const result = agentRoleRepo.update({ ...request, id: validated });
+        if (!result) {
+            throw new Error('Agent role not found');
+        }
+        return result;
+    });
+    electron_1.ipcMain.handle(types_1.IPC_CHANNELS.AGENT_ROLE_DELETE, async (_, id) => {
+        checkRateLimit(types_1.IPC_CHANNELS.AGENT_ROLE_DELETE);
+        const validated = (0, validation_1.validateInput)(validation_1.UUIDSchema, id, 'agent role ID');
+        const success = agentRoleRepo.delete(validated);
+        if (!success) {
+            throw new Error('Agent role not found or cannot be deleted');
+        }
+        return { success: true };
+    });
+    electron_1.ipcMain.handle(types_1.IPC_CHANNELS.AGENT_ROLE_ASSIGN_TO_TASK, async (_, taskId, agentRoleId) => {
+        checkRateLimit(types_1.IPC_CHANNELS.AGENT_ROLE_ASSIGN_TO_TASK);
+        const validatedTaskId = (0, validation_1.validateInput)(validation_1.UUIDSchema, taskId, 'task ID');
+        if (agentRoleId !== null) {
+            const validatedRoleId = (0, validation_1.validateInput)(validation_1.UUIDSchema, agentRoleId, 'agent role ID');
+            const role = agentRoleRepo.findById(validatedRoleId);
+            if (!role) {
+                throw new Error('Agent role not found');
+            }
+        }
+        taskRepo.update(validatedTaskId, { assignedAgentRoleId: agentRoleId ?? undefined });
+        const task = taskRepo.findById(validatedTaskId);
+        if (task) {
+            if (agentRoleId) {
+                const role = agentRoleRepo.findById(agentRoleId);
+                const activity = activityRepo.create({
+                    workspaceId: task.workspaceId,
+                    taskId: task.id,
+                    agentRoleId,
+                    actorType: 'system',
+                    activityType: 'agent_assigned',
+                    title: `Assigned to ${role?.displayName || 'agent'}`,
+                    description: task.title,
+                });
+                getMainWindow()?.webContents.send(types_1.IPC_CHANNELS.ACTIVITY_EVENT, { type: 'created', activity });
+            }
+            else {
+                const activity = activityRepo.create({
+                    workspaceId: task.workspaceId,
+                    taskId: task.id,
+                    actorType: 'system',
+                    activityType: 'info',
+                    title: 'Task unassigned',
+                    description: task.title,
+                });
+                getMainWindow()?.webContents.send(types_1.IPC_CHANNELS.ACTIVITY_EVENT, { type: 'created', activity });
+            }
+        }
+        return { success: true };
+    });
+    electron_1.ipcMain.handle(types_1.IPC_CHANNELS.AGENT_ROLE_GET_DEFAULTS, async () => {
+        const { DEFAULT_AGENT_ROLES } = await Promise.resolve().then(() => __importStar(require('../../shared/types')));
+        return DEFAULT_AGENT_ROLES;
+    });
+    electron_1.ipcMain.handle(types_1.IPC_CHANNELS.AGENT_ROLE_SEED_DEFAULTS, async () => {
+        checkRateLimit(types_1.IPC_CHANNELS.AGENT_ROLE_SEED_DEFAULTS);
+        return agentRoleRepo.seedDefaults();
+    });
+    electron_1.ipcMain.handle(types_1.IPC_CHANNELS.AGENT_ROLE_SYNC_DEFAULTS, async () => {
+        checkRateLimit(types_1.IPC_CHANNELS.AGENT_ROLE_SYNC_DEFAULTS);
+        return agentRoleRepo.syncNewDefaults();
+    });
+    // Activity Feed handlers
+    electron_1.ipcMain.handle(types_1.IPC_CHANNELS.ACTIVITY_LIST, async (_, query) => {
+        const validated = (0, validation_1.validateInput)(validation_1.UUIDSchema, query.workspaceId, 'workspace ID');
+        return activityRepo.list({ ...query, workspaceId: validated });
+    });
+    electron_1.ipcMain.handle(types_1.IPC_CHANNELS.ACTIVITY_CREATE, async (_, request) => {
+        checkRateLimit(types_1.IPC_CHANNELS.ACTIVITY_CREATE);
+        const validatedWorkspaceId = (0, validation_1.validateInput)(validation_1.UUIDSchema, request.workspaceId, 'workspace ID');
+        const activity = activityRepo.create({ ...request, workspaceId: validatedWorkspaceId });
+        // Emit activity event for real-time updates
+        getMainWindow()?.webContents.send(types_1.IPC_CHANNELS.ACTIVITY_EVENT, { type: 'created', activity });
+        return activity;
+    });
+    electron_1.ipcMain.handle(types_1.IPC_CHANNELS.ACTIVITY_MARK_READ, async (_, id) => {
+        checkRateLimit(types_1.IPC_CHANNELS.ACTIVITY_MARK_READ);
+        const validated = (0, validation_1.validateInput)(validation_1.UUIDSchema, id, 'activity ID');
+        const success = activityRepo.markRead(validated);
+        if (success) {
+            getMainWindow()?.webContents.send(types_1.IPC_CHANNELS.ACTIVITY_EVENT, { type: 'read', id: validated });
+        }
+        return { success };
+    });
+    electron_1.ipcMain.handle(types_1.IPC_CHANNELS.ACTIVITY_MARK_ALL_READ, async (_, workspaceId) => {
+        checkRateLimit(types_1.IPC_CHANNELS.ACTIVITY_MARK_ALL_READ);
+        const validated = (0, validation_1.validateInput)(validation_1.UUIDSchema, workspaceId, 'workspace ID');
+        const count = activityRepo.markAllRead(validated);
+        getMainWindow()?.webContents.send(types_1.IPC_CHANNELS.ACTIVITY_EVENT, { type: 'all_read', workspaceId: validated });
+        return { count };
+    });
+    electron_1.ipcMain.handle(types_1.IPC_CHANNELS.ACTIVITY_PIN, async (_, id) => {
+        checkRateLimit(types_1.IPC_CHANNELS.ACTIVITY_PIN);
+        const validated = (0, validation_1.validateInput)(validation_1.UUIDSchema, id, 'activity ID');
+        const activity = activityRepo.togglePin(validated);
+        if (activity) {
+            getMainWindow()?.webContents.send(types_1.IPC_CHANNELS.ACTIVITY_EVENT, { type: 'pinned', activity });
+        }
+        return activity;
+    });
+    electron_1.ipcMain.handle(types_1.IPC_CHANNELS.ACTIVITY_DELETE, async (_, id) => {
+        checkRateLimit(types_1.IPC_CHANNELS.ACTIVITY_DELETE);
+        const validated = (0, validation_1.validateInput)(validation_1.UUIDSchema, id, 'activity ID');
+        const success = activityRepo.delete(validated);
+        if (success) {
+            getMainWindow()?.webContents.send(types_1.IPC_CHANNELS.ACTIVITY_EVENT, { type: 'deleted', id: validated });
+        }
+        return { success };
+    });
+    // @Mention handlers
+    electron_1.ipcMain.handle(types_1.IPC_CHANNELS.MENTION_LIST, async (_, query) => {
+        return mentionRepo.list(query);
+    });
+    electron_1.ipcMain.handle(types_1.IPC_CHANNELS.MENTION_CREATE, async (_, request) => {
+        checkRateLimit(types_1.IPC_CHANNELS.MENTION_CREATE);
+        const validatedWorkspaceId = (0, validation_1.validateInput)(validation_1.UUIDSchema, request.workspaceId, 'workspace ID');
+        const mention = mentionRepo.create({ ...request, workspaceId: validatedWorkspaceId });
+        // Emit mention event for real-time updates
+        getMainWindow()?.webContents.send(types_1.IPC_CHANNELS.MENTION_EVENT, { type: 'created', mention });
+        // Also create an activity entry for the mention
+        const fromAgent = request.fromAgentRoleId ? agentRoleRepo.findById(request.fromAgentRoleId) : null;
+        const toAgent = agentRoleRepo.findById(request.toAgentRoleId);
+        activityRepo.create({
+            workspaceId: validatedWorkspaceId,
+            taskId: request.taskId,
+            agentRoleId: request.toAgentRoleId,
+            actorType: fromAgent ? 'agent' : 'user',
+            activityType: 'mention',
+            title: `@${toAgent?.displayName || 'Agent'} mentioned`,
+            description: request.context,
+            metadata: { mentionId: mention.id, mentionType: request.mentionType },
+        });
+        return mention;
+    });
+    electron_1.ipcMain.handle(types_1.IPC_CHANNELS.MENTION_ACKNOWLEDGE, async (_, id) => {
+        checkRateLimit(types_1.IPC_CHANNELS.MENTION_ACKNOWLEDGE);
+        const validated = (0, validation_1.validateInput)(validation_1.UUIDSchema, id, 'mention ID');
+        const mention = mentionRepo.acknowledge(validated);
+        if (mention) {
+            getMainWindow()?.webContents.send(types_1.IPC_CHANNELS.MENTION_EVENT, { type: 'acknowledged', mention });
+        }
+        return mention;
+    });
+    electron_1.ipcMain.handle(types_1.IPC_CHANNELS.MENTION_COMPLETE, async (_, id) => {
+        checkRateLimit(types_1.IPC_CHANNELS.MENTION_COMPLETE);
+        const validated = (0, validation_1.validateInput)(validation_1.UUIDSchema, id, 'mention ID');
+        const mention = mentionRepo.complete(validated);
+        if (mention) {
+            getMainWindow()?.webContents.send(types_1.IPC_CHANNELS.MENTION_EVENT, { type: 'completed', mention });
+        }
+        return mention;
+    });
+    electron_1.ipcMain.handle(types_1.IPC_CHANNELS.MENTION_DISMISS, async (_, id) => {
+        checkRateLimit(types_1.IPC_CHANNELS.MENTION_DISMISS);
+        const validated = (0, validation_1.validateInput)(validation_1.UUIDSchema, id, 'mention ID');
+        const mention = mentionRepo.dismiss(validated);
+        if (mention) {
+            getMainWindow()?.webContents.send(types_1.IPC_CHANNELS.MENTION_EVENT, { type: 'dismissed', mention });
+        }
+        return mention;
+    });
+    // Task Board handlers
+    electron_1.ipcMain.handle(types_1.IPC_CHANNELS.TASK_MOVE_COLUMN, async (_, taskId, column) => {
+        checkRateLimit(types_1.IPC_CHANNELS.TASK_MOVE_COLUMN);
+        const validatedId = (0, validation_1.validateInput)(validation_1.UUIDSchema, taskId, 'task ID');
+        const task = taskRepo.moveToColumn(validatedId, column);
+        if (task) {
+            getMainWindow()?.webContents.send(types_1.IPC_CHANNELS.TASK_BOARD_EVENT, { type: 'moved', task, column });
+            const columnLabels = {
+                backlog: 'Inbox',
+                todo: 'Assigned',
+                in_progress: 'In Progress',
+                review: 'Review',
+                done: 'Done',
+            };
+            const activity = activityRepo.create({
+                workspaceId: task.workspaceId,
+                taskId: task.id,
+                agentRoleId: task.assignedAgentRoleId,
+                actorType: 'system',
+                activityType: 'info',
+                title: `Moved to ${columnLabels[column] || column}`,
+                description: task.title,
+            });
+            getMainWindow()?.webContents.send(types_1.IPC_CHANNELS.ACTIVITY_EVENT, { type: 'created', activity });
+        }
+        return task;
+    });
+    electron_1.ipcMain.handle(types_1.IPC_CHANNELS.TASK_SET_PRIORITY, async (_, taskId, priority) => {
+        checkRateLimit(types_1.IPC_CHANNELS.TASK_SET_PRIORITY);
+        const validatedId = (0, validation_1.validateInput)(validation_1.UUIDSchema, taskId, 'task ID');
+        const task = taskRepo.setPriority(validatedId, priority);
+        if (task) {
+            getMainWindow()?.webContents.send(types_1.IPC_CHANNELS.TASK_BOARD_EVENT, { type: 'priority_changed', task });
+        }
+        return task;
+    });
+    electron_1.ipcMain.handle(types_1.IPC_CHANNELS.TASK_SET_DUE_DATE, async (_, taskId, dueDate) => {
+        checkRateLimit(types_1.IPC_CHANNELS.TASK_SET_DUE_DATE);
+        const validatedId = (0, validation_1.validateInput)(validation_1.UUIDSchema, taskId, 'task ID');
+        const task = taskRepo.setDueDate(validatedId, dueDate);
+        if (task) {
+            getMainWindow()?.webContents.send(types_1.IPC_CHANNELS.TASK_BOARD_EVENT, { type: 'due_date_changed', task });
+        }
+        return task;
+    });
+    electron_1.ipcMain.handle(types_1.IPC_CHANNELS.TASK_SET_ESTIMATE, async (_, taskId, minutes) => {
+        checkRateLimit(types_1.IPC_CHANNELS.TASK_SET_ESTIMATE);
+        const validatedId = (0, validation_1.validateInput)(validation_1.UUIDSchema, taskId, 'task ID');
+        const task = taskRepo.setEstimate(validatedId, minutes);
+        if (task) {
+            getMainWindow()?.webContents.send(types_1.IPC_CHANNELS.TASK_BOARD_EVENT, { type: 'estimate_changed', task });
+        }
+        return task;
+    });
+    electron_1.ipcMain.handle(types_1.IPC_CHANNELS.TASK_ADD_LABEL, async (_, taskId, labelId) => {
+        checkRateLimit(types_1.IPC_CHANNELS.TASK_ADD_LABEL);
+        const validatedTaskId = (0, validation_1.validateInput)(validation_1.UUIDSchema, taskId, 'task ID');
+        const validatedLabelId = (0, validation_1.validateInput)(validation_1.UUIDSchema, labelId, 'label ID');
+        const task = taskRepo.addLabel(validatedTaskId, validatedLabelId);
+        if (task) {
+            getMainWindow()?.webContents.send(types_1.IPC_CHANNELS.TASK_BOARD_EVENT, { type: 'label_added', task, labelId: validatedLabelId });
+        }
+        return task;
+    });
+    electron_1.ipcMain.handle(types_1.IPC_CHANNELS.TASK_REMOVE_LABEL, async (_, taskId, labelId) => {
+        checkRateLimit(types_1.IPC_CHANNELS.TASK_REMOVE_LABEL);
+        const validatedTaskId = (0, validation_1.validateInput)(validation_1.UUIDSchema, taskId, 'task ID');
+        const validatedLabelId = (0, validation_1.validateInput)(validation_1.UUIDSchema, labelId, 'label ID');
+        const task = taskRepo.removeLabel(validatedTaskId, validatedLabelId);
+        if (task) {
+            getMainWindow()?.webContents.send(types_1.IPC_CHANNELS.TASK_BOARD_EVENT, { type: 'label_removed', task, labelId: validatedLabelId });
+        }
+        return task;
+    });
+    // Task Label handlers
+    electron_1.ipcMain.handle(types_1.IPC_CHANNELS.TASK_LABEL_LIST, async (_, workspaceId) => {
+        const validated = (0, validation_1.validateInput)(validation_1.UUIDSchema, workspaceId, 'workspace ID');
+        return taskLabelRepo.list({ workspaceId: validated });
+    });
+    electron_1.ipcMain.handle(types_1.IPC_CHANNELS.TASK_LABEL_CREATE, async (_, request) => {
+        checkRateLimit(types_1.IPC_CHANNELS.TASK_LABEL_CREATE);
+        const validatedWorkspaceId = (0, validation_1.validateInput)(validation_1.UUIDSchema, request.workspaceId, 'workspace ID');
+        return taskLabelRepo.create({ ...request, workspaceId: validatedWorkspaceId });
+    });
+    electron_1.ipcMain.handle(types_1.IPC_CHANNELS.TASK_LABEL_UPDATE, async (_, id, request) => {
+        checkRateLimit(types_1.IPC_CHANNELS.TASK_LABEL_UPDATE);
+        const validated = (0, validation_1.validateInput)(validation_1.UUIDSchema, id, 'label ID');
+        return taskLabelRepo.update(validated, request);
+    });
+    electron_1.ipcMain.handle(types_1.IPC_CHANNELS.TASK_LABEL_DELETE, async (_, id) => {
+        checkRateLimit(types_1.IPC_CHANNELS.TASK_LABEL_DELETE);
+        const validated = (0, validation_1.validateInput)(validation_1.UUIDSchema, id, 'label ID');
+        return { success: taskLabelRepo.delete(validated) };
+    });
+    // Working State handlers
+    electron_1.ipcMain.handle(types_1.IPC_CHANNELS.WORKING_STATE_GET, async (_, id) => {
+        const validated = (0, validation_1.validateInput)(validation_1.UUIDSchema, id, 'working state ID');
+        return workingStateRepo.findById(validated);
+    });
+    electron_1.ipcMain.handle(types_1.IPC_CHANNELS.WORKING_STATE_GET_CURRENT, async (_, query) => {
+        const validatedAgentRoleId = (0, validation_1.validateInput)(validation_1.UUIDSchema, query.agentRoleId, 'agent role ID');
+        const validatedWorkspaceId = (0, validation_1.validateInput)(validation_1.UUIDSchema, query.workspaceId, 'workspace ID');
+        return workingStateRepo.getCurrent({
+            agentRoleId: validatedAgentRoleId,
+            workspaceId: validatedWorkspaceId,
+            taskId: query.taskId,
+            stateType: query.stateType,
+        });
+    });
+    electron_1.ipcMain.handle(types_1.IPC_CHANNELS.WORKING_STATE_UPDATE, async (_, request) => {
+        checkRateLimit(types_1.IPC_CHANNELS.WORKING_STATE_UPDATE);
+        const validatedAgentRoleId = (0, validation_1.validateInput)(validation_1.UUIDSchema, request.agentRoleId, 'agent role ID');
+        const validatedWorkspaceId = (0, validation_1.validateInput)(validation_1.UUIDSchema, request.workspaceId, 'workspace ID');
+        return workingStateRepo.update({
+            agentRoleId: validatedAgentRoleId,
+            workspaceId: validatedWorkspaceId,
+            taskId: request.taskId,
+            stateType: request.stateType,
+            content: request.content,
+            fileReferences: request.fileReferences,
+        });
+    });
+    electron_1.ipcMain.handle(types_1.IPC_CHANNELS.WORKING_STATE_HISTORY, async (_, query) => {
+        const validatedAgentRoleId = (0, validation_1.validateInput)(validation_1.UUIDSchema, query.agentRoleId, 'agent role ID');
+        const validatedWorkspaceId = (0, validation_1.validateInput)(validation_1.UUIDSchema, query.workspaceId, 'workspace ID');
+        return workingStateRepo.getHistory({
+            agentRoleId: validatedAgentRoleId,
+            workspaceId: validatedWorkspaceId,
+            limit: query.limit,
+            offset: query.offset,
+        });
+    });
+    electron_1.ipcMain.handle(types_1.IPC_CHANNELS.WORKING_STATE_RESTORE, async (_, id) => {
+        checkRateLimit(types_1.IPC_CHANNELS.WORKING_STATE_RESTORE);
+        const validated = (0, validation_1.validateInput)(validation_1.UUIDSchema, id, 'working state ID');
+        return workingStateRepo.restore(validated);
+    });
+    electron_1.ipcMain.handle(types_1.IPC_CHANNELS.WORKING_STATE_DELETE, async (_, id) => {
+        checkRateLimit(types_1.IPC_CHANNELS.WORKING_STATE_DELETE);
+        const validated = (0, validation_1.validateInput)(validation_1.UUIDSchema, id, 'working state ID');
+        return { success: workingStateRepo.delete(validated) };
+    });
+    electron_1.ipcMain.handle(types_1.IPC_CHANNELS.WORKING_STATE_LIST_FOR_TASK, async (_, taskId) => {
+        const validated = (0, validation_1.validateInput)(validation_1.UUIDSchema, taskId, 'task ID');
+        return workingStateRepo.listForTask(validated);
+    });
+    // Context Policy handlers (per-context security DM vs group)
+    electron_1.ipcMain.handle(types_1.IPC_CHANNELS.CONTEXT_POLICY_GET, async (_, channelId, contextType) => {
+        return contextPolicyManager.getPolicy(channelId, contextType);
+    });
+    electron_1.ipcMain.handle(types_1.IPC_CHANNELS.CONTEXT_POLICY_GET_FOR_CHAT, async (_, channelId, chatId, isGroup) => {
+        return contextPolicyManager.getPolicyForChat(channelId, chatId, isGroup);
+    });
+    electron_1.ipcMain.handle(types_1.IPC_CHANNELS.CONTEXT_POLICY_LIST, async (_, channelId) => {
+        return contextPolicyManager.getPoliciesForChannel(channelId);
+    });
+    electron_1.ipcMain.handle(types_1.IPC_CHANNELS.CONTEXT_POLICY_UPDATE, async (_, channelId, contextType, options) => {
+        checkRateLimit(types_1.IPC_CHANNELS.CONTEXT_POLICY_UPDATE);
+        return contextPolicyManager.updateByContext(channelId, contextType, {
+            securityMode: options.securityMode,
+            toolRestrictions: options.toolRestrictions,
+        });
+    });
+    electron_1.ipcMain.handle(types_1.IPC_CHANNELS.CONTEXT_POLICY_DELETE, async (_, channelId) => {
+        checkRateLimit(types_1.IPC_CHANNELS.CONTEXT_POLICY_DELETE);
+        return { count: contextPolicyManager.deleteByChannel(channelId) };
+    });
+    electron_1.ipcMain.handle(types_1.IPC_CHANNELS.CONTEXT_POLICY_CREATE_DEFAULTS, async (_, channelId) => {
+        checkRateLimit(types_1.IPC_CHANNELS.CONTEXT_POLICY_CREATE_DEFAULTS);
+        contextPolicyManager.createDefaultPolicies(channelId);
+        return { success: true };
+    });
+    electron_1.ipcMain.handle(types_1.IPC_CHANNELS.CONTEXT_POLICY_IS_TOOL_ALLOWED, async (_, channelId, contextType, toolName, toolGroups) => {
+        return { allowed: contextPolicyManager.isToolAllowed(channelId, contextType, toolName, toolGroups) };
+    });
+    // Queue handlers
+    electron_1.ipcMain.handle(types_1.IPC_CHANNELS.QUEUE_GET_STATUS, async () => {
+        return agentDaemon.getQueueStatus();
+    });
+    electron_1.ipcMain.handle(types_1.IPC_CHANNELS.QUEUE_GET_SETTINGS, async () => {
+        return agentDaemon.getQueueSettings();
+    });
+    electron_1.ipcMain.handle(types_1.IPC_CHANNELS.QUEUE_SAVE_SETTINGS, async (_, settings) => {
+        checkRateLimit(types_1.IPC_CHANNELS.QUEUE_SAVE_SETTINGS);
+        agentDaemon.saveQueueSettings(settings);
+        return { success: true };
+    });
+    electron_1.ipcMain.handle(types_1.IPC_CHANNELS.QUEUE_CLEAR, async () => {
+        checkRateLimit(types_1.IPC_CHANNELS.QUEUE_CLEAR);
+        const result = await agentDaemon.clearStuckTasks();
+        return { success: true, ...result };
+    });
+    // MCP handlers
+    setupMCPHandlers();
+    // Notification handlers
+    setupNotificationHandlers();
+    // Hooks (Webhooks & Gmail Pub/Sub) handlers
+    setupHooksHandlers(agentDaemon);
+    // Memory system handlers
+    setupMemoryHandlers();
+}
+/**
+ * Set up MCP (Model Context Protocol) IPC handlers
+ */
+function setupMCPHandlers() {
+    // Configure rate limits for MCP channels
+    rate_limiter_1.rateLimiter.configure(types_1.IPC_CHANNELS.MCP_SAVE_SETTINGS, rate_limiter_1.RATE_LIMIT_CONFIGS.limited);
+    rate_limiter_1.rateLimiter.configure(types_1.IPC_CHANNELS.MCP_CONNECT_SERVER, rate_limiter_1.RATE_LIMIT_CONFIGS.expensive);
+    rate_limiter_1.rateLimiter.configure(types_1.IPC_CHANNELS.MCP_TEST_SERVER, rate_limiter_1.RATE_LIMIT_CONFIGS.expensive);
+    rate_limiter_1.rateLimiter.configure(types_1.IPC_CHANNELS.MCP_REGISTRY_INSTALL, rate_limiter_1.RATE_LIMIT_CONFIGS.expensive);
+    // Initialize MCP settings manager
+    settings_1.MCPSettingsManager.initialize();
+    // Get settings
+    electron_1.ipcMain.handle(types_1.IPC_CHANNELS.MCP_GET_SETTINGS, async () => {
+        return settings_1.MCPSettingsManager.getSettingsForDisplay();
+    });
+    // Save settings
+    electron_1.ipcMain.handle(types_1.IPC_CHANNELS.MCP_SAVE_SETTINGS, async (_, settings) => {
+        checkRateLimit(types_1.IPC_CHANNELS.MCP_SAVE_SETTINGS);
+        const validated = (0, validation_1.validateInput)(validation_2.MCPSettingsSchema, settings, 'MCP settings');
+        settings_1.MCPSettingsManager.saveSettings(validated);
+        settings_1.MCPSettingsManager.clearCache();
+        return { success: true };
+    });
+    // Get all servers
+    electron_1.ipcMain.handle(types_1.IPC_CHANNELS.MCP_GET_SERVERS, async () => {
+        const settings = settings_1.MCPSettingsManager.loadSettings();
+        return settings.servers;
+    });
+    // Add a server
+    electron_1.ipcMain.handle(types_1.IPC_CHANNELS.MCP_ADD_SERVER, async (_, serverConfig) => {
+        checkRateLimit(types_1.IPC_CHANNELS.MCP_ADD_SERVER);
+        const validated = (0, validation_1.validateInput)(validation_2.MCPServerConfigSchema, serverConfig, 'MCP server config');
+        const { id, ...configWithoutId } = validated;
+        return settings_1.MCPSettingsManager.addServer(configWithoutId);
+    });
+    // Update a server
+    electron_1.ipcMain.handle(types_1.IPC_CHANNELS.MCP_UPDATE_SERVER, async (_, serverId, updates) => {
+        const validatedId = (0, validation_1.validateInput)(validation_1.UUIDSchema, serverId, 'server ID');
+        const validatedUpdates = (0, validation_1.validateInput)(validation_2.MCPServerUpdateSchema, updates, 'server updates');
+        return settings_1.MCPSettingsManager.updateServer(validatedId, validatedUpdates);
+    });
+    // Remove a server
+    electron_1.ipcMain.handle(types_1.IPC_CHANNELS.MCP_REMOVE_SERVER, async (_, serverId) => {
+        const validatedId = (0, validation_1.validateInput)(validation_1.UUIDSchema, serverId, 'server ID');
+        // Disconnect if connected
+        try {
+            await MCPClientManager_1.MCPClientManager.getInstance().disconnectServer(validatedId);
+        }
+        catch {
+            // Ignore errors
+        }
+        return settings_1.MCPSettingsManager.removeServer(validatedId);
+    });
+    // Connect to a server
+    electron_1.ipcMain.handle(types_1.IPC_CHANNELS.MCP_CONNECT_SERVER, async (_, serverId) => {
+        checkRateLimit(types_1.IPC_CHANNELS.MCP_CONNECT_SERVER);
+        const validatedId = (0, validation_1.validateInput)(validation_1.UUIDSchema, serverId, 'server ID');
+        await MCPClientManager_1.MCPClientManager.getInstance().connectServer(validatedId);
+        return { success: true };
+    });
+    // Disconnect from a server
+    electron_1.ipcMain.handle(types_1.IPC_CHANNELS.MCP_DISCONNECT_SERVER, async (_, serverId) => {
+        const validatedId = (0, validation_1.validateInput)(validation_1.UUIDSchema, serverId, 'server ID');
+        await MCPClientManager_1.MCPClientManager.getInstance().disconnectServer(validatedId);
+        return { success: true };
+    });
+    // Get status of all servers
+    electron_1.ipcMain.handle(types_1.IPC_CHANNELS.MCP_GET_STATUS, async () => {
+        return MCPClientManager_1.MCPClientManager.getInstance().getStatus();
+    });
+    // Get tools from a specific server
+    electron_1.ipcMain.handle(types_1.IPC_CHANNELS.MCP_GET_SERVER_TOOLS, async (_, serverId) => {
+        const validatedId = (0, validation_1.validateInput)(validation_1.UUIDSchema, serverId, 'server ID');
+        return MCPClientManager_1.MCPClientManager.getInstance().getServerTools(validatedId);
+    });
+    // Test server connection
+    electron_1.ipcMain.handle(types_1.IPC_CHANNELS.MCP_TEST_SERVER, async (_, serverId) => {
+        checkRateLimit(types_1.IPC_CHANNELS.MCP_TEST_SERVER);
+        const validatedId = (0, validation_1.validateInput)(validation_1.UUIDSchema, serverId, 'server ID');
+        return MCPClientManager_1.MCPClientManager.getInstance().testServer(validatedId);
+    });
+    // MCP Registry handlers
+    electron_1.ipcMain.handle(types_1.IPC_CHANNELS.MCP_REGISTRY_FETCH, async () => {
+        const registry = await MCPRegistryManager_1.MCPRegistryManager.fetchRegistry();
+        const categories = await MCPRegistryManager_1.MCPRegistryManager.getCategories();
+        const featured = registry.servers.filter(s => s.featured);
+        return { ...registry, categories, featured };
+    });
+    electron_1.ipcMain.handle(types_1.IPC_CHANNELS.MCP_REGISTRY_SEARCH, async (_, options) => {
+        const validatedOptions = (0, validation_1.validateInput)(validation_2.MCPRegistrySearchSchema, options, 'registry search options');
+        return MCPRegistryManager_1.MCPRegistryManager.searchServers(validatedOptions);
+    });
+    electron_1.ipcMain.handle(types_1.IPC_CHANNELS.MCP_REGISTRY_INSTALL, async (_, entryId) => {
+        checkRateLimit(types_1.IPC_CHANNELS.MCP_REGISTRY_INSTALL);
+        const validatedId = (0, validation_1.validateInput)(validation_1.StringIdSchema, entryId, 'registry entry ID');
+        return MCPRegistryManager_1.MCPRegistryManager.installServer(validatedId);
+    });
+    electron_1.ipcMain.handle(types_1.IPC_CHANNELS.MCP_REGISTRY_UNINSTALL, async (_, serverId) => {
+        const validatedId = (0, validation_1.validateInput)(validation_1.UUIDSchema, serverId, 'server ID');
+        // Disconnect if connected
+        try {
+            await MCPClientManager_1.MCPClientManager.getInstance().disconnectServer(validatedId);
+        }
+        catch {
+            // Ignore errors
+        }
+        await MCPRegistryManager_1.MCPRegistryManager.uninstallServer(validatedId);
+    });
+    electron_1.ipcMain.handle(types_1.IPC_CHANNELS.MCP_REGISTRY_CHECK_UPDATES, async () => {
+        return MCPRegistryManager_1.MCPRegistryManager.checkForUpdates();
+    });
+    electron_1.ipcMain.handle(types_1.IPC_CHANNELS.MCP_REGISTRY_UPDATE_SERVER, async (_, serverId) => {
+        const validatedId = (0, validation_1.validateInput)(validation_1.UUIDSchema, serverId, 'server ID');
+        return MCPRegistryManager_1.MCPRegistryManager.updateServer(validatedId);
+    });
+    // MCP Host handlers
+    electron_1.ipcMain.handle(types_1.IPC_CHANNELS.MCP_HOST_START, async () => {
+        const hostServer = MCPHostServer_1.MCPHostServer.getInstance();
+        // If no tool provider is set, create a minimal one that exposes MCP tools
+        // from connected servers (useful for tool aggregation/forwarding)
+        if (!hostServer.hasToolProvider()) {
+            const mcpClientManager = MCPClientManager_1.MCPClientManager.getInstance();
+            // Create a minimal tool provider that exposes MCP tools
+            hostServer.setToolProvider({
+                getTools() {
+                    return mcpClientManager.getAllTools();
+                },
+                async executeTool(name, args) {
+                    return mcpClientManager.callTool(name, args);
+                },
+            });
+        }
+        await hostServer.startStdio();
+        return { success: true };
+    });
+    electron_1.ipcMain.handle(types_1.IPC_CHANNELS.MCP_HOST_STOP, async () => {
+        const hostServer = MCPHostServer_1.MCPHostServer.getInstance();
+        await hostServer.stop();
+        return { success: true };
+    });
+    electron_1.ipcMain.handle(types_1.IPC_CHANNELS.MCP_HOST_GET_STATUS, async () => {
+        const hostServer = MCPHostServer_1.MCPHostServer.getInstance();
+        return {
+            running: hostServer.isRunning(),
+            toolCount: hostServer.hasToolProvider() ? MCPClientManager_1.MCPClientManager.getInstance().getAllTools().length : 0,
+        };
+    });
+    // =====================
+    // Built-in Tools Settings Handlers
+    // =====================
+    electron_1.ipcMain.handle(types_1.IPC_CHANNELS.BUILTIN_TOOLS_GET_SETTINGS, async () => {
+        return builtin_settings_1.BuiltinToolsSettingsManager.loadSettings();
+    });
+    electron_1.ipcMain.handle(types_1.IPC_CHANNELS.BUILTIN_TOOLS_SAVE_SETTINGS, async (_, settings) => {
+        builtin_settings_1.BuiltinToolsSettingsManager.saveSettings(settings);
+        builtin_settings_1.BuiltinToolsSettingsManager.clearCache(); // Clear cache to force reload
+        return { success: true };
+    });
+    electron_1.ipcMain.handle(types_1.IPC_CHANNELS.BUILTIN_TOOLS_GET_CATEGORIES, async () => {
+        return builtin_settings_1.BuiltinToolsSettingsManager.getToolsByCategory();
+    });
+    // =====================
+    // Tray (Menu Bar) Handlers
+    // =====================
+    electron_1.ipcMain.handle(types_1.IPC_CHANNELS.TRAY_GET_SETTINGS, async () => {
+        // Import trayManager lazily to avoid circular dependencies
+        const { trayManager } = await Promise.resolve().then(() => __importStar(require('../tray')));
+        return trayManager.getSettings();
+    });
+    electron_1.ipcMain.handle(types_1.IPC_CHANNELS.TRAY_SAVE_SETTINGS, async (_, settings) => {
+        const { trayManager } = await Promise.resolve().then(() => __importStar(require('../tray')));
+        trayManager.saveSettings(settings);
+        return { success: true };
+    });
+    // =====================
+    // Cron (Scheduled Tasks) Handlers
+    // =====================
+    setupCronHandlers();
+}
+/**
+ * Set up Cron (Scheduled Tasks) IPC handlers
+ */
+function setupCronHandlers() {
+    const { getCronService } = require('../cron');
+    // Get service status
+    electron_1.ipcMain.handle(types_1.IPC_CHANNELS.CRON_GET_STATUS, async () => {
+        const service = getCronService();
+        if (!service) {
+            return {
+                enabled: false,
+                storePath: '',
+                jobCount: 0,
+                enabledJobCount: 0,
+                nextWakeAtMs: null,
+            };
+        }
+        return service.status();
+    });
+    // List all jobs
+    electron_1.ipcMain.handle(types_1.IPC_CHANNELS.CRON_LIST_JOBS, async (_, opts) => {
+        const service = getCronService();
+        if (!service)
+            return [];
+        return service.list(opts);
+    });
+    // Get a single job
+    electron_1.ipcMain.handle(types_1.IPC_CHANNELS.CRON_GET_JOB, async (_, id) => {
+        const service = getCronService();
+        if (!service)
+            return null;
+        return service.get(id);
+    });
+    // Add a new job
+    electron_1.ipcMain.handle(types_1.IPC_CHANNELS.CRON_ADD_JOB, async (_, jobData) => {
+        const service = getCronService();
+        if (!service) {
+            return { ok: false, error: 'Cron service not initialized' };
+        }
+        return service.add(jobData);
+    });
+    // Update an existing job
+    electron_1.ipcMain.handle(types_1.IPC_CHANNELS.CRON_UPDATE_JOB, async (_, id, patch) => {
+        const service = getCronService();
+        if (!service) {
+            return { ok: false, error: 'Cron service not initialized' };
+        }
+        return service.update(id, patch);
+    });
+    // Remove a job
+    electron_1.ipcMain.handle(types_1.IPC_CHANNELS.CRON_REMOVE_JOB, async (_, id) => {
+        const service = getCronService();
+        if (!service) {
+            return { ok: false, removed: false, error: 'Cron service not initialized' };
+        }
+        return service.remove(id);
+    });
+    // Run a job immediately
+    electron_1.ipcMain.handle(types_1.IPC_CHANNELS.CRON_RUN_JOB, async (_, id, mode) => {
+        const service = getCronService();
+        if (!service) {
+            return { ok: false, error: 'Cron service not initialized' };
+        }
+        return service.run(id, mode);
+    });
+    // Get run history for a job
+    electron_1.ipcMain.handle('cron:getRunHistory', async (_, id) => {
+        const service = getCronService();
+        if (!service)
+            return null;
+        return service.getRunHistory(id);
+    });
+    // Clear run history for a job
+    electron_1.ipcMain.handle('cron:clearRunHistory', async (_, id) => {
+        const service = getCronService();
+        if (!service)
+            return false;
+        return service.clearRunHistory(id);
+    });
+    // Get webhook status
+    electron_1.ipcMain.handle('cron:getWebhookStatus', async () => {
+        const service = getCronService();
+        if (!service)
+            return { enabled: false };
+        const status = await service.status();
+        return status.webhook ?? { enabled: false };
+    });
+}
+/**
+ * Set up Notification IPC handlers
+ */
+function setupNotificationHandlers() {
+    // Initialize notification service with event forwarding to main window
+    notificationService = new notifications_1.NotificationService({
+        onEvent: (event) => {
+            // Forward notification events to renderer
+            // We need to import BrowserWindow from electron to send to all windows
+            const { BrowserWindow } = require('electron');
+            const windows = BrowserWindow.getAllWindows();
+            for (const win of windows) {
+                if (win.webContents) {
+                    win.webContents.send(types_1.IPC_CHANNELS.NOTIFICATION_EVENT, event);
+                }
+            }
+        },
+    });
+    console.log('[Notifications] Service initialized');
+    // List all notifications
+    electron_1.ipcMain.handle(types_1.IPC_CHANNELS.NOTIFICATION_LIST, async () => {
+        if (!notificationService)
+            return [];
+        return notificationService.list();
+    });
+    // Get unread count
+    electron_1.ipcMain.handle('notification:unreadCount', async () => {
+        if (!notificationService)
+            return 0;
+        return notificationService.getUnreadCount();
+    });
+    // Mark notification as read
+    electron_1.ipcMain.handle(types_1.IPC_CHANNELS.NOTIFICATION_MARK_READ, async (_, id) => {
+        if (!notificationService)
+            return null;
+        return notificationService.markRead(id);
+    });
+    // Mark all notifications as read
+    electron_1.ipcMain.handle(types_1.IPC_CHANNELS.NOTIFICATION_MARK_ALL_READ, async () => {
+        if (!notificationService)
+            return;
+        await notificationService.markAllRead();
+    });
+    // Delete a notification
+    electron_1.ipcMain.handle(types_1.IPC_CHANNELS.NOTIFICATION_DELETE, async (_, id) => {
+        if (!notificationService)
+            return false;
+        return notificationService.delete(id);
+    });
+    // Delete all notifications
+    electron_1.ipcMain.handle(types_1.IPC_CHANNELS.NOTIFICATION_DELETE_ALL, async () => {
+        if (!notificationService)
+            return;
+        await notificationService.deleteAll();
+    });
+    // Add a notification (internal use, for programmatic notifications)
+    electron_1.ipcMain.handle(types_1.IPC_CHANNELS.NOTIFICATION_ADD, async (_, data) => {
+        if (!notificationService)
+            return null;
+        return notificationService.add(data);
+    });
+}
+// Global hooks server instance
+let hooksServer = null;
+let hooksServerStarting = false; // Lock to prevent concurrent server creation
+/**
+ * Get the hooks server instance
+ */
+function getHooksServer() {
+    return hooksServer;
+}
+/**
+ * Set up Hooks (Webhooks & Gmail Pub/Sub) IPC handlers
+ */
+function setupHooksHandlers(agentDaemon) {
+    // Initialize settings manager
+    hooks_1.HooksSettingsManager.initialize();
+    // Get hooks settings
+    electron_1.ipcMain.handle(types_1.IPC_CHANNELS.HOOKS_GET_SETTINGS, async () => {
+        const settings = hooks_1.HooksSettingsManager.getSettingsForDisplay();
+        return {
+            enabled: settings.enabled,
+            token: settings.token,
+            path: settings.path,
+            maxBodyBytes: settings.maxBodyBytes,
+            port: hooks_1.DEFAULT_HOOKS_PORT,
+            host: '127.0.0.1',
+            presets: settings.presets,
+            mappings: settings.mappings,
+            gmail: settings.gmail,
+        };
+    });
+    // Save hooks settings
+    electron_1.ipcMain.handle(types_1.IPC_CHANNELS.HOOKS_SAVE_SETTINGS, async (_, data) => {
+        checkRateLimit(types_1.IPC_CHANNELS.HOOKS_SAVE_SETTINGS, rate_limiter_1.RATE_LIMIT_CONFIGS.limited);
+        const currentSettings = hooks_1.HooksSettingsManager.loadSettings();
+        const updated = hooks_1.HooksSettingsManager.updateConfig({
+            ...currentSettings,
+            enabled: data.enabled ?? currentSettings.enabled,
+            token: data.token ?? currentSettings.token,
+            path: data.path ?? currentSettings.path,
+            maxBodyBytes: data.maxBodyBytes ?? currentSettings.maxBodyBytes,
+            presets: data.presets ?? currentSettings.presets,
+            mappings: data.mappings ?? currentSettings.mappings,
+            gmail: data.gmail ?? currentSettings.gmail,
+        });
+        // Restart hooks server if needed
+        if (hooksServer && updated.enabled) {
+            hooksServer.setHooksConfig(updated);
+        }
+        return {
+            enabled: updated.enabled,
+            token: updated.token ? '***configured***' : '',
+            path: updated.path,
+            maxBodyBytes: updated.maxBodyBytes,
+            port: hooks_1.DEFAULT_HOOKS_PORT,
+            host: '127.0.0.1',
+            presets: updated.presets,
+            mappings: updated.mappings,
+            gmail: updated.gmail,
+        };
+    });
+    // Enable hooks
+    electron_1.ipcMain.handle(types_1.IPC_CHANNELS.HOOKS_ENABLE, async () => {
+        checkRateLimit(types_1.IPC_CHANNELS.HOOKS_ENABLE, rate_limiter_1.RATE_LIMIT_CONFIGS.limited);
+        // Prevent concurrent enable attempts
+        if (hooksServerStarting) {
+            throw new Error('Hooks server is already starting. Please wait.');
+        }
+        const settings = hooks_1.HooksSettingsManager.enableHooks();
+        // Start the hooks server if not running
+        if (!hooksServer) {
+            hooksServerStarting = true;
+            const server = new hooks_1.HooksServer({
+                port: hooks_1.DEFAULT_HOOKS_PORT,
+                host: '127.0.0.1',
+                enabled: true,
+            });
+            server.setHooksConfig(settings);
+            // Set up handlers for hook actions
+            server.setHandlers({
+                onWake: async (action) => {
+                    console.log('[Hooks] Wake action:', action);
+                    // For now, just log. In the future, this could trigger a heartbeat
+                },
+                onAgent: async (action) => {
+                    console.log('[Hooks] Agent action:', action.message.substring(0, 100));
+                    // Create a task for the agent action
+                    const task = await agentDaemon.createTask({
+                        title: action.name || 'Webhook Task',
+                        prompt: action.message,
+                        workspaceId: action.workspaceId || types_1.TEMP_WORKSPACE_ID,
+                    });
+                    return { taskId: task.id };
+                },
+                onEvent: (event) => {
+                    console.log('[Hooks] Server event:', event.action);
+                    // Forward events to renderer (with error handling for destroyed windows)
+                    const windows = electron_1.BrowserWindow.getAllWindows();
+                    for (const win of windows) {
+                        try {
+                            if (win.webContents && !win.isDestroyed()) {
+                                win.webContents.send(types_1.IPC_CHANNELS.HOOKS_EVENT, event);
+                            }
+                        }
+                        catch (err) {
+                            // Window may have been destroyed between check and send
+                            console.warn('[Hooks] Failed to send event to window:', err);
+                        }
+                    }
+                },
+            });
+            try {
+                await server.start();
+                hooksServer = server;
+            }
+            catch (err) {
+                console.error('[Hooks] Failed to start hooks server:', err);
+                throw new Error(`Failed to start hooks server: ${err instanceof Error ? err.message : String(err)}`);
+            }
+            finally {
+                hooksServerStarting = false;
+            }
+        }
+        // Start Gmail watcher if configured (capture result for response)
+        let gmailWatcherError;
+        if (settings.gmail?.account) {
+            try {
+                const result = await (0, hooks_1.startGmailWatcher)(settings);
+                if (!result.started) {
+                    gmailWatcherError = result.reason;
+                    console.warn('[Hooks] Gmail watcher not started:', result.reason);
+                }
+            }
+            catch (err) {
+                gmailWatcherError = err instanceof Error ? err.message : String(err);
+                console.error('[Hooks] Failed to start Gmail watcher:', err);
+            }
+        }
+        return { enabled: true, gmailWatcherError };
+    });
+    // Disable hooks
+    electron_1.ipcMain.handle(types_1.IPC_CHANNELS.HOOKS_DISABLE, async () => {
+        checkRateLimit(types_1.IPC_CHANNELS.HOOKS_DISABLE, rate_limiter_1.RATE_LIMIT_CONFIGS.limited);
+        hooks_1.HooksSettingsManager.disableHooks();
+        // Stop the hooks server
+        if (hooksServer) {
+            await hooksServer.stop();
+            hooksServer = null;
+        }
+        // Stop Gmail watcher
+        await (0, hooks_1.stopGmailWatcher)();
+        return { enabled: false };
+    });
+    // Regenerate hook token
+    electron_1.ipcMain.handle(types_1.IPC_CHANNELS.HOOKS_REGENERATE_TOKEN, async () => {
+        checkRateLimit(types_1.IPC_CHANNELS.HOOKS_REGENERATE_TOKEN, rate_limiter_1.RATE_LIMIT_CONFIGS.limited);
+        const newToken = hooks_1.HooksSettingsManager.regenerateToken();
+        // Update the running server with new token
+        if (hooksServer) {
+            const settings = hooks_1.HooksSettingsManager.loadSettings();
+            hooksServer.setHooksConfig(settings);
+        }
+        return { token: newToken };
+    });
+    // Get hooks status
+    electron_1.ipcMain.handle(types_1.IPC_CHANNELS.HOOKS_GET_STATUS, async () => {
+        const settings = hooks_1.HooksSettingsManager.loadSettings();
+        const gogAvailable = await (0, hooks_1.isGogAvailable)();
+        return {
+            enabled: settings.enabled,
+            serverRunning: hooksServer?.isRunning() ?? false,
+            serverAddress: hooksServer?.getAddress() ?? undefined,
+            gmailWatcherRunning: (0, hooks_1.isGmailWatcherRunning)(),
+            gmailAccount: settings.gmail?.account,
+            gogAvailable,
+        };
+    });
+    // Add a hook mapping
+    electron_1.ipcMain.handle(types_1.IPC_CHANNELS.HOOKS_ADD_MAPPING, async (_, mapping) => {
+        checkRateLimit(types_1.IPC_CHANNELS.HOOKS_ADD_MAPPING, rate_limiter_1.RATE_LIMIT_CONFIGS.limited);
+        // Validate the mapping input
+        const validated = (0, validation_1.validateInput)(validation_2.HookMappingSchema, mapping, 'hook mapping');
+        const settings = hooks_1.HooksSettingsManager.addMapping(validated);
+        // Update the server config if running
+        if (hooksServer) {
+            hooksServer.setHooksConfig(settings);
+        }
+        return { ok: true };
+    });
+    // Remove a hook mapping
+    electron_1.ipcMain.handle(types_1.IPC_CHANNELS.HOOKS_REMOVE_MAPPING, async (_, id) => {
+        checkRateLimit(types_1.IPC_CHANNELS.HOOKS_REMOVE_MAPPING, rate_limiter_1.RATE_LIMIT_CONFIGS.limited);
+        // Validate the mapping ID
+        const validatedId = (0, validation_1.validateInput)(validation_1.StringIdSchema, id, 'mapping ID');
+        const settings = hooks_1.HooksSettingsManager.removeMapping(validatedId);
+        // Update the server config if running
+        if (hooksServer) {
+            hooksServer.setHooksConfig(settings);
+        }
+        return { ok: true };
+    });
+    // Configure Gmail hooks
+    electron_1.ipcMain.handle(types_1.IPC_CHANNELS.HOOKS_CONFIGURE_GMAIL, async (_, config) => {
+        checkRateLimit(types_1.IPC_CHANNELS.HOOKS_CONFIGURE_GMAIL, rate_limiter_1.RATE_LIMIT_CONFIGS.limited);
+        // Generate push token if not provided
+        if (!config.pushToken) {
+            config.pushToken = (0, hooks_1.generateHookToken)();
+        }
+        const settings = hooks_1.HooksSettingsManager.configureGmail(config);
+        // Update the server config if running
+        if (hooksServer) {
+            hooksServer.setHooksConfig(settings);
+        }
+        return {
+            ok: true,
+            gmail: hooks_1.HooksSettingsManager.getGmailConfig(),
+        };
+    });
+    // Get Gmail watcher status
+    electron_1.ipcMain.handle(types_1.IPC_CHANNELS.HOOKS_GET_GMAIL_STATUS, async () => {
+        const settings = hooks_1.HooksSettingsManager.loadSettings();
+        const gogAvailable = await (0, hooks_1.isGogAvailable)();
+        return {
+            configured: hooks_1.HooksSettingsManager.isGmailConfigured(),
+            running: (0, hooks_1.isGmailWatcherRunning)(),
+            account: settings.gmail?.account,
+            topic: settings.gmail?.topic,
+            gogAvailable,
+        };
+    });
+    // Start Gmail watcher manually
+    electron_1.ipcMain.handle(types_1.IPC_CHANNELS.HOOKS_START_GMAIL_WATCHER, async () => {
+        checkRateLimit(types_1.IPC_CHANNELS.HOOKS_START_GMAIL_WATCHER, rate_limiter_1.RATE_LIMIT_CONFIGS.expensive);
+        const settings = hooks_1.HooksSettingsManager.loadSettings();
+        if (!settings.enabled) {
+            return { ok: false, error: 'Hooks must be enabled first' };
+        }
+        if (!hooks_1.HooksSettingsManager.isGmailConfigured()) {
+            return { ok: false, error: 'Gmail hooks not configured' };
+        }
+        const result = await (0, hooks_1.startGmailWatcher)(settings);
+        return { ok: result.started, error: result.reason };
+    });
+    // Stop Gmail watcher manually
+    electron_1.ipcMain.handle(types_1.IPC_CHANNELS.HOOKS_STOP_GMAIL_WATCHER, async () => {
+        checkRateLimit(types_1.IPC_CHANNELS.HOOKS_STOP_GMAIL_WATCHER, rate_limiter_1.RATE_LIMIT_CONFIGS.limited);
+        await (0, hooks_1.stopGmailWatcher)();
+        return { ok: true };
+    });
+    console.log('[Hooks] IPC handlers initialized');
+}
+/**
+ * Broadcast personality settings changed event to all renderer windows.
+ * This allows the UI to stay in sync when settings are changed via tools.
+ */
+function broadcastPersonalitySettingsChanged(settings) {
+    try {
+        const windows = electron_1.BrowserWindow.getAllWindows();
+        for (const win of windows) {
+            try {
+                if (win.webContents && !win.isDestroyed()) {
+                    win.webContents.send(types_1.IPC_CHANNELS.PERSONALITY_SETTINGS_CHANGED, settings);
+                }
+            }
+            catch (err) {
+                // Window may have been destroyed between check and send
+                console.warn('[Personality] Failed to send settings changed event to window:', err);
+            }
+        }
+    }
+    catch (err) {
+        console.error('[Personality] Failed to broadcast settings changed:', err);
+    }
+}
+/**
+ * Set up Memory System IPC handlers
+ */
+function setupMemoryHandlers() {
+    // Get memory settings for a workspace
+    electron_1.ipcMain.handle(types_1.IPC_CHANNELS.MEMORY_GET_SETTINGS, async (_, workspaceId) => {
+        try {
+            return MemoryService_1.MemoryService.getSettings(workspaceId);
+        }
+        catch (error) {
+            console.error('[Memory] Failed to get settings:', error);
+            // Return default settings if service not initialized
+            return {
+                workspaceId,
+                enabled: true,
+                autoCapture: true,
+                compressionEnabled: true,
+                retentionDays: 90,
+                maxStorageMb: 100,
+                privacyMode: 'normal',
+                excludedPatterns: [],
+            };
+        }
+    });
+    // Save memory settings for a workspace
+    electron_1.ipcMain.handle(types_1.IPC_CHANNELS.MEMORY_SAVE_SETTINGS, async (_, data) => {
+        checkRateLimit(types_1.IPC_CHANNELS.MEMORY_SAVE_SETTINGS, rate_limiter_1.RATE_LIMIT_CONFIGS.limited);
+        try {
+            MemoryService_1.MemoryService.updateSettings(data.workspaceId, data.settings);
+            return { success: true };
+        }
+        catch (error) {
+            console.error('[Memory] Failed to save settings:', error);
+            throw error;
+        }
+    });
+    // Search memories
+    electron_1.ipcMain.handle(types_1.IPC_CHANNELS.MEMORY_SEARCH, async (_, data) => {
+        try {
+            return MemoryService_1.MemoryService.search(data.workspaceId, data.query, data.limit);
+        }
+        catch (error) {
+            console.error('[Memory] Failed to search:', error);
+            return [];
+        }
+    });
+    // Get timeline context (Layer 2)
+    electron_1.ipcMain.handle(types_1.IPC_CHANNELS.MEMORY_GET_TIMELINE, async (_, data) => {
+        try {
+            return MemoryService_1.MemoryService.getTimelineContext(data.memoryId, data.windowSize);
+        }
+        catch (error) {
+            console.error('[Memory] Failed to get timeline:', error);
+            return [];
+        }
+    });
+    // Get full details (Layer 3)
+    electron_1.ipcMain.handle(types_1.IPC_CHANNELS.MEMORY_GET_DETAILS, async (_, ids) => {
+        try {
+            return MemoryService_1.MemoryService.getFullDetails(ids);
+        }
+        catch (error) {
+            console.error('[Memory] Failed to get details:', error);
+            return [];
+        }
+    });
+    // Get recent memories
+    electron_1.ipcMain.handle(types_1.IPC_CHANNELS.MEMORY_GET_RECENT, async (_, data) => {
+        try {
+            return MemoryService_1.MemoryService.getRecent(data.workspaceId, data.limit);
+        }
+        catch (error) {
+            console.error('[Memory] Failed to get recent:', error);
+            return [];
+        }
+    });
+    // Get memory statistics
+    electron_1.ipcMain.handle(types_1.IPC_CHANNELS.MEMORY_GET_STATS, async (_, workspaceId) => {
+        try {
+            return MemoryService_1.MemoryService.getStats(workspaceId);
+        }
+        catch (error) {
+            console.error('[Memory] Failed to get stats:', error);
+            return { count: 0, totalTokens: 0, compressedCount: 0, compressionRatio: 0 };
+        }
+    });
+    // Clear all memories for a workspace
+    electron_1.ipcMain.handle(types_1.IPC_CHANNELS.MEMORY_CLEAR, async (_, workspaceId) => {
+        checkRateLimit(types_1.IPC_CHANNELS.MEMORY_CLEAR, rate_limiter_1.RATE_LIMIT_CONFIGS.limited);
+        try {
+            MemoryService_1.MemoryService.clearWorkspace(workspaceId);
+            return { success: true };
+        }
+        catch (error) {
+            console.error('[Memory] Failed to clear:', error);
+            throw error;
+        }
+    });
+    console.log('[Memory] Handlers initialized');
+    // === Migration Status Handlers ===
+    // These handlers help show one-time notifications after app migration (cowork-oss → cowork-os)
+    const userDataPath = electron_1.app.getPath('userData');
+    const migrationMarkerPath = path.join(userDataPath, '.migrated-from-cowork-oss');
+    const notificationDismissedPath = path.join(userDataPath, '.migration-notification-dismissed');
+    // Get migration status
+    electron_1.ipcMain.handle(types_1.IPC_CHANNELS.MIGRATION_GET_STATUS, async () => {
+        try {
+            const migrated = fsSync.existsSync(migrationMarkerPath);
+            const notificationDismissed = fsSync.existsSync(notificationDismissedPath);
+            let timestamp;
+            if (migrated) {
+                try {
+                    const markerContent = fsSync.readFileSync(migrationMarkerPath, 'utf-8');
+                    const markerData = JSON.parse(markerContent);
+                    timestamp = markerData.timestamp;
+                }
+                catch {
+                    // Old format marker or read error
+                }
+            }
+            return {
+                migrated,
+                notificationDismissed,
+                timestamp,
+            };
+        }
+        catch (error) {
+            console.error('[Migration] Failed to get status:', error);
+            return { migrated: false, notificationDismissed: true }; // Default to no notification on error
+        }
+    });
+    // Dismiss migration notification (user has acknowledged it)
+    electron_1.ipcMain.handle(types_1.IPC_CHANNELS.MIGRATION_DISMISS_NOTIFICATION, async () => {
+        try {
+            fsSync.writeFileSync(notificationDismissedPath, JSON.stringify({
+                dismissedAt: new Date().toISOString(),
+            }));
+            console.log('[Migration] Notification dismissed');
+            return { success: true };
+        }
+        catch (error) {
+            console.error('[Migration] Failed to dismiss notification:', error);
+            throw error;
+        }
+    });
+    console.log('[Migration] Handlers initialized');
+    // === Extension / Plugin Handlers ===
+    // eslint-disable-next-line @typescript-eslint/no-var-requires
+    const { getPluginRegistry } = require('../extensions/registry');
+    // List all extensions
+    electron_1.ipcMain.handle(types_1.IPC_CHANNELS.EXTENSIONS_LIST, async () => {
+        try {
+            const registry = getPluginRegistry();
+            const plugins = registry.getPlugins();
+            return plugins.map((p) => ({
+                name: p.manifest.name,
+                displayName: p.manifest.displayName,
+                version: p.manifest.version,
+                description: p.manifest.description,
+                author: p.manifest.author,
+                type: p.manifest.type,
+                state: p.state,
+                path: p.path,
+                loadedAt: p.loadedAt.getTime(),
+                error: p.error?.message,
+                capabilities: p.manifest.capabilities,
+                configSchema: p.manifest.configSchema,
+            }));
+        }
+        catch (error) {
+            console.error('[Extensions] Failed to list:', error);
+            return [];
+        }
+    });
+    // Get single extension
+    electron_1.ipcMain.handle(types_1.IPC_CHANNELS.EXTENSIONS_GET, async (_, name) => {
+        try {
+            const registry = getPluginRegistry();
+            const plugin = registry.getPlugin(name);
+            if (!plugin)
+                return null;
+            return {
+                name: plugin.manifest.name,
+                displayName: plugin.manifest.displayName,
+                version: plugin.manifest.version,
+                description: plugin.manifest.description,
+                author: plugin.manifest.author,
+                type: plugin.manifest.type,
+                state: plugin.state,
+                path: plugin.path,
+                loadedAt: plugin.loadedAt.getTime(),
+                error: plugin.error?.message,
+                capabilities: plugin.manifest.capabilities,
+                configSchema: plugin.manifest.configSchema,
+            };
+        }
+        catch (error) {
+            console.error('[Extensions] Failed to get:', error);
+            return null;
+        }
+    });
+    // Enable extension
+    electron_1.ipcMain.handle(types_1.IPC_CHANNELS.EXTENSIONS_ENABLE, async (_, name) => {
+        try {
+            const registry = getPluginRegistry();
+            await registry.enablePlugin(name);
+            return { success: true };
+        }
+        catch (error) {
+            console.error('[Extensions] Failed to enable:', error);
+            return { success: false, error: error.message };
+        }
+    });
+    // Disable extension
+    electron_1.ipcMain.handle(types_1.IPC_CHANNELS.EXTENSIONS_DISABLE, async (_, name) => {
+        try {
+            const registry = getPluginRegistry();
+            await registry.disablePlugin(name);
+            return { success: true };
+        }
+        catch (error) {
+            console.error('[Extensions] Failed to disable:', error);
+            return { success: false, error: error.message };
+        }
+    });
+    // Reload extension
+    electron_1.ipcMain.handle(types_1.IPC_CHANNELS.EXTENSIONS_RELOAD, async (_, name) => {
+        try {
+            const registry = getPluginRegistry();
+            await registry.reloadPlugin(name);
+            return { success: true };
+        }
+        catch (error) {
+            console.error('[Extensions] Failed to reload:', error);
+            return { success: false, error: error.message };
+        }
+    });
+    // Get extension config
+    electron_1.ipcMain.handle(types_1.IPC_CHANNELS.EXTENSIONS_GET_CONFIG, async (_, name) => {
+        try {
+            const registry = getPluginRegistry();
+            return registry.getPluginConfig(name) || {};
+        }
+        catch (error) {
+            console.error('[Extensions] Failed to get config:', error);
+            return {};
+        }
+    });
+    // Set extension config
+    electron_1.ipcMain.handle(types_1.IPC_CHANNELS.EXTENSIONS_SET_CONFIG, async (_, data) => {
+        try {
+            const registry = getPluginRegistry();
+            await registry.setPluginConfig(data.name, data.config);
+            return { success: true };
+        }
+        catch (error) {
+            console.error('[Extensions] Failed to set config:', error);
+            return { success: false, error: error.message };
+        }
+    });
+    // Discover extensions (re-scan directories)
+    electron_1.ipcMain.handle(types_1.IPC_CHANNELS.EXTENSIONS_DISCOVER, async () => {
+        try {
+            const registry = getPluginRegistry();
+            await registry.initialize();
+            const plugins = registry.getPlugins();
+            return plugins.map((p) => ({
+                name: p.manifest.name,
+                displayName: p.manifest.displayName,
+                version: p.manifest.version,
+                description: p.manifest.description,
+                type: p.manifest.type,
+                state: p.state,
+            }));
+        }
+        catch (error) {
+            console.error('[Extensions] Failed to discover:', error);
+            return [];
+        }
+    });
+    console.log('[Extensions] Handlers initialized');
+    // === Webhook Tunnel Handlers ===
+    let tunnelManager = null;
+    // Get tunnel status
+    electron_1.ipcMain.handle(types_1.IPC_CHANNELS.TUNNEL_GET_STATUS, async () => {
+        try {
+            if (!tunnelManager) {
+                return { status: 'stopped' };
+            }
+            return {
+                status: tunnelManager.status,
+                provider: tunnelManager.config?.provider,
+                url: tunnelManager.url,
+                error: tunnelManager.error?.message,
+                startedAt: tunnelManager.startedAt?.getTime(),
+            };
+        }
+        catch (error) {
+            console.error('[Tunnel] Failed to get status:', error);
+            return { status: 'stopped' };
+        }
+    });
+    // Start tunnel
+    electron_1.ipcMain.handle(types_1.IPC_CHANNELS.TUNNEL_START, async (_, config) => {
+        try {
+            const { TunnelManager } = await Promise.resolve().then(() => __importStar(require('../gateway/tunnel')));
+            if (tunnelManager) {
+                await tunnelManager.stop();
+            }
+            tunnelManager = new TunnelManager(config);
+            const url = await tunnelManager.start();
+            return { success: true, url };
+        }
+        catch (error) {
+            console.error('[Tunnel] Failed to start:', error);
+            return { success: false, error: error.message };
+        }
+    });
+    // Stop tunnel
+    electron_1.ipcMain.handle(types_1.IPC_CHANNELS.TUNNEL_STOP, async () => {
+        try {
+            if (tunnelManager) {
+                await tunnelManager.stop();
+                tunnelManager = null;
+            }
+            return { success: true };
+        }
+        catch (error) {
+            console.error('[Tunnel] Failed to stop:', error);
+            return { success: false, error: error.message };
+        }
+    });
+    console.log('[Tunnel] Handlers initialized');
+    // === Voice Mode Handlers ===
+    // Initialize voice settings manager with secure database storage
+    const voiceDb = schema_1.DatabaseManager.getInstance().getDatabase();
+    voice_settings_manager_1.VoiceSettingsManager.initialize(voiceDb);
+    // Get voice settings
+    electron_1.ipcMain.handle(types_1.IPC_CHANNELS.VOICE_GET_SETTINGS, async () => {
+        try {
+            return voice_settings_manager_1.VoiceSettingsManager.loadSettings();
+        }
+        catch (error) {
+            console.error('[Voice] Failed to get settings:', error);
+            throw error;
+        }
+    });
+    // Save voice settings
+    electron_1.ipcMain.handle(types_1.IPC_CHANNELS.VOICE_SAVE_SETTINGS, async (_, settings) => {
+        try {
+            const updated = voice_settings_manager_1.VoiceSettingsManager.updateSettings(settings);
+            // Update the voice service with new settings
+            const voiceService = (0, VoiceService_1.getVoiceService)();
+            voiceService.updateSettings(updated);
+            return updated;
+        }
+        catch (error) {
+            console.error('[Voice] Failed to save settings:', error);
+            throw error;
+        }
+    });
+    // Get voice state
+    electron_1.ipcMain.handle(types_1.IPC_CHANNELS.VOICE_GET_STATE, async () => {
+        try {
+            const voiceService = (0, VoiceService_1.getVoiceService)();
+            return voiceService.getState();
+        }
+        catch (error) {
+            console.error('[Voice] Failed to get state:', error);
+            throw error;
+        }
+    });
+    // Speak text - returns audio data for renderer to play
+    electron_1.ipcMain.handle(types_1.IPC_CHANNELS.VOICE_SPEAK, async (_, text) => {
+        try {
+            const voiceService = (0, VoiceService_1.getVoiceService)();
+            const audioBuffer = await voiceService.speak(text);
+            if (audioBuffer) {
+                // Return audio data as array for serialization over IPC
+                return { success: true, audioData: Array.from(audioBuffer) };
+            }
+            return { success: true, audioData: null };
+        }
+        catch (error) {
+            console.error('[Voice] Failed to speak:', error);
+            return { success: false, error: error.message, audioData: null };
+        }
+    });
+    // Stop speaking
+    electron_1.ipcMain.handle(types_1.IPC_CHANNELS.VOICE_STOP_SPEAKING, async () => {
+        try {
+            const voiceService = (0, VoiceService_1.getVoiceService)();
+            voiceService.stopSpeaking();
+            return { success: true };
+        }
+        catch (error) {
+            console.error('[Voice] Failed to stop speaking:', error);
+            return { success: false, error: error.message };
+        }
+    });
+    // Transcribe audio - accepts audio data as array from renderer
+    electron_1.ipcMain.handle(types_1.IPC_CHANNELS.VOICE_TRANSCRIBE, async (_, audioData) => {
+        try {
+            const voiceService = (0, VoiceService_1.getVoiceService)();
+            // Convert array back to Buffer
+            const audioBuffer = Buffer.from(audioData);
+            const text = await voiceService.transcribe(audioBuffer);
+            return { text };
+        }
+        catch (error) {
+            console.error('[Voice] Failed to transcribe:', error);
+            return { text: '', error: error.message };
+        }
+    });
+    // Get ElevenLabs voices
+    electron_1.ipcMain.handle(types_1.IPC_CHANNELS.VOICE_GET_ELEVENLABS_VOICES, async () => {
+        try {
+            const voiceService = (0, VoiceService_1.getVoiceService)();
+            return await voiceService.getElevenLabsVoices();
+        }
+        catch (error) {
+            console.error('[Voice] Failed to get ElevenLabs voices:', error);
+            return [];
+        }
+    });
+    // Test ElevenLabs connection
+    electron_1.ipcMain.handle(types_1.IPC_CHANNELS.VOICE_TEST_ELEVENLABS, async () => {
+        try {
+            const voiceService = (0, VoiceService_1.getVoiceService)();
+            return await voiceService.testElevenLabsConnection();
+        }
+        catch (error) {
+            console.error('[Voice] Failed to test ElevenLabs:', error);
+            return { success: false, error: error.message };
+        }
+    });
+    // Test OpenAI voice connection
+    electron_1.ipcMain.handle(types_1.IPC_CHANNELS.VOICE_TEST_OPENAI, async () => {
+        try {
+            const voiceService = (0, VoiceService_1.getVoiceService)();
+            return await voiceService.testOpenAIConnection();
+        }
+        catch (error) {
+            console.error('[Voice] Failed to test OpenAI voice:', error);
+            return { success: false, error: error.message };
+        }
+    });
+    // Test Azure OpenAI voice connection
+    electron_1.ipcMain.handle(types_1.IPC_CHANNELS.VOICE_TEST_AZURE, async () => {
+        try {
+            const voiceService = (0, VoiceService_1.getVoiceService)();
+            return await voiceService.testAzureConnection();
+        }
+        catch (error) {
+            console.error('[Voice] Failed to test Azure OpenAI voice:', error);
+            return { success: false, error: error.message };
+        }
+    });
+    // Initialize voice service with saved settings
+    const savedVoiceSettings = voice_settings_manager_1.VoiceSettingsManager.loadSettings();
+    const voiceService = (0, VoiceService_1.getVoiceService)({ settings: savedVoiceSettings });
+    // Forward voice events to renderer
+    voiceService.on('stateChange', (state) => {
+        const mainWindow = getMainWindow();
+        if (mainWindow) {
+            mainWindow.webContents.send(types_1.IPC_CHANNELS.VOICE_EVENT, {
+                type: 'voice:state-changed',
+                data: state,
+            });
+        }
+    });
+    voiceService.on('speakingStart', (text) => {
+        const mainWindow = getMainWindow();
+        if (mainWindow) {
+            mainWindow.webContents.send(types_1.IPC_CHANNELS.VOICE_EVENT, {
+                type: 'voice:speaking-start',
+                data: text,
+            });
+        }
+    });
+    voiceService.on('speakingEnd', () => {
+        const mainWindow = getMainWindow();
+        if (mainWindow) {
+            mainWindow.webContents.send(types_1.IPC_CHANNELS.VOICE_EVENT, {
+                type: 'voice:speaking-end',
+                data: null,
+            });
+        }
+    });
+    voiceService.on('transcript', (text) => {
+        const mainWindow = getMainWindow();
+        if (mainWindow) {
+            mainWindow.webContents.send(types_1.IPC_CHANNELS.VOICE_EVENT, {
+                type: 'voice:transcript',
+                data: text,
+            });
+        }
+    });
+    voiceService.on('error', (error) => {
+        const mainWindow = getMainWindow();
+        if (mainWindow) {
+            mainWindow.webContents.send(types_1.IPC_CHANNELS.VOICE_EVENT, {
+                type: 'voice:error',
+                data: { message: error.message },
+            });
+        }
+    });
+    // Initialize voice service
+    voiceService.initialize().catch((err) => {
+        console.error('[Voice] Failed to initialize:', err);
+    });
+    console.log('[Voice] Handlers initialized');
+}