@critical-path/core 0.36.0 → 0.36.1

package/src/domain/calendar.ts

@@ -1,502 +0,0 @@
-import type {
-  DaySchedule,
-  Holiday,
-  Project,
-  Team,
-  User,
-  WorkingHoursRange,
-  WorkSchedule
-} from '../types/index.js';
-
-export const DEFAULT_WORK_SCHEDULE: WorkSchedule = {
-  name: 'Standard 40-Hour Work Week',
-  defaultHoursPerDay: 8,
-  days: [
-    { dayOfWeek: 0, isWorkingDay: false }, // Sunday
-    { dayOfWeek: 1, isWorkingDay: true, hours: [{ start: '09:00', end: '17:00' }] }, // Monday
-    { dayOfWeek: 2, isWorkingDay: true, hours: [{ start: '09:00', end: '17:00' }] }, // Tuesday
-    { dayOfWeek: 3, isWorkingDay: true, hours: [{ start: '09:00', end: '17:00' }] }, // Wednesday
-    { dayOfWeek: 4, isWorkingDay: true, hours: [{ start: '09:00', end: '17:00' }] }, // Thursday
-    { dayOfWeek: 5, isWorkingDay: true, hours: [{ start: '09:00', end: '17:00' }] }, // Friday
-    { dayOfWeek: 6, isWorkingDay: false }  // Saturday
-  ],
-  holidays: []
-};
-
-export interface ScheduleResolutionContext {
-  user?: User | null;
-  team?: Team | null;
-  project?: Project | null;
-  defaultSchedule?: WorkSchedule | null;
-}
-
-/**
- * Resolves the effective work schedule following the hierarchy:
- * 1. User schedule (if present)
- * 2. Team schedule (if present)
- * 3. Project schedule (if present)
- * 4. Engine / default schedule (fallback to DEFAULT_WORK_SCHEDULE)
- */
-export function resolveEffectiveSchedule(context?: ScheduleResolutionContext): WorkSchedule {
-  if (context?.user?.schedule) return context.user.schedule;
-  if (context?.team?.schedule) return context.team.schedule;
-  if (context?.project?.schedule) return context.project.schedule;
-  if (context?.defaultSchedule) return context.defaultSchedule;
-  return DEFAULT_WORK_SCHEDULE;
-}
-
-export function toDateString(d: Date): string {
-  return d.toISOString().split('T')[0];
-}
-
-export function parseDate(input: Date | string): Date {
-  if (input instanceof Date) {
-    return new Date(input.getTime());
-  }
-  if (!input.includes('T')) {
-    // Treat date-only string as UTC midnight
-    const parts = input.split('-');
-    return new Date(Date.UTC(parseInt(parts[0], 10), parseInt(parts[1], 10) - 1, parseInt(parts[2], 10)));
-  }
-  return new Date(input);
-}
-
-function parseTimeToMinutes(timeStr: string): number {
-  const parts = timeStr.split(':');
-  const h = parseInt(parts[0], 10) || 0;
-  const m = parseInt(parts[1], 10) || 0;
-  return h * 60 + m;
-}
-
-function getDayConfig(dayOfWeek: number, schedule: WorkSchedule): DaySchedule | undefined {
-  return schedule.days.find((d) => d.dayOfWeek === dayOfWeek);
-}
-
-function getHoliday(dateStr: string, schedule: WorkSchedule): Holiday | undefined {
-  if (!schedule.holidays) return undefined;
-  return schedule.holidays.find((h) => h.date === dateStr);
-}
-
-/**
- * Checks whether a given calendar date is an active working day under the provided schedule.
- */
-export function isWorkingDay(input: Date | string, schedule: WorkSchedule = DEFAULT_WORK_SCHEDULE): boolean {
-  const d = parseDate(input);
-  const dateStr = toDateString(d);
-  const holiday = getHoliday(dateStr, schedule);
-  if (holiday && !holiday.halfDay) {
-    return false;
-  }
-  const dayOfWeek = d.getUTCDay();
-  const dayConfig = getDayConfig(dayOfWeek, schedule);
-  if (!dayConfig || !dayConfig.isWorkingDay) {
-    return false;
-  }
-  return true;
-}
-
-/**
- * Returns the effective working hours available on a specific calendar day.
- */
-export function getWorkingHoursInDay(input: Date | string, schedule: WorkSchedule = DEFAULT_WORK_SCHEDULE): number {
-  const d = parseDate(input);
-  const dateStr = toDateString(d);
-  const holiday = getHoliday(dateStr, schedule);
-  if (holiday && !holiday.halfDay) {
-    return 0;
-  }
-
-  const dayOfWeek = d.getUTCDay();
-  const dayConfig = getDayConfig(dayOfWeek, schedule);
-  if (!dayConfig || !dayConfig.isWorkingDay) {
-    return 0;
-  }
-
-  let baseHours = schedule.defaultHoursPerDay ?? 8;
-  if (dayConfig.hours && dayConfig.hours.length > 0) {
-    baseHours = dayConfig.hours.reduce((sum, range) => {
-      const startMin = parseTimeToMinutes(range.start);
-      const endMin = parseTimeToMinutes(range.end);
-      return sum + Math.max(0, (endMin - startMin) / 60);
-    }, 0);
-  }
-
-  if (holiday && holiday.halfDay) {
-    return Math.round((baseHours / 2) * 100) / 100;
-  }
-
-  return baseHours;
-}
-
-/**
- * Returns the normalized working time windows (in minutes from UTC midnight) for a given date.
- */
-function getDayWorkingWindows(d: Date, schedule: WorkSchedule): Array<{ start: number; end: number }> {
-  const dateStr = toDateString(d);
-  const holiday = getHoliday(dateStr, schedule);
-  if (holiday && !holiday.halfDay) {
-    return [];
-  }
-
-  const dayOfWeek = d.getUTCDay();
-  const dayConfig = getDayConfig(dayOfWeek, schedule);
-  if (!dayConfig || !dayConfig.isWorkingDay) {
-    return [];
-  }
-
-  let ranges = dayConfig.hours && dayConfig.hours.length > 0
-    ? dayConfig.hours.map((r) => ({ start: parseTimeToMinutes(r.start), end: parseTimeToMinutes(r.end) }))
-    : [{ start: 9 * 60, end: (9 + (schedule.defaultHoursPerDay ?? 8)) * 60 }];
-
-  if (holiday && holiday.halfDay && ranges.length > 0) {
-    // Take the first half of the working hours
-    const totalMinutes = ranges.reduce((acc, r) => acc + (r.end - r.start), 0);
-    let targetMinutes = totalMinutes / 2;
-    const adjustedRanges: Array<{ start: number; end: number }> = [];
-    for (const r of ranges) {
-      const dur = r.end - r.start;
-      if (targetMinutes <= 0) break;
-      if (dur <= targetMinutes) {
-        adjustedRanges.push(r);
-        targetMinutes -= dur;
-      } else {
-        adjustedRanges.push({ start: r.start, end: r.start + targetMinutes });
-        targetMinutes = 0;
-      }
-    }
-    return adjustedRanges;
-  }
-
-  return ranges;
-}
-
-/**
- * Advances a start date forward by a given number of working hours,
- * skipping non-working days, holidays, and non-working hours.
- */
-export function addWorkingHours(
-  startInput: Date | string,
-  hoursToAdd: number,
-  schedule: WorkSchedule = DEFAULT_WORK_SCHEDULE
-): Date {
-  if (hoursToAdd <= 0) {
-    return parseDate(startInput);
-  }
-
-  let current = parseDate(startInput);
-  let remainingMinutes = Math.round(hoursToAdd * 60);
-
-  // Safety guard against infinite loops
-  let daysScanned = 0;
-  const maxDays = 3650; // 10 years
-
-  while (remainingMinutes > 0 && daysScanned < maxDays) {
-    const windows = getDayWorkingWindows(current, schedule);
-
-    if (windows.length === 0) {
-      // Non-working day or holiday: move to start of next UTC day
-      current = new Date(Date.UTC(current.getUTCFullYear(), current.getUTCMonth(), current.getUTCDate() + 1, 0, 0, 0, 0));
-      daysScanned++;
-      continue;
-    }
-
-    const currentMinuteOfDay = current.getUTCHours() * 60 + current.getUTCMinutes() + current.getUTCSeconds() / 60;
-
-    for (let i = 0; i < windows.length && remainingMinutes > 0; i++) {
-      const w = windows[i];
-      if (currentMinuteOfDay >= w.end) {
-        // Already past this window
-        continue;
-      }
-
-      // If current time is before the window starts, jump to window start
-      const windowStartMin = Math.max(w.start, currentMinuteOfDay);
-      const availableMinutes = w.end - windowStartMin;
-
-      if (remainingMinutes <= availableMinutes) {
-        const finalMinuteOfDay = windowStartMin + remainingMinutes;
-        const finalHour = Math.floor(finalMinuteOfDay / 60);
-        const finalMin = Math.round(finalMinuteOfDay % 60);
-        return new Date(Date.UTC(
-          current.getUTCFullYear(),
-          current.getUTCMonth(),
-          current.getUTCDate(),
-          finalHour,
-          finalMin,
-          0,
-          0
-        ));
-      } else {
-        remainingMinutes -= availableMinutes;
-        // Advance current time to end of this window
-        current = new Date(Date.UTC(
-          current.getUTCFullYear(),
-          current.getUTCMonth(),
-          current.getUTCDate(),
-          Math.floor(w.end / 60),
-          Math.round(w.end % 60),
-          0,
-          0
-        ));
-      }
-    }
-
-    // Finished processing windows for today; advance to tomorrow at 00:00
-    current = new Date(Date.UTC(current.getUTCFullYear(), current.getUTCMonth(), current.getUTCDate() + 1, 0, 0, 0, 0));
-    daysScanned++;
-  }
-
-  return current;
-}
-
-/**
- * Moves backward from an end date by a given number of working hours,
- * skipping non-working days, holidays, and non-working hours.
- */
-export function subtractWorkingHours(
-  endInput: Date | string,
-  hoursToSubtract: number,
-  schedule: WorkSchedule = DEFAULT_WORK_SCHEDULE
-): Date {
-  if (hoursToSubtract <= 0) {
-    return parseDate(endInput);
-  }
-
-  let current = parseDate(endInput);
-  let remainingMinutes = Math.round(hoursToSubtract * 60);
-
-  let daysScanned = 0;
-  const maxDays = 3650;
-
-  while (remainingMinutes > 0 && daysScanned < maxDays) {
-    const windows = getDayWorkingWindows(current, schedule);
-
-    if (windows.length === 0) {
-      // Non-working day: move to end of previous UTC day (23:59:59)
-      current = new Date(Date.UTC(current.getUTCFullYear(), current.getUTCMonth(), current.getUTCDate() - 1, 23, 59, 59, 999));
-      daysScanned++;
-      continue;
-    }
-
-    const currentMinuteOfDay = current.getUTCHours() * 60 + current.getUTCMinutes() + current.getUTCSeconds() / 60;
-
-    // Traverse windows backwards
-    for (let i = windows.length - 1; i >= 0 && remainingMinutes > 0; i--) {
-      const w = windows[i];
-      if (currentMinuteOfDay <= w.start) {
-        continue;
-      }
-
-      const windowEndMin = Math.min(w.end, currentMinuteOfDay);
-      const availableMinutes = windowEndMin - w.start;
-
-      if (remainingMinutes <= availableMinutes) {
-        const finalMinuteOfDay = windowEndMin - remainingMinutes;
-        const finalHour = Math.floor(finalMinuteOfDay / 60);
-        const finalMin = Math.round(finalMinuteOfDay % 60);
-        return new Date(Date.UTC(
-          current.getUTCFullYear(),
-          current.getUTCMonth(),
-          current.getUTCDate(),
-          finalHour,
-          finalMin,
-          0,
-          0
-        ));
-      } else {
-        remainingMinutes -= availableMinutes;
-        current = new Date(Date.UTC(
-          current.getUTCFullYear(),
-          current.getUTCMonth(),
-          current.getUTCDate(),
-          Math.floor(w.start / 60),
-          Math.round(w.start % 60),
-          0,
-          0
-        ));
-      }
-    }
-
-    // Move to end of previous day
-    current = new Date(Date.UTC(current.getUTCFullYear(), current.getUTCMonth(), current.getUTCDate() - 1, 23, 59, 59, 999));
-    daysScanned++;
-  }
-
-  return current;
-}
-
-/**
- * Calculates the exact number of active working hours between two dates under the schedule.
- */
-export function getWorkingHoursBetween(
-  startInput: Date | string,
-  endInput: Date | string,
-  schedule: WorkSchedule = DEFAULT_WORK_SCHEDULE
-): number {
-  const start = parseDate(startInput);
-  const end = parseDate(endInput);
-
-  if (end <= start) {
-    return 0;
-  }
-
-  let totalMinutes = 0;
-  let current = new Date(Date.UTC(start.getUTCFullYear(), start.getUTCMonth(), start.getUTCDate(), 0, 0, 0, 0));
-  const endDay = new Date(Date.UTC(end.getUTCFullYear(), end.getUTCMonth(), end.getUTCDate(), 0, 0, 0, 0));
-
-  let days = 0;
-  while (current <= endDay && days < 3650) {
-    const windows = getDayWorkingWindows(current, schedule);
-    const isFirstDay = current.getTime() === Date.UTC(start.getUTCFullYear(), start.getUTCMonth(), start.getUTCDate(), 0, 0, 0, 0);
-    const isLastDay = current.getTime() === endDay.getTime();
-
-    const startMin = isFirstDay ? start.getUTCHours() * 60 + start.getUTCMinutes() : 0;
-    const endMin = isLastDay ? end.getUTCHours() * 60 + end.getUTCMinutes() : 24 * 60;
-
-    for (const w of windows) {
-      const activeStart = Math.max(w.start, startMin);
-      const activeEnd = Math.min(w.end, endMin);
-      if (activeEnd > activeStart) {
-        totalMinutes += (activeEnd - activeStart);
-      }
-    }
-
-    current = new Date(Date.UTC(current.getUTCFullYear(), current.getUTCMonth(), current.getUTCDate() + 1, 0, 0, 0, 0));
-    days++;
-  }
-
-  return Math.round((totalMinutes / 60) * 100) / 100;
-}
-
-/**
- * Returns the count of working days between two dates (inclusive of start and end).
- */
-export function getWorkingDaysBetween(
-  startInput: Date | string,
-  endInput: Date | string,
-  schedule: WorkSchedule = DEFAULT_WORK_SCHEDULE
-): number {
-  const start = parseDate(startInput);
-  const end = parseDate(endInput);
-
-  if (end < start) {
-    return 0;
-  }
-
-  let current = new Date(Date.UTC(start.getUTCFullYear(), start.getUTCMonth(), start.getUTCDate(), 0, 0, 0, 0));
-  const endDay = new Date(Date.UTC(end.getUTCFullYear(), end.getUTCMonth(), end.getUTCDate(), 0, 0, 0, 0));
-
-  let count = 0;
-  let days = 0;
-  while (current <= endDay && days < 3650) {
-    if (isWorkingDay(current, schedule)) {
-      const holiday = getHoliday(toDateString(current), schedule);
-      count += (holiday && holiday.halfDay) ? 0.5 : 1;
-    }
-    current = new Date(Date.UTC(current.getUTCFullYear(), current.getUTCMonth(), current.getUTCDate() + 1, 0, 0, 0, 0));
-    days++;
-  }
-
-  return count;
-}
-
-/**
- * Returns an array of YYYY-MM-DD date strings for all active working days between start and end.
- */
-export function getWorkingDaysList(
-  startInput: Date | string,
-  endInput: Date | string,
-  schedule: WorkSchedule = DEFAULT_WORK_SCHEDULE
-): string[] {
-  const start = parseDate(startInput);
-  const end = parseDate(endInput);
-
-  if (end < start) {
-    return [];
-  }
-
-  let current = new Date(Date.UTC(start.getUTCFullYear(), start.getUTCMonth(), start.getUTCDate(), 0, 0, 0, 0));
-  const endDay = new Date(Date.UTC(end.getUTCFullYear(), end.getUTCMonth(), end.getUTCDate(), 0, 0, 0, 0));
-
-  const list: string[] = [];
-  let days = 0;
-  while (current <= endDay && days < 3650) {
-    if (isWorkingDay(current, schedule)) {
-      list.push(toDateString(current));
-    }
-    current = new Date(Date.UTC(current.getUTCFullYear(), current.getUTCMonth(), current.getUTCDate() + 1, 0, 0, 0, 0));
-    days++;
-  }
-
-  return list;
-}
-
-/**
- * Computes net available capacity (in working hours) over a contiguous date interval.
- */
-export function getNetAvailableCapacity(
-  startInput: Date | string,
-  endInput: Date | string,
-  schedule: WorkSchedule = DEFAULT_WORK_SCHEDULE
-): number {
-  const start = parseDate(startInput);
-  const end = parseDate(endInput);
-
-  let current = new Date(Date.UTC(start.getUTCFullYear(), start.getUTCMonth(), start.getUTCDate(), 0, 0, 0, 0));
-  const endDay = new Date(Date.UTC(end.getUTCFullYear(), end.getUTCMonth(), end.getUTCDate(), 0, 0, 0, 0));
-
-  let totalCapacity = 0;
-  let days = 0;
-  while (current <= endDay && days < 3650) {
-    totalCapacity += getWorkingHoursInDay(current, schedule);
-    current = new Date(Date.UTC(current.getUTCFullYear(), current.getUTCMonth(), current.getUTCDate() + 1, 0, 0, 0, 0));
-    days++;
-  }
-
-  return Math.round(totalCapacity * 100) / 100;
-}
-
-export interface FormatDurationOptions {
-  /** Optional custom work schedule to determine working hours in a day */
-  schedule?: WorkSchedule;
-  /** 'working_days' uses schedule.defaultHoursPerDay (default 8h). 'calendar_days' uses 24h. Default: 'working_days' */
-  dayBasis?: 'working_days' | 'calendar_days';
-}
-
-/**
- * Formats task execution duration dynamically based on magnitude:
- * - < 120s: Seconds with 1 decimal place (e.g. '110.3s', '45s')
- * - < 1 day (based on dayBasis): Hours and minutes (e.g. '0h 44m', '2h 15m')
- * - >= 1 day: Days with 1 decimal place (e.g. '1.5 days', '3.2 days')
- */
-export function formatTaskDuration(
-  durationSeconds: number | null | undefined,
-  options?: FormatDurationOptions
-): string {
-  if (durationSeconds === null || durationSeconds === undefined || isNaN(durationSeconds) || durationSeconds <= 0) {
-    return '0s';
-  }
-
-  // Under 120 seconds: return seconds with 1 decimal place (or whole if integer)
-  if (durationSeconds < 120) {
-    const formatted = durationSeconds.toFixed(1);
-    return `${formatted.endsWith('.0') ? formatted.slice(0, -2) : formatted}s`;
-  }
-
-  const hoursPerDay = options?.dayBasis === 'calendar_days'
-    ? 24
-    : (options?.schedule?.defaultHoursPerDay || DEFAULT_WORK_SCHEDULE.defaultHoursPerDay || 8);
-
-  const totalHours = durationSeconds / 3600;
-  if (totalHours >= hoursPerDay) {
-    const days = totalHours / hoursPerDay;
-    const formatted = days.toFixed(1);
-    const cleanDays = formatted.endsWith('.0') ? formatted.slice(0, -2) : formatted;
-    return `${cleanDays} ${cleanDays === '1' ? 'day' : 'days'}`;
-  }
-
-  const hours = Math.floor(totalHours);
-  const minutes = Math.floor((durationSeconds % 3600) / 60);
-  return `${hours}h ${minutes}m`;
-}
-

package/src/domain/cpm.test.ts

@@ -1,189 +0,0 @@
-import { describe, it, expect } from 'vitest';
-import { calculateCPM, getTaskDurationHours } from './cpm.js';
-import type { Task, TaskDependency } from '../types/index.js';
-
-describe('Critical Path Method (CPM)', () => {
-  it('returns empty analysis for empty tasks array', () => {
-    const analysis = calculateCPM('proj-1', [], []);
-    expect(analysis.projectId).toBe('proj-1');
-    expect(analysis.totalDurationHours).toBe(0);
-    expect(analysis.criticalTaskIds).toEqual([]);
-    expect(analysis.tasks).toEqual([]);
-  });
-
-  it('calculates duration, slack, and critical path for sequential linear tasks', () => {
-    const now = new Date().toISOString();
-    const tasks: Task[] = [
-      {
-        id: 'task-1',
-        projectId: 'proj-1',
-        title: 'Task 1',
-        status: 'todo',
-        priority: 'medium',
-        estimatedHours: 2,
-        createdAt: now,
-        updatedAt: now
-      },
-      {
-        id: 'task-2',
-        projectId: 'proj-1',
-        title: 'Task 2',
-        status: 'todo',
-        priority: 'medium',
-        estimatedHours: 3,
-        createdAt: now,
-        updatedAt: now
-      },
-      {
-        id: 'task-3',
-        projectId: 'proj-1',
-        title: 'Task 3',
-        status: 'todo',
-        priority: 'medium',
-        estimatedHours: 1,
-        createdAt: now,
-        updatedAt: now
-      }
-    ];
-
-    const dependencies: TaskDependency[] = [
-      { id: 'dep-1', taskId: 'task-2', dependsOnTaskId: 'task-1', type: 'blocking' },
-      { id: 'dep-2', taskId: 'task-3', dependsOnTaskId: 'task-2', type: 'blocking' }
-    ];
-
-    const result = calculateCPM('proj-1', tasks, dependencies);
-
-    expect(result.totalDurationHours).toBe(6);
-    expect(result.criticalTaskIds).toEqual(['task-1', 'task-2', 'task-3']);
-
-    const sched1 = result.tasks.find((t) => t.taskId === 'task-1')!;
-    expect(sched1.earlyStart).toBe(0);
-    expect(sched1.earlyFinish).toBe(2);
-    expect(sched1.lateStart).toBe(0);
-    expect(sched1.lateFinish).toBe(2);
-    expect(sched1.totalSlack).toBe(0);
-    expect(sched1.isCritical).toBe(true);
-
-    const sched2 = result.tasks.find((t) => t.taskId === 'task-2')!;
-    expect(sched2.earlyStart).toBe(2);
-    expect(sched2.earlyFinish).toBe(5);
-    expect(sched2.totalSlack).toBe(0);
-    expect(sched2.isCritical).toBe(true);
-
-    const sched3 = result.tasks.find((t) => t.taskId === 'task-3')!;
-    expect(sched3.earlyStart).toBe(5);
-    expect(sched3.earlyFinish).toBe(6);
-    expect(sched3.totalSlack).toBe(0);
-    expect(sched3.isCritical).toBe(true);
-  });
-
-  it('correctly identifies bottleneck critical path vs non-critical slack in parallel branches', () => {
-    // A (1h) -> B (4h) -> D (1h)  => Path length = 6h (CRITICAL)
-    // A (1h) -> C (2h) -> D (1h)  => Path length = 4h (Non-critical, C has 2h slack)
-    const now = new Date().toISOString();
-    const tasks: Task[] = [
-      { id: 'A', projectId: 'p1', title: 'A', status: 'todo', priority: 'medium', estimatedHours: 1, createdAt: now, updatedAt: now },
-      { id: 'B', projectId: 'p1', title: 'B', status: 'todo', priority: 'medium', estimatedHours: 4, createdAt: now, updatedAt: now },
-      { id: 'C', projectId: 'p1', title: 'C', status: 'todo', priority: 'medium', estimatedHours: 2, createdAt: now, updatedAt: now },
-      { id: 'D', projectId: 'p1', title: 'D', status: 'todo', priority: 'medium', estimatedHours: 1, createdAt: now, updatedAt: now }
-    ];
-
-    const dependencies: TaskDependency[] = [
-      { id: 'd1', taskId: 'B', dependsOnTaskId: 'A', type: 'blocking' },
-      { id: 'd2', taskId: 'C', dependsOnTaskId: 'A', type: 'blocking' },
-      { id: 'd3', taskId: 'D', dependsOnTaskId: 'B', type: 'blocking' },
-      { id: 'd4', taskId: 'D', dependsOnTaskId: 'C', type: 'blocking' }
-    ];
-
-    const result = calculateCPM('p1', tasks, dependencies);
-
-    expect(result.totalDurationHours).toBe(6);
-    expect(result.criticalTaskIds).toEqual(['A', 'B', 'D']);
-
-    const schedC = result.tasks.find((t) => t.taskId === 'C')!;
-    expect(schedC.earlyStart).toBe(1);
-    expect(schedC.earlyFinish).toBe(3);
-    expect(schedC.lateStart).toBe(3);
-    expect(schedC.lateFinish).toBe(5);
-    expect(schedC.totalSlack).toBe(2);
-    expect(schedC.isCritical).toBe(false);
-
-    const schedB = result.tasks.find((t) => t.taskId === 'B')!;
-    expect(schedB.totalSlack).toBe(0);
-    expect(schedB.isCritical).toBe(true);
-  });
-
-  it('falls back gracefully to 1 hour duration if no estimate or minutes are set', () => {
-    const task: Task = {
-      id: 'no-est',
-      projectId: 'p1',
-      title: 'Unestimated Task',
-      status: 'todo',
-      priority: 'none',
-      createdAt: '',
-      updatedAt: ''
-    };
-    expect(getTaskDurationHours(task)).toBe(1);
-  });
-
-  it('calculates calendar-aware dates skipping weekends and respecting working hours', () => {
-    // Friday 2026-09-18 at 09:00
-    // Task 1: 16 working hours (Friday 09:00-17:00 = 8h, skips weekend, Monday 2026-09-21 09:00-17:00 = 8h) -> Finishes Mon 17:00
-    // Task 2: 8 working hours (depends on Task 1) -> Tuesday 2026-09-22 09:00-17:00
-    const tasks: Task[] = [
-      { id: 'T1', projectId: 'p1', title: 'Task 1', status: 'todo', priority: 'medium', estimatedHours: 16, createdAt: '', updatedAt: '' },
-      { id: 'T2', projectId: 'p1', title: 'Task 2', status: 'todo', priority: 'medium', estimatedHours: 8, createdAt: '', updatedAt: '' }
-    ];
-    const deps: TaskDependency[] = [
-      { id: 'd1', taskId: 'T2', dependsOnTaskId: 'T1', type: 'blocking' }
-    ];
-
-    const projectStartDate = '2026-09-18T09:00:00Z';
-    const result = calculateCPM('p1', tasks, deps, { projectStartDate });
-
-    expect(result.totalDurationHours).toBe(24);
-    expect(result.totalWorkingHours).toBe(24);
-    expect(result.projectStartDate).toBe('2026-09-18T09:00:00.000Z');
-    expect(result.projectEndDate).toBe('2026-09-22T17:00:00.000Z');
-
-    const s1 = result.tasks.find((t) => t.taskId === 'T1')!;
-    expect(s1.earlyStartDate).toBe('2026-09-18T09:00:00.000Z');
-    expect(s1.earlyFinishDate).toBe('2026-09-21T17:00:00.000Z');
-    expect(s1.durationHours).toBe(16);
-
-    const s2 = result.tasks.find((t) => t.taskId === 'T2')!;
-    expect(s2.earlyStartDate).toBe('2026-09-21T17:00:00.000Z');
-    expect(s2.earlyFinishDate).toBe('2026-09-22T17:00:00.000Z');
-    expect(s2.durationHours).toBe(8);
-  });
-
-  it('skips configured holidays during CPM scheduling', () => {
-    // Friday 2026-09-18 09:00, with Monday 2026-09-21 as a holiday!
-    // Task 1: 16 working hours (Friday 8h, Sat/Sun off, Mon off [holiday], Tuesday 2026-09-22 8h) -> Finishes Tuesday 17:00!
-    const tasks: Task[] = [
-      { id: 'T1', projectId: 'p1', title: 'Task 1', status: 'todo', priority: 'medium', estimatedHours: 16, createdAt: '', updatedAt: '' }
-    ];
-
-    const result = calculateCPM('p1', tasks, [], {
-      projectStartDate: '2026-09-18T09:00:00Z',
-      schedule: {
-        name: 'Custom',
-        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 s1 = result.tasks.find((t) => t.taskId === 'T1')!;
-    expect(s1.earlyStartDate).toBe('2026-09-18T09:00:00.000Z');
-    expect(s1.earlyFinishDate).toBe('2026-09-22T17:00:00.000Z');
-  });
-});