@critical-path/core 0.17.0 → 0.19.0

package/src/domain/workload.ts

@@ -0,0 +1,457 @@
+import type {
+  Task,
+  TimeEntry,
+  User,
+  Team,
+  WorkloadInterval,
+  WorkloadGroupBy,
+  WorkloadMetric,
+  WorkloadBucket,
+  WorkloadDistribution,
+  WorkloadDistributionOptions
+} from '../types/index.js';
+import {
+  DEFAULT_WORK_SCHEDULE,
+  getWorkingDaysList,
+  getNetAvailableCapacity,
+  getWorkingHoursInDay
+} from './calendar.js';
+
+export interface WorkloadContext {
+  tasks: Task[];
+  timeEntries?: TimeEntry[];
+  users?: User[];
+  teams?: Team[];
+  projectId?: string;
+}
+
+function toDateString(d: Date): string {
+  return d.toISOString().split('T')[0];
+}
+
+function parseDateOnly(isoString: string): Date {
+  const parts = isoString.split('T')[0].split('-');
+  return new Date(Date.UTC(parseInt(parts[0], 10), parseInt(parts[1], 10) - 1, parseInt(parts[2], 10)));
+}
+
+function addDays(d: Date, days: number): Date {
+  const res = new Date(d.getTime());
+  res.setUTCDate(res.getUTCDate() + days);
+  return res;
+}
+
+function startOfWeek(d: Date): Date {
+  const date = new Date(d.getTime());
+  const day = date.getUTCDay();
+  // Monday is day 1, Sunday is day 0 -> shift Sunday to 7
+  const diff = date.getUTCDate() - day + (day === 0 ? -6 : 1);
+  return new Date(Date.UTC(date.getUTCFullYear(), date.getUTCMonth(), diff));
+}
+
+function startOfMonth(d: Date): Date {
+  return new Date(Date.UTC(d.getUTCFullYear(), d.getUTCMonth(), 1));
+}
+
+function nextBucketDate(d: Date, interval: WorkloadInterval): Date {
+  if (interval === 'day') {
+    return addDays(d, 1);
+  }
+  if (interval === 'week') {
+    return addDays(d, 7);
+  }
+  // month: next month 1st
+  return new Date(Date.UTC(d.getUTCFullYear(), d.getUTCMonth() + 1, 1));
+}
+
+function getBucketKey(d: Date, interval: WorkloadInterval): string {
+  if (interval === 'day') {
+    return toDateString(d);
+  }
+  if (interval === 'week') {
+    return toDateString(startOfWeek(d));
+  }
+  return toDateString(startOfMonth(d));
+}
+
+function getTaskDurationHours(task: Task): number {
+  if (typeof task.estimatedHours === 'number' && task.estimatedHours >= 0) {
+    return task.estimatedHours;
+  }
+  if (typeof task.estimatedDurationMinutes === 'number' && task.estimatedDurationMinutes >= 0) {
+    return task.estimatedDurationMinutes / 60;
+  }
+  if (typeof task.actualHours === 'number' && task.actualHours > 0) {
+    return task.actualHours;
+  }
+  return 1;
+}
+
+export function calculateWorkloadDistribution(
+  context: WorkloadContext,
+  options: WorkloadDistributionOptions = {}
+): WorkloadDistribution {
+  const { tasks, timeEntries = [], users = [], teams = [], projectId } = context;
+  const interval: WorkloadInterval = options.interval || 'week';
+  const groupBy: WorkloadGroupBy = options.groupBy || 'assignee';
+  const metric: WorkloadMetric = options.metric || 'blended';
+  const defaultWeeklyCapacity = options.defaultWeeklyCapacityHours ?? 40;
+
+  // Build lookups for human-readable labels
+  const userMap = new Map<string, User>(users.map((u) => [u.id, u]));
+  const teamMap = new Map<string, Team>(teams.map((t) => [t.id, t]));
+
+  // 1. Determine date range
+  let minDate: Date | null = options.startDate ? parseDateOnly(options.startDate) : null;
+  let maxDate: Date | null = options.endDate ? parseDateOnly(options.endDate) : null;
+
+  if (!minDate || !maxDate) {
+    const dates: number[] = [];
+    for (const t of tasks) {
+      if (t.plannedStartDate) dates.push(parseDateOnly(t.plannedStartDate).getTime());
+      if (t.actualStartDate) dates.push(parseDateOnly(t.actualStartDate).getTime());
+      if (t.dueDate) dates.push(parseDateOnly(t.dueDate).getTime());
+      if (t.actualEndDate) dates.push(parseDateOnly(t.actualEndDate).getTime());
+      if (t.createdAt) dates.push(parseDateOnly(t.createdAt).getTime());
+    }
+    for (const te of timeEntries) {
+      if (te.loggedAt) dates.push(parseDateOnly(te.loggedAt).getTime());
+    }
+
+    if (dates.length > 0) {
+      if (!minDate) minDate = new Date(Math.min(...dates));
+      if (!maxDate) maxDate = new Date(Math.max(...dates));
+    } else {
+      const now = new Date();
+      if (!minDate) minDate = addDays(now, -7);
+      if (!maxDate) maxDate = addDays(now, 28);
+    }
+  }
+
+  // Ensure minDate <= maxDate
+  if (minDate > maxDate) {
+    maxDate = new Date(minDate.getTime());
+  }
+
+  // Align start to bucket boundary
+  let cursor = interval === 'week' ? startOfWeek(minDate) : interval === 'month' ? startOfMonth(minDate) : minDate;
+  const endLimit = interval === 'week' ? startOfWeek(maxDate) : interval === 'month' ? startOfMonth(maxDate) : maxDate;
+
+  // Generate contiguous buckets
+  interface InternalBucket {
+    date: string;
+    startDate: Date;
+    endDate: Date;
+    timestamp: number;
+    values: Record<string, number>;
+  }
+
+  const bucketList: InternalBucket[] = [];
+  const bucketMap = new Map<string, InternalBucket>();
+
+  while (cursor <= endLimit || bucketList.length === 0) {
+    const dateStr = toDateString(cursor);
+    const nextDate = nextBucketDate(cursor, interval);
+    const b: InternalBucket = {
+      date: dateStr,
+      startDate: new Date(cursor.getTime()),
+      endDate: nextDate,
+      timestamp: cursor.getTime(),
+      values: {}
+    };
+    bucketList.push(b);
+    bucketMap.set(dateStr, b);
+    cursor = nextDate;
+  }
+
+  const seriesKeySet = new Set<string>();
+
+  const getDimensionKey = (task: Task, timeEntry?: TimeEntry): string => {
+    switch (groupBy) {
+      case 'assignee':
+        if (timeEntry?.userId) return timeEntry.userId;
+        return task.assigneeId || 'unassigned';
+      case 'team':
+        return task.teamId || (task.customFields?.teamId as string) || 'unassigned';
+      case 'taskType':
+        return task.taskType || (task.customFields?.type as string) || 'standard';
+      case 'priority':
+        return task.priority || 'none';
+      case 'status':
+        return task.status || 'todo';
+      default:
+        return 'unassigned';
+    }
+  };
+
+  const addValue = (bucket: InternalBucket, key: string, hours: number) => {
+    if (hours <= 0) return;
+    seriesKeySet.add(key);
+    bucket.values[key] = (bucket.values[key] || 0) + hours;
+  };
+
+  const todayStr = toDateString(new Date());
+  const taskMap = new Map<string, Task>(tasks.map((t) => [t.id, t]));
+
+  // 2. Process Logged Hours from TimeEntries
+  if (metric === 'logged' || metric === 'blended') {
+    for (const entry of timeEntries) {
+      if (!entry.hours || entry.hours <= 0) continue;
+      const entryDate = parseDateOnly(entry.loggedAt);
+      const bKey = getBucketKey(entryDate, interval);
+      const bucket = bucketMap.get(bKey);
+      if (bucket) {
+        const associatedTask = taskMap.get(entry.taskId) || ({
+          id: entry.taskId,
+          projectId: projectId || '',
+          title: '',
+          status: 'in_progress',
+          priority: 'medium',
+          createdAt: entry.loggedAt,
+          updatedAt: entry.loggedAt
+        } as Task);
+        const dimKey = getDimensionKey(associatedTask, entry);
+        addValue(bucket, dimKey, entry.hours);
+      }
+    }
+  }
+
+  // 3. Process Scheduled / Remaining / Blended Hours from Tasks
+  if (metric === 'scheduled' || metric === 'remaining' || metric === 'blended') {
+    for (const task of tasks) {
+      const estimated = getTaskDurationHours(task);
+      const logged = task.loggedHours || 0;
+      let hoursToDistribute = 0;
+
+      if (metric === 'scheduled') {
+        hoursToDistribute = estimated;
+      } else if (metric === 'remaining' || metric === 'blended') {
+        if (task.semanticStatus === 'completed' || task.semanticStatus === 'canceled') {
+          hoursToDistribute = 0;
+        } else {
+          hoursToDistribute = Math.max(0, estimated - logged);
+        }
+      }
+
+      if (hoursToDistribute <= 0) continue;
+
+      const dimKey = getDimensionKey(task);
+
+      // Determine task date range
+      let taskStart = task.plannedStartDate
+        ? parseDateOnly(task.plannedStartDate)
+        : task.actualStartDate
+          ? parseDateOnly(task.actualStartDate)
+          : task.createdAt
+            ? parseDateOnly(task.createdAt)
+            : minDate;
+
+      let taskEnd = task.dueDate
+        ? parseDateOnly(task.dueDate)
+        : taskStart
+          ? addDays(taskStart, Math.max(1, Math.ceil(hoursToDistribute / 8)))
+          : maxDate;
+
+      // In blended mode, uncompleted tasks' remaining hours start from today or planned start (whichever is later)
+      if (metric === 'blended') {
+        const today = parseDateOnly(todayStr);
+        if (taskStart < today) {
+          taskStart = today;
+        }
+        if (taskEnd < taskStart) {
+          taskEnd = addDays(taskStart, 1);
+        }
+      }
+
+      if (taskEnd < taskStart) {
+        taskEnd = taskStart;
+      }
+
+      // Resolve schedule for task assignee / team / project
+      const taskSchedule =
+        (task.assigneeId && options.userSchedules?.[task.assigneeId]) ||
+        (task.assigneeId && userMap.get(task.assigneeId)?.schedule) ||
+        (task.teamId && options.teamSchedules?.[task.teamId]) ||
+        (task.teamId && teamMap.get(task.teamId)?.schedule) ||
+        options.schedule ||
+        DEFAULT_WORK_SCHEDULE;
+
+      const workingDays = getWorkingDaysList(taskStart, taskEnd, taskSchedule);
+      const msPerDay = 1000 * 60 * 60 * 24;
+
+      if (workingDays.length > 0) {
+        const hoursPerWorkingDay = hoursToDistribute / workingDays.length;
+
+        for (const bucket of bucketList) {
+          const bucketStart = bucket.startDate.getTime();
+          const bucketEnd = bucket.endDate.getTime();
+
+          let workingDaysInBucket = 0;
+          for (const wdStr of workingDays) {
+            const wdTime = parseDateOnly(wdStr).getTime();
+            if (wdTime >= bucketStart && wdTime < bucketEnd) {
+              workingDaysInBucket++;
+            }
+          }
+
+          if (workingDaysInBucket > 0) {
+            const bucketEffort = workingDaysInBucket * hoursPerWorkingDay;
+            addValue(bucket, dimKey, bucketEffort);
+          }
+        }
+      } else {
+        // Fallback if no working days in range (e.g. task scheduled on an all-holiday window)
+        const totalDays = Math.max(1, Math.round((taskEnd.getTime() - taskStart.getTime()) / msPerDay) + 1);
+        const hoursPerDay = hoursToDistribute / totalDays;
+
+        for (const bucket of bucketList) {
+          const bucketLastDay = addDays(bucket.endDate, -1);
+          const overlapStart = new Date(Math.max(taskStart.getTime(), bucket.startDate.getTime()));
+          const overlapEnd = new Date(Math.min(taskEnd.getTime(), bucketLastDay.getTime()));
+
+          if (overlapStart <= overlapEnd) {
+            const overlapDays = Math.round((overlapEnd.getTime() - overlapStart.getTime()) / msPerDay) + 1;
+            const bucketEffort = overlapDays * hoursPerDay;
+            addValue(bucket, dimKey, bucketEffort);
+          }
+        }
+      }
+    }
+  }
+
+  // Ensure all registered users are in series keys if grouping by assignee
+  if (groupBy === 'assignee' && users.length > 0) {
+    for (const u of users) {
+      seriesKeySet.add(u.id);
+    }
+  }
+  if (groupBy === 'team' && teams.length > 0) {
+    for (const t of teams) {
+      seriesKeySet.add(t.id);
+    }
+  }
+
+  const seriesKeys = Array.from(seriesKeySet).sort();
+
+  // Create human-readable series labels
+  const seriesLabels: Record<string, string> = {};
+  for (const key of seriesKeys) {
+    if (groupBy === 'assignee') {
+      const u = userMap.get(key);
+      seriesLabels[key] = u ? u.name : key === 'unassigned' ? 'Unassigned' : key;
+    } else if (groupBy === 'team') {
+      const t = teamMap.get(key);
+      seriesLabels[key] = t ? t.name : key === 'unassigned' ? 'Unassigned' : key;
+    } else {
+      seriesLabels[key] = key.charAt(0).toUpperCase() + key.slice(1).replace(/_/g, ' ');
+    }
+  }
+
+  // 4. Calculate Capacity & Normalize Buckets
+  let totalDistributedHours = 0;
+  let sumCapacityAcrossBuckets = 0;
+
+  const buckets: WorkloadBucket[] = bucketList.map((ib) => {
+    const values: Record<string, number> = {};
+    const capacity: Record<string, number> = {};
+    let bucketTotalHours = 0;
+    let bucketTotalCapacity = 0;
+
+    for (const key of seriesKeys) {
+      const rawHours = ib.values[key] || 0;
+      const roundedHours = Math.round(rawHours * 100) / 100;
+      values[key] = roundedHours;
+      bucketTotalHours += roundedHours;
+
+      // Capacity calculation
+      const entitySchedule =
+        (groupBy === 'assignee' && (options.userSchedules?.[key] || userMap.get(key)?.schedule)) ||
+        (groupBy === 'team' && (options.teamSchedules?.[key] || teamMap.get(key)?.schedule)) ||
+        options.schedule ||
+        DEFAULT_WORK_SCHEDULE;
+
+      let weeklyCap = defaultWeeklyCapacity;
+      if (options.capacityOverrides && typeof options.capacityOverrides[key] === 'number') {
+        weeklyCap = options.capacityOverrides[key];
+      } else if (groupBy === 'assignee') {
+        const u = userMap.get(key);
+        if (u?.weeklyCapacityHours) weeklyCap = u.weeklyCapacityHours;
+        else if (key === 'unassigned') weeklyCap = 0;
+      } else if (groupBy === 'team') {
+        const t = teamMap.get(key);
+        if (t?.weeklyCapacityHours) {
+          weeklyCap = t.weeklyCapacityHours;
+        } else if (t?.memberIds?.length) {
+          weeklyCap = t.memberIds.length * defaultWeeklyCapacity;
+        } else if (key === 'unassigned') {
+          weeklyCap = 0;
+        }
+      }
+
+      let bucketCap = 0;
+      if (key === 'unassigned') {
+        bucketCap = 0;
+      } else if (interval === 'week') {
+        const netWeekCap = getNetAvailableCapacity(ib.startDate, addDays(ib.endDate, -1), entitySchedule);
+        const baseline = (entitySchedule.defaultHoursPerDay ?? 8) * 5;
+        const scale = baseline > 0 ? weeklyCap / baseline : 1;
+        bucketCap = Math.round(netWeekCap * scale * 100) / 100;
+      } else if (interval === 'day') {
+        const dayHours = getWorkingHoursInDay(ib.startDate, entitySchedule);
+        const baseline = (entitySchedule.defaultHoursPerDay ?? 8) * 5;
+        const scale = baseline > 0 ? weeklyCap / baseline : 1;
+        bucketCap = Math.round(dayHours * scale * 100) / 100;
+      } else if (interval === 'month') {
+        const netMonthCap = getNetAvailableCapacity(ib.startDate, addDays(ib.endDate, -1), entitySchedule);
+        const baseline = (entitySchedule.defaultHoursPerDay ?? 8) * 5;
+        const scale = baseline > 0 ? weeklyCap / baseline : 1;
+        bucketCap = Math.round(netMonthCap * scale * 100) / 100;
+      }
+
+      capacity[key] = bucketCap;
+      bucketTotalCapacity += bucketCap;
+    }
+
+    bucketTotalHours = Math.round(bucketTotalHours * 100) / 100;
+    bucketTotalCapacity = Math.round(bucketTotalCapacity * 100) / 100;
+    totalDistributedHours += bucketTotalHours;
+    sumCapacityAcrossBuckets += bucketTotalCapacity;
+
+    const utilizationRatio =
+      bucketTotalCapacity > 0
+        ? Math.round((bucketTotalHours / bucketTotalCapacity) * 1000) / 1000
+        : undefined;
+
+    return {
+      date: ib.date,
+      timestamp: ib.timestamp,
+      totalHours: bucketTotalHours,
+      values,
+      capacity,
+      totalCapacity: bucketTotalCapacity,
+      utilizationRatio
+    };
+  });
+
+  totalDistributedHours = Math.round(totalDistributedHours * 100) / 100;
+  sumCapacityAcrossBuckets = Math.round(sumCapacityAcrossBuckets * 100) / 100;
+
+  const averageUtilization =
+    sumCapacityAcrossBuckets > 0
+      ? Math.round((totalDistributedHours / sumCapacityAcrossBuckets) * 1000) / 1000
+      : undefined;
+
+  return {
+    projectId,
+    startDate: toDateString(minDate),
+    endDate: toDateString(maxDate),
+    interval,
+    groupBy,
+    metric,
+    seriesKeys,
+    seriesLabels,
+    buckets,
+    totalHours: totalDistributedHours,
+    totalCapacity: sumCapacityAcrossBuckets,
+    averageUtilization
+  };
+}

package/src/engine/index.ts

@@ -30,7 +30,9 @@ import type {
   StandardTaskTimelineItem,
   ConcreteTaskEvidence,
   TaskMetrics,
-  TaskProgressHistory
+  TaskProgressHistory,
+  WorkloadDistribution,
+  WorkloadDistributionOptions
 } from '../types/index.js';
 import { StorageAdapter, InMemoryStore } from '../store/index.js';
 import { PluginRegistry } from '../plugins/index.js';
@@ -49,6 +51,7 @@ import {
   TaskCreatedEvent,
   TaskUpdatedEvent,
   TaskStatusChangedEvent,
+  TaskBlockedEvent,
   TaskUnblockedEvent,
   TaskDeletedEvent,
   ProjectCreatedEvent,
@@ -77,15 +80,17 @@ import {
 import { validateAttachmentUrl, AttachmentValidationError } from '../domain/entities.js';
 import { validateCustomFieldValues } from '../domain/custom-fields.js';
 import { detectDependencyCycle, CircularDependencyError } from '../domain/graph.js';
-import { calculateCPM } from '../domain/cpm.js';
+import { calculateCPM, type CPMOptions } from '../domain/cpm.js';
 import { buildTimelineLadder, aggregateConcreteEvidenceForTask } from '../domain/ladder.js';
 import {
   calculateTaskMetrics,
   reconstructTaskProgressHistory,
   type MetricOptions
 } from '../domain/metrics.js';
+import { calculateWorkloadDistribution } from '../domain/workload.js';
 
 export class CriticalPathEngine {
+  public readonly config: CriticalPathConfig;
   public readonly store: StorageAdapter;
   public readonly fileStorage?: FileStorageAdapter;
   public readonly plugins: PluginRegistry;
@@ -93,6 +98,7 @@ export class CriticalPathEngine {
   public readonly ready: Promise<void> = Promise.resolve();
 
   constructor(config: CriticalPathConfig = {}) {
+    this.config = config;
     this.store = typeof config.store === 'object' && config.store !== null
       ? (config.store as StorageAdapter)
       : new InMemoryStore();
@@ -528,6 +534,58 @@ export class CriticalPathEngine {
       await this.events.publish(updateEvent);
     }
 
+    const wasBlocked = Boolean(existing.isBlocked || existing.customFields?.isBlocked || existing.status === 'blocked');
+    const isNowBlocked = Boolean(updated.isBlocked || updated.customFields?.isBlocked || updated.status === 'blocked');
+
+    if (!wasBlocked && isNowBlocked) {
+      const blockedReason = updated.blockedReason ?? (updated.customFields?.blockedReason as string | undefined) ?? null;
+      const blockedEvent: TaskBlockedEvent = {
+        id: `evt_${Math.random().toString(36).substring(2, 9)}`,
+        name: 'task.blocked',
+        aggregateId: updated.id,
+        aggregateType: 'Task',
+        occurredAt: now,
+        payload: {
+          task: updated,
+          reason: blockedReason
+        }
+      };
+      await this.events.publish(blockedEvent);
+      await this.store.logActivity({
+        projectId: updated.projectId,
+        taskId: updated.id,
+        actorId: updated.assigneeId || 'system',
+        action: 'task.blocked',
+        details: { reason: blockedReason }
+      });
+      this.dispatchWebhook('task.blocked', {
+        task: updated,
+        reason: blockedReason
+      });
+    } else if (wasBlocked && !isNowBlocked) {
+      const unblockedEvent: TaskUnblockedEvent = {
+        id: `evt_${Math.random().toString(36).substring(2, 9)}`,
+        name: 'task.unblocked',
+        aggregateId: updated.id,
+        aggregateType: 'Task',
+        occurredAt: now,
+        payload: {
+          task: updated
+        }
+      };
+      await this.events.publish(unblockedEvent);
+      await this.store.logActivity({
+        projectId: updated.projectId,
+        taskId: updated.id,
+        actorId: updated.assigneeId || 'system',
+        action: 'task.unblocked',
+        details: {}
+      });
+      this.dispatchWebhook('task.unblocked', {
+        task: updated
+      });
+    }
+
     await this.store.logActivity({
       projectId: updated.projectId,
       taskId: updated.id,
@@ -574,6 +632,11 @@ export class CriticalPathEngine {
             updates.status = defaultStatus;
           }
 
+          if (downstream.isBlocked || downstream.blockedReason) {
+            updates.isBlocked = false;
+            updates.blockedReason = null;
+          }
+
           if (downstream.customFields?.isBlocked || downstream.customFields?.blockedReason) {
             updates.customFields = {
               ...downstream.customFields,
@@ -1376,7 +1439,11 @@ export class CriticalPathEngine {
   }
 
   // --- Ladder of Abstraction & Critical Path Method ---
-  async calculateCriticalPath(projectId: string): Promise<CriticalPathAnalysis> {
+  async calculateCriticalPath(
+    projectId: string,
+    options: CPMOptions = {}
+  ): Promise<CriticalPathAnalysis> {
+    const project = await this.store.getProject(projectId);
     const tasks = await this.store.getTasks(projectId);
     const allDepArrays = await Promise.all(tasks.map((t) => this.store.getDependencies(t.id)));
     const seenDepIds = new Set<string>();
@@ -1389,7 +1456,9 @@ export class CriticalPathEngine {
         }
       }
     }
-    return calculateCPM(projectId, tasks, dependencies);
+    const schedule = options.schedule || project?.schedule || this.config.defaultSchedule;
+    const projectStartDate = options.projectStartDate || project?.startDate;
+    return calculateCPM(projectId, tasks, dependencies, { schedule, projectStartDate });
   }
 
   async getTimelineLadder(
@@ -1432,6 +1501,8 @@ export class CriticalPathEngine {
     const timeEntriesNested = await Promise.all(tasks.map((t) => this.store.getTimeEntries(t.id)));
     const timeEntries: TimeEntry[] = timeEntriesNested.flat();
 
+    const schedule = project.schedule || this.config.defaultSchedule;
+
     return buildTimelineLadder(
       {
         project,
@@ -1442,7 +1513,8 @@ export class CriticalPathEngine {
         deliverables,
         attachments,
         timeEntries,
-        activities
+        activities,
+        schedule
       },
       options
     );
@@ -1509,6 +1581,32 @@ export class CriticalPathEngine {
     });
   }
 
+  async getWorkloadDistribution(
+    projectId?: string,
+    options: WorkloadDistributionOptions = {}
+  ): Promise<WorkloadDistribution> {
+    const tasks = await this.store.getTasks(projectId);
+    const teams = await this.store.getTeams();
+    const project = projectId ? await this.store.getProject(projectId) : undefined;
+    const schedule = options.schedule || project?.schedule || this.config.defaultSchedule;
+
+    const timeEntriesNested = await Promise.all(tasks.map((t) => this.store.getTimeEntries(t.id)));
+    const timeEntries: TimeEntry[] = timeEntriesNested.flat();
+
+    return calculateWorkloadDistribution(
+      {
+        tasks,
+        timeEntries,
+        teams,
+        projectId
+      },
+      {
+        ...options,
+        schedule
+      }
+    );
+  }
+
   private async dispatchWebhook(event: WebhookEvent, payload: Record<string, unknown>): Promise<void> {
     const webhooks = await this.store.getWebhooks();
     const active = webhooks.filter((w) => w.active && w.events.includes(event));

package/src/store/sqlite.test.ts

@@ -40,8 +40,24 @@ describe('SQLiteStore', () => {
     expect(task.priority).toBe('high');
     expect(task.tags).toContain('sqlite');
 
-    const updated = await store.updateTask(task.id, { status: 'in_progress' });
+    const updated = await store.updateTask(task.id, {
+      status: 'in_progress',
+      isBlocked: true,
+      blockedReason: 'Waiting for SQLite lock'
+    });
     expect(updated?.status).toBe('in_progress');
+    expect(updated?.isBlocked).toBe(true);
+    expect(updated?.blockedReason).toBe('Waiting for SQLite lock');
+
+    const fetchedTask = await store.getTask(task.id);
+    expect(fetchedTask?.isBlocked).toBe(true);
+    expect(fetchedTask?.blockedReason).toBe('Waiting for SQLite lock');
+
+    const unblocked = await store.updateTask(task.id, {
+      isBlocked: false,
+      blockedReason: null
+    });
+    expect(unblocked?.isBlocked).toBe(false);
 
     const projectTasks = await store.getTasks(project.id);
     expect(projectTasks).toHaveLength(1);