@flowdot.ai/daemon 1.0.0

package/LICENSE

@@ -0,0 +1,45 @@
+FlowDot Proprietary Software License
+
+Copyright (c) 2026 FlowDot LLC. All Rights Reserved.
+
+TERMS AND CONDITIONS
+
+1. GRANT OF LICENSE
+   FlowDot LLC grants you a limited, non-exclusive, non-transferable license
+   to install and use this software for personal or commercial purposes,
+   subject to the terms of this agreement.
+
+2. RESTRICTIONS
+   You may NOT:
+   - Modify, alter, adapt, or create derivative works of this software
+   - Reverse engineer, decompile, disassemble, or attempt to derive the
+     source code of this software
+   - Redistribute, sublicense, lease, rent, or sell copies of this software
+   - Remove, alter, or obscure any proprietary notices, labels, or marks
+   - Use this software to create a competing product or service
+
+3. OWNERSHIP
+   This software is licensed, not sold. FlowDot LLC retains all right, title,
+   and interest in and to the software, including all intellectual property
+   rights therein.
+
+4. TERMINATION
+   This license is effective until terminated. Your rights under this license
+   will terminate automatically without notice if you fail to comply with any
+   of its terms.
+
+5. DISCLAIMER OF WARRANTIES
+   THIS SOFTWARE IS PROVIDED "AS IS" WITHOUT WARRANTY OF ANY KIND, EXPRESS OR
+   IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY,
+   FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT.
+
+6. LIMITATION OF LIABILITY
+   IN NO EVENT SHALL FLOWDOT LLC BE LIABLE FOR ANY INDIRECT, INCIDENTAL,
+   SPECIAL, EXEMPLARY, OR CONSEQUENTIAL DAMAGES ARISING OUT OF OR IN
+   CONNECTION WITH THIS SOFTWARE.
+
+7. GOVERNING LAW
+   This agreement shall be governed by the laws of the State of Delaware,
+   United States, without regard to its conflict of law provisions.
+
+For licensing inquiries, contact: hello@flowdot.ai

package/README.md

@@ -0,0 +1,51 @@
+# @flowdot.ai/daemon
+
+Shared daemon and loop/goal management for the [FlowDot](https://flowdot.ai) platform.
+
+Used by the FlowDot CLI and the FlowDot native desktop app to run background loops, track autonomous goals, and coordinate IPC between local clients and the FlowDot Hub.
+
+## Features
+
+- **Loop scheduling** — background execution of scheduled FlowDot workflows
+- **Goal tracking** — autonomous task execution with dependency resolution, progress tracking, and error recovery
+- **IPC** — daemon-to-client communication over local sockets
+- **Notifications** — terminal, webhook, and Slack delivery
+- **State management** — persistent daemon state with crash recovery
+
+## Installation
+
+```bash
+npm install @flowdot.ai/daemon
+```
+
+`@flowdot.ai/api` is an optional peer dependency — install it if you want to use the api-backed features.
+
+```bash
+npm install @flowdot.ai/daemon @flowdot.ai/api
+```
+
+## Usage
+
+```typescript
+import {
+  LoopDaemon,
+  LoopManager,
+  IPCClient,
+  createNotifier,
+  GoalManager,
+  TaskGenerator,
+  TaskExecutor,
+} from '@flowdot.ai/daemon';
+```
+
+See the [FlowDot CLI source](https://github.com/ElliotTheGreek/flowdot-cli) for end-to-end integration examples.
+
+## Requirements
+
+- Node.js ≥ 20.0.0
+
+## License
+
+Proprietary — see [LICENSE](./LICENSE).
+
+Copyright © 2026 FlowDot LLC. All rights reserved.

package/dist/goals/DependencyResolver.d.ts

@@ -0,0 +1,54 @@
+import type { Goal, Task, GoalHash, Logger } from './types.js';
+import { GoalError } from './errors.js';
+export interface DependencyNode {
+    readonly id: string;
+    readonly dependsOn: string[];
+    readonly dependents: string[];
+    readonly status: 'pending' | 'ready' | 'blocked' | 'completed';
+    readonly blockReason?: string;
+}
+export interface GoalResolutionResult {
+    readonly orderedGoals: GoalHash[];
+    readonly blockedGoals: Map<GoalHash, string>;
+    readonly circularGoals: GoalHash[];
+    readonly graph: Map<GoalHash, DependencyNode>;
+    readonly success: boolean;
+    readonly errors: string[];
+}
+export interface TaskDependencyNode {
+    readonly taskId: number;
+    readonly goalHash: GoalHash;
+    readonly title: string;
+    readonly dependsOn: number[];
+    readonly isReady: boolean;
+    readonly blockReason?: string;
+}
+export interface DependencyResolverOptions {
+    readonly logger?: Logger;
+}
+export declare class DependencyResolutionError extends GoalError {
+    constructor(message: string, cause?: Error);
+}
+export declare class DependencyResolver {
+    private readonly logger;
+    constructor(options?: DependencyResolverOptions);
+    resolveGoals(goals: Goal[]): GoalResolutionResult;
+    canStartGoal(goal: Goal, allGoals: Goal[]): {
+        canStart: boolean;
+        reason?: string;
+        waitingOn?: GoalHash[];
+    };
+    getBlockedBy(goalHash: GoalHash, allGoals: Goal[]): GoalHash[];
+    wouldCreateCycle(fromGoal: GoalHash, toGoal: GoalHash, allGoals: Goal[]): boolean;
+    resolveTasks(tasks: Task[], _goalHash: GoalHash): {
+        orderedTasks: Task[];
+        blocked: Map<number, string>;
+    };
+    getTaskExecutionOrder(tasks: Task[], milestoneOrder: number[]): Task[];
+    private detectCircularDependencies;
+    private topologicalSort;
+}
+export declare function getTransitiveDependencies(goalHash: GoalHash, allGoals: Goal[]): GoalHash[];
+export declare function getTransitiveDependents(goalHash: GoalHash, allGoals: Goal[]): GoalHash[];
+export declare function calculateCriticalPath(goals: Goal[]): GoalHash[];
+export declare function createDependencyResolver(options?: DependencyResolverOptions): DependencyResolver;

package/dist/goals/DependencyResolver.js

@@ -0,0 +1,329 @@
+function getPriorityWeight(priority) {
+    switch (priority) {
+        case 'high': return 3;
+        case 'medium': return 2;
+        case 'low': return 1;
+        default: return 0;
+    }
+}
+import { GoalError } from './errors.js';
+const noopLogger = {
+    debug: () => { },
+    info: () => { },
+    warn: () => { },
+    error: () => { },
+};
+export class DependencyResolutionError extends GoalError {
+    constructor(message, cause) {
+        super('DEPENDENCY_RESOLUTION_ERROR', message, cause ? { cause } : {});
+    }
+}
+export class DependencyResolver {
+    logger;
+    constructor(options = {}) {
+        this.logger = options.logger ?? noopLogger;
+    }
+    resolveGoals(goals) {
+        const graph = new Map();
+        const errors = [];
+        for (const goal of goals) {
+            const dependsOn = goal.dependsOn ?? [];
+            graph.set(goal.hash, {
+                id: goal.hash,
+                dependsOn,
+                dependents: [],
+                status: goal.status === 'completed' ? 'completed' : 'pending',
+            });
+        }
+        for (const node of graph.values()) {
+            for (const depId of node.dependsOn) {
+                const depNode = graph.get(depId);
+                if (depNode) {
+                    depNode.dependents.push(node.id);
+                }
+            }
+        }
+        const circularGoals = this.detectCircularDependencies(graph);
+        if (circularGoals.length > 0) {
+            errors.push(`Circular dependencies detected: ${circularGoals.join(' -> ')}`);
+        }
+        const blockedGoals = new Map();
+        for (const [hash, node] of graph) {
+            if (circularGoals.includes(hash)) {
+                blockedGoals.set(hash, 'Circular dependency detected');
+                node.status = 'blocked';
+                node.blockReason =
+                    'Circular dependency detected';
+                continue;
+            }
+            const incompleteDeps = [];
+            for (const depId of node.dependsOn) {
+                const depNode = graph.get(depId);
+                if (depNode && depNode.status !== 'completed') {
+                    incompleteDeps.push(depId);
+                }
+                else if (!depNode) {
+                    incompleteDeps.push(`${depId} (not found)`);
+                }
+            }
+            if (incompleteDeps.length > 0) {
+                blockedGoals.set(hash, `Waiting on: ${incompleteDeps.join(', ')}`);
+                node.status = 'blocked';
+                node.blockReason =
+                    `Waiting on: ${incompleteDeps.join(', ')}`;
+            }
+            else if (node.status !== 'completed') {
+                node.status = 'ready';
+            }
+        }
+        const orderedGoals = this.topologicalSort(graph, circularGoals);
+        this.logger.debug('DEPENDENCY_RESOLVER', 'Goals resolved', {
+            total: goals.length,
+            ready: orderedGoals.length,
+            blocked: blockedGoals.size,
+            circular: circularGoals.length,
+        });
+        return {
+            orderedGoals,
+            blockedGoals,
+            circularGoals,
+            graph,
+            success: errors.length === 0,
+            errors,
+        };
+    }
+    canStartGoal(goal, allGoals) {
+        if (!goal.dependsOn || goal.dependsOn.length === 0) {
+            return { canStart: true };
+        }
+        const waitingOn = [];
+        for (const depHash of goal.dependsOn) {
+            const depGoal = allGoals.find((g) => g.hash === depHash);
+            if (!depGoal) {
+                waitingOn.push(depHash);
+            }
+            else if (depGoal.status !== 'completed') {
+                waitingOn.push(depHash);
+            }
+        }
+        if (waitingOn.length > 0) {
+            return {
+                canStart: false,
+                reason: `Waiting on ${waitingOn.length} dependent goal(s)`,
+                waitingOn,
+            };
+        }
+        return { canStart: true };
+    }
+    getBlockedBy(goalHash, allGoals) {
+        const blocked = [];
+        for (const goal of allGoals) {
+            if (goal.dependsOn?.includes(goalHash)) {
+                blocked.push(goal.hash);
+            }
+        }
+        return blocked;
+    }
+    wouldCreateCycle(fromGoal, toGoal, allGoals) {
+        const visited = new Set();
+        const stack = [toGoal];
+        while (stack.length > 0) {
+            const current = stack.pop();
+            if (visited.has(current)) {
+                continue;
+            }
+            visited.add(current);
+            if (current === fromGoal) {
+                return true;
+            }
+            const goal = allGoals.find((g) => g.hash === current);
+            if (goal?.dependsOn) {
+                for (const dep of goal.dependsOn) {
+                    stack.push(dep);
+                }
+            }
+        }
+        return false;
+    }
+    resolveTasks(tasks, _goalHash) {
+        const blocked = new Map();
+        const completed = new Set();
+        const pending = [];
+        for (const task of tasks) {
+            if (task.status === 'completed') {
+                completed.add(task.id);
+            }
+            else if (task.status === 'pending' || task.status === 'awaiting_approval') {
+                pending.push(task);
+            }
+        }
+        const ready = [];
+        for (const task of pending) {
+            ready.push(task);
+        }
+        ready.sort((a, b) => getPriorityWeight(b.priority) - getPriorityWeight(a.priority));
+        return {
+            orderedTasks: ready,
+            blocked,
+        };
+    }
+    getTaskExecutionOrder(tasks, milestoneOrder) {
+        const byMilestone = new Map();
+        for (const task of tasks) {
+            const key = task.milestoneId ?? null;
+            if (!byMilestone.has(key)) {
+                byMilestone.set(key, []);
+            }
+            byMilestone.get(key).push(task);
+        }
+        const ordered = [];
+        const general = byMilestone.get(null) ?? [];
+        general.sort((a, b) => getPriorityWeight(b.priority) - getPriorityWeight(a.priority));
+        ordered.push(...general);
+        for (const milestoneId of milestoneOrder) {
+            const milestoneTasks = byMilestone.get(milestoneId) ?? [];
+            milestoneTasks.sort((a, b) => getPriorityWeight(b.priority) - getPriorityWeight(a.priority));
+            ordered.push(...milestoneTasks);
+        }
+        return ordered;
+    }
+    detectCircularDependencies(graph) {
+        const circularGoals = [];
+        const visited = new Set();
+        const recursionStack = new Set();
+        const dfs = (nodeId, path) => {
+            if (recursionStack.has(nodeId)) {
+                const cycleStart = path.indexOf(nodeId);
+                const cycle = path.slice(cycleStart);
+                cycle.forEach((id) => {
+                    if (!circularGoals.includes(id)) {
+                        circularGoals.push(id);
+                    }
+                });
+                return true;
+            }
+            if (visited.has(nodeId)) {
+                return false;
+            }
+            visited.add(nodeId);
+            recursionStack.add(nodeId);
+            path.push(nodeId);
+            const node = graph.get(nodeId);
+            if (node) {
+                for (const depId of node.dependsOn) {
+                    if (dfs(depId, [...path])) {
+                    }
+                }
+            }
+            recursionStack.delete(nodeId);
+            return false;
+        };
+        for (const nodeId of graph.keys()) {
+            if (!visited.has(nodeId)) {
+                dfs(nodeId, []);
+            }
+        }
+        return circularGoals;
+    }
+    topologicalSort(graph, exclude) {
+        const result = [];
+        const visited = new Set();
+        const temp = new Set();
+        const visit = (nodeId) => {
+            if (visited.has(nodeId) || exclude.includes(nodeId)) {
+                return;
+            }
+            if (temp.has(nodeId)) {
+                return;
+            }
+            temp.add(nodeId);
+            const node = graph.get(nodeId);
+            if (node) {
+                for (const depId of node.dependsOn) {
+                    visit(depId);
+                }
+            }
+            temp.delete(nodeId);
+            visited.add(nodeId);
+            if (node && node.status === 'ready') {
+                result.push(nodeId);
+            }
+        };
+        for (const nodeId of graph.keys()) {
+            visit(nodeId);
+        }
+        return result;
+    }
+}
+export function getTransitiveDependencies(goalHash, allGoals) {
+    const result = new Set();
+    const stack = [goalHash];
+    while (stack.length > 0) {
+        const current = stack.pop();
+        const goal = allGoals.find((g) => g.hash === current);
+        if (goal?.dependsOn) {
+            for (const dep of goal.dependsOn) {
+                if (!result.has(dep)) {
+                    result.add(dep);
+                    stack.push(dep);
+                }
+            }
+        }
+    }
+    return Array.from(result);
+}
+export function getTransitiveDependents(goalHash, allGoals) {
+    const result = new Set();
+    const stack = [goalHash];
+    while (stack.length > 0) {
+        const current = stack.pop();
+        for (const goal of allGoals) {
+            if (goal.dependsOn?.includes(current) && !result.has(goal.hash)) {
+                result.add(goal.hash);
+                stack.push(goal.hash);
+            }
+        }
+    }
+    return Array.from(result);
+}
+export function calculateCriticalPath(goals) {
+    const endNodes = goals.filter((g) => {
+        const hasDependents = goals.some((other) => other.dependsOn?.includes(g.hash));
+        return !hasDependents && g.status !== 'completed';
+    });
+    if (endNodes.length === 0) {
+        return [];
+    }
+    let longestPath = [];
+    for (const endNode of endNodes) {
+        const path = findLongestPath(endNode.hash, goals, new Set());
+        if (path.length > longestPath.length) {
+            longestPath = path;
+        }
+    }
+    return longestPath.reverse();
+}
+function findLongestPath(goalHash, allGoals, visited) {
+    if (visited.has(goalHash)) {
+        return [];
+    }
+    visited.add(goalHash);
+    const goal = allGoals.find((g) => g.hash === goalHash);
+    if (!goal) {
+        return [goalHash];
+    }
+    if (!goal.dependsOn || goal.dependsOn.length === 0) {
+        return [goalHash];
+    }
+    let longestDepPath = [];
+    for (const depHash of goal.dependsOn) {
+        const depPath = findLongestPath(depHash, allGoals, new Set(visited));
+        if (depPath.length > longestDepPath.length) {
+            longestDepPath = depPath;
+        }
+    }
+    return [goalHash, ...longestDepPath];
+}
+export function createDependencyResolver(options = {}) {
+    return new DependencyResolver(options);
+}

package/dist/goals/ErrorRecovery.d.ts

@@ -0,0 +1,133 @@
+import { EventEmitter } from 'node:events';
+import type { Goal, GoalHash, Task, TaskStatus, Logger } from './types.js';
+import { GoalError } from './errors.js';
+import type { ExecutionResult } from './TaskExecutor.js';
+export type RecoveryStrategy = 'retry' | 'skip' | 'rollback' | 'escalate' | 'abort';
+export type ErrorCategory = 'transient' | 'permission' | 'validation' | 'resource' | 'timeout' | 'network' | 'system' | 'unknown';
+export interface Checkpoint {
+    readonly id: string;
+    readonly goalHash: GoalHash;
+    readonly taskId: number;
+    readonly taskStatus: TaskStatus;
+    readonly timestamp: Date;
+    readonly stateData: CheckpointState;
+    readonly description?: string;
+}
+export interface CheckpointState {
+    readonly completedTasks: number[];
+    readonly pendingTasks: number[];
+    readonly customData?: Record<string, unknown>;
+}
+export interface ErrorAnalysis {
+    readonly category: ErrorCategory;
+    readonly rootCause: string;
+    readonly isRecoverable: boolean;
+    readonly recommendedStrategy: RecoveryStrategy;
+    readonly confidence: number;
+    readonly suggestions: string[];
+    readonly relatedErrors?: string[];
+}
+export interface RecoveryAction {
+    readonly type: RecoveryStrategy;
+    readonly taskId: number;
+    readonly goalHash: GoalHash;
+    readonly attempt: number;
+    readonly maxAttempts: number;
+    readonly delayMs: number;
+    readonly checkpointId?: string;
+    readonly timestamp: Date;
+}
+export interface RecoveryResult {
+    readonly success: boolean;
+    readonly strategy: RecoveryStrategy;
+    readonly details: string;
+    readonly newStatus?: TaskStatus;
+    readonly shouldContinue: boolean;
+}
+export interface RetryConfig {
+    readonly maxAttempts: number;
+    readonly baseDelayMs: number;
+    readonly multiplier: number;
+    readonly maxDelayMs: number;
+    readonly jitter: number;
+}
+export interface ErrorRecoveryOptions {
+    readonly logger?: Logger;
+    readonly retryConfig?: Partial<RetryConfig>;
+    readonly maxCheckpointsPerGoal?: number;
+    readonly autoRetryTransient?: boolean;
+    readonly escalateThreshold?: number;
+}
+export interface ErrorRecoveryEvents {
+    'checkpoint-created': [Checkpoint];
+    'checkpoint-restored': [Checkpoint];
+    'error-analyzed': [ErrorAnalysis, ExecutionResult];
+    'recovery-started': [RecoveryAction];
+    'recovery-completed': [RecoveryResult, RecoveryAction];
+    'recovery-failed': [RecoveryResult, RecoveryAction];
+    'escalation-triggered': [{
+        goalHash: GoalHash;
+        taskId: number;
+        reason: string;
+    }];
+    'error': [Error];
+}
+export declare class ErrorRecoveryError extends GoalError {
+    constructor(message: string, cause?: Error);
+}
+export declare class CheckpointNotFoundError extends GoalError {
+    readonly checkpointId: string;
+    constructor(checkpointId: string);
+}
+export declare class ErrorRecovery extends EventEmitter<ErrorRecoveryEvents> {
+    private readonly logger;
+    private readonly retryConfig;
+    private readonly maxCheckpointsPerGoal;
+    private readonly autoRetryTransient;
+    private readonly escalateThreshold;
+    private readonly checkpoints;
+    private readonly failureCounts;
+    private readonly retryState;
+    constructor(options?: ErrorRecoveryOptions);
+    createCheckpoint(goal: Goal, task: Task, state: CheckpointState, description?: string): Checkpoint;
+    getCheckpoints(goalHash: GoalHash): Checkpoint[];
+    getCheckpoint(checkpointId: string): Checkpoint | null;
+    restoreCheckpoint(checkpointId: string, restoreFunction: (state: CheckpointState) => Promise<void>): Promise<void>;
+    clearCheckpoints(goalHash: GoalHash): void;
+    analyzeError(result: ExecutionResult): ErrorAnalysis;
+    private categorizeError;
+    private isRecoverable;
+    private recommendStrategy;
+    private generateSuggestions;
+    private extractRootCause;
+    private calculateConfidence;
+    executeRecovery(action: RecoveryAction, handlers: {
+        retry: (taskId: number) => Promise<ExecutionResult>;
+        skip: (taskId: number) => Promise<void>;
+        rollback: (checkpointId: string) => Promise<void>;
+        escalate: (taskId: number, goalHash: GoalHash) => Promise<void>;
+        abort: (goalHash: GoalHash) => Promise<void>;
+    }): Promise<RecoveryResult>;
+    createRecoveryAction(strategy: RecoveryStrategy, taskId: number, goalHash: GoalHash, options?: {
+        checkpointId?: string;
+        customDelay?: number;
+    }): RecoveryAction;
+    private calculateRetryDelay;
+    private updateRetryState;
+    canRetry(taskId: number): boolean;
+    getRemainingRetries(taskId: number): number;
+    resetRetryState(taskId: number): void;
+    recordFailure(taskId: number): number;
+    getFailureCount(taskId: number): number;
+    shouldEscalate(taskId: number): boolean;
+    private generateCheckpointId;
+    private delay;
+    clearAll(): void;
+    getStats(): {
+        totalCheckpoints: number;
+        goalCheckpoints: Map<GoalHash, number>;
+        failedTasks: number;
+        pendingRetries: number;
+    };
+}
+export declare function createErrorRecovery(options?: ErrorRecoveryOptions): ErrorRecovery;