cowork-os 0.3.21

package/dist/electron/electron/agent/daemon.js

@@ -0,0 +1,975 @@
+"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;
+    };
+})();
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.AgentDaemon = void 0;
+const events_1 = require("events");
+const electron_1 = require("electron");
+const fs = __importStar(require("fs"));
+const crypto = __importStar(require("crypto"));
+const repositories_1 = require("../database/repositories");
+const ActivityRepository_1 = require("../activity/ActivityRepository");
+const types_1 = require("../../shared/types");
+const executor_1 = require("./executor");
+const queue_manager_1 = require("./queue-manager");
+const concurrency_1 = require("../security/concurrency");
+const MemoryService_1 = require("../memory/MemoryService");
+// Memory management constants
+const MAX_CACHED_EXECUTORS = 10; // Maximum number of completed task executors to keep in memory
+const EXECUTOR_CACHE_TTL_MS = 30 * 60 * 1000; // 30 minutes - time before completed executors are cleaned up
+/**
+ * AgentDaemon is the core orchestrator that manages task execution
+ * It coordinates between the database, task executors, and UI
+ */
+class AgentDaemon extends events_1.EventEmitter {
+    constructor(dbManager) {
+        super();
+        this.dbManager = dbManager;
+        this.activeTasks = new Map();
+        this.pendingApprovals = new Map();
+        const db = dbManager.getDatabase();
+        this.taskRepo = new repositories_1.TaskRepository(db);
+        this.eventRepo = new repositories_1.TaskEventRepository(db);
+        this.workspaceRepo = new repositories_1.WorkspaceRepository(db);
+        this.approvalRepo = new repositories_1.ApprovalRepository(db);
+        this.artifactRepo = new repositories_1.ArtifactRepository(db);
+        this.activityRepo = new ActivityRepository_1.ActivityRepository(db);
+        // Initialize queue manager with callbacks
+        this.queueManager = new queue_manager_1.TaskQueueManager({
+            startTaskImmediate: (task) => this.startTaskImmediate(task),
+            emitQueueUpdate: (status) => this.emitQueueUpdate(status),
+            getTaskById: (taskId) => this.taskRepo.findById(taskId),
+            updateTaskStatus: (taskId, status) => this.taskRepo.update(taskId, { status }),
+            onTaskTimeout: (taskId) => this.handleTaskTimeout(taskId),
+        });
+        // Start periodic cleanup of old executors
+        this.cleanupIntervalHandle = setInterval(() => this.cleanupOldExecutors(), 5 * 60 * 1000); // Run every 5 minutes
+    }
+    /**
+     * Initialize the daemon - call after construction to set up queue
+     */
+    async initialize() {
+        // Find queued tasks from database for queue recovery
+        const queuedTasks = this.taskRepo.findByStatus('queued');
+        // Find "running" tasks from previous session - these are orphaned since we lost their executors
+        const orphanedTasks = this.taskRepo.findByStatus(['planning', 'executing']);
+        // Mark orphaned tasks as failed - they can't be resumed since we lost their state
+        if (orphanedTasks.length > 0) {
+            console.log(`[AgentDaemon] Found ${orphanedTasks.length} orphaned tasks from previous session, marking as failed`);
+            for (const task of orphanedTasks) {
+                this.taskRepo.update(task.id, {
+                    status: 'failed',
+                    error: 'Task interrupted - application was restarted while task was running',
+                });
+            }
+        }
+        // Only initialize queue with queued tasks (not orphaned "running" tasks)
+        await this.queueManager.initialize(queuedTasks, []);
+    }
+    /**
+     * Clean up old completed task executors to prevent memory leaks
+     */
+    cleanupOldExecutors() {
+        const now = Date.now();
+        const toDelete = [];
+        let completedCount = 0;
+        // Find executors to clean up
+        this.activeTasks.forEach((cached, taskId) => {
+            if (cached.status === 'completed') {
+                completedCount++;
+                // Remove if older than TTL
+                if (now - cached.lastAccessed > EXECUTOR_CACHE_TTL_MS) {
+                    toDelete.push(taskId);
+                }
+            }
+        });
+        // Also remove oldest completed executors if we have too many
+        if (completedCount > MAX_CACHED_EXECUTORS) {
+            const completedTasks = Array.from(this.activeTasks.entries())
+                .filter(([_, cached]) => cached.status === 'completed')
+                .sort((a, b) => a[1].lastAccessed - b[1].lastAccessed);
+            const excessCount = completedCount - MAX_CACHED_EXECUTORS;
+            for (let i = 0; i < excessCount; i++) {
+                const [taskId] = completedTasks[i];
+                if (!toDelete.includes(taskId)) {
+                    toDelete.push(taskId);
+                }
+            }
+        }
+        // Delete the marked executors
+        for (const taskId of toDelete) {
+            console.log(`[AgentDaemon] Cleaning up cached executor for task ${taskId}`);
+            this.activeTasks.delete(taskId);
+        }
+        if (toDelete.length > 0) {
+            console.log(`[AgentDaemon] Cleaned up ${toDelete.length} old executor(s). Active: ${this.activeTasks.size}`);
+        }
+    }
+    /**
+     * Queue a task for execution
+     * The task will either start immediately or be queued based on concurrency limits
+     */
+    async startTask(task) {
+        await this.queueManager.enqueue(task);
+    }
+    /**
+     * Start executing a task immediately (internal - called by queue manager)
+     */
+    async startTaskImmediate(task) {
+        console.log(`[AgentDaemon] Starting task ${task.id}: ${task.title}`);
+        // Get workspace details
+        const workspace = this.workspaceRepo.findById(task.workspaceId);
+        if (!workspace) {
+            throw new Error(`Workspace ${task.workspaceId} not found`);
+        }
+        console.log(`[AgentDaemon] Workspace found: ${workspace.name}`);
+        // Create task executor - wrapped in try-catch to handle provider initialization errors
+        let executor;
+        try {
+            console.log(`[AgentDaemon] Creating TaskExecutor...`);
+            executor = new executor_1.TaskExecutor(task, workspace, this);
+            console.log(`[AgentDaemon] TaskExecutor created successfully`);
+        }
+        catch (error) {
+            console.error(`[AgentDaemon] Task ${task.id} failed to initialize:`, error);
+            this.taskRepo.update(task.id, {
+                status: 'failed',
+                error: error.message || 'Failed to initialize task executor',
+                completedAt: Date.now(),
+            });
+            this.logEvent(task.id, 'error', { error: error.message });
+            // Notify queue manager so it can start next task
+            this.queueManager.onTaskFinished(task.id);
+            return;
+        }
+        this.activeTasks.set(task.id, {
+            executor,
+            lastAccessed: Date.now(),
+            status: 'active',
+        });
+        // Update task status
+        this.taskRepo.update(task.id, { status: 'planning' });
+        this.logEvent(task.id, 'task_created', { task });
+        console.log(`[AgentDaemon] Task status updated to 'planning', starting execution...`);
+        // Start execution (non-blocking)
+        executor.execute().catch(error => {
+            console.error(`[AgentDaemon] Task ${task.id} execution failed:`, error);
+            this.taskRepo.update(task.id, {
+                status: 'failed',
+                error: error.message,
+                completedAt: Date.now(),
+            });
+            this.logEvent(task.id, 'error', { error: error.message });
+            this.activeTasks.delete(task.id);
+            // Notify queue manager so it can start next task
+            this.queueManager.onTaskFinished(task.id);
+        });
+    }
+    /**
+     * Create a new task in the database and start it
+     * This is a convenience method used by the cron service
+     */
+    async createTask(params) {
+        const task = this.taskRepo.create({
+            title: params.title,
+            prompt: params.prompt,
+            status: 'pending',
+            workspaceId: params.workspaceId,
+            budgetTokens: params.budgetTokens,
+            budgetCost: params.budgetCost,
+        });
+        // Start the task (will be queued if necessary)
+        await this.startTask(task);
+        return task;
+    }
+    /**
+     * Get a task by its ID
+     */
+    async getTaskById(taskId) {
+        return this.taskRepo.findById(taskId);
+    }
+    /**
+     * Get all child tasks for a given parent task
+     */
+    async getChildTasks(parentTaskId) {
+        return this.taskRepo.findByParent(parentTaskId);
+    }
+    /**
+     * Create a child task (sub-agent or parallel agent)
+     */
+    async createChildTask(params) {
+        const task = this.taskRepo.create({
+            title: params.title,
+            prompt: params.prompt,
+            status: 'pending',
+            workspaceId: params.workspaceId,
+            parentTaskId: params.parentTaskId,
+            agentType: params.agentType,
+            agentConfig: params.agentConfig,
+            depth: params.depth ?? 0,
+            budgetTokens: params.budgetTokens,
+            budgetCost: params.budgetCost,
+        });
+        // Start the task (will be queued if necessary)
+        await this.startTask(task);
+        return task;
+    }
+    /**
+     * Cancel a running or queued task
+     */
+    async cancelTask(taskId) {
+        // Check if task is queued (not yet started)
+        if (this.queueManager.cancelQueuedTask(taskId)) {
+            this.taskRepo.update(taskId, { status: 'cancelled', completedAt: Date.now() });
+            this.logEvent(taskId, 'task_cancelled', {
+                message: 'Task removed from queue',
+            });
+            return;
+        }
+        // Task is running - cancel it
+        const cached = this.activeTasks.get(taskId);
+        if (cached) {
+            await cached.executor.cancel();
+            this.activeTasks.delete(taskId);
+        }
+        // Always notify queue manager to remove from running set
+        // (handles orphaned tasks that are in runningTaskIds but have no executor)
+        this.queueManager.onTaskFinished(taskId);
+        // Always emit cancelled event so UI updates
+        this.logEvent(taskId, 'task_cancelled', {
+            message: 'Task was stopped by user',
+        });
+    }
+    /**
+     * Pause a running task
+     */
+    async pauseTask(taskId) {
+        const cached = this.activeTasks.get(taskId);
+        if (cached) {
+            cached.lastAccessed = Date.now();
+            await cached.executor.pause();
+        }
+    }
+    /**
+     * Resume a paused task
+     */
+    async resumeTask(taskId) {
+        const cached = this.activeTasks.get(taskId);
+        if (cached) {
+            cached.lastAccessed = Date.now();
+            cached.status = 'active';
+            this.updateTaskStatus(taskId, 'executing');
+            this.logEvent(taskId, 'task_resumed', { message: 'Task resumed' });
+            await cached.executor.resume();
+        }
+    }
+    /**
+     * Send stdin input to a running command in a task
+     */
+    sendStdinToTask(taskId, input) {
+        const cached = this.activeTasks.get(taskId);
+        if (!cached) {
+            return false;
+        }
+        return cached.executor.sendStdin(input);
+    }
+    /**
+     * Kill the running command in a task (send SIGINT like Ctrl+C)
+     * @param taskId - The task ID
+     * @param force - If true, send SIGKILL immediately instead of graceful escalation
+     */
+    killCommandInTask(taskId, force) {
+        const cached = this.activeTasks.get(taskId);
+        if (!cached) {
+            return false;
+        }
+        return cached.executor.killShellProcess(force);
+    }
+    /**
+     * Request approval from user for an action
+     */
+    async requestApproval(taskId, type, description, details) {
+        const approval = this.approvalRepo.create({
+            taskId,
+            type: type,
+            description,
+            details,
+            status: 'pending',
+            requestedAt: Date.now(),
+        });
+        // Emit event to UI
+        this.logEvent(taskId, 'approval_requested', { approval });
+        // Wait for user response
+        return new Promise((resolve, reject) => {
+            // Timeout after 5 minutes
+            const timeoutHandle = setTimeout(() => {
+                const pending = this.pendingApprovals.get(approval.id);
+                if (pending && !pending.resolved) {
+                    pending.resolved = true;
+                    this.pendingApprovals.delete(approval.id);
+                    this.approvalRepo.update(approval.id, 'denied');
+                    this.logEvent(taskId, 'approval_denied', { approvalId: approval.id, reason: 'timeout' });
+                    reject(new Error('Approval request timed out'));
+                }
+            }, 5 * 60 * 1000);
+            this.pendingApprovals.set(approval.id, { taskId, resolve, reject, resolved: false, timeoutHandle });
+        });
+    }
+    /**
+     * Respond to an approval request
+     * Uses idempotency to prevent double-approval race conditions
+     * Implements C6: Approval Gate Enforcement
+     */
+    async respondToApproval(approvalId, approved) {
+        // Generate idempotency key for this approval response
+        const idempotencyKey = concurrency_1.IdempotencyManager.generateKey('approval:respond', approvalId, approved ? 'approve' : 'deny');
+        // Check if this exact response was already processed
+        const existing = concurrency_1.approvalIdempotency.check(idempotencyKey);
+        if (existing.exists) {
+            console.log(`[AgentDaemon] Duplicate approval response ignored: ${approvalId}`);
+            return; // Silently ignore duplicate
+        }
+        // Start tracking this operation
+        if (!concurrency_1.approvalIdempotency.start(idempotencyKey)) {
+            console.log(`[AgentDaemon] Concurrent approval response in progress: ${approvalId}`);
+            return; // Another response is being processed
+        }
+        try {
+            const pending = this.pendingApprovals.get(approvalId);
+            if (pending && !pending.resolved) {
+                // Mark as resolved first to prevent race condition with timeout
+                pending.resolved = true;
+                // Clear the timeout
+                clearTimeout(pending.timeoutHandle);
+                this.pendingApprovals.delete(approvalId);
+                this.approvalRepo.update(approvalId, approved ? 'approved' : 'denied');
+                // Emit event so UI knows the approval has been handled
+                const eventType = approved ? 'approval_granted' : 'approval_denied';
+                this.logEvent(pending.taskId, eventType, { approvalId });
+                if (approved) {
+                    pending.resolve(true);
+                }
+                else {
+                    pending.reject(new Error('User denied approval'));
+                }
+            }
+            concurrency_1.approvalIdempotency.complete(idempotencyKey, { success: true });
+        }
+        catch (error) {
+            concurrency_1.approvalIdempotency.fail(idempotencyKey, error);
+            throw error;
+        }
+    }
+    /**
+     * Log an event for a task
+     */
+    logEvent(taskId, type, payload) {
+        this.eventRepo.create({
+            taskId,
+            timestamp: Date.now(),
+            type: type,
+            payload,
+        });
+        this.logActivityForEvent(taskId, type, payload);
+        this.emitTaskEvent(taskId, type, payload);
+        // Capture to memory system (async, don't block)
+        this.captureToMemory(taskId, type, payload).catch((error) => {
+            // Silently log - memory capture is optional enhancement
+            console.debug('[AgentDaemon] Memory capture failed:', error);
+        });
+    }
+    /**
+     * Capture task event to memory system for cross-session context
+     */
+    async captureToMemory(taskId, type, payload) {
+        // Map event types to memory types
+        const memoryTypeMap = {
+            tool_call: 'observation',
+            tool_result: 'observation',
+            tool_error: 'error',
+            step_started: 'observation',
+            step_completed: 'observation',
+            step_failed: 'error',
+            assistant_message: 'observation',
+            plan_created: 'decision',
+            plan_revised: 'decision',
+            error: 'error',
+            verification_passed: 'insight',
+            verification_failed: 'error',
+            file_created: 'observation',
+            file_modified: 'observation',
+        };
+        const memoryType = memoryTypeMap[type];
+        if (!memoryType)
+            return;
+        const task = this.taskRepo.findById(taskId);
+        if (!task)
+            return;
+        // Build content string based on event type
+        let content = '';
+        if (type === 'tool_call') {
+            content = `Tool called: ${payload.tool || payload.name}\nInput: ${JSON.stringify(payload.input, null, 2)}`;
+        }
+        else if (type === 'tool_result') {
+            const result = typeof payload.result === 'string' ? payload.result : JSON.stringify(payload.result);
+            content = `Tool result for ${payload.tool || payload.name}:\n${result}`;
+        }
+        else if (type === 'tool_error') {
+            content = `Tool error for ${payload.tool || payload.name}: ${payload.error}`;
+        }
+        else if (type === 'assistant_message') {
+            content = payload.content || payload.message || JSON.stringify(payload);
+        }
+        else if (type === 'plan_created' || type === 'plan_revised') {
+            content = `Plan ${type === 'plan_revised' ? 'revised' : 'created'}:\n${JSON.stringify(payload.plan || payload, null, 2)}`;
+        }
+        else if (type === 'step_completed') {
+            content = `Step completed: ${payload.step?.description || JSON.stringify(payload)}`;
+        }
+        else if (type === 'step_failed') {
+            content = `Step failed: ${payload.step?.description || ''}\nError: ${payload.error || 'Unknown error'}`;
+        }
+        else if (type === 'file_created' || type === 'file_modified') {
+            content = `File ${type === 'file_created' ? 'created' : 'modified'}: ${payload.path}`;
+        }
+        else if (type === 'verification_passed') {
+            content = `Verification passed: ${payload.message || 'Task completed successfully'}`;
+        }
+        else if (type === 'verification_failed') {
+            content = `Verification failed: ${payload.message || payload.error || 'Unknown failure'}`;
+        }
+        else {
+            content = JSON.stringify(payload);
+        }
+        // Truncate very long content
+        if (content.length > 5000) {
+            content = content.slice(0, 5000) + '\n[... truncated]';
+        }
+        await MemoryService_1.MemoryService.capture(task.workspaceId, taskId, memoryType, content);
+    }
+    /**
+     * Log notable task events to the Activity feed
+     */
+    logActivityForEvent(taskId, type, payload) {
+        const task = this.taskRepo.findById(taskId);
+        if (!task)
+            return;
+        const activity = this.buildActivityFromEvent(task, type, payload);
+        if (!activity)
+            return;
+        const created = this.activityRepo.create(activity);
+        this.emitActivityEvent(created);
+    }
+    buildActivityFromEvent(task, type, payload) {
+        const actorType = task.assignedAgentRoleId ? 'agent' : 'system';
+        const agentRoleId = task.assignedAgentRoleId;
+        const activityType = type;
+        switch (type) {
+            case 'task_created':
+                return {
+                    workspaceId: task.workspaceId,
+                    taskId: task.id,
+                    agentRoleId,
+                    actorType,
+                    activityType,
+                    title: 'Task created',
+                    description: task.title,
+                };
+            case 'task_completed':
+                return {
+                    workspaceId: task.workspaceId,
+                    taskId: task.id,
+                    agentRoleId,
+                    actorType,
+                    activityType,
+                    title: 'Task completed',
+                    description: task.title,
+                };
+            case 'executing':
+                return {
+                    workspaceId: task.workspaceId,
+                    taskId: task.id,
+                    agentRoleId,
+                    actorType,
+                    activityType: 'task_started',
+                    title: 'Task started',
+                    description: task.title,
+                };
+            case 'task_cancelled':
+                return {
+                    workspaceId: task.workspaceId,
+                    taskId: task.id,
+                    agentRoleId,
+                    actorType,
+                    activityType: 'info',
+                    title: 'Task cancelled',
+                    description: task.title,
+                };
+            case 'task_paused':
+                return {
+                    workspaceId: task.workspaceId,
+                    taskId: task.id,
+                    agentRoleId,
+                    actorType,
+                    activityType,
+                    title: 'Task paused',
+                    description: task.title,
+                };
+            case 'task_resumed':
+                return {
+                    workspaceId: task.workspaceId,
+                    taskId: task.id,
+                    agentRoleId,
+                    actorType,
+                    activityType,
+                    title: 'Task resumed',
+                    description: task.title,
+                };
+            case 'approval_requested':
+                return {
+                    workspaceId: task.workspaceId,
+                    taskId: task.id,
+                    agentRoleId,
+                    actorType,
+                    activityType: 'info',
+                    title: 'Approval requested',
+                    description: payload?.approval?.description || task.title,
+                };
+            case 'approval_granted':
+                return {
+                    workspaceId: task.workspaceId,
+                    taskId: task.id,
+                    agentRoleId,
+                    actorType,
+                    activityType: 'info',
+                    title: 'Approval granted',
+                    description: task.title,
+                };
+            case 'approval_denied':
+                return {
+                    workspaceId: task.workspaceId,
+                    taskId: task.id,
+                    agentRoleId,
+                    actorType,
+                    activityType: 'info',
+                    title: 'Approval denied',
+                    description: payload?.reason || task.title,
+                };
+            case 'error':
+            case 'step_failed':
+            case 'verification_failed':
+                return {
+                    workspaceId: task.workspaceId,
+                    taskId: task.id,
+                    agentRoleId,
+                    actorType,
+                    activityType: 'error',
+                    title: type === 'error' ? 'Task error' : 'Execution issue',
+                    description: payload?.error || payload?.message || payload?.step?.description || task.title,
+                };
+            case 'verification_passed':
+                return {
+                    workspaceId: task.workspaceId,
+                    taskId: task.id,
+                    agentRoleId,
+                    actorType,
+                    activityType: 'info',
+                    title: 'Verification passed',
+                    description: payload?.message || task.title,
+                };
+            case 'file_created':
+                return {
+                    workspaceId: task.workspaceId,
+                    taskId: task.id,
+                    agentRoleId,
+                    actorType,
+                    activityType,
+                    title: 'File created',
+                    description: payload?.path || task.title,
+                };
+            case 'file_modified':
+                return {
+                    workspaceId: task.workspaceId,
+                    taskId: task.id,
+                    agentRoleId,
+                    actorType,
+                    activityType,
+                    title: 'File modified',
+                    description: payload?.path || task.title,
+                };
+            case 'file_deleted':
+                return {
+                    workspaceId: task.workspaceId,
+                    taskId: task.id,
+                    agentRoleId,
+                    actorType,
+                    activityType,
+                    title: 'File deleted',
+                    description: payload?.path || task.title,
+                };
+            case 'tool_call':
+                return {
+                    workspaceId: task.workspaceId,
+                    taskId: task.id,
+                    agentRoleId,
+                    actorType,
+                    activityType: 'tool_used',
+                    title: 'Tool used',
+                    description: payload?.tool || payload?.name || task.title,
+                };
+            default:
+                return undefined;
+        }
+    }
+    emitActivityEvent(activity) {
+        const windows = electron_1.BrowserWindow.getAllWindows();
+        windows.forEach(window => {
+            try {
+                if (!window.isDestroyed() && window.webContents && !window.webContents.isDestroyed()) {
+                    window.webContents.send(types_1.IPC_CHANNELS.ACTIVITY_EVENT, { type: 'created', activity });
+                }
+            }
+            catch (error) {
+                console.error('[AgentDaemon] Error sending activity IPC:', error);
+            }
+        });
+    }
+    /**
+     * Register an artifact (file created during task execution)
+     * This allows files like screenshots to be sent back to the user
+     */
+    registerArtifact(taskId, filePath, mimeType) {
+        try {
+            if (!fs.existsSync(filePath)) {
+                console.error(`[AgentDaemon] Artifact file not found: ${filePath}`);
+                return;
+            }
+            const stats = fs.statSync(filePath);
+            const fileBuffer = fs.readFileSync(filePath);
+            const sha256 = crypto.createHash('sha256').update(fileBuffer).digest('hex');
+            this.artifactRepo.create({
+                taskId,
+                path: filePath,
+                mimeType,
+                sha256,
+                size: stats.size,
+                createdAt: Date.now(),
+            });
+            console.log(`[AgentDaemon] Registered artifact: ${filePath}`);
+        }
+        catch (error) {
+            console.error(`[AgentDaemon] Failed to register artifact:`, error);
+        }
+    }
+    /**
+     * Emit event to renderer process and local listeners
+     */
+    emitTaskEvent(taskId, type, payload) {
+        // Emit to local EventEmitter listeners (for gateway integration)
+        try {
+            this.emit(type, { taskId, ...payload });
+        }
+        catch (error) {
+            console.error(`[AgentDaemon] Error emitting event ${type}:`, error);
+        }
+        // Emit to renderer process via IPC
+        const windows = electron_1.BrowserWindow.getAllWindows();
+        windows.forEach(window => {
+            // Check if window is still valid before sending
+            try {
+                if (!window.isDestroyed() && window.webContents && !window.webContents.isDestroyed()) {
+                    window.webContents.send(types_1.IPC_CHANNELS.TASK_EVENT, {
+                        taskId,
+                        type,
+                        payload,
+                        timestamp: Date.now(),
+                    });
+                }
+            }
+            catch (error) {
+                // Window might have been destroyed between check and send
+                console.error(`[AgentDaemon] Error sending IPC to window:`, error);
+            }
+        });
+    }
+    /**
+     * Update task status
+     */
+    updateTaskStatus(taskId, status) {
+        this.taskRepo.update(taskId, { status });
+    }
+    /**
+     * Get task by ID
+     */
+    getTask(taskId) {
+        return this.taskRepo.findById(taskId);
+    }
+    /**
+     * Update task workspace ID in database
+     */
+    updateTaskWorkspace(taskId, workspaceId) {
+        this.taskRepo.update(taskId, { workspaceId });
+    }
+    /**
+     * Get workspace by ID
+     */
+    getWorkspaceById(id) {
+        return this.workspaceRepo.findById(id);
+    }
+    /**
+     * Get workspace by path
+     */
+    getWorkspaceByPath(path) {
+        return this.workspaceRepo.findByPath(path);
+    }
+    /**
+     * Create a new workspace with default permissions
+     */
+    createWorkspace(name, path) {
+        const defaultPermissions = {
+            read: true,
+            write: true,
+            delete: false,
+            network: true,
+            shell: false,
+        };
+        return this.workspaceRepo.create(name, path, defaultPermissions);
+    }
+    /**
+     * Update task fields (for Goal Mode attempt tracking, etc.)
+     */
+    updateTask(taskId, updates) {
+        this.taskRepo.update(taskId, updates);
+    }
+    /**
+     * Mark task as completed
+     * Note: We keep the executor in memory for follow-up messages (with TTL-based cleanup)
+     */
+    completeTask(taskId) {
+        this.taskRepo.update(taskId, {
+            status: 'completed',
+            completedAt: Date.now(),
+        });
+        // Mark executor as completed for TTL-based cleanup
+        const cached = this.activeTasks.get(taskId);
+        if (cached) {
+            cached.status = 'completed';
+            cached.lastAccessed = Date.now();
+        }
+        this.logEvent(taskId, 'task_completed', { message: 'Task completed successfully' });
+        // Notify queue manager so it can start next task
+        this.queueManager.onTaskFinished(taskId);
+    }
+    /**
+     * Send a follow-up message to a task
+     */
+    async sendMessage(taskId, message) {
+        let cached = this.activeTasks.get(taskId);
+        let executor;
+        // Always get fresh task and workspace from DB to pick up permission changes
+        const task = this.taskRepo.findById(taskId);
+        if (!task) {
+            throw new Error(`Task ${taskId} not found`);
+        }
+        const workspace = this.workspaceRepo.findById(task.workspaceId);
+        if (!workspace) {
+            throw new Error(`Workspace ${task.workspaceId} not found`);
+        }
+        if (!cached) {
+            // Task executor not in memory - need to recreate it
+            // Create new executor
+            executor = new executor_1.TaskExecutor(task, workspace, this);
+            // Rebuild conversation history from saved events
+            const events = this.eventRepo.findByTaskId(taskId);
+            if (events.length > 0) {
+                executor.rebuildConversationFromEvents(events);
+            }
+            this.activeTasks.set(taskId, {
+                executor,
+                lastAccessed: Date.now(),
+                status: 'active',
+            });
+        }
+        else {
+            executor = cached.executor;
+            // Update workspace to pick up permission changes (e.g., shell enabled)
+            executor.updateWorkspace(workspace);
+            cached.lastAccessed = Date.now();
+            cached.status = 'active';
+        }
+        // Send the message
+        await executor.sendMessage(message);
+    }
+    // ===== Queue Management Methods =====
+    /**
+     * Get current queue status
+     */
+    getQueueStatus() {
+        return this.queueManager.getStatus();
+    }
+    /**
+     * Get queue settings
+     */
+    getQueueSettings() {
+        return this.queueManager.getSettings();
+    }
+    /**
+     * Save queue settings
+     */
+    saveQueueSettings(settings) {
+        this.queueManager.saveSettings(settings);
+    }
+    /**
+     * Clear stuck tasks from the queue
+     * Used to recover from stuck state when tasks fail to clean up
+     * Also properly cancels running tasks to clean up resources (browser sessions, etc.)
+     */
+    async clearStuckTasks() {
+        // Get running task IDs before clearing
+        const status = this.queueManager.getStatus();
+        const runningTaskIds = [...status.runningTaskIds];
+        const queuedTaskIds = [...status.queuedTaskIds];
+        console.log(`[AgentDaemon] Clearing ${runningTaskIds.length} running tasks and ${queuedTaskIds.length} queued tasks`);
+        // Cancel all running tasks properly (this cleans up browser sessions, etc.)
+        for (const taskId of runningTaskIds) {
+            const cached = this.activeTasks.get(taskId);
+            if (cached) {
+                try {
+                    console.log(`[AgentDaemon] Cancelling running task: ${taskId}`);
+                    await cached.executor.cancel();
+                    this.activeTasks.delete(taskId);
+                }
+                catch (error) {
+                    console.error(`[AgentDaemon] Error cancelling task ${taskId}:`, error);
+                }
+            }
+        }
+        // Now clear the queue state
+        return this.queueManager.clearStuckTasks();
+    }
+    /**
+     * Handle a task that has timed out
+     * Called by queue manager when a task exceeds the configured timeout
+     */
+    async handleTaskTimeout(taskId) {
+        console.log(`[AgentDaemon] Task ${taskId} has timed out, cancelling...`);
+        const cached = this.activeTasks.get(taskId);
+        if (cached) {
+            try {
+                // Cancel the task (this cleans up browser sessions, etc.)
+                await cached.executor.cancel();
+                this.activeTasks.delete(taskId);
+            }
+            catch (error) {
+                console.error(`[AgentDaemon] Error cancelling timed out task ${taskId}:`, error);
+            }
+        }
+        // Update task status to failed with timeout message
+        this.taskRepo.update(taskId, {
+            status: 'failed',
+            error: 'Task timed out - exceeded maximum allowed execution time',
+        });
+        // Emit timeout event
+        this.logEvent(taskId, 'step_timeout', {
+            message: 'Task exceeded maximum execution time and was automatically cancelled',
+        });
+    }
+    /**
+     * Emit queue update event to all windows
+     */
+    emitQueueUpdate(status) {
+        const windows = electron_1.BrowserWindow.getAllWindows();
+        windows.forEach(window => {
+            try {
+                if (!window.isDestroyed() && window.webContents && !window.webContents.isDestroyed()) {
+                    window.webContents.send(types_1.IPC_CHANNELS.QUEUE_UPDATE, status);
+                }
+            }
+            catch (error) {
+                console.error(`[AgentDaemon] Error sending queue update to window:`, error);
+            }
+        });
+    }
+    /**
+     * Shutdown daemon
+     * Properly awaits all task cancellations and clears intervals
+     */
+    async shutdown() {
+        console.log('Shutting down agent daemon...');
+        // Clear the cleanup interval
+        if (this.cleanupIntervalHandle) {
+            clearInterval(this.cleanupIntervalHandle);
+            this.cleanupIntervalHandle = undefined;
+        }
+        // Clear all pending approval timeouts and reject pending promises
+        this.pendingApprovals.forEach((pending, approvalId) => {
+            clearTimeout(pending.timeoutHandle);
+            if (!pending.resolved) {
+                pending.resolved = true;
+                pending.reject(new Error('Daemon shutting down'));
+            }
+        });
+        this.pendingApprovals.clear();
+        // Cancel all active tasks and wait for them to complete
+        const cancelPromises = [];
+        this.activeTasks.forEach((cached, taskId) => {
+            const promise = cached.executor.cancel().catch(err => {
+                console.error(`Error cancelling task ${taskId}:`, err);
+            });
+            cancelPromises.push(promise);
+        });
+        // Wait for all cancellations to complete (with timeout)
+        await Promise.race([
+            Promise.all(cancelPromises),
+            new Promise(resolve => setTimeout(resolve, 5000)), // 5 second timeout
+        ]);
+        this.activeTasks.clear();
+        // Remove all EventEmitter listeners to prevent memory leaks
+        this.removeAllListeners();
+        console.log('Agent daemon shutdown complete');
+    }
+    /**
+     * Prune old conversation snapshots for a task, keeping only the most recent one.
+     * This prevents database bloat from accumulating snapshots.
+     */
+    pruneOldSnapshots(taskId) {
+        try {
+            this.eventRepo.pruneOldSnapshots(taskId);
+        }
+        catch (error) {
+            console.debug('[AgentDaemon] Failed to prune old snapshots:', error);
+        }
+    }
+}
+exports.AgentDaemon = AgentDaemon;