@flowdot.ai/daemon 1.0.0

package/dist/loop/LoopDaemon.js

@@ -0,0 +1,1821 @@
+import { spawn } from 'node:child_process';
+import { promises as fs } from 'node:fs';
+import path from 'node:path';
+import { EventEmitter } from 'node:events';
+import { DaemonNotRunningError, DaemonAlreadyRunningError, DaemonStartFailedError, DaemonStopFailedError, } from './errors.js';
+import { LoopManager } from './LoopManager.js';
+import { LoopStore } from './LoopStore.js';
+import { GoalManager, TaskGenerator, TaskExecutor, PermissionBridge, GoalCommsHandler, ReviewScheduler, ProgressTracker, ErrorRecovery, GoalScheduler, } from '../goals/index.js';
+import { IPCServer, IPCClient, isDaemonRunning } from './DaemonIPC.js';
+const DAEMON_STARTUP_TIMEOUT_MS = 10000;
+const DAEMON_SHUTDOWN_TIMEOUT_MS = 5000;
+const PROCESS_CHECK_INTERVAL_MS = 100;
+const noopLogger = {
+    debug: () => { },
+    info: () => { },
+    warn: () => { },
+    error: () => { },
+};
+export class LoopDaemon extends EventEmitter {
+    baseDir;
+    flowdotDir;
+    config;
+    store;
+    managerOptions;
+    goalConfig;
+    logger;
+    manager = null;
+    goalManager = null;
+    taskGenerator = null;
+    taskExecutor = null;
+    permissionBridge = null;
+    goalCommsHandler = null;
+    reviewScheduler = null;
+    progressTracker = null;
+    errorRecovery = null;
+    goalScheduler = null;
+    ipcServer = null;
+    logStream = null;
+    startedAt = null;
+    isShuttingDown = false;
+    constructor(options = {}) {
+        super();
+        this.baseDir = options.baseDir ?? process.cwd();
+        this.flowdotDir = path.join(this.baseDir, '.flowdot');
+        this.logger = options.logger ?? noopLogger;
+        const defaultConfig = {
+            port: 47691,
+            logLevel: 'info',
+            healthCheckInterval: 30000,
+        };
+        this.config = { ...defaultConfig, ...options.daemonConfig };
+        this.store = new LoopStore({ baseDir: this.baseDir, logger: this.logger });
+        this.managerOptions = options.managerOptions ?? {};
+        this.goalConfig = options.goalConfig;
+    }
+    async start() {
+        if (this.ipcServer) {
+            throw new DaemonAlreadyRunningError(process.pid);
+        }
+        this.logger.info('LOOP', 'Starting loop daemon...');
+        try {
+            await this.ensureDirectories();
+            await this.setupLogging();
+            this.logMessage('info', 'Daemon starting...');
+            await this.store.initialize();
+            await this.store.writeDaemonPid(process.pid);
+            this.manager = new LoopManager({
+                baseDir: this.baseDir,
+                logger: this.logger,
+                ...this.managerOptions,
+            });
+            await this.manager.initialize();
+            this.setupManagerEvents();
+            if (this.goalConfig) {
+                this.logMessage('info', 'Initializing GoalManager...');
+                this.goalManager = new GoalManager({
+                    baseUrl: this.goalConfig.baseUrl,
+                    tokenProvider: this.goalConfig.tokenProvider,
+                    logger: this.logger,
+                    ...this.goalConfig.managerOptions,
+                });
+                await this.goalManager.initialize();
+                this.setupGoalManagerEvents();
+                this.logMessage('info', 'GoalManager initialized');
+                if (this.goalConfig.llmFunction) {
+                    this.logMessage('info', 'Initializing TaskGenerator...');
+                    this.taskGenerator = new TaskGenerator({
+                        llmFunction: this.goalConfig.llmFunction,
+                        logger: this.logger,
+                        ...this.goalConfig.taskGeneratorOptions,
+                    });
+                    this.logMessage('info', 'TaskGenerator initialized');
+                }
+                if (this.goalConfig.taskHandlers || this.goalConfig.approvalRequestFunction) {
+                    this.logMessage('info', 'Initializing PermissionBridge...');
+                    this.permissionBridge = new PermissionBridge({
+                        logger: this.logger,
+                        ...this.goalConfig.permissionBridgeOptions,
+                    });
+                    this.logMessage('info', 'PermissionBridge initialized');
+                    this.logMessage('info', 'Initializing TaskExecutor...');
+                    this.taskExecutor = new TaskExecutor({
+                        logger: this.logger,
+                        handlers: this.goalConfig.taskHandlers,
+                        requestApproval: this.goalConfig.approvalRequestFunction,
+                        checkPermission: (category, context) => this.permissionBridge.checkPermission(category, context),
+                        updateTaskStatus: async (taskId, status) => {
+                            this.logMessage('debug', `Task ${taskId} status update to ${status}`);
+                        },
+                        ...this.goalConfig.taskExecutorOptions,
+                    });
+                    this.setupTaskExecutorEvents();
+                    this.logMessage('info', 'TaskExecutor initialized');
+                }
+                if (this.goalConfig.commsSendFunction) {
+                    this.logMessage('info', 'Initializing GoalCommsHandler...');
+                    this.goalCommsHandler = new GoalCommsHandler({
+                        logger: this.logger,
+                        sendFunction: this.goalConfig.commsSendFunction,
+                        ...this.goalConfig.commsHandlerOptions,
+                    });
+                    this.setupCommsHandlerEvents();
+                    this.logMessage('info', 'GoalCommsHandler initialized');
+                }
+                if (this.goalConfig.enableReviewScheduler) {
+                    this.logMessage('info', 'Initializing ReviewScheduler...');
+                    this.reviewScheduler = new ReviewScheduler({
+                        logger: this.logger,
+                        ...this.goalConfig.reviewSchedulerOptions,
+                    });
+                    this.setupReviewSchedulerEvents();
+                    this.reviewScheduler.start();
+                    this.logMessage('info', 'ReviewScheduler initialized and started');
+                }
+                if (this.goalConfig.enableProgressTracker) {
+                    this.logMessage('info', 'Initializing ProgressTracker...');
+                    this.progressTracker = new ProgressTracker({
+                        logger: this.logger,
+                        ...this.goalConfig.progressTrackerOptions,
+                    });
+                    this.setupProgressTrackerEvents();
+                    this.logMessage('info', 'ProgressTracker initialized');
+                }
+                if (this.goalConfig.enableErrorRecovery) {
+                    this.logMessage('info', 'Initializing ErrorRecovery...');
+                    this.errorRecovery = new ErrorRecovery({
+                        logger: this.logger,
+                        ...this.goalConfig.errorRecoveryOptions,
+                    });
+                    this.setupErrorRecoveryEvents();
+                    this.logMessage('info', 'ErrorRecovery initialized');
+                }
+                if (this.goalConfig.enableGoalScheduler) {
+                    this.logMessage('info', 'Initializing GoalScheduler...');
+                    this.goalScheduler = new GoalScheduler({
+                        logger: this.logger,
+                        getDueGoals: this.createGetDueGoalsFunction(),
+                        markGoalStarted: this.createMarkGoalStartedFunction(),
+                        markGoalCompleted: this.createMarkGoalCompletedFunction(),
+                        executeGoal: this.goalConfig.executeGoalFunction ?? this.createDefaultExecuteGoalFunction(),
+                        ...this.goalConfig.goalSchedulerOptions,
+                    });
+                    this.setupGoalSchedulerEvents();
+                    this.goalScheduler.start();
+                    this.logMessage('info', 'GoalScheduler initialized and started');
+                }
+            }
+            this.ipcServer = new IPCServer({
+                port: this.config.port,
+                onRequest: this.handleRequest.bind(this),
+                logger: this.logger,
+            });
+            await this.ipcServer.start();
+            this.manager.start();
+            this.startedAt = new Date();
+            this.setupSignalHandlers();
+            this.logMessage('info', `Daemon started on port ${this.config.port} (PID: ${process.pid})`);
+            this.logger.info('LOOP', `Daemon started on port ${this.config.port}`);
+            this.emit('started');
+        }
+        catch (error) {
+            this.logMessage('error', `Failed to start daemon: ${error instanceof Error ? error.message : String(error)}`);
+            await this.cleanup();
+            throw new DaemonStartFailedError(error instanceof Error ? error.message : String(error), error instanceof Error ? error : undefined);
+        }
+    }
+    async stop() {
+        if (this.isShuttingDown) {
+            return;
+        }
+        this.isShuttingDown = true;
+        this.emit('stopping');
+        this.logMessage('info', 'Daemon stopping...');
+        this.logger.info('LOOP', 'Daemon stopping...');
+        const shutdownTimeout = setTimeout(() => {
+            this.logMessage('warn', 'Forced shutdown due to timeout');
+            process.exit(1);
+        }, DAEMON_SHUTDOWN_TIMEOUT_MS);
+        try {
+            if (this.manager) {
+                await this.manager.shutdown();
+                this.manager = null;
+            }
+            if (this.goalManager) {
+                this.goalManager.clearCache();
+                this.goalManager = null;
+            }
+            this.taskGenerator = null;
+            this.taskExecutor = null;
+            this.permissionBridge = null;
+            this.goalCommsHandler = null;
+            if (this.reviewScheduler) {
+                this.reviewScheduler.stop();
+                this.reviewScheduler = null;
+            }
+            this.progressTracker = null;
+            this.errorRecovery = null;
+            if (this.goalScheduler) {
+                this.goalScheduler.stop();
+                this.goalScheduler = null;
+            }
+            if (this.ipcServer) {
+                await this.ipcServer.stop();
+                this.ipcServer = null;
+            }
+            await this.store.deleteDaemonPid();
+            await this.closeLogStream();
+            clearTimeout(shutdownTimeout);
+            this.logMessage('info', 'Daemon stopped');
+            this.logger.info('LOOP', 'Daemon stopped');
+            this.emit('stopped');
+        }
+        catch (error) {
+            clearTimeout(shutdownTimeout);
+            this.logMessage('error', `Error during shutdown: ${error instanceof Error ? error.message : String(error)}`);
+            await this.cleanup();
+            throw new DaemonStopFailedError(process.pid, error instanceof Error ? error.message : String(error));
+        }
+    }
+    async getStatus() {
+        const stats = this.manager ? await this.manager.getStats() : null;
+        return {
+            running: this.ipcServer?.isRunning() ?? false,
+            pid: process.pid,
+            startedAt: this.startedAt,
+            activeLoops: stats?.activeLoops ?? 0,
+            uptime: this.startedAt ? Date.now() - this.startedAt.getTime() : null,
+        };
+    }
+    isRunning() {
+        return this.ipcServer?.isRunning() ?? false;
+    }
+    async resolveLoopId(idOrName) {
+        const isUUID = /^[0-9a-f]{8}-[0-9a-f]{4}-[0-9a-f]{4}-[0-9a-f]{4}-[0-9a-f]{12}$/i.test(idOrName);
+        if (isUUID) {
+            try {
+                const loop = await this.manager.getLoop(idOrName);
+                return loop.id;
+            }
+            catch {
+            }
+        }
+        const loopByName = await this.manager.getLoopByName(idOrName);
+        if (loopByName) {
+            return loopByName.id;
+        }
+        const allLoops = await this.manager.getAllLoops();
+        const matchingLoop = allLoops.find(l => l.id.startsWith(idOrName));
+        if (matchingLoop) {
+            return matchingLoop.id;
+        }
+        throw new Error(`Loop not found: ${idOrName}`);
+    }
+    assertGoalManager() {
+        if (!this.goalManager) {
+            throw new Error('Goal tracking is not enabled. Configure goalConfig to use goal features.');
+        }
+    }
+    assertTaskGenerator() {
+        if (!this.taskGenerator) {
+            throw new Error('Task generation is not enabled. Configure goalConfig.llmFunction to use task generation features.');
+        }
+    }
+    assertTaskExecutor() {
+        if (!this.taskExecutor) {
+            throw new Error('Task execution is not enabled. Configure goalConfig.taskHandlers or goalConfig.approvalRequestFunction to use task execution features.');
+        }
+    }
+    assertPermissionBridge() {
+        if (!this.permissionBridge) {
+            throw new Error('Permission bridge is not initialized. This is required for task execution.');
+        }
+    }
+    assertGoalCommsHandler() {
+        if (!this.goalCommsHandler) {
+            throw new Error('COMMS is not enabled. Configure goalConfig.commsSendFunction to use COMMS features.');
+        }
+    }
+    assertReviewScheduler() {
+        if (!this.reviewScheduler) {
+            throw new Error('ReviewScheduler is not enabled. Configure goalConfig.enableReviewScheduler to use review features.');
+        }
+    }
+    assertProgressTracker() {
+        if (!this.progressTracker) {
+            throw new Error('ProgressTracker is not enabled. Configure goalConfig.enableProgressTracker to use progress tracking features.');
+        }
+    }
+    assertErrorRecovery() {
+        if (!this.errorRecovery) {
+            throw new Error('ErrorRecovery is not enabled. Configure goalConfig.enableErrorRecovery to use error recovery features.');
+        }
+    }
+    async handleRequest(method, params) {
+        if (!this.manager && method !== 'ping' && method !== 'status' && method !== 'shutdown') {
+            throw new Error('Daemon not fully initialized');
+        }
+        this.logMessage('debug', `IPC request: ${method}`, params);
+        const getLoopId = async () => {
+            if (params.loopId) {
+                return params.loopId;
+            }
+            if (params.idOrName) {
+                return this.resolveLoopId(params.idOrName);
+            }
+            throw new Error('Missing loopId or idOrName parameter');
+        };
+        switch (method) {
+            case 'ping':
+                return { pong: true, timestamp: Date.now() };
+            case 'status':
+                return this.getStatus();
+            case 'shutdown':
+                setImmediate(() => this.stop().catch(() => process.exit(1)));
+                return { shutting_down: true };
+            case 'createLoop':
+                return this.manager.createLoop(params);
+            case 'getLoop': {
+                const loopId = await getLoopId();
+                return this.manager.getLoop(loopId);
+            }
+            case 'getLoopByName':
+                return this.manager.getLoopByName(params.name);
+            case 'getAllLoops':
+                return this.manager.getAllLoops();
+            case 'getLoopsByStatus':
+                return this.manager.getLoopsByStatus(params.status);
+            case 'pauseLoop': {
+                const loopId = await getLoopId();
+                return this.manager.pauseLoop(loopId);
+            }
+            case 'resumeLoop': {
+                const loopId = await getLoopId();
+                return this.manager.resumeLoop(loopId);
+            }
+            case 'stopLoop': {
+                const loopId = await getLoopId();
+                return this.manager.stopLoop(loopId);
+            }
+            case 'deleteLoop': {
+                const loopId = await getLoopId();
+                await this.manager.deleteLoop(loopId);
+                return { deleted: true };
+            }
+            case 'runNow':
+            case 'runLoopNow': {
+                const loopId = await getLoopId();
+                const run = await this.manager.runNow(loopId);
+                const loop = await this.manager.getLoop(loopId);
+                return { loop, run };
+            }
+            case 'getRunHistory':
+            case 'getLoopHistory': {
+                const loopId = await getLoopId();
+                return this.manager.getRunHistory(loopId, params.limit);
+            }
+            case 'getRun': {
+                const loopId = await getLoopId();
+                return this.manager.getRun(loopId, params.runId);
+            }
+            case 'getStats':
+                return this.manager.getStats();
+            case 'listGoals':
+                this.assertGoalManager();
+                return this.goalManager.listGoals(params);
+            case 'getGoal':
+                this.assertGoalManager();
+                return this.goalManager.getGoal(params.goalHash);
+            case 'createGoal':
+                this.assertGoalManager();
+                return this.goalManager.createGoal(params);
+            case 'updateGoal':
+                this.assertGoalManager();
+                return this.goalManager.updateGoal(params.goalHash, params.data);
+            case 'deleteGoal':
+                this.assertGoalManager();
+                await this.goalManager.deleteGoal(params.goalHash);
+                return { deleted: true };
+            case 'pauseGoal':
+                this.assertGoalManager();
+                return this.goalManager.pauseGoal(params.goalHash);
+            case 'resumeGoal':
+                this.assertGoalManager();
+                return this.goalManager.resumeGoal(params.goalHash);
+            case 'completeGoal':
+                this.assertGoalManager();
+                return this.goalManager.completeGoal(params.goalHash);
+            case 'abandonGoal':
+                this.assertGoalManager();
+                return this.goalManager.abandonGoal(params.goalHash);
+            case 'getGoalProgress':
+                this.assertGoalManager();
+                return this.goalManager.getGoalProgress(params.goalHash);
+            case 'listMilestones':
+                this.assertGoalManager();
+                return this.goalManager.listMilestones(params.goalHash, params.forceRefresh);
+            case 'getMilestone':
+                this.assertGoalManager();
+                return this.goalManager.getMilestone(params.goalHash, params.milestoneId);
+            case 'createMilestone':
+                this.assertGoalManager();
+                return this.goalManager.createMilestone(params.goalHash, params.data);
+            case 'updateMilestone':
+                this.assertGoalManager();
+                return this.goalManager.updateMilestone(params.goalHash, params.milestoneId, params.data);
+            case 'deleteMilestone':
+                this.assertGoalManager();
+                await this.goalManager.deleteMilestone(params.goalHash, params.milestoneId);
+                return { deleted: true };
+            case 'completeMilestone':
+                this.assertGoalManager();
+                return this.goalManager.completeMilestone(params.goalHash, params.milestoneId);
+            case 'listTasks':
+                this.assertGoalManager();
+                return this.goalManager.listTasks(params.goalHash, params);
+            case 'getTask':
+                this.assertGoalManager();
+                return this.goalManager.getTask(params.goalHash, params.taskId);
+            case 'createTask':
+                this.assertGoalManager();
+                return this.goalManager.createTask(params.goalHash, params.data);
+            case 'updateTask':
+                this.assertGoalManager();
+                return this.goalManager.updateTask(params.goalHash, params.taskId, params.data);
+            case 'deleteTask':
+                this.assertGoalManager();
+                await this.goalManager.deleteTask(params.goalHash, params.taskId);
+                return { deleted: true };
+            case 'approveTask':
+                this.assertGoalManager();
+                return this.goalManager.approveTask(params.goalHash, params.taskId);
+            case 'denyTask':
+                this.assertGoalManager();
+                return this.goalManager.denyTask(params.goalHash, params.taskId);
+            case 'startTask':
+                this.assertGoalManager();
+                return this.goalManager.startTask(params.goalHash, params.taskId);
+            case 'completeTask':
+                this.assertGoalManager();
+                return this.goalManager.completeTask(params.goalHash, params.taskId, params.result);
+            case 'failTask':
+                this.assertGoalManager();
+                return this.goalManager.failTask(params.goalHash, params.taskId, params.data);
+            case 'skipTask':
+                this.assertGoalManager();
+                return this.goalManager.skipTask(params.goalHash, params.taskId);
+            case 'addTaskFeedback':
+                this.assertGoalManager();
+                return this.goalManager.addTaskFeedback(params.goalHash, params.taskId, params.data);
+            case 'getPendingTasks':
+                this.assertGoalManager();
+                return this.goalManager.getPendingTasks();
+            case 'getTasksAwaitingApproval':
+                this.assertGoalManager();
+                return this.goalManager.getTasksAwaitingApproval();
+            case 'listMemories':
+                this.assertGoalManager();
+                return this.goalManager.listMemories(params.goalHash, params.forceRefresh);
+            case 'createMemory':
+                this.assertGoalManager();
+                return this.goalManager.createMemory(params.goalHash, params.data);
+            case 'updateMemory':
+                this.assertGoalManager();
+                return this.goalManager.updateMemory(params.goalHash, params.memoryId, params.data);
+            case 'toggleMemory':
+                this.assertGoalManager();
+                return this.goalManager.toggleMemory(params.goalHash, params.memoryId);
+            case 'deleteMemory':
+                this.assertGoalManager();
+                await this.goalManager.deleteMemory(params.goalHash, params.memoryId);
+                return { deleted: true };
+            case 'getEnabledMemories':
+                this.assertGoalManager();
+                return this.goalManager.getEnabledMemories(params.goalHash);
+            case 'getGoalStats':
+                this.assertGoalManager();
+                return this.goalManager.getStats();
+            case 'getActionLogs':
+                this.assertGoalManager();
+                return this.goalManager.getActionLogs(params.goalHash, params.limit);
+            case 'isTaskGenerationEnabled':
+                return { enabled: this.taskGenerator !== null };
+            case 'generateTasks': {
+                this.assertGoalManager();
+                this.assertTaskGenerator();
+                const goal = await this.goalManager.getGoal(params.goalHash);
+                const milestones = await this.goalManager.listMilestones(params.goalHash);
+                const existingTasks = await this.goalManager.listTasks(params.goalHash);
+                const result = await this.taskGenerator.generateTasks(goal, milestones, existingTasks, params.options);
+                return result;
+            }
+            case 'generateDailyTasks': {
+                this.assertGoalManager();
+                this.assertTaskGenerator();
+                const goal = await this.goalManager.getGoal(params.goalHash);
+                const milestones = await this.goalManager.listMilestones(params.goalHash);
+                const existingTasks = await this.goalManager.listTasks(params.goalHash);
+                const result = await this.taskGenerator.generateDailyTasks(goal, milestones, existingTasks, params.options);
+                return result;
+            }
+            case 'suggestNextTask': {
+                this.assertGoalManager();
+                this.assertTaskGenerator();
+                const goal = await this.goalManager.getGoal(params.goalHash);
+                const milestones = await this.goalManager.listMilestones(params.goalHash);
+                const pendingTasks = await this.goalManager.listTasks(params.goalHash, {
+                    status: 'pending',
+                });
+                const suggestion = await this.taskGenerator.suggestNextTask(goal, milestones, pendingTasks, params.options);
+                return suggestion;
+            }
+            case 'isTaskExecutionEnabled':
+                return { enabled: this.taskExecutor !== null };
+            case 'getExecutionCapabilities': {
+                if (!this.taskExecutor) {
+                    return {
+                        enabled: false,
+                        handlerTypes: [],
+                        hasApprovalFunction: false,
+                        hasPermissionBridge: false,
+                    };
+                }
+                return {
+                    enabled: true,
+                    handlerTypes: Object.keys(this.goalConfig?.taskHandlers ?? {}),
+                    hasApprovalFunction: !!this.goalConfig?.approvalRequestFunction,
+                    hasPermissionBridge: !!this.permissionBridge,
+                };
+            }
+            case 'executeTask': {
+                this.assertGoalManager();
+                this.assertTaskExecutor();
+                const goal = await this.goalManager.getGoal(params.goalHash);
+                const task = await this.goalManager.getTask(params.goalHash, params.taskId);
+                const result = await this.taskExecutor.execute(goal, task);
+                if (result.success) {
+                    await this.goalManager.completeTask(params.goalHash, params.taskId, result.data);
+                }
+                else if (result.status === 'failed') {
+                    await this.goalManager.failTask(params.goalHash, params.taskId, { error: result.error ?? 'Task execution failed' });
+                }
+                else if (result.approvalSkipped) {
+                    await this.goalManager.skipTask(params.goalHash, params.taskId);
+                }
+                return result;
+            }
+            case 'executeTaskSequence': {
+                this.assertGoalManager();
+                this.assertTaskExecutor();
+                const goal = await this.goalManager.getGoal(params.goalHash);
+                let tasks;
+                if (params.taskIds && Array.isArray(params.taskIds)) {
+                    tasks = await Promise.all(params.taskIds.map(id => this.goalManager.getTask(params.goalHash, id)));
+                }
+                else {
+                    tasks = await this.goalManager.listTasks(params.goalHash, {
+                        status: 'pending',
+                    });
+                }
+                const results = await this.taskExecutor.executeSequence(goal, tasks);
+                for (let i = 0; i < results.length; i++) {
+                    const result = results[i];
+                    const task = tasks[i];
+                    if (result.success) {
+                        await this.goalManager.completeTask(params.goalHash, task.id, result.data);
+                    }
+                    else if (result.status === 'failed') {
+                        await this.goalManager.failTask(params.goalHash, task.id, { error: result.error ?? 'Task execution failed' });
+                    }
+                    else if (result.approvalSkipped) {
+                        await this.goalManager.skipTask(params.goalHash, task.id);
+                    }
+                }
+                return { results, executed: results.length, total: tasks.length };
+            }
+            case 'runGoalAutoMode': {
+                this.assertGoalManager();
+                this.assertTaskExecutor();
+                const goalHash = params.goalHash;
+                const maxTasks = params.maxTasks ?? 10;
+                const goal = await this.goalManager.getGoal(goalHash);
+                const allTasks = await this.goalManager.listTasks(goalHash, { forceRefresh: true });
+                const pendingTasks = allTasks.filter(t => t.status === 'pending');
+                const tasksToRun = pendingTasks.slice(0, maxTasks);
+                let tasksExecuted = 0;
+                let tasksCompleted = 0;
+                let tasksFailed = 0;
+                for (const task of tasksToRun) {
+                    try {
+                        const result = await this.taskExecutor.execute(goal, task);
+                        tasksExecuted++;
+                        if (result.success) {
+                            await this.goalManager.completeTask(goalHash, task.id, result.data);
+                            tasksCompleted++;
+                        }
+                        else {
+                            await this.goalManager.failTask(goalHash, task.id, { error: result.error ?? 'Task execution failed' });
+                            tasksFailed++;
+                        }
+                    }
+                    catch (error) {
+                        tasksFailed++;
+                        try {
+                            await this.goalManager.failTask(goalHash, task.id, {
+                                error: error instanceof Error ? error.message : String(error)
+                            });
+                        }
+                        catch { }
+                    }
+                }
+                return {
+                    success: true,
+                    tasksExecuted,
+                    tasksCompleted,
+                    tasksFailed,
+                };
+            }
+            case 'canExecuteTask': {
+                this.assertGoalManager();
+                this.assertTaskExecutor();
+                const goal = await this.goalManager.getGoal(params.goalHash);
+                const task = await this.goalManager.getTask(params.goalHash, params.taskId);
+                const result = await this.taskExecutor.canExecute(goal, task);
+                return result;
+            }
+            case 'checkTaskPermission': {
+                this.assertGoalManager();
+                this.assertPermissionBridge();
+                const goal = await this.goalManager.getGoal(params.goalHash);
+                const task = await this.goalManager.getTask(params.goalHash, params.taskId);
+                const context = {
+                    goal,
+                    task,
+                    permissionCategory: params.category,
+                    approvalMode: goal.approvalMode,
+                    startTime: new Date(),
+                };
+                const result = await this.permissionBridge.checkPermission(params.category, context, params.options);
+                return result;
+            }
+            case 'recordPermissionDecision': {
+                this.assertPermissionBridge();
+                this.permissionBridge.recordDecision(params.category, params.decision, params.options);
+                return { recorded: true };
+            }
+            case 'getPermissionAuditLog': {
+                this.assertPermissionBridge();
+                const auditLog = this.permissionBridge.getAuditLog({
+                    goalHash: params.goalHash,
+                    taskId: params.taskId,
+                    category: params.category,
+                    since: params.since ? new Date(params.since) : undefined,
+                    limit: params.limit,
+                });
+                return auditLog;
+            }
+            case 'clearPermissionCache': {
+                this.assertPermissionBridge();
+                this.permissionBridge.clearCache();
+                return { cleared: true };
+            }
+            case 'isCommsEnabled': {
+                return {
+                    enabled: this.goalCommsHandler !== null,
+                };
+            }
+            case 'sendGoalNotification': {
+                this.assertGoalCommsHandler();
+                this.assertGoalManager();
+                const goal = await this.goalManager.getGoal(params.goalHash);
+                await this.goalCommsHandler.sendNotification(params.subtype, goal, params.message, params.details);
+                return { sent: true };
+            }
+            case 'requestGoalApproval': {
+                this.assertGoalCommsHandler();
+                this.assertGoalManager();
+                const goal = await this.goalManager.getGoal(params.goalHash);
+                const task = await this.goalManager.getTask(params.goalHash, params.taskId);
+                const response = await this.goalCommsHandler.requestApproval(goal, task, params.reason);
+                return response;
+            }
+            case 'handleApprovalResponse': {
+                this.assertGoalCommsHandler();
+                this.goalCommsHandler.handleApprovalResponse(params.requestId, params.response, params.userId);
+                return { handled: true };
+            }
+            case 'isReviewSchedulerEnabled': {
+                return {
+                    enabled: this.reviewScheduler !== null,
+                };
+            }
+            case 'setReviewSchedule': {
+                this.assertReviewScheduler();
+                const scheduleConfig = {
+                    goalHash: params.goalHash,
+                    frequency: params.frequency,
+                    enabled: params.enabled !== false,
+                    customIntervalDays: params.customIntervalDays,
+                    preferredTime: params.preferredTime,
+                    preferredDay: params.preferredDay,
+                    notifyVia: params.notifyVia,
+                };
+                this.reviewScheduler.setSchedule(scheduleConfig);
+                return { scheduled: true };
+            }
+            case 'removeReviewSchedule': {
+                this.assertReviewScheduler();
+                this.reviewScheduler.removeSchedule(params.goalHash);
+                return { removed: true };
+            }
+            case 'scheduleReview': {
+                this.assertReviewScheduler();
+                const scheduledFor = params.scheduledFor
+                    ? new Date(params.scheduledFor)
+                    : new Date();
+                const review = this.reviewScheduler.scheduleReview(params.goalHash, params.reviewType, scheduledFor, params.frequency, params.metadata);
+                return review;
+            }
+            case 'completeReview': {
+                this.assertReviewScheduler();
+                this.reviewScheduler.completeReview(params.reviewId, params.result);
+                return { completed: true };
+            }
+            case 'snoozeReview': {
+                this.assertReviewScheduler();
+                const snoozeHours = params.hours;
+                this.reviewScheduler.snoozeReview(params.reviewId, snoozeHours);
+                return { snoozed: true };
+            }
+            case 'getPendingReviews': {
+                this.assertReviewScheduler();
+                const pending = this.reviewScheduler.getPendingReviews(params.goalHash);
+                return pending;
+            }
+            case 'getDueReviews': {
+                this.assertReviewScheduler();
+                const due = this.reviewScheduler.getDueReviews();
+                return due;
+            }
+            case 'isProgressTrackerEnabled': {
+                return {
+                    enabled: this.progressTracker !== null,
+                };
+            }
+            case 'calculateGoalProgress': {
+                this.assertProgressTracker();
+                this.assertGoalManager();
+                const goal = await this.goalManager.getGoal(params.goalHash);
+                const milestones = await this.goalManager.listMilestones(params.goalHash);
+                const tasks = await this.goalManager.listTasks(params.goalHash);
+                const progress = this.progressTracker.calculateProgress(goal, milestones, tasks);
+                return progress;
+            }
+            case 'recordTaskCompletion': {
+                this.assertProgressTracker();
+                this.progressTracker.recordTaskCompletion(params.taskId, params.goalHash, params.durationMs, params.wasSuccessful);
+                return { recorded: true };
+            }
+            case 'createProgressSnapshot': {
+                this.assertProgressTracker();
+                const snapshot = this.progressTracker.createSnapshot(params.goalHash);
+                return snapshot;
+            }
+            case 'getProgressSnapshots': {
+                this.assertProgressTracker();
+                const snapshots = this.progressTracker.getSnapshots(params.goalHash);
+                return snapshots;
+            }
+            case 'getVelocityMetrics': {
+                this.assertProgressTracker();
+                this.assertGoalManager();
+                const goal = await this.goalManager.getGoal(params.goalHash);
+                const milestones = await this.goalManager.listMilestones(params.goalHash);
+                const tasks = await this.goalManager.listTasks(params.goalHash);
+                const progress = this.progressTracker.calculateProgress(goal, milestones, tasks);
+                return progress.velocity;
+            }
+            case 'isErrorRecoveryEnabled': {
+                return {
+                    enabled: this.errorRecovery !== null,
+                };
+            }
+            case 'createCheckpoint': {
+                this.assertErrorRecovery();
+                this.assertGoalManager();
+                const goal = await this.goalManager.getGoal(params.goalHash);
+                const task = await this.goalManager.getTask(params.goalHash, params.taskId);
+                const checkpoint = this.errorRecovery.createCheckpoint(goal, task, params.state, params.description);
+                return checkpoint;
+            }
+            case 'getCheckpoints': {
+                this.assertErrorRecovery();
+                const checkpoints = this.errorRecovery.getCheckpoints(params.goalHash);
+                return checkpoints;
+            }
+            case 'restoreCheckpoint': {
+                this.assertErrorRecovery();
+                const checkpoint = this.errorRecovery.getCheckpoint(params.checkpointId);
+                if (!checkpoint) {
+                    throw new Error(`Checkpoint not found: ${params.checkpointId}`);
+                }
+                return checkpoint.stateData;
+            }
+            case 'clearCheckpoints': {
+                this.assertErrorRecovery();
+                this.errorRecovery.clearCheckpoints(params.goalHash);
+                return { cleared: true };
+            }
+            case 'analyzeError': {
+                this.assertErrorRecovery();
+                const executionResult = {
+                    success: false,
+                    taskId: params.taskId,
+                    goalHash: params.goalHash,
+                    status: params.status ?? 'failed',
+                    error: params.error,
+                    durationMs: params.durationMs ?? 0,
+                    executedAt: params.executedAt
+                        ? new Date(params.executedAt)
+                        : new Date(),
+                    cost: params.cost,
+                };
+                const analysis = this.errorRecovery.analyzeError(executionResult);
+                return analysis;
+            }
+            default:
+                throw new Error(`Unknown method: ${method}`);
+        }
+    }
+    setupManagerEvents() {
+        if (!this.manager || !this.ipcServer) {
+            return;
+        }
+        const events = [
+            'created',
+            'started',
+            'paused',
+            'resumed',
+            'stopped',
+            'deleted',
+            'expired',
+            'runStarted',
+            'runCompleted',
+            'runFailed',
+            'autoPaused',
+            'error',
+        ];
+        for (const event of events) {
+            this.manager.on(event, (...args) => {
+                const data = this.serializeEventData(event, args);
+                this.ipcServer.broadcast(`loop:${event}`, data);
+                this.emit('loopEvent', event, data);
+                if (event === 'created' || event === 'stopped' || event === 'error') {
+                    this.logMessage('info', `Loop event: ${event}`, data);
+                }
+            });
+        }
+    }
+    serializeEventData(event, args) {
+        const data = { event };
+        switch (event) {
+            case 'created':
+            case 'started':
+            case 'paused':
+            case 'resumed':
+            case 'stopped':
+            case 'expired':
+                if (args[0] && typeof args[0] === 'object' && 'id' in args[0]) {
+                    const loop = args[0];
+                    data.loopId = loop.id;
+                    data.loopName = loop.name;
+                    data.status = loop.status;
+                }
+                break;
+            case 'deleted':
+                data.loopId = args[0];
+                break;
+            case 'runStarted':
+                if (args[0] && typeof args[0] === 'object' && 'id' in args[0]) {
+                    const loop = args[0];
+                    data.loopId = loop.id;
+                    data.runId = args[1];
+                }
+                break;
+            case 'runCompleted':
+            case 'runFailed':
+                if (args[0] && typeof args[0] === 'object' && 'id' in args[0]) {
+                    const loop = args[0];
+                    data.loopId = loop.id;
+                    data.result = args[1];
+                }
+                break;
+            case 'autoPaused':
+                if (args[0] && typeof args[0] === 'object' && 'id' in args[0]) {
+                    const loop = args[0];
+                    data.loopId = loop.id;
+                    data.reason = args[1];
+                }
+                break;
+            case 'error':
+                data.error = args[0] instanceof Error ? args[0].message : String(args[0]);
+                data.loopId = args[1];
+                break;
+            default:
+                break;
+        }
+        return data;
+    }
+    setupGoalManagerEvents() {
+        if (!this.goalManager || !this.ipcServer) {
+            return;
+        }
+        const events = [
+            'goalCreated',
+            'goalUpdated',
+            'goalPaused',
+            'goalResumed',
+            'goalCompleted',
+            'goalAbandoned',
+            'goalDeleted',
+            'milestoneCreated',
+            'milestoneUpdated',
+            'milestoneCompleted',
+            'milestoneDeleted',
+            'taskCreated',
+            'taskUpdated',
+            'taskApproved',
+            'taskDenied',
+            'taskStarted',
+            'taskCompleted',
+            'taskFailed',
+            'taskSkipped',
+            'taskDeleted',
+            'memoryCreated',
+            'memoryUpdated',
+            'memoryToggled',
+            'memoryDeleted',
+            'error',
+        ];
+        for (const event of events) {
+            this.goalManager.on(event, (...args) => {
+                const data = this.serializeGoalEventData(event, args);
+                this.ipcServer.broadcast(`goal:${event}`, data);
+                this.emit('goalEvent', event, data);
+                if (event.startsWith('goal') || event === 'error') {
+                    this.logMessage('info', `Goal event: ${event}`, data);
+                }
+            });
+        }
+    }
+    serializeGoalEventData(event, args) {
+        const data = { event };
+        if (args[0] && typeof args[0] === 'object') {
+            const entity = args[0];
+            if ('hash' in entity) {
+                data.goalHash = entity.hash;
+            }
+            if ('id' in entity) {
+                data.id = entity.id;
+            }
+            if ('name' in entity) {
+                data.name = entity.name;
+            }
+            if ('title' in entity) {
+                data.title = entity.title;
+            }
+            if ('status' in entity) {
+                data.status = entity.status;
+            }
+            if (event.startsWith('task')) {
+                if ('goal_hash' in entity) {
+                    data.goalHash = entity.goal_hash;
+                }
+                if ('milestone_id' in entity) {
+                    data.milestoneId = entity.milestone_id;
+                }
+            }
+            if (event.startsWith('milestone')) {
+                if ('goal_hash' in entity) {
+                    data.goalHash = entity.goal_hash;
+                }
+            }
+        }
+        if (event === 'error') {
+            data.error = args[0] instanceof Error ? args[0].message : String(args[0]);
+            if (args[1]) {
+                data.context = args[1];
+            }
+        }
+        return data;
+    }
+    setupTaskExecutorEvents() {
+        if (!this.taskExecutor || !this.ipcServer) {
+            return;
+        }
+        const events = [
+            'execution-started',
+            'execution-completed',
+            'permission-checked',
+            'approval-requested',
+            'approval-received',
+            'error',
+        ];
+        for (const event of events) {
+            this.taskExecutor.on(event, (...args) => {
+                const data = this.serializeExecutorEventData(event, args);
+                this.ipcServer.broadcast(`executor:${event}`, data);
+                if (event === 'execution-started' || event === 'execution-completed' || event === 'error') {
+                    this.logMessage('info', `Executor event: ${event}`, data);
+                }
+            });
+        }
+        if (this.permissionBridge) {
+            const permissionEvents = [
+                'permission-granted',
+                'permission-denied',
+                'approval-required',
+                'audit-logged',
+            ];
+            for (const event of permissionEvents) {
+                this.permissionBridge.on(event, (...args) => {
+                    const data = this.serializePermissionEventData(event, args);
+                    this.ipcServer.broadcast(`permission:${event}`, data);
+                });
+            }
+        }
+    }
+    serializeExecutorEventData(event, args) {
+        const data = { event };
+        switch (event) {
+            case 'execution-started':
+            case 'approval-requested': {
+                const context = args[0];
+                if (context) {
+                    data.goalHash = context.goal.hash;
+                    data.taskId = context.task.id;
+                    data.taskTitle = context.task.title;
+                    data.permissionCategory = context.permissionCategory;
+                    data.approvalMode = context.approvalMode;
+                }
+                break;
+            }
+            case 'execution-completed': {
+                const result = args[0];
+                const context = args[1];
+                if (result) {
+                    data.success = result.success;
+                    data.status = result.status;
+                    if (result.error)
+                        data.error = result.error;
+                    if (result.cost !== undefined)
+                        data.cost = result.cost;
+                }
+                if (context) {
+                    data.goalHash = context.goal.hash;
+                    data.taskId = context.task.id;
+                }
+                break;
+            }
+            case 'permission-checked': {
+                const permResult = args[0];
+                const context = args[1];
+                if (permResult) {
+                    data.allowed = permResult.allowed;
+                    data.requiresApproval = permResult.requiresApproval;
+                    data.category = permResult.category;
+                }
+                if (context) {
+                    data.goalHash = context.goal.hash;
+                    data.taskId = context.task.id;
+                }
+                break;
+            }
+            case 'approval-received': {
+                const approvalResult = args[0];
+                const context = args[1];
+                if (approvalResult) {
+                    data.approved = approvalResult.approved;
+                    data.response = approvalResult.response;
+                }
+                if (context) {
+                    data.goalHash = context.goal.hash;
+                    data.taskId = context.task.id;
+                }
+                break;
+            }
+            case 'error':
+                data.error = args[0] instanceof Error ? args[0].message : String(args[0]);
+                break;
+        }
+        return data;
+    }
+    serializePermissionEventData(event, args) {
+        const data = { event };
+        if (args[0] && typeof args[0] === 'object') {
+            const eventData = args[0];
+            Object.assign(data, eventData);
+        }
+        if (args[1] && typeof args[1] === 'object') {
+            const context = args[1];
+            data.goalHash = context.goal?.hash;
+            data.taskId = context.task?.id;
+        }
+        return data;
+    }
+    setupCommsHandlerEvents() {
+        if (!this.goalCommsHandler || !this.ipcServer) {
+            return;
+        }
+        const events = [
+            'notification-sent',
+            'approval-sent',
+            'approval-received',
+            'view-request',
+            'view-response-sent',
+            'modification-redirected',
+            'error',
+        ];
+        for (const event of events) {
+            this.goalCommsHandler.on(event, (...args) => {
+                const data = this.serializeCommsEventData(event, args);
+                this.ipcServer.broadcast(`comms:${event}`, data);
+                if (event === 'approval-received' || event === 'error') {
+                    this.logMessage('info', `COMMS event: ${event}`, data);
+                }
+            });
+        }
+    }
+    serializeCommsEventData(event, args) {
+        const data = { event };
+        switch (event) {
+            case 'notification-sent': {
+                const notification = args[0];
+                if (notification) {
+                    data.type = notification.type;
+                    data.subtype = notification.subtype;
+                    data.goalHash = notification.goalHash;
+                    data.goalName = notification.goalName;
+                    data.message = notification.message;
+                }
+                break;
+            }
+            case 'approval-sent': {
+                const request = args[0];
+                if (request) {
+                    data.requestId = request.requestId;
+                    data.goalHash = request.goalHash;
+                    data.taskId = request.taskId;
+                    data.taskTitle = request.taskTitle;
+                    data.reason = request.reason;
+                }
+                break;
+            }
+            case 'approval-received': {
+                const response = args[0];
+                if (response) {
+                    data.requestId = response.requestId;
+                    data.response = response.response;
+                    data.userId = response.userId;
+                }
+                break;
+            }
+            case 'view-request': {
+                const viewReq = args[0];
+                if (viewReq) {
+                    data.goalHash = viewReq.goalHash;
+                    data.viewType = viewReq.viewType;
+                }
+                break;
+            }
+            case 'view-response-sent':
+            case 'modification-redirected': {
+                const payload = args[0];
+                if (payload) {
+                    Object.assign(data, payload);
+                }
+                break;
+            }
+            case 'error':
+                data.error = args[0] instanceof Error ? args[0].message : String(args[0]);
+                break;
+        }
+        return data;
+    }
+    setupReviewSchedulerEvents() {
+        if (!this.reviewScheduler || !this.ipcServer) {
+            return;
+        }
+        const events = [
+            'review-scheduled',
+            'review-due',
+            'review-completed',
+            'review-snoozed',
+            'error',
+        ];
+        for (const event of events) {
+            this.reviewScheduler.on(event, (...args) => {
+                const data = this.serializeReviewSchedulerEventData(event, args);
+                this.ipcServer.broadcast(`review:${event}`, data);
+                if (event === 'review-due' || event === 'review-completed') {
+                    this.logMessage('info', `Review event: ${event}`, data);
+                }
+            });
+        }
+    }
+    serializeReviewSchedulerEventData(event, args) {
+        const data = { event };
+        if (args[0] && typeof args[0] === 'object') {
+            const review = args[0];
+            if ('id' in review)
+                data.reviewId = review.id;
+            if ('goalHash' in review)
+                data.goalHash = review.goalHash;
+            if ('type' in review)
+                data.reviewType = review.type;
+            if ('scheduledFor' in review)
+                data.scheduledFor = review.scheduledFor;
+            if ('status' in review)
+                data.status = review.status;
+        }
+        if (event === 'error') {
+            data.error = args[0] instanceof Error ? args[0].message : String(args[0]);
+        }
+        return data;
+    }
+    setupProgressTrackerEvents() {
+        if (!this.progressTracker || !this.ipcServer) {
+            return;
+        }
+        const events = [
+            'task-completed',
+            'milestone-completed',
+            'goal-completed',
+            'velocity-updated',
+            'snapshot-created',
+            'error',
+        ];
+        for (const event of events) {
+            this.progressTracker.on(event, (...args) => {
+                const data = this.serializeProgressTrackerEventData(event, args);
+                this.ipcServer.broadcast(`progress:${event}`, data);
+                if (event.includes('completed')) {
+                    this.logMessage('info', `Progress event: ${event}`, data);
+                }
+            });
+        }
+    }
+    serializeProgressTrackerEventData(event, args) {
+        const data = { event };
+        if (args[0] && typeof args[0] === 'object') {
+            const entity = args[0];
+            if ('hash' in entity)
+                data.goalHash = entity.hash;
+            if ('goal_hash' in entity)
+                data.goalHash = entity.goal_hash;
+            if ('goalHash' in entity)
+                data.goalHash = entity.goalHash;
+            if ('id' in entity)
+                data.id = entity.id;
+            if ('progress' in entity)
+                data.progress = entity.progress;
+            if ('completedAt' in entity)
+                data.completedAt = entity.completedAt;
+        }
+        if (args[1] && typeof args[1] === 'object') {
+            const context = args[1];
+            if ('velocity' in context)
+                data.velocity = context.velocity;
+            if ('milestone' in context)
+                data.milestoneId = context.milestone?.id;
+        }
+        if (event === 'error') {
+            data.error = args[0] instanceof Error ? args[0].message : String(args[0]);
+        }
+        return data;
+    }
+    setupErrorRecoveryEvents() {
+        if (!this.errorRecovery || !this.ipcServer) {
+            return;
+        }
+        const events = [
+            'checkpoint-created',
+            'checkpoint-restored',
+            'checkpoint-cleared',
+            'error-analyzed',
+            'recovery-attempted',
+            'recovery-succeeded',
+            'recovery-failed',
+            'error',
+        ];
+        for (const event of events) {
+            this.errorRecovery.on(event, (...args) => {
+                const data = this.serializeErrorRecoveryEventData(event, args);
+                this.ipcServer.broadcast(`recovery:${event}`, data);
+                if (event === 'recovery-succeeded' || event === 'recovery-failed' || event === 'error') {
+                    this.logMessage('info', `Recovery event: ${event}`, data);
+                }
+            });
+        }
+    }
+    serializeErrorRecoveryEventData(event, args) {
+        const data = { event };
+        if (args[0] && typeof args[0] === 'object') {
+            const payload = args[0];
+            if ('id' in payload)
+                data.checkpointId = payload.id;
+            if ('goalHash' in payload)
+                data.goalHash = payload.goalHash;
+            if ('taskId' in payload)
+                data.taskId = payload.taskId;
+            if ('createdAt' in payload)
+                data.createdAt = payload.createdAt;
+            if ('category' in payload)
+                data.category = payload.category;
+            if ('recoverable' in payload)
+                data.recoverable = payload.recoverable;
+            if ('suggestedAction' in payload)
+                data.suggestedAction = payload.suggestedAction;
+            if ('message' in payload)
+                data.message = payload.message;
+        }
+        if (event === 'error') {
+            data.error = args[0] instanceof Error ? args[0].message : String(args[0]);
+        }
+        return data;
+    }
+    setupGoalSchedulerEvents() {
+        if (!this.goalScheduler || !this.ipcServer) {
+            return;
+        }
+        const events = [
+            'poll-started',
+            'poll-completed',
+            'execution-started',
+            'execution-completed',
+            'execution-skipped',
+            'error',
+        ];
+        for (const event of events) {
+            this.goalScheduler.on(event, (...args) => {
+                const data = this.serializeGoalSchedulerEventData(event, args);
+                this.ipcServer.broadcast(`goal-scheduler:${event}`, data);
+                if (event === 'execution-started' || event === 'execution-completed' || event === 'error') {
+                    this.logMessage('info', `GoalScheduler event: ${event}`, data);
+                }
+            });
+        }
+    }
+    serializeGoalSchedulerEventData(event, args) {
+        const data = { event };
+        if (event === 'poll-completed' && typeof args[0] === 'number') {
+            data.dueGoalsCount = args[0];
+        }
+        if (event === 'execution-started' || event === 'execution-completed' || event === 'execution-skipped') {
+            const goal = args[0];
+            if (goal) {
+                data.goalHash = goal.hash;
+                data.goalName = goal.name;
+                data.goalId = goal.id;
+            }
+            if (event === 'execution-completed' && args.length > 1) {
+                data.success = args[1];
+                if (args[2])
+                    data.error = args[2];
+            }
+            if (event === 'execution-skipped' && args[1]) {
+                data.reason = args[1];
+            }
+        }
+        if (event === 'error') {
+            data.error = args[0] instanceof Error ? args[0].message : String(args[0]);
+            if (args[1] && typeof args[1] === 'object') {
+                data.context = args[1];
+            }
+        }
+        return data;
+    }
+    createGetDueGoalsFunction() {
+        return async () => {
+            if (!this.goalConfig) {
+                return [];
+            }
+            const os = await import('os');
+            const fs = await import('fs');
+            const pathMod = await import('path');
+            const goalsDir = pathMod.join(os.homedir(), '.flowdot', 'goals');
+            if (!fs.existsSync(goalsDir))
+                return [];
+            const now = new Date();
+            const dueGoals = [];
+            const goalDirs = fs.readdirSync(goalsDir).filter(name => {
+                const p = pathMod.join(goalsDir, name);
+                return fs.statSync(p).isDirectory();
+            });
+            for (const goalHash of goalDirs) {
+                const schedulePath = pathMod.join(goalsDir, goalHash, 'schedule.json');
+                if (!fs.existsSync(schedulePath))
+                    continue;
+                let schedule;
+                try {
+                    schedule = JSON.parse(fs.readFileSync(schedulePath, 'utf-8'));
+                }
+                catch {
+                    continue;
+                }
+                if (!schedule.enabled)
+                    continue;
+                if (schedule.nextRunAt) {
+                    const nextRun = new Date(schedule.nextRunAt);
+                    if (nextRun > now)
+                        continue;
+                }
+                let name = goalHash;
+                const statePath = pathMod.join(goalsDir, goalHash, 'state.json');
+                if (fs.existsSync(statePath)) {
+                    try {
+                        const state = JSON.parse(fs.readFileSync(statePath, 'utf-8'));
+                        name = state.name || goalHash;
+                    }
+                    catch { }
+                }
+                dueGoals.push({
+                    id: 0,
+                    hash: goalHash,
+                    userId: 0,
+                    name,
+                    description: null,
+                    approvalMode: 'category',
+                    scheduleType: schedule.type === 'cron' ? 'cron' : 'interval',
+                    cronExpression: schedule.cronExpression || null,
+                    intervalMinutes: schedule.intervalMinutes || null,
+                    scheduleTimezone: schedule.timezone || 'UTC',
+                    executionRecipe: schedule.executionRecipe || null,
+                    maxIterations: schedule.maxIterations || 50,
+                    maxRuntimeMinutes: schedule.maxRuntimeMinutes || 30,
+                    llmTier: (schedule.llmTier || 'capable'),
+                    allowedActions: null,
+                    blockedActions: null,
+                    nextRunAt: schedule.nextRunAt || now.toISOString(),
+                    consecutiveFailures: schedule.consecutiveFailures || 0,
+                    user: { id: 0, name: '', email: '' },
+                });
+            }
+            return dueGoals;
+        };
+    }
+    createMarkGoalStartedFunction() {
+        return async (goalId, metadata) => {
+            if (!this.goalConfig) {
+                return;
+            }
+            const token = await this.goalConfig.tokenProvider();
+            const response = await fetch(`${this.goalConfig.baseUrl}/api/internal/goals/schedule/${goalId}/started`, {
+                method: 'POST',
+                headers: {
+                    'Authorization': `Bearer ${token}`,
+                    'Content-Type': 'application/json',
+                    'Accept': 'application/json',
+                },
+                body: JSON.stringify({ metadata }),
+            });
+            if (!response.ok) {
+                throw new Error(`Failed to mark goal started: ${response.status}`);
+            }
+        };
+    }
+    createMarkGoalCompletedFunction() {
+        return async (goalId, status, options) => {
+            if (!this.goalConfig) {
+                return { nextRunAt: null, scheduleActive: false };
+            }
+            const token = await this.goalConfig.tokenProvider();
+            const response = await fetch(`${this.goalConfig.baseUrl}/api/internal/goals/schedule/${goalId}/completed`, {
+                method: 'POST',
+                headers: {
+                    'Authorization': `Bearer ${token}`,
+                    'Content-Type': 'application/json',
+                    'Accept': 'application/json',
+                },
+                body: JSON.stringify({
+                    status,
+                    error: options?.error,
+                    progress: options?.progress,
+                }),
+            });
+            if (!response.ok) {
+                throw new Error(`Failed to mark goal completed: ${response.status}`);
+            }
+            const json = await response.json();
+            return {
+                nextRunAt: json.next_run_at ?? null,
+                scheduleActive: json.schedule_active ?? false,
+            };
+        };
+    }
+    createDefaultExecuteGoalFunction() {
+        return async (goal) => {
+            try {
+                this.logMessage('info', `Executing scheduled goal: ${goal.name}`, {
+                    goalHash: goal.hash,
+                    executionRecipe: goal.executionRecipe,
+                });
+                if (goal.executionRecipe) {
+                    this.emit('goal:execute-recipe', goal.hash, goal.executionRecipe);
+                    if (this.ipcServer) {
+                        this.ipcServer.broadcast('goal:execute-recipe', {
+                            goalHash: goal.hash,
+                            recipeHash: goal.executionRecipe,
+                            goalId: goal.id,
+                            userId: goal.userId,
+                            approvalMode: goal.approvalMode,
+                            llmTier: goal.llmTier,
+                            maxIterations: goal.maxIterations,
+                            maxRuntimeMinutes: goal.maxRuntimeMinutes,
+                            allowedActions: goal.allowedActions,
+                            blockedActions: goal.blockedActions,
+                        });
+                    }
+                    return { success: true, data: { recipeStarted: goal.executionRecipe } };
+                }
+                if (this.taskExecutor && this.goalManager) {
+                    const fullGoal = await this.goalManager.getGoal(goal.hash);
+                    const tasks = await this.goalManager.listTasks(goal.hash, { status: 'pending' });
+                    if (tasks.length === 0) {
+                        return { success: true, data: { message: 'No pending tasks' } };
+                    }
+                    let successCount = 0;
+                    let failCount = 0;
+                    const errors = [];
+                    for (const task of tasks.slice(0, goal.maxIterations)) {
+                        try {
+                            const result = await this.taskExecutor.execute(fullGoal, task);
+                            if (result.success) {
+                                successCount++;
+                                await this.goalManager.completeTask(goal.hash, task.id, result.data);
+                            }
+                            else {
+                                failCount++;
+                                errors.push(result.error ?? 'Unknown error');
+                                await this.goalManager.failTask(goal.hash, task.id, {
+                                    error: result.error ?? 'Unknown error',
+                                });
+                            }
+                        }
+                        catch (err) {
+                            failCount++;
+                            const errorMessage = err instanceof Error ? err.message : String(err);
+                            errors.push(errorMessage);
+                            try {
+                                await this.goalManager.failTask(goal.hash, task.id, {
+                                    error: errorMessage,
+                                });
+                            }
+                            catch {
+                            }
+                        }
+                    }
+                    const success = failCount === 0 || successCount > 0;
+                    return {
+                        success,
+                        data: { successCount, failCount, totalTasks: tasks.length },
+                        error: errors.length > 0 ? errors.join('; ') : undefined,
+                    };
+                }
+                return { success: false, error: 'No task execution capability configured' };
+            }
+            catch (err) {
+                const errorMessage = err instanceof Error ? err.message : String(err);
+                this.logMessage('error', `Goal execution failed: ${errorMessage}`, { goalHash: goal.hash });
+                return { success: false, error: errorMessage };
+            }
+        };
+    }
+    setupSignalHandlers() {
+        const handleShutdown = (signal) => {
+            this.logMessage('info', `Received ${signal}, shutting down...`);
+            this.stop()
+                .then(() => process.exit(0))
+                .catch(() => process.exit(1));
+        };
+        process.on('SIGTERM', () => handleShutdown('SIGTERM'));
+        process.on('SIGINT', () => handleShutdown('SIGINT'));
+        process.on('uncaughtException', (error) => {
+            this.logMessage('error', `Uncaught exception: ${error.message}`, { stack: error.stack });
+            this.stop()
+                .then(() => process.exit(1))
+                .catch(() => process.exit(1));
+        });
+        process.on('unhandledRejection', (reason) => {
+            this.logMessage('error', `Unhandled rejection: ${reason}`);
+        });
+    }
+    async setupLogging() {
+        const logPath = path.join(this.flowdotDir, 'loops', 'daemon.log');
+        try {
+            this.logStream = await fs.open(logPath, 'a');
+        }
+        catch (error) {
+            this.logger.warn('LOOP', 'Could not open daemon log file', {
+                error: error instanceof Error ? error.message : String(error),
+            });
+        }
+    }
+    async closeLogStream() {
+        if (this.logStream) {
+            try {
+                await this.logStream.close();
+            }
+            catch {
+            }
+            this.logStream = null;
+        }
+    }
+    logMessage(level, message, data) {
+        if (level === 'debug' && this.config.logLevel !== 'debug') {
+            return;
+        }
+        const timestamp = new Date().toISOString();
+        const logLine = JSON.stringify({
+            timestamp,
+            level,
+            message,
+            ...data,
+        }) + '\n';
+        if (this.logStream) {
+            this.logStream.write(logLine).catch(() => {
+            });
+        }
+    }
+    async ensureDirectories() {
+        const loopsDir = path.join(this.flowdotDir, 'loops');
+        await fs.mkdir(loopsDir, { recursive: true });
+    }
+    async cleanup() {
+        try {
+            if (this.manager) {
+                await this.manager.shutdown();
+                this.manager = null;
+            }
+        }
+        catch {
+        }
+        try {
+            if (this.goalManager) {
+                this.goalManager.clearCache();
+                this.goalManager = null;
+            }
+        }
+        catch {
+        }
+        this.taskGenerator = null;
+        this.taskExecutor = null;
+        this.permissionBridge = null;
+        this.goalCommsHandler = null;
+        if (this.reviewScheduler) {
+            this.reviewScheduler.stop();
+        }
+        this.reviewScheduler = null;
+        this.progressTracker = null;
+        this.errorRecovery = null;
+        try {
+            if (this.ipcServer) {
+                await this.ipcServer.stop();
+                this.ipcServer = null;
+            }
+        }
+        catch {
+        }
+        try {
+            await this.store.deleteDaemonPid();
+        }
+        catch {
+        }
+        await this.closeLogStream();
+    }
+}
+export async function startDaemon(options) {
+    const baseDir = options?.baseDir ?? process.cwd();
+    const port = options?.daemonConfig?.port ?? options?.port ?? 47691;
+    const logger = options?.logger ?? noopLogger;
+    if (await isDaemonRunning({ port })) {
+        const store = new LoopStore({ baseDir, logger });
+        const pidInfo = await store.readDaemonPid();
+        throw new DaemonAlreadyRunningError(pidInfo?.pid ?? 0);
+    }
+    const daemonScript = options?.daemonScript ?? getDaemonEntryPoint();
+    const args = [
+        '--daemon',
+        '--base-dir', baseDir,
+        '--port', String(port),
+    ];
+    if (options?.daemonConfig?.logLevel) {
+        args.push('--log-level', options.daemonConfig.logLevel);
+    }
+    const child = spawn(process.execPath, [daemonScript, ...args], {
+        detached: true,
+        stdio: 'ignore',
+        cwd: baseDir,
+        env: {
+            ...process.env,
+            FLOWDOT_DAEMON: 'true',
+        },
+    });
+    child.unref();
+    const startTime = Date.now();
+    while (Date.now() - startTime < DAEMON_STARTUP_TIMEOUT_MS) {
+        if (await isDaemonRunning({ port })) {
+            const store = new LoopStore({ baseDir, logger });
+            const pidInfo = await store.readDaemonPid();
+            return { pid: pidInfo?.pid ?? child.pid ?? 0 };
+        }
+        await sleep(PROCESS_CHECK_INTERVAL_MS);
+    }
+    throw new DaemonStartFailedError('Daemon failed to start within timeout');
+}
+export async function stopDaemon(options) {
+    const port = options?.port ?? 47691;
+    const baseDir = options?.baseDir ?? process.cwd();
+    const logger = options?.logger ?? noopLogger;
+    if (!(await isDaemonRunning({ port }))) {
+        throw new DaemonNotRunningError();
+    }
+    const client = new IPCClient({ port, logger });
+    try {
+        await client.connect();
+        await client.request('shutdown', {});
+    }
+    finally {
+        client.disconnect();
+    }
+    const startTime = Date.now();
+    while (Date.now() - startTime < DAEMON_SHUTDOWN_TIMEOUT_MS) {
+        if (!(await isDaemonRunning({ port }))) {
+            return;
+        }
+        await sleep(PROCESS_CHECK_INTERVAL_MS);
+    }
+    const store = new LoopStore({ baseDir, logger });
+    const pidInfo = await store.readDaemonPid();
+    if (pidInfo) {
+        try {
+            process.kill(pidInfo.pid, 'SIGKILL');
+            await store.deleteDaemonPid();
+        }
+        catch {
+        }
+    }
+}
+export async function getDaemonStatus(options) {
+    const port = options?.port ?? 47691;
+    const baseDir = options?.baseDir ?? process.cwd();
+    const logger = options?.logger ?? noopLogger;
+    if (!(await isDaemonRunning({ port }))) {
+        const store = new LoopStore({ baseDir, logger });
+        const pidInfo = await store.readDaemonPid();
+        return {
+            running: false,
+            pid: pidInfo?.pid ?? null,
+            startedAt: pidInfo?.startedAt ?? null,
+            activeLoops: 0,
+            uptime: null,
+        };
+    }
+    const client = new IPCClient({ port, logger });
+    try {
+        await client.connect();
+        return await client.request('status', {});
+    }
+    finally {
+        client.disconnect();
+    }
+}
+export function isProcessRunning(pid) {
+    try {
+        process.kill(pid, 0);
+        return true;
+    }
+    catch {
+        return false;
+    }
+}
+function getDaemonEntryPoint() {
+    if (process.env.FLOWDOT_DAEMON_SCRIPT) {
+        return process.env.FLOWDOT_DAEMON_SCRIPT;
+    }
+    const cliPath = path.join(__dirname, 'daemon-runner.js');
+    return cliPath;
+}
+function sleep(ms) {
+    return new Promise((resolve) => setTimeout(resolve, ms));
+}
+export function createLoopDaemon(options) {
+    return new LoopDaemon(options);
+}
+export async function runDaemon(options) {
+    const daemon = createLoopDaemon(options);
+    await daemon.start();
+    await new Promise((resolve) => {
+        daemon.on('stopped', resolve);
+    });
+}