@flowdot.ai/daemon 1.0.0

package/dist/goals/GoalManager.js

@@ -0,0 +1,535 @@
+import { EventEmitter } from 'node:events';
+import { GoalApiClient, } from './GoalApiClient.js';
+import { GoalValidator } from './GoalValidator.js';
+import { GoalCache } from './GoalCache.js';
+import { GoalNotFoundError, GoalBlockedError, GoalCircularDependencyError, } from './errors.js';
+const noopLogger = {
+    debug: () => { },
+    info: () => { },
+    warn: () => { },
+    error: () => { },
+};
+export class GoalManager extends EventEmitter {
+    apiClient;
+    validator;
+    cache;
+    logger;
+    apiCallCount = 0;
+    loadedGoals = new Set();
+    constructor(options) {
+        super();
+        this.logger = options.logger ?? noopLogger;
+        this.apiClient = new GoalApiClient({
+            baseUrl: options.baseUrl,
+            tokenProvider: options.tokenProvider,
+            logger: this.logger,
+            ...options.apiOptions,
+        });
+        this.validator = new GoalValidator(options.validationConstraints);
+        this.cache = new GoalCache({
+            logger: this.logger,
+            ...options.cacheOptions,
+        });
+        this.cache.on('cleared', (type) => {
+            this.emit('cacheInvalidated', type ?? 'all');
+        });
+        this.logger.info('GOAL_MANAGER', 'Manager initialized');
+    }
+    async initialize() {
+        this.logger.debug('GOAL_MANAGER', 'Async initialization complete');
+    }
+    async listGoals(options) {
+        const cacheKey = JSON.stringify(options ?? {});
+        if (!options?.forceRefresh) {
+            const cached = this.cache.getGoalList(cacheKey);
+            if (cached) {
+                return cached;
+            }
+        }
+        this.apiCallCount++;
+        const goals = await this.apiClient.listGoals(options);
+        this.cache.setGoalList(goals, cacheKey);
+        for (const goal of goals) {
+            this.loadedGoals.add(goal.hash);
+        }
+        return goals;
+    }
+    async getGoal(hash, forceRefresh = false) {
+        this.validator.validateGoalHash(hash);
+        if (!forceRefresh) {
+            const cached = this.cache.getGoal(hash);
+            if (cached) {
+                return cached;
+            }
+        }
+        this.apiCallCount++;
+        const goal = await this.apiClient.getGoal(hash);
+        this.cache.setGoal(goal);
+        this.loadedGoals.add(goal.hash);
+        return goal;
+    }
+    async createGoal(input) {
+        this.validator.validateCreateGoalInput(input);
+        if (input.dependsOn?.length) {
+            await this.validateNoDependencyCycle(input.dependsOn, input.parentHash);
+        }
+        this.apiCallCount++;
+        const goal = await this.apiClient.createGoal(input);
+        this.cache.setGoal(goal);
+        this.cache.invalidateAllGoals();
+        this.loadedGoals.add(goal.hash);
+        this.emit('goalCreated', goal);
+        this.logger.info('GOAL_MANAGER', 'Goal created', { hash: goal.hash, name: goal.name });
+        return goal;
+    }
+    async updateGoal(hash, input) {
+        this.validator.validateGoalHash(hash);
+        this.validator.validateUpdateGoalInput(input);
+        if (input.dependsOn?.length) {
+            await this.validateNoDependencyCycle(input.dependsOn, undefined, hash);
+        }
+        this.apiCallCount++;
+        const goal = await this.apiClient.updateGoal(hash, input);
+        this.cache.setGoal(goal);
+        this.cache.invalidateAllGoals();
+        this.emit('goalUpdated', goal);
+        this.logger.info('GOAL_MANAGER', 'Goal updated', { hash: goal.hash });
+        return goal;
+    }
+    async deleteGoal(hash) {
+        this.validator.validateGoalHash(hash);
+        this.apiCallCount++;
+        await this.apiClient.deleteGoal(hash);
+        this.cache.invalidateGoal(hash);
+        this.cache.invalidateMilestones(hash);
+        this.cache.invalidateTasks(hash);
+        this.cache.invalidateMemories(hash);
+        this.loadedGoals.delete(hash);
+        this.emit('goalDeleted', hash);
+        this.logger.info('GOAL_MANAGER', 'Goal deleted', { hash });
+    }
+    async pauseGoal(hash) {
+        this.validator.validateGoalHash(hash);
+        this.apiCallCount++;
+        const goal = await this.apiClient.pauseGoal(hash);
+        this.cache.setGoal(goal);
+        this.emit('goalPaused', goal);
+        this.logger.info('GOAL_MANAGER', 'Goal paused', { hash });
+        return goal;
+    }
+    async resumeGoal(hash) {
+        this.validator.validateGoalHash(hash);
+        const goal = await this.getGoal(hash);
+        if (goal.isBlocked && goal.blockedBy?.length) {
+            throw new GoalBlockedError(hash, goal.blockedBy);
+        }
+        this.apiCallCount++;
+        const updated = await this.apiClient.resumeGoal(hash);
+        this.cache.setGoal(updated);
+        this.emit('goalResumed', updated);
+        this.logger.info('GOAL_MANAGER', 'Goal resumed', { hash });
+        return updated;
+    }
+    async completeGoal(hash) {
+        this.validator.validateGoalHash(hash);
+        this.apiCallCount++;
+        const goal = await this.apiClient.completeGoal(hash);
+        this.cache.setGoal(goal);
+        this.cache.invalidateAllGoals();
+        this.emit('goalCompleted', goal);
+        this.logger.info('GOAL_MANAGER', 'Goal completed', { hash });
+        return goal;
+    }
+    async abandonGoal(hash) {
+        this.validator.validateGoalHash(hash);
+        this.apiCallCount++;
+        const goal = await this.apiClient.abandonGoal(hash);
+        this.cache.setGoal(goal);
+        this.emit('goalAbandoned', goal);
+        this.logger.info('GOAL_MANAGER', 'Goal abandoned', { hash });
+        return goal;
+    }
+    async getGoalProgress(hash) {
+        this.validator.validateGoalHash(hash);
+        this.apiCallCount++;
+        return await this.apiClient.getGoalProgress(hash);
+    }
+    async listMilestones(goalHash, forceRefresh = false) {
+        this.validator.validateGoalHash(goalHash);
+        if (!forceRefresh) {
+            const cached = this.cache.getMilestones(goalHash);
+            if (cached) {
+                return cached;
+            }
+        }
+        this.apiCallCount++;
+        const milestones = await this.apiClient.listMilestones(goalHash);
+        this.cache.setMilestones(goalHash, milestones);
+        return milestones;
+    }
+    async createMilestone(goalHash, input) {
+        this.validator.validateGoalHash(goalHash);
+        this.validator.validateCreateMilestoneInput(input);
+        this.apiCallCount++;
+        const milestone = await this.apiClient.createMilestone(goalHash, input);
+        this.cache.invalidateMilestones(goalHash);
+        this.emit('milestoneCreated', goalHash, milestone);
+        this.logger.info('GOAL_MANAGER', 'Milestone created', { goalHash, id: milestone.id });
+        return milestone;
+    }
+    async getMilestone(goalHash, milestoneId) {
+        this.validator.validateGoalHash(goalHash);
+        this.apiCallCount++;
+        return await this.apiClient.getMilestone(goalHash, milestoneId);
+    }
+    async updateMilestone(goalHash, milestoneId, input) {
+        this.validator.validateGoalHash(goalHash);
+        this.validator.validateUpdateMilestoneInput(input);
+        this.apiCallCount++;
+        const milestone = await this.apiClient.updateMilestone(goalHash, milestoneId, input);
+        this.cache.invalidateMilestones(goalHash);
+        this.emit('milestoneUpdated', goalHash, milestone);
+        this.logger.info('GOAL_MANAGER', 'Milestone updated', { goalHash, id: milestoneId });
+        return milestone;
+    }
+    async deleteMilestone(goalHash, milestoneId) {
+        this.validator.validateGoalHash(goalHash);
+        this.apiCallCount++;
+        await this.apiClient.deleteMilestone(goalHash, milestoneId);
+        this.cache.invalidateMilestones(goalHash);
+        this.emit('milestoneDeleted', goalHash, milestoneId);
+        this.logger.info('GOAL_MANAGER', 'Milestone deleted', { goalHash, id: milestoneId });
+    }
+    async completeMilestone(goalHash, milestoneId) {
+        this.validator.validateGoalHash(goalHash);
+        this.apiCallCount++;
+        const milestone = await this.apiClient.completeMilestone(goalHash, milestoneId);
+        this.cache.invalidateMilestones(goalHash);
+        this.cache.invalidateGoal(goalHash);
+        this.emit('milestoneCompleted', goalHash, milestone);
+        this.logger.info('GOAL_MANAGER', 'Milestone completed', { goalHash, id: milestoneId });
+        return milestone;
+    }
+    async listTasks(goalHash, options) {
+        this.validator.validateGoalHash(goalHash);
+        if (!options?.forceRefresh) {
+            const cached = this.cache.getTasks(goalHash);
+            if (cached) {
+                return cached;
+            }
+        }
+        this.apiCallCount++;
+        const tasks = await this.apiClient.listTasks(goalHash, options);
+        this.cache.setTasks(goalHash, tasks);
+        return tasks;
+    }
+    async getPendingTasks() {
+        this.apiCallCount++;
+        return await this.apiClient.getPendingTasks();
+    }
+    async getTasksAwaitingApproval() {
+        this.apiCallCount++;
+        return await this.apiClient.getTasksAwaitingApproval();
+    }
+    async createTask(goalHash, input) {
+        this.validator.validateGoalHash(goalHash);
+        this.validator.validateCreateTaskInput(input);
+        this.apiCallCount++;
+        const task = await this.apiClient.createTask(goalHash, input);
+        this.cache.invalidateTasks(goalHash);
+        this.emit('taskCreated', goalHash, task);
+        this.logger.info('GOAL_MANAGER', 'Task created', { goalHash, id: task.id });
+        return task;
+    }
+    async getTask(goalHash, taskId) {
+        this.validator.validateGoalHash(goalHash);
+        this.apiCallCount++;
+        return await this.apiClient.getTask(goalHash, taskId);
+    }
+    async updateTask(goalHash, taskId, input) {
+        this.validator.validateGoalHash(goalHash);
+        this.validator.validateUpdateTaskInput(input);
+        this.apiCallCount++;
+        const task = await this.apiClient.updateTask(goalHash, taskId, input);
+        this.cache.invalidateTasks(goalHash);
+        this.emit('taskUpdated', goalHash, task);
+        this.logger.info('GOAL_MANAGER', 'Task updated', { goalHash, id: taskId });
+        return task;
+    }
+    async deleteTask(goalHash, taskId) {
+        this.validator.validateGoalHash(goalHash);
+        this.apiCallCount++;
+        await this.apiClient.deleteTask(goalHash, taskId);
+        this.cache.invalidateTasks(goalHash);
+        this.emit('taskDeleted', goalHash, taskId);
+        this.logger.info('GOAL_MANAGER', 'Task deleted', { goalHash, id: taskId });
+    }
+    async approveTask(goalHash, taskId) {
+        this.validator.validateGoalHash(goalHash);
+        const currentTask = await this.getTask(goalHash, taskId);
+        const previousStatus = currentTask.status;
+        this.apiCallCount++;
+        const task = await this.apiClient.approveTask(goalHash, taskId);
+        this.cache.invalidateTasks(goalHash);
+        this.emit('taskStatusChanged', goalHash, task, previousStatus);
+        this.logger.info('GOAL_MANAGER', 'Task approved', { goalHash, id: taskId });
+        return task;
+    }
+    async denyTask(goalHash, taskId) {
+        this.validator.validateGoalHash(goalHash);
+        const currentTask = await this.getTask(goalHash, taskId);
+        const previousStatus = currentTask.status;
+        this.apiCallCount++;
+        const task = await this.apiClient.denyTask(goalHash, taskId);
+        this.cache.invalidateTasks(goalHash);
+        this.emit('taskStatusChanged', goalHash, task, previousStatus);
+        this.logger.info('GOAL_MANAGER', 'Task denied', { goalHash, id: taskId });
+        return task;
+    }
+    async startTask(goalHash, taskId) {
+        this.validator.validateGoalHash(goalHash);
+        const currentTask = await this.getTask(goalHash, taskId);
+        const previousStatus = currentTask.status;
+        this.apiCallCount++;
+        const task = await this.apiClient.startTask(goalHash, taskId);
+        this.cache.invalidateTasks(goalHash);
+        this.emit('taskStatusChanged', goalHash, task, previousStatus);
+        this.logger.info('GOAL_MANAGER', 'Task started', { goalHash, id: taskId });
+        return task;
+    }
+    async completeTask(goalHash, taskId, result) {
+        this.validator.validateGoalHash(goalHash);
+        const currentTask = await this.getTask(goalHash, taskId);
+        const previousStatus = currentTask.status;
+        this.apiCallCount++;
+        const task = await this.apiClient.completeTask(goalHash, taskId, result);
+        this.cache.invalidateTasks(goalHash);
+        this.cache.invalidateGoal(goalHash);
+        this.emit('taskStatusChanged', goalHash, task, previousStatus);
+        this.logger.info('GOAL_MANAGER', 'Task completed', { goalHash, id: taskId });
+        return task;
+    }
+    async failTask(goalHash, taskId, input) {
+        this.validator.validateGoalHash(goalHash);
+        const currentTask = await this.getTask(goalHash, taskId);
+        const previousStatus = currentTask.status;
+        this.apiCallCount++;
+        const task = await this.apiClient.failTask(goalHash, taskId, input);
+        this.cache.invalidateTasks(goalHash);
+        this.emit('taskStatusChanged', goalHash, task, previousStatus);
+        this.logger.info('GOAL_MANAGER', 'Task failed', { goalHash, id: taskId, error: input.error });
+        return task;
+    }
+    async skipTask(goalHash, taskId) {
+        this.validator.validateGoalHash(goalHash);
+        const currentTask = await this.getTask(goalHash, taskId);
+        const previousStatus = currentTask.status;
+        this.apiCallCount++;
+        const task = await this.apiClient.skipTask(goalHash, taskId);
+        this.cache.invalidateTasks(goalHash);
+        this.emit('taskStatusChanged', goalHash, task, previousStatus);
+        this.logger.info('GOAL_MANAGER', 'Task skipped', { goalHash, id: taskId });
+        return task;
+    }
+    async addTaskFeedback(goalHash, taskId, input) {
+        this.validator.validateGoalHash(goalHash);
+        this.validator.validateTaskFeedbackInput(input);
+        this.apiCallCount++;
+        const task = await this.apiClient.addTaskFeedback(goalHash, taskId, input);
+        this.cache.invalidateTasks(goalHash);
+        this.emit('taskUpdated', goalHash, task);
+        this.logger.info('GOAL_MANAGER', 'Task feedback added', { goalHash, id: taskId, quality: input.quality });
+        return task;
+    }
+    async listMemories(goalHash, forceRefresh = false) {
+        this.validator.validateGoalHash(goalHash);
+        if (!forceRefresh) {
+            const cached = this.cache.getMemories(goalHash);
+            if (cached) {
+                return cached;
+            }
+        }
+        this.apiCallCount++;
+        const memories = await this.apiClient.listMemories(goalHash);
+        this.cache.setMemories(goalHash, memories);
+        return memories;
+    }
+    async getEnabledMemories(goalHash) {
+        this.validator.validateGoalHash(goalHash);
+        this.apiCallCount++;
+        return await this.apiClient.getEnabledMemories(goalHash);
+    }
+    async createMemory(goalHash, input) {
+        this.validator.validateGoalHash(goalHash);
+        this.validator.validateCreateMemoryInput(input);
+        this.apiCallCount++;
+        const memory = await this.apiClient.createMemory(goalHash, input);
+        this.cache.invalidateMemories(goalHash);
+        this.emit('memoryCreated', goalHash, memory);
+        this.logger.info('GOAL_MANAGER', 'Memory created', { goalHash, id: memory.id });
+        return memory;
+    }
+    async updateMemory(goalHash, memoryId, input) {
+        this.validator.validateGoalHash(goalHash);
+        this.validator.validateUpdateMemoryInput(input);
+        this.apiCallCount++;
+        const memory = await this.apiClient.updateMemory(goalHash, memoryId, input);
+        this.cache.invalidateMemories(goalHash);
+        this.emit('memoryUpdated', goalHash, memory);
+        this.logger.info('GOAL_MANAGER', 'Memory updated', { goalHash, id: memoryId });
+        return memory;
+    }
+    async toggleMemory(goalHash, memoryId) {
+        this.validator.validateGoalHash(goalHash);
+        this.apiCallCount++;
+        const memory = await this.apiClient.toggleMemory(goalHash, memoryId);
+        this.cache.invalidateMemories(goalHash);
+        this.emit('memoryUpdated', goalHash, memory);
+        this.logger.info('GOAL_MANAGER', 'Memory toggled', { goalHash, id: memoryId, enabled: memory.isEnabled });
+        return memory;
+    }
+    async deleteMemory(goalHash, memoryId) {
+        this.validator.validateGoalHash(goalHash);
+        this.apiCallCount++;
+        await this.apiClient.deleteMemory(goalHash, memoryId);
+        this.cache.invalidateMemories(goalHash);
+        this.emit('memoryDeleted', goalHash, memoryId);
+        this.logger.info('GOAL_MANAGER', 'Memory deleted', { goalHash, id: memoryId });
+    }
+    async listMetaGoals(active, forceRefresh = false) {
+        const cacheKey = active !== undefined ? `active:${active}` : 'all';
+        if (!forceRefresh) {
+            const cached = this.cache.getMetaGoals(cacheKey);
+            if (cached) {
+                return cached;
+            }
+        }
+        this.apiCallCount++;
+        const metaGoals = await this.apiClient.listMetaGoals(active);
+        this.cache.setMetaGoals(metaGoals, cacheKey);
+        return metaGoals;
+    }
+    async getMetaGoalsForGoal(goalHash) {
+        this.validator.validateGoalHash(goalHash);
+        this.apiCallCount++;
+        return await this.apiClient.getMetaGoalsForGoal(goalHash);
+    }
+    async createMetaGoal(input) {
+        this.validator.validateCreateMetaGoalInput(input);
+        this.apiCallCount++;
+        const metaGoal = await this.apiClient.createMetaGoal(input);
+        this.cache.invalidateMetaGoals();
+        this.emit('metaGoalCreated', metaGoal);
+        this.logger.info('GOAL_MANAGER', 'Meta-goal created', { id: metaGoal.id });
+        return metaGoal;
+    }
+    async getMetaGoal(id) {
+        this.apiCallCount++;
+        return await this.apiClient.getMetaGoal(id);
+    }
+    async updateMetaGoal(id, input) {
+        this.validator.validateUpdateMetaGoalInput(input);
+        this.apiCallCount++;
+        const metaGoal = await this.apiClient.updateMetaGoal(id, input);
+        this.cache.invalidateMetaGoals();
+        this.emit('metaGoalUpdated', metaGoal);
+        this.logger.info('GOAL_MANAGER', 'Meta-goal updated', { id });
+        return metaGoal;
+    }
+    async toggleMetaGoal(id) {
+        this.apiCallCount++;
+        const metaGoal = await this.apiClient.toggleMetaGoal(id);
+        this.cache.invalidateMetaGoals();
+        this.emit('metaGoalToggled', metaGoal);
+        this.logger.info('GOAL_MANAGER', 'Meta-goal toggled', { id, active: metaGoal.isActive });
+        return metaGoal;
+    }
+    async deleteMetaGoal(id) {
+        this.apiCallCount++;
+        await this.apiClient.deleteMetaGoal(id);
+        this.cache.invalidateMetaGoals();
+        this.emit('metaGoalDeleted', id);
+        this.logger.info('GOAL_MANAGER', 'Meta-goal deleted', { id });
+    }
+    async getActionLogs(goalHash, limit) {
+        this.validator.validateGoalHash(goalHash);
+        this.apiCallCount++;
+        return await this.apiClient.getActionLogs(goalHash, limit);
+    }
+    clearCache() {
+        this.cache.clearAll();
+        this.logger.info('GOAL_MANAGER', 'Cache cleared');
+    }
+    pruneCache() {
+        return this.cache.pruneExpired();
+    }
+    getCacheStats() {
+        return this.cache.getStats();
+    }
+    getStats() {
+        return {
+            cache: this.cache.getStats(),
+            apiCalls: this.apiCallCount,
+            goalsLoaded: this.loadedGoals.size,
+        };
+    }
+    resetStats() {
+        this.apiCallCount = 0;
+        this.loadedGoals.clear();
+        this.cache.resetStats();
+        this.logger.debug('GOAL_MANAGER', 'Statistics reset');
+    }
+    async validateNoDependencyCycle(newDeps, parentHash, currentHash) {
+        const goals = await this.listGoals();
+        const goalMap = new Map(goals.map((g) => [g.hash, g]));
+        for (const depHash of newDeps) {
+            if (depHash === currentHash) {
+                throw new GoalCircularDependencyError(currentHash, [currentHash]);
+            }
+            if (!goalMap.has(depHash)) {
+                throw new GoalNotFoundError(depHash);
+            }
+            const visited = new Set();
+            const path = [];
+            if (currentHash) {
+                visited.add(currentHash);
+                path.push(currentHash);
+            }
+            if (this.hasCycleDFS(depHash, currentHash ?? '', goalMap, visited, path)) {
+                throw new GoalCircularDependencyError(currentHash ?? depHash, path);
+            }
+        }
+        if (parentHash) {
+            if (parentHash === currentHash) {
+                throw new GoalCircularDependencyError(currentHash, [currentHash]);
+            }
+            if (!goalMap.has(parentHash)) {
+                throw new GoalNotFoundError(parentHash);
+            }
+        }
+    }
+    hasCycleDFS(hash, targetHash, goalMap, visited, path) {
+        if (hash === targetHash && visited.has(hash)) {
+            return true;
+        }
+        if (visited.has(hash)) {
+            return false;
+        }
+        visited.add(hash);
+        path.push(hash);
+        const goal = goalMap.get(hash);
+        if (!goal) {
+            return false;
+        }
+        for (const depHash of goal.dependsOn) {
+            if (this.hasCycleDFS(depHash, targetHash, goalMap, visited, path)) {
+                return true;
+            }
+        }
+        path.pop();
+        return false;
+    }
+}
+export function createGoalManager(options) {
+    return new GoalManager(options);
+}

package/dist/goals/GoalReporter.d.ts

@@ -0,0 +1,105 @@
+import { EventEmitter } from 'events';
+import type { Goal, GoalHash, Milestone, Task, Logger } from './types.js';
+import type { GoalProgress, ProgressSnapshot, TaskStats, VelocityMetrics } from './ProgressTracker.js';
+export type ReportFormat = 'text' | 'markdown' | 'json' | 'html';
+export type ReportDetailLevel = 'summary' | 'standard' | 'detailed' | 'full';
+export type ReportSection = 'overview' | 'milestones' | 'tasks' | 'velocity' | 'history' | 'actions' | 'risks';
+export interface ProgressReport {
+    readonly id: string;
+    readonly goalHash: GoalHash;
+    readonly title: string;
+    readonly generatedAt: Date;
+    readonly period: ReportPeriod;
+    readonly format: ReportFormat;
+    readonly detailLevel: ReportDetailLevel;
+    readonly content: string;
+    readonly sections: ReportSectionContent[];
+    readonly metadata: ReportMetadata;
+}
+export interface ReportPeriod {
+    readonly start: Date;
+    readonly end: Date;
+    readonly label: string;
+}
+export interface ReportSectionContent {
+    readonly section: ReportSection;
+    readonly title: string;
+    readonly content: string;
+    readonly data?: Record<string, unknown>;
+}
+export interface ReportMetadata {
+    readonly progress: number;
+    readonly taskStats: TaskStats;
+    readonly velocity: VelocityMetrics;
+    readonly estimatedCompletion: Date | null;
+    readonly previousProgress?: number;
+    readonly progressDelta?: number;
+}
+export interface ReportOptions {
+    readonly format?: ReportFormat;
+    readonly detailLevel?: ReportDetailLevel;
+    readonly sections?: ReportSection[];
+    readonly periodDays?: number;
+    readonly includeHistory?: boolean;
+    readonly includeActionItems?: boolean;
+    readonly includeRisks?: boolean;
+    readonly compareWithSnapshot?: ProgressSnapshot;
+}
+export interface ActionItem {
+    readonly id: string;
+    readonly type: 'blocked_task' | 'overdue' | 'at_risk' | 'review_needed' | 'approval_pending';
+    readonly priority: 'high' | 'medium' | 'low';
+    readonly description: string;
+    readonly relatedTaskId?: number;
+    readonly relatedMilestoneId?: number;
+    readonly suggestedAction?: string;
+}
+export interface RiskAssessment {
+    readonly id: string;
+    readonly severity: 'high' | 'medium' | 'low';
+    readonly category: 'deadline' | 'resources' | 'dependencies' | 'technical' | 'other';
+    readonly description: string;
+    readonly mitigation?: string;
+    readonly likelihood: number;
+}
+export interface GoalReporterOptions {
+    readonly logger?: Logger;
+    readonly defaultFormat?: ReportFormat;
+    readonly defaultDetailLevel?: ReportDetailLevel;
+    readonly defaultPeriodDays?: number;
+}
+export interface GoalReporterEvents {
+    'report:generated': [report: ProgressReport];
+    'actions:identified': [goalHash: GoalHash, actions: ActionItem[]];
+    'risks:identified': [goalHash: GoalHash, risks: RiskAssessment[]];
+    error: [error: Error];
+}
+export declare class GoalReporter extends EventEmitter<GoalReporterEvents> {
+    private readonly logger;
+    private readonly defaultFormat;
+    private readonly defaultDetailLevel;
+    private readonly defaultPeriodDays;
+    private reportCounter;
+    constructor(options?: GoalReporterOptions);
+    generateReport(goal: Goal, progress: GoalProgress, milestones: Milestone[], tasks: Task[], snapshots?: ProgressSnapshot[], options?: ReportOptions): ProgressReport;
+    generateSummary(goal: Goal, progress: GoalProgress): string;
+    generateComparisonReport(goal: Goal, current: GoalProgress, previous: ProgressSnapshot, format?: ReportFormat): string;
+    identifyActionItems(goal: Goal, progress: GoalProgress, milestones: Milestone[], tasks: Task[]): ActionItem[];
+    assessRisks(goal: Goal, progress: GoalProgress, _milestones: Milestone[], _tasks: Task[]): RiskAssessment[];
+    private calculatePeriod;
+    private buildMetadata;
+    private generateSection;
+    private generateOverviewSection;
+    private generateMilestonesSection;
+    private generateTasksSection;
+    private generateVelocitySection;
+    private generateHistorySection;
+    private generateActionsSection;
+    private generateRisksSection;
+    private combineContent;
+    private renderProgressBar;
+    private formatDate;
+    private formatDuration;
+    private formatTrend;
+}
+export declare function createGoalReporter(options?: GoalReporterOptions): GoalReporter;