@critical-path/core 0.18.0 → 0.19.1

package/src/domain/ladder.ts

@@ -17,9 +17,11 @@ import type {
   ConcreteTaskEvidence,
   ConcreteEvidenceSummary,
   RealityDelta,
-  TaskLadderView
+  TaskLadderView,
+  WorkSchedule
 } from '../types/index.js';
 import { calculateCPM, getTaskDurationHours } from './cpm.js';
+import { DEFAULT_WORK_SCHEDULE, getWorkingDaysBetween } from './calendar.js';
 
 export interface LadderContext {
   project: Project;
@@ -31,6 +33,7 @@ export interface LadderContext {
   attachments?: Attachment[];
   timeEntries?: TimeEntry[];
   activities?: Activity[];
+  schedule?: WorkSchedule;
 }
 
 export function aggregateConcreteEvidenceForTask(
@@ -38,7 +41,8 @@ export function aggregateConcreteEvidenceForTask(
   attachments: Attachment[] = [],
   deliverables: Deliverable[] = [],
   timeEntries: TimeEntry[] = [],
-  activities: Activity[] = []
+  activities: Activity[] = [],
+  schedule?: WorkSchedule
 ): ConcreteTaskEvidence {
   const taskAttachments = attachments.filter((a) => a.taskId === task.id);
   const taskDeliverables = deliverables.filter(
@@ -70,10 +74,19 @@ export function aggregateConcreteEvidenceForTask(
   const isOverEstimate = Boolean(estimatedHours > 0 && effectiveLoggedHours > estimatedHours);
 
   let scheduleVarianceDays: number | undefined;
+  let scheduleVarianceWorkingDays: number | undefined;
   if (task.dueDate && task.actualEndDate) {
     const dueTime = new Date(task.dueDate).getTime();
     const actualTime = new Date(task.actualEndDate).getTime();
     scheduleVarianceDays = Math.round((actualTime - dueTime) / (1000 * 60 * 60 * 24));
+    const effectiveSched = schedule || DEFAULT_WORK_SCHEDULE;
+    if (actualTime > dueTime) {
+      scheduleVarianceWorkingDays = Math.max(0, getWorkingDaysBetween(task.dueDate, task.actualEndDate, effectiveSched) - 1);
+    } else if (actualTime < dueTime) {
+      scheduleVarianceWorkingDays = -Math.max(0, getWorkingDaysBetween(task.actualEndDate, task.dueDate, effectiveSched) - 1);
+    } else {
+      scheduleVarianceWorkingDays = 0;
+    }
   }
 
   let durationVarianceHours: number | undefined;
@@ -100,6 +113,7 @@ export function aggregateConcreteEvidenceForTask(
     effortVarianceHours: varianceHours,
     durationVarianceHours,
     scheduleVarianceDays,
+    scheduleVarianceWorkingDays,
     accuracyRatio,
     isOverdue,
     isOverEstimate
@@ -309,8 +323,14 @@ export function buildTimelineLadder(
   const targetLevel = options.level || 'all';
   const generatedAt = new Date().toISOString();
 
+  const effectiveSchedule = context.schedule || project.schedule || DEFAULT_WORK_SCHEDULE;
+  const projectStartDate = project.startDate || (tasks.length > 0 ? tasks.find((t) => t.plannedStartDate)?.plannedStartDate : undefined);
+
   // Run Critical Path Method (CPM)
-  const cpm = calculateCPM(project.id, tasks, dependencies);
+  const cpm = calculateCPM(project.id, tasks, dependencies, {
+    schedule: effectiveSchedule,
+    projectStartDate
+  });
   const criticalSet = new Set(cpm.criticalTaskIds);
   const scheduleMap = new Map(cpm.tasks.map((s) => [s.taskId, s]));
 
@@ -352,7 +372,8 @@ export function buildTimelineLadder(
       attachments,
       deliverables,
       timeEntries,
-      activities
+      activities,
+      effectiveSchedule
     );
   }
 

package/src/domain/metrics.test.ts

@@ -148,6 +148,8 @@ describe('Task Metrics Domain', () => {
   });
 
   describe('reconstructTaskProgressHistory & Curve Profile', () => {
+    const referenceDate = new Date('2026-09-09T12:00:00Z');
+
     it('detects linear progress', () => {
       const activities: Activity[] = [
         { id: 'a1', taskId: 'task-1', actorId: 'u1', action: 'task.updated', details: { progress: 25 }, createdAt: '2026-09-02T10:00:00Z' },
@@ -156,7 +158,7 @@ describe('Task Metrics Domain', () => {
         { id: 'a4', taskId: 'task-1', actorId: 'u1', action: 'task.updated', details: { progress: 100 }, createdAt: '2026-09-08T10:00:00Z' }
       ];
       const task: Task = { ...baseTask, progress: 100, updatedAt: '2026-09-08T10:00:00Z' };
-      const history = reconstructTaskProgressHistory(task, activities);
+      const history = reconstructTaskProgressHistory(task, activities, { referenceDate });
 
       expect(history.points.length).toBeGreaterThanOrEqual(4);
       expect(history.curveProfile).toBe('linear');
@@ -170,7 +172,7 @@ describe('Task Metrics Domain', () => {
         { id: 'a4', taskId: 'task-1', actorId: 'u1', action: 'task.updated', details: { progress: 95 }, createdAt: '2026-09-09T10:00:00Z' }
       ];
       const task: Task = { ...baseTask, progress: 95, updatedAt: '2026-09-09T10:00:00Z' };
-      const history = reconstructTaskProgressHistory(task, activities);
+      const history = reconstructTaskProgressHistory(task, activities, { referenceDate });
 
       expect(history.curveProfile).toBe('s_curve');
     });
@@ -182,7 +184,7 @@ describe('Task Metrics Domain', () => {
         { id: 'a3', taskId: 'task-1', actorId: 'u1', action: 'task.updated', details: { progress: 78 }, createdAt: '2026-09-08T10:00:00Z' }
       ];
       const task: Task = { ...baseTask, progress: 78, updatedAt: '2026-09-08T10:00:00Z' };
-      const history = reconstructTaskProgressHistory(task, activities);
+      const history = reconstructTaskProgressHistory(task, activities, { referenceDate });
 
       expect(history.curveProfile).toBe('early_surge');
     });
@@ -194,7 +196,7 @@ describe('Task Metrics Domain', () => {
         { id: 'a3', taskId: 'task-1', actorId: 'u1', action: 'task.updated', details: { progress: 90 }, createdAt: '2026-09-08T10:00:00Z' }
       ];
       const task: Task = { ...baseTask, progress: 90, updatedAt: '2026-09-08T10:00:00Z' };
-      const history = reconstructTaskProgressHistory(task, activities);
+      const history = reconstructTaskProgressHistory(task, activities, { referenceDate });
 
       expect(history.curveProfile).toBe('late_rush');
     });

package/src/domain/workload.test.ts

@@ -235,4 +235,77 @@ describe('calculateWorkloadDistribution', () => {
     expect(distribution.buckets.length).toBeGreaterThan(0);
     expect(distribution.seriesKeys).toContain('u1');
   });
+
+  it('distributes task effort only on working days and reduces capacity on holidays', () => {
+    // Friday 2026-09-18 to Tuesday 2026-09-22 (5 calendar days: Fri, Sat, Sun, Mon, Tue)
+    // Monday 2026-09-21 is a Holiday!
+    // Active working days: Friday 2026-09-18 and Tuesday 2026-09-22 (2 days total)
+    // 16 estimated hours should be divided into 8h on Fri, 0h on Sat, 0h on Sun, 0h on Mon, 8h on Tue!
+    const customSchedule = {
+      name: 'Holiday Calendar',
+      defaultHoursPerDay: 8,
+      days: [
+        { dayOfWeek: 0, isWorkingDay: false },
+        { dayOfWeek: 1, isWorkingDay: true, hours: [{ start: '09:00', end: '17:00' }] },
+        { dayOfWeek: 2, isWorkingDay: true, hours: [{ start: '09:00', end: '17:00' }] },
+        { dayOfWeek: 3, isWorkingDay: true, hours: [{ start: '09:00', end: '17:00' }] },
+        { dayOfWeek: 4, isWorkingDay: true, hours: [{ start: '09:00', end: '17:00' }] },
+        { dayOfWeek: 5, isWorkingDay: true, hours: [{ start: '09:00', end: '17:00' }] },
+        { dayOfWeek: 6, isWorkingDay: false }
+      ],
+      holidays: [{ date: '2026-09-21', name: 'Monday Holiday' }]
+    };
+
+    const tasks: Task[] = [
+      {
+        id: 't_holiday',
+        projectId: 'p1',
+        title: 'Holiday Spanning Task',
+        status: 'todo',
+        priority: 'high',
+        assigneeId: 'u2',
+        estimatedHours: 16,
+        plannedStartDate: '2026-09-18', // Friday
+        dueDate: '2026-09-22',          // Tuesday
+        createdAt: '2026-09-01',
+        updatedAt: '2026-09-01'
+      }
+    ];
+
+    const result = calculateWorkloadDistribution(
+      { tasks, users },
+      {
+        startDate: '2026-09-18',
+        endDate: '2026-09-22',
+        interval: 'day',
+        groupBy: 'assignee',
+        metric: 'scheduled',
+        schedule: customSchedule
+      }
+    );
+
+    const fri = result.buckets.find((b) => b.date === '2026-09-18');
+    const sat = result.buckets.find((b) => b.date === '2026-09-19');
+    const sun = result.buckets.find((b) => b.date === '2026-09-20');
+    const mon = result.buckets.find((b) => b.date === '2026-09-21');
+    const tue = result.buckets.find((b) => b.date === '2026-09-22');
+
+    expect(fri?.values.u2).toBe(8);
+    expect(fri?.capacity?.u2).toBe(8);
+
+    expect(sat?.values.u2).toBe(0);
+    expect(sat?.capacity?.u2).toBe(0);
+
+    expect(sun?.values.u2).toBe(0);
+    expect(sun?.capacity?.u2).toBe(0);
+
+    // Monday is holiday: 0 scheduled effort, 0 capacity
+    expect(mon?.values.u2).toBe(0);
+    expect(mon?.capacity?.u2).toBe(0);
+
+    expect(tue?.values.u2).toBe(8);
+    expect(tue?.capacity?.u2).toBe(8);
+
+    expect(result.totalHours).toBe(16);
+  });
 });

package/src/domain/workload.ts

@@ -10,6 +10,12 @@ import type {
   WorkloadDistribution,
   WorkloadDistributionOptions
 } from '../types/index.js';
+import {
+  DEFAULT_WORK_SCHEDULE,
+  getWorkingDaysList,
+  getNetAvailableCapacity,
+  getWorkingHoursInDay
+} from './calendar.js';
 
 export interface WorkloadContext {
   tasks: Task[];
@@ -260,21 +266,53 @@ export function calculateWorkloadDistribution(
         taskEnd = taskStart;
       }
 
-      // Calculate days in task window
+      // 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;
-      const totalDays = Math.max(1, Math.round((taskEnd.getTime() - taskStart.getTime()) / msPerDay) + 1);
-      const hoursPerDay = hoursToDistribute / totalDays;
-
-      // Distribute across overlapping buckets
-      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);
+
+      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);
+          }
         }
       }
     }
@@ -325,6 +363,12 @@ export function calculateWorkloadDistribution(
       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];
@@ -344,13 +388,23 @@ export function calculateWorkloadDistribution(
       }
 
       let bucketCap = 0;
-      if (interval === 'week') {
-        bucketCap = weeklyCap;
+      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') {
-        bucketCap = Math.round((weeklyCap / 5) * 100) / 100;
+        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 daysInMonth = new Date(Date.UTC(ib.startDate.getUTCFullYear(), ib.startDate.getUTCMonth() + 1, 0)).getUTCDate();
-        bucketCap = Math.round((weeklyCap * (daysInMonth / 7)) * 100) / 100;
+        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;

package/src/engine/index.ts

@@ -51,6 +51,7 @@ import {
   TaskCreatedEvent,
   TaskUpdatedEvent,
   TaskStatusChangedEvent,
+  TaskBlockedEvent,
   TaskUnblockedEvent,
   TaskDeletedEvent,
   ProjectCreatedEvent,
@@ -79,7 +80,7 @@ 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,
@@ -89,6 +90,7 @@ import {
 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;
@@ -96,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();
@@ -428,30 +431,76 @@ export class CriticalPathEngine {
     return created;
   }
 
-  async updateTask(id: string, updates: Partial<Task>): Promise<Task | null> {
+  async updateTask(
+    id: string,
+    updates: Partial<Task> & {
+      actorId?: string;
+      actorName?: string;
+      actorType?: string;
+      actor?: { userId: string; username?: string; actorType?: string };
+    },
+    options?: {
+      actorId?: string;
+      actorName?: string;
+      actorType?: string;
+      actor?: { userId: string; username?: string; actorType?: string };
+    }
+  ): Promise<Task | null> {
     const existing = await this.store.getTask(id);
     if (!existing) return null;
 
+    const actorId =
+      options?.actorId ||
+      updates.actorId ||
+      options?.actor?.userId ||
+      updates.actor?.userId ||
+      'system';
+    const actorName =
+      options?.actorName ||
+      updates.actorName ||
+      options?.actor?.username ||
+      updates.actor?.username ||
+      (actorId === 'system' ? 'System' : undefined);
+    const actorType =
+      options?.actorType ||
+      updates.actorType ||
+      options?.actor?.actorType ||
+      updates.actor?.actorType ||
+      (actorId === 'system' ? 'system' : 'user');
+    const actorObj = options?.actor || updates.actor || {
+      userId: actorId,
+      username: actorName,
+      actorType
+    };
+
+    const {
+      actorId: _aId,
+      actorName: _aName,
+      actorType: _aType,
+      actor: _aObj,
+      ...taskUpdates
+    } = updates;
+
     const project = await this.store.getProject(existing.projectId);
     const workflow = await this.resolveProjectWorkflow(existing.projectId);
 
     // Validate workflow transition invariant
-    if (updates.status && updates.status !== existing.status) {
-      const isValid = validateTransition(workflow || undefined, existing.status, updates.status);
+    if (taskUpdates.status && taskUpdates.status !== existing.status) {
+      const isValid = validateTransition(workflow || undefined, existing.status, taskUpdates.status);
       if (!isValid) {
-        throw new WorkflowValidationError(existing.status, updates.status, workflow?.id);
+        throw new WorkflowValidationError(existing.status, taskUpdates.status, workflow?.id);
       }
     }
 
     // Validate custom field invariants
-    if (project?.customFieldDefinitions && updates.customFields) {
+    if (project?.customFieldDefinitions && taskUpdates.customFields) {
       validateCustomFieldValues(project.customFieldDefinitions, {
         ...existing.customFields,
-        ...updates.customFields
+        ...taskUpdates.customFields
       });
     }
 
-    const processedUpdates = await this.plugins.runBeforeTaskUpdate(id, updates);
+    const processedUpdates = await this.plugins.runBeforeTaskUpdate(id, taskUpdates);
 
     // Auto-update execution/completion timestamps if status changes
     if (processedUpdates.status && processedUpdates.status !== existing.status) {
@@ -504,7 +553,10 @@ export class CriticalPathEngine {
         payload: {
           task: updated,
           previousStatus: existing.status,
-          newStatus: updated.status
+          newStatus: updated.status,
+          actorId,
+          ...(actorName ? { actorName } : {}),
+          actor: actorObj
         }
       };
       await this.events.publish(statusEvent);
@@ -525,18 +577,83 @@ export class CriticalPathEngine {
         occurredAt: now,
         payload: {
           task: updated,
-          previous: existing
+          previous: existing,
+          actorId,
+          ...(actorName ? { actorName } : {}),
+          actor: actorObj
         }
       };
       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,
+          actorId,
+          ...(actorName ? { actorName } : {}),
+          actor: actorObj
+        }
+      };
+      await this.events.publish(blockedEvent);
+      await this.store.logActivity({
+        projectId: updated.projectId,
+        taskId: updated.id,
+        actorId,
+        action: 'task.blocked',
+        details: { reason: blockedReason, ...(actorName ? { actorName } : {}) }
+      });
+      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,
+          actorId,
+          ...(actorName ? { actorName } : {}),
+          actor: actorObj
+        }
+      };
+      await this.events.publish(unblockedEvent);
+      await this.store.logActivity({
+        projectId: updated.projectId,
+        taskId: updated.id,
+        actorId,
+        action: 'task.unblocked',
+        details: { ...(actorName ? { actorName } : {}) }
+      });
+      this.dispatchWebhook('task.unblocked', {
+        task: updated
+      });
+    }
+
     await this.store.logActivity({
       projectId: updated.projectId,
       taskId: updated.id,
-      actorId: updated.assigneeId || 'system',
+      actorId,
       action: isStatusChange ? 'task.status_changed' : 'task.updated',
-      details: { fromStatus: existing.status, toStatus: updated.status }
+      details: {
+        fromStatus: existing.status,
+        toStatus: updated.status,
+        ...(actorName ? { actorName } : {})
+      }
     });
 
     this.dispatchWebhook(isStatusChange ? 'task.status_changed' : 'task.updated', {
@@ -577,6 +694,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,
@@ -1379,7 +1501,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>();
@@ -1392,7 +1518,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(
@@ -1435,6 +1563,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,
@@ -1445,7 +1575,8 @@ export class CriticalPathEngine {
         deliverables,
         attachments,
         timeEntries,
-        activities
+        activities,
+        schedule
       },
       options
     );
@@ -1518,6 +1649,8 @@ export class CriticalPathEngine {
   ): 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();
@@ -1529,7 +1662,10 @@ export class CriticalPathEngine {
         teams,
         projectId
       },
-      options
+      {
+        ...options,
+        schedule
+      }
     );
   }
 

package/src/index.test.ts

@@ -440,6 +440,54 @@ describe('CriticalPathEngine Core Tests', () => {
     const updated = await engine.updateTask(task.id, { status: 'in_production' });
     expect(updated?.status).toBe('in_production');
   });
+
+  it('attributes activities and domain events to the real actor rather than the assignee', async () => {
+    const engine = new CriticalPathEngine();
+    const proj = await engine.createProject({ key: 'ACT', name: 'Actor Attribution Project' });
+    const task = await engine.createTask({
+      projectId: proj.id,
+      title: 'Assigned Task',
+      status: 'todo',
+      assigneeId: 'agent_worker_1'
+    });
+
+    const receivedEvents: any[] = [];
+    engine.events.subscribe('task.status_changed', async (evt) => {
+      receivedEvents.push(evt);
+    });
+    engine.events.subscribe('task.updated', async (evt) => {
+      receivedEvents.push(evt);
+    });
+
+    // Update with explicit actor (e.g. human user updating an assigned agent task)
+    await engine.updateTask(task.id, {
+      status: 'in_progress',
+      actorId: 'user_human_42',
+      actorName: 'Jack James'
+    });
+
+    const activities = await engine.store.getActivities({ taskId: task.id });
+    const statusActivity = activities.find((a) => a.action === 'task.status_changed');
+    expect(statusActivity).toBeDefined();
+    expect(statusActivity?.actorId).toBe('user_human_42');
+    expect((statusActivity?.details as any)?.actorName).toBe('Jack James');
+    expect(statusActivity?.actorId).not.toBe('agent_worker_1');
+
+    expect(receivedEvents).toHaveLength(1);
+    expect(receivedEvents[0].payload.actorId).toBe('user_human_42');
+    expect(receivedEvents[0].payload.actorName).toBe('Jack James');
+
+    // Update without explicit actor - should fall back to 'system', NEVER task.assigneeId
+    await engine.updateTask(task.id, {
+      title: 'Updated title'
+    });
+
+    const updatedActivities = await engine.store.getActivities({ taskId: task.id });
+    const updateActivity = updatedActivities.find((a) => a.action === 'task.updated');
+    expect(updateActivity).toBeDefined();
+    expect(updateActivity?.actorId).toBe('system');
+    expect(updateActivity?.actorId).not.toBe('agent_worker_1');
+  });
 });