@critical-path/core 0.53.0 → 0.55.0

package/CHANGELOG.md

@@ -1,5 +1,29 @@
 # @critical-path/core
 
+## 0.55.0
+
+### Minor Changes
+
+- 5dbf25b: Effort and progress roll-ups agree, count subtasks once and leave canceled work out.
+  
+  - New `getTaskEstimateHours(task)` is the one place that reads an estimate (0 for milestones; an explicit 0 counts). Critical path analysis, workload, the ladder, metrics/EVM and deliverable summaries all use it, along with `getSummaryTaskIds` / `getLeafTasks`.
+  - **BREAKING:** a task with subtasks is a summary task. Critical path analysis schedules only leaf tasks: dependencies and deadlines on a summary apply to every leaf under it, and the summary is reported as a roll-up (`isSummary: true`; not in `criticalTaskIds`). Workload, the ladder and deliverable summaries count effort from leaves only, so an epic's estimate no longer doubles its subtasks'.
+  - **BREAKING:** canceled tasks leave estimate totals and progress denominators in the ladder and deliverable summaries (their logged hours still count), so a project can reach 100% and `completed`. Canceled tasks have zero planned and earned value in EVM. The ladder and deliverable summaries use inferred progress (`inferTaskProgress`) like task metrics.
+  - Unestimated tasks are listed in `unestimatedTaskIds`, and the hours assumed for them are configurable: `defaultEstimateHours` per call (`?defaultEstimateHours=` over HTTP, client and MCP options) or `criticalPathDefaultEstimateHours` on the engine. Default 1, as before.
+
+## 0.54.0
+
+### Minor Changes
+
+- 1021eb5: Status, workflow and effort integrity.
+  
+  - **BREAKING:** a task's `status` must be one of its project's statuses (`statusDefinitions`, else the workflow's), on create and update (`400` otherwise). Unknown keys are no longer guessed from their spelling (`unfinished` was treated as completed); `resolveStatusDefinition` returns `not_started` for them.
+  - **BREAKING:** derived task fields are rejected in request bodies and left out of `CreateTaskInput`: `semanticStatus`, `loggedHours`, `actualHours`, `billableHours`, `actualDurationSeconds`, `actualDurationMinutes`, `billableDurationMinutes`, `inProgressSince`, `blockedSince`, `blockedDurationSeconds`. `semanticStatus` is always derived from the status, so CPM, metrics and lifecycle agree. Hours come from time entries.
+  - `actualHours` is no longer overwritten with wall-clock time when a task leaves in-progress (logged effort was being lost). Elapsed time stays in `actualDurationSeconds` / `actualDurationMinutes`.
+  - **BREAKING:** changing a project's statuses (`workflowId`, `workflow` or `statusDefinitions`) requires `statusMapping` for every status its tasks are in that the project will no longer have (`engine.updateProject(id, updates, { statusMapping })`, or `statusMapping` in the `PATCH /projects/:id` body); tasks are moved in the same operation. Deleting a workflow that a project uses, or removing a status tasks are in, is refused with the new `ConflictError` (`409`).
+  - New projects are pinned to the workflow they start with, so a later default does not move them.
+  - MCP: new `log_time` tool; `update_task` no longer takes `loggedHours`.
+
 ## 0.53.0
 
 ### Minor Changes

package/README.md

@@ -238,15 +238,16 @@ const deliverable = await engine.createDeliverable({
 });
 
 // 2. Attach tasks to deliverable
-await engine.createTask({
+const storyboard = await engine.createTask({
   projectId: 'proj_1',
   deliverableId: deliverable.id,
   title: 'Storyboard & Animatic',
   status: 'approved',
   estimatedHours: 12,
-  loggedHours: 12,
   progress: 100
 });
+// Logged hours come from time entries
+await engine.logTime({ taskId: storyboard.id, hours: 12 });
 
 // 3. Rollup metrics
 const summary = await engine.getDeliverableSummary(deliverable.id);
@@ -364,7 +365,7 @@ console.log(leveled.unleveledProjectEndDate, '->', leveled.projectEndDate);
 
 With `calendars: 'assignee'` (or `criticalPathCalendars: 'assignee'` on the engine), each task uses its assignee's schedule, then its team's, then the project calendar. Passes run on dates, slack is measured in each task's calendar, and each calendar is evaluated in its own `timezone` (IANA name; default UTC), including daylight-saving changes. `levelResources: true` additionally delays tasks so nobody works on two at once (priority rule `levelingPriority`, default least slack), reporting `levelingDelayHours` and `waitingOn` per task. Tasks with `allocation` below 1 take that share of their assignee (a 16h task at 0.5 spans 32 working hours); levelling fits them within 100% per person, and `overallocations` lists who is booked above 100% and when. Teams act as pools of `headcount` people (default: member count) shared by team-only tasks and members' own tasks. Finished tasks take no time. `calculatePortfolioCriticalPath({ projectIds })` levels several projects together, sharing people and teams across them; `includeHiddenWork` also counts unreadable projects' work as `'hidden'`. `effort: 'remaining'` schedules only what is left on in-progress tasks.
 
-Tasks with `isMilestone: true` are zero-duration checkpoints (their estimates are ignored). A `deadline` on any task caps its late finish: a forecast that misses it shows as negative slack along the path driving it, with `deadlineDate` and `deadlineVarianceHours` per task and `missedDeadlineTaskIds` on the analysis. A date-only deadline means the end of that working day; project-calendar mode needs a start date to apply deadlines.
+Tasks with subtasks are summary tasks, reported as roll-ups of their leaves (`isSummary`); dependencies and deadlines on them apply to every leaf. Unestimated tasks use `defaultEstimateHours` (default 1) and are listed in `unestimatedTaskIds`. Tasks with `isMilestone: true` are zero-duration checkpoints (their estimates are ignored). A `deadline` on any task caps its late finish: a forecast that misses it shows as negative slack along the path driving it, with `deadlineDate` and `deadlineVarianceHours` per task and `missedDeadlineTaskIds` on the analysis. A date-only deadline means the end of that working day; project-calendar mode needs a start date to apply deadlines.
 
 ### 9. Fractional Lexical Indexing (Kanban Reordering)
 

package/dist/domain/cpm.d.ts

@@ -1,9 +1,15 @@
 import type { Task, TaskDependency, CriticalPathAnalysis, WorkSchedule, User, Team, PortfolioCriticalPathAnalysis } from '../types/index.js';
-export declare function getTaskDurationHours(task: Task): number;
+/** Hours assumed for a task with no estimate and no logged effort (see `CPMOptions.defaultEstimateHours`). */
+export declare const DEFAULT_ESTIMATE_HOURS = 1;
+/**
+ * Effort critical path analysis and workload plan for a task: its estimate (`getTaskEstimateHours`;
+ * 0 for milestones), else the effort logged on it, else `defaultEstimateHours`.
+ */
+export declare function getTaskDurationHours(task: Task, defaultEstimateHours?: number): number;
 /** The task's `allocation`, clamped to (0, 1]; 1 when unset or invalid. */
 export declare function getTaskAllocation(task: Task): number;
 /** Working hours a task spans: its effort divided by its allocation. */
-export declare function getTaskElapsedHours(task: Task): number;
+export declare function getTaskElapsedHours(task: Task, defaultEstimateHours?: number): number;
 /** True for completed or canceled tasks (by `semanticStatus`, else the default `done`/`canceled` statuses). */
 export declare function isTaskFinished(task: Task): boolean;
 /** What effort critical path analysis schedules: the full estimate, or what remains on in-progress tasks. */
@@ -13,7 +19,7 @@ export type EffortBasis = 'estimate' | 'remaining';
  * more time and occupies nobody), otherwise its effort divided by its allocation. With
  * `effort: 'remaining'`, an in-progress task's effort is `max(0, estimate - loggedHours)`.
  */
-export declare function getTaskScheduledHours(task: Task, effort?: EffortBasis): number;
+export declare function getTaskScheduledHours(task: Task, effort?: EffortBasis, defaultEstimateHours?: number): number;
 export interface CPMOptions {
     projectStartDate?: string | Date;
     /** The project calendar. Default: `DEFAULT_WORK_SCHEDULE`. */
@@ -47,6 +53,11 @@ export interface CPMOptions {
      * no time either way.
      */
     effort?: EffortBasis;
+    /**
+     * Hours assumed for an unfinished task with no estimate and no logged effort. Default 1. Such
+     * tasks are listed in `unestimatedTaskIds`, so a half-estimated plan does not look certain.
+     */
+    defaultEstimateHours?: number;
 }
 export type LevelingPriority = 'slack' | 'priority' | 'dueDate' | 'order';
 /** The calendar a task runs on in assignee mode: assignee, then task team, then project. */

package/dist/domain/cpm.d.ts.map

@@ -1 +1 @@
-{"version":3,"file":"cpm.d.ts","sourceRoot":"","sources":["../../src/domain/cpm.ts"],"names":[],"mappings":"AAAA,OAAO,KAAK,EACV,IAAI,EACJ,cAAc,EAEd,oBAAoB,EACpB,YAAY,EACZ,IAAI,EACJ,IAAI,EAEJ,6BAA6B,EAC9B,MAAM,mBAAmB,CAAC;AAc3B,wBAAgB,oBAAoB,CAAC,IAAI,EAAE,IAAI,GAAG,MAAM,CAcvD;AAED,2EAA2E;AAC3E,wBAAgB,iBAAiB,CAAC,IAAI,EAAE,IAAI,GAAG,MAAM,CAGpD;AAED,wEAAwE;AACxE,wBAAgB,mBAAmB,CAAC,IAAI,EAAE,IAAI,GAAG,MAAM,CAEtD;AAED,+GAA+G;AAC/G,wBAAgB,cAAc,CAAC,IAAI,EAAE,IAAI,GAAG,OAAO,CAGlD;AAED,6GAA6G;AAC7G,MAAM,MAAM,WAAW,GAAG,UAAU,GAAG,WAAW,CAAC;AAEnD;;;;GAIG;AACH,wBAAgB,qBAAqB,CAAC,IAAI,EAAE,IAAI,EAAE,MAAM,GAAE,WAAwB,GAAG,MAAM,CAM1F;AAED,MAAM,WAAW,UAAU;IACzB,gBAAgB,CAAC,EAAE,MAAM,GAAG,IAAI,CAAC;IACjC,8DAA8D;IAC9D,QAAQ,CAAC,EAAE,YAAY,CAAC;IACxB;;;;;OAKG;IACH,SAAS,CAAC,EAAE,SAAS,GAAG,UAAU,CAAC;IACnC,iFAAiF;IACjF,KAAK,CAAC,EAAE,IAAI,EAAE,CAAC;IACf,kFAAkF;IAClF,KAAK,CAAC,EAAE,IAAI,EAAE,CAAC;IACf;;;;OAIG;IACH,cAAc,CAAC,EAAE,OAAO,CAAC;IACzB;;;;OAIG;IACH,gBAAgB,CAAC,EAAE,gBAAgB,CAAC;IACpC;;;;OAIG;IACH,MAAM,CAAC,EAAE,WAAW,CAAC;CACtB;AAED,MAAM,MAAM,gBAAgB,GAAG,OAAO,GAAG,UAAU,GAAG,SAAS,GAAG,OAAO,CAAC;AAE1E,4FAA4F;AAC5F,wBAAgB,mBAAmB,CACjC,IAAI,EAAE,IAAI,EACV,OAAO,EAAE;IAAE,KAAK,CAAC,EAAE,IAAI,EAAE,CAAC;IAAC,KAAK,CAAC,EAAE,IAAI,EAAE,CAAC;IAAC,QAAQ,CAAC,EAAE,YAAY,CAAA;CAAE,GACnE,YAAY,CAOd;AAID;;;GAGG;AACH,wBAAgB,kBAAkB,CAAC,QAAQ,EAAE,MAAM,EAAE,QAAQ,GAAE,YAAoC,GAAG,IAAI,CAKzG;AA2kBD,MAAM,WAAW,qBAAqB;IACpC,SAAS,EAAE,MAAM,CAAC;IAClB,KAAK,EAAE,IAAI,EAAE,CAAC;IACd,0DAA0D;IAC1D,gBAAgB,CAAC,EAAE,MAAM,GAAG,IAAI,CAAC;IACjC,8DAA8D;IAC9D,QAAQ,CAAC,EAAE,YAAY,CAAC;IACxB;;;;OAIG;IACH,UAAU,CAAC,EAAE,SAAS,GAAG,QAAQ,CAAC;CACnC;AAED,MAAM,WAAW,mBAAoB,SAAQ,IAAI,CAAC,UAAU,EAAE,kBAAkB,GAAG,UAAU,CAAC;IAC5F,gHAAgH;IAChH,YAAY,CAAC,EAAE,MAAM,EAAE,CAAC;CACzB;AAED;;;;;;GAMG;AACH,wBAAgB,qBAAqB,CACnC,QAAQ,EAAE,qBAAqB,EAAE,EACjC,YAAY,EAAE,cAAc,EAAE,EAC9B,OAAO,GAAE,mBAAwB,GAChC,6BAA6B,CAsC/B;AAED;;;;;;GAMG;AACH,wBAAgB,YAAY,CAC1B,SAAS,EAAE,MAAM,EACjB,KAAK,EAAE,IAAI,EAAE,EACb,YAAY,EAAE,cAAc,EAAE,EAC9B,OAAO,GAAE,UAAe,GACvB,oBAAoB,CAqLtB"}
+{"version":3,"file":"cpm.d.ts","sourceRoot":"","sources":["../../src/domain/cpm.ts"],"names":[],"mappings":"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"}

package/dist/domain/cpm.js

@@ -1,21 +1,24 @@
 import { DEFAULT_WORK_SCHEDULE, addWorkingHours, subtractWorkingHours, getWorkingHoursBetween, nextWorkingTime, previousWorkingTime, parseDate, toDateString } from './calendar.js';
 import { isTaskInProgress } from '../utils/status.js';
 import { precedenceOf } from './graph.js';
-export function getTaskDurationHours(task) {
-    // A milestone is a point in time: it never takes effort, whatever its estimates say
-    if (task.isMilestone)
-        return 0;
-    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) {
+import { getTaskEstimateHours, getSummaryTaskIds } from './effort.js';
+/** Hours assumed for a task with no estimate and no logged effort (see `CPMOptions.defaultEstimateHours`). */
+export const DEFAULT_ESTIMATE_HOURS = 1;
+/**
+ * Effort critical path analysis and workload plan for a task: its estimate (`getTaskEstimateHours`;
+ * 0 for milestones), else the effort logged on it, else `defaultEstimateHours`.
+ */
+export function getTaskDurationHours(task, defaultEstimateHours = DEFAULT_ESTIMATE_HOURS) {
+    const estimate = getTaskEstimateHours(task);
+    if (estimate !== undefined)
+        return estimate;
+    if (typeof task.actualHours === 'number' && task.actualHours > 0)
         return task.actualHours;
-    }
-    // Default to 1 hour for non-empty tasks without explicit estimate
-    return 1;
+    return defaultEstimateHours;
+}
+/** True when `getTaskDurationHours` falls back to the default: no estimate and no logged effort. */
+function isUnestimated(task) {
+    return getTaskEstimateHours(task) === undefined && !(typeof task.actualHours === 'number' && task.actualHours > 0);
 }
 /** The task's `allocation`, clamped to (0, 1]; 1 when unset or invalid. */
 export function getTaskAllocation(task) {
@@ -23,8 +26,8 @@ export function getTaskAllocation(task) {
     return typeof a === 'number' && a > 0 && a <= 1 ? a : 1;
 }
 /** Working hours a task spans: its effort divided by its allocation. */
-export function getTaskElapsedHours(task) {
-    return getTaskDurationHours(task) / getTaskAllocation(task);
+export function getTaskElapsedHours(task, defaultEstimateHours) {
+    return getTaskDurationHours(task, defaultEstimateHours) / getTaskAllocation(task);
 }
 /** True for completed or canceled tasks (by `semanticStatus`, else the default `done`/`canceled` statuses). */
 export function isTaskFinished(task) {
@@ -37,13 +40,13 @@ export function isTaskFinished(task) {
  * more time and occupies nobody), otherwise its effort divided by its allocation. With
  * `effort: 'remaining'`, an in-progress task's effort is `max(0, estimate - loggedHours)`.
  */
-export function getTaskScheduledHours(task, effort = 'estimate') {
+export function getTaskScheduledHours(task, effort = 'estimate', defaultEstimateHours) {
     if (isTaskFinished(task))
         return 0;
     if (effort === 'remaining' && isTaskInProgress({ status: task.status, semanticStatus: task.semanticStatus })) {
-        return Math.max(0, getTaskDurationHours(task) - (task.loggedHours ?? 0)) / getTaskAllocation(task);
+        return Math.max(0, getTaskDurationHours(task, defaultEstimateHours) - (task.loggedHours ?? 0)) / getTaskAllocation(task);
     }
-    return getTaskElapsedHours(task);
+    return getTaskElapsedHours(task, defaultEstimateHours);
 }
 /** The calendar a task runs on in assignee mode: assignee, then task team, then project. */
 export function resolveTaskSchedule(task, context) {
@@ -71,8 +74,35 @@ const milestoneFields = (task, deadline, varianceHours) => ({
     ...(deadline ? { deadlineDate: deadline.toISOString(), deadlineVarianceHours: round2(varianceHours) } : {})
 });
 const allocationField = (task) => (getTaskAllocation(task) < 1 ? { allocation: getTaskAllocation(task) } : {});
+const deadlinesOf = (graph, id) => graph.deadlines.get(id) ?? [];
+/**
+ * The scheduling graph. Only leaf tasks are scheduled: a summary task (one with subtasks among
+ * `tasks`) spans its subtasks, so a dependency on it applies to every leaf under it, and its
+ * deadline caps those leaves. Summaries are reported afterwards as roll-ups (`addSummaries`).
+ */
 function buildGraph(tasks, dependencies) {
-    const taskMap = new Map(tasks.map((t) => [t.id, t]));
+    const summaryIds = getSummaryTaskIds(tasks);
+    const all = new Map(tasks.map((t) => [t.id, t]));
+    const childrenOf = new Map();
+    for (const t of tasks) {
+        if (t.parentId && summaryIds.has(t.parentId))
+            childrenOf.set(t.parentId, [...(childrenOf.get(t.parentId) ?? []), t.id]);
+    }
+    const leavesOf = (id, seen = new Set()) => {
+        if (!summaryIds.has(id) || seen.has(id))
+            return [id];
+        seen.add(id);
+        return childrenOf.get(id).flatMap((child) => leavesOf(child, seen));
+    };
+    const summaries = new Map([...summaryIds].map((id) => [id, { task: all.get(id), leafIds: leavesOf(id) }]));
+    const deadlines = new Map();
+    for (const t of tasks) {
+        if (!t.deadline)
+            continue;
+        for (const leaf of leavesOf(t.id))
+            deadlines.set(leaf, [...(deadlines.get(leaf) ?? []), t.deadline]);
+    }
+    const taskMap = new Map(tasks.filter((t) => !summaryIds.has(t.id)).map((t) => [t.id, t]));
     const taskIds = Array.from(taskMap.keys());
     // Build adjacency graph:
     // prerequisites[v] = tasks that v depends on (must finish before v starts)
@@ -85,9 +115,15 @@ function buildGraph(tasks, dependencies) {
     }
     for (const dep of dependencies) {
         const edge = precedenceOf(dep);
-        if (edge && taskMap.has(edge.before) && taskMap.has(edge.after) && edge.before !== edge.after) {
-            prerequisites.get(edge.after).add(edge.before);
-            successors.get(edge.before).add(edge.after);
+        if (!edge || !all.has(edge.before) || !all.has(edge.after))
+            continue;
+        for (const before of leavesOf(edge.before)) {
+            for (const after of leavesOf(edge.after)) {
+                if (before === after)
+                    continue;
+                prerequisites.get(after).add(before);
+                successors.get(before).add(after);
+            }
         }
     }
     // Topological sorting via Kahn's algorithm
@@ -118,7 +154,58 @@ function buildGraph(tasks, dependencies) {
     const sorted = new Set(topoOrder);
     const cyclicTaskIds = taskIds.filter((id) => !sorted.has(id));
     topoOrder.push(...cyclicTaskIds);
-    return { taskMap, taskIds, prerequisites, successors, topoOrder, cyclicTaskIds };
+    return { taskMap, taskIds, prerequisites, successors, topoOrder, cyclicTaskIds, summaries, deadlines };
+}
+/**
+ * Adds each summary task to `analysis` as a roll-up of the leaf tasks under it: earliest start,
+ * latest finish, least slack, critical when any leaf is. Summaries are not added to
+ * `criticalTaskIds`, whose tasks are the scheduled (leaf) ones. A summary's own deadline is
+ * reported against its latest finish.
+ */
+function addSummaries(analysis, graph, schedule) {
+    const byId = new Map(analysis.tasks.map((t) => [t.taskId, t]));
+    const rollups = [];
+    const missed = [];
+    for (const [id, { task, leafIds }] of graph.summaries) {
+        const leaves = leafIds.map((leaf) => byId.get(leaf)).filter((t) => Boolean(t));
+        if (!leaves.length)
+            continue;
+        const min = (pick) => Math.min(...leaves.map(pick));
+        const max = (pick) => Math.max(...leaves.map(pick));
+        const dates = (pick) => leaves.map(pick).filter((d) => Boolean(d)).sort();
+        const [starts, finishes, lateStarts, lateFinishes] = [dates((t) => t.earlyStartDate), dates((t) => t.earlyFinishDate), dates((t) => t.lateStartDate), dates((t) => t.lateFinishDate)];
+        const slack = min((t) => t.totalSlack);
+        const earlyFinishDate = finishes[finishes.length - 1];
+        const deadline = task.deadline && earlyFinishDate ? getDeadlineInstant(task.deadline, schedule) : undefined;
+        const variance = deadline ? slackHours(new Date(earlyFinishDate), deadline, schedule) : undefined;
+        if (variance !== undefined && variance < -0.001)
+            missed.push(id);
+        rollups.push({
+            taskId: id,
+            isSummary: true,
+            earlyStart: min((t) => t.earlyStart),
+            earlyFinish: max((t) => t.earlyFinish),
+            lateStart: min((t) => t.lateStart),
+            lateFinish: max((t) => t.lateFinish),
+            totalSlack: slack,
+            slackWorkingHours: slack,
+            isCritical: leaves.some((t) => t.isCritical),
+            durationHours: round2(max((t) => t.earlyFinish) - min((t) => t.earlyStart)),
+            ...(starts.length ? { earlyStartDate: starts[0], earlyFinishDate, lateStartDate: lateStarts[0], lateFinishDate: lateFinishes[lateFinishes.length - 1] } : {}),
+            ...milestoneFields({ ...task, isMilestone: false }, deadline, variance)
+        });
+    }
+    if (!rollups.length)
+        return analysis;
+    return { ...analysis, tasks: [...analysis.tasks, ...rollups], missedDeadlineTaskIds: [...analysis.missedDeadlineTaskIds, ...missed] };
+}
+/** Completes a project's analysis: unestimated tasks and summary roll-ups. */
+function finishAnalysis(analysis, graph, schedule, taskIds) {
+    const unestimatedTaskIds = taskIds.filter((id) => {
+        const task = graph.taskMap.get(id);
+        return !isTaskFinished(task) && isUnestimated(task);
+    });
+    return addSummaries({ ...analysis, ...(unestimatedTaskIds.length ? { unestimatedTaskIds } : {}) }, graph, schedule);
 }
 /**
  * Assignee-calendar CPM. Passes run on dates, because working-hour offsets mean different
@@ -160,12 +247,17 @@ function scheduleOnDates(graph, segments, options, calculatedAt) {
         const task = taskMap.get(id);
         return [id, options.calendars === 'assignee' ? resolveTaskSchedule(task, { ...options, schedule: seg.schedule }) : seg.schedule];
     }));
-    const durationOf = new Map(taskIds.map((id) => [id, getTaskScheduledHours(taskMap.get(id), options.effort)]));
+    const durationOf = new Map(taskIds.map((id) => [id, getTaskScheduledHours(taskMap.get(id), options.effort, options.defaultEstimateHours)]));
+    // A task's late finish is capped by its own deadline and by those of the summary tasks above it
     const deadlineOf = new Map(taskIds.flatMap((id) => {
-        const deadline = taskMap.get(id).deadline;
-        return deadline ? [[id, getDeadlineInstant(deadline, calendarOf.get(id))]] : [];
+        const instants = deadlinesOf(graph, id).map((d) => getDeadlineInstant(d, calendarOf.get(id)));
+        return instants.length ? [[id, new Date(Math.min(...instants.map((d) => d.getTime())))]] : [];
     }));
-    const ctx = { taskMap, calendarOf, durationOf, deadlineOf, startOf: (id) => segmentOf.get(id).start };
+    const ownDeadlineOf = (id) => {
+        const deadline = taskMap.get(id).deadline;
+        return deadline ? getDeadlineInstant(deadline, calendarOf.get(id)) : undefined;
+    };
+    const ctx = { taskMap, calendarOf, durationOf, deadlineOf, ownDeadlineOf, startOf: (id) => segmentOf.get(id).start };
     const endOfProjects = (dates) => {
         const ends = new Map(segments.map((seg) => [seg.projectId, latest(seg.taskIds.map((id) => dates.finish.get(id)), seg.start)]));
         return (id) => ends.get(segmentOf.get(id).projectId);
@@ -176,7 +268,7 @@ function scheduleOnDates(graph, segments, options, calculatedAt) {
     const cyclic = new Set(graph.cyclicTaskIds);
     const analyse = (seg, e, l, extra) => {
         const cyclicTaskIds = seg.taskIds.filter((id) => cyclic.has(id));
-        return { ...buildAnalysis(seg, calculatedAt, e, l, ctx, extra), ...(cyclicTaskIds.length ? { cyclicTaskIds } : {}) };
+        return finishAnalysis({ ...buildAnalysis(seg, calculatedAt, e, l, ctx, extra), ...(cyclicTaskIds.length ? { cyclicTaskIds } : {}) }, graph, seg.schedule, seg.taskIds);
     };
     if (!options.levelResources) {
         const overallocations = findOverallocations(taskMap, early, resourcesOf);
@@ -490,7 +582,7 @@ function findOverallocations(taskMap, dates, resourcesOf) {
     return result;
 }
 function buildAnalysis({ projectId, start: projectStart, schedule: projectSchedule, taskIds }, calculatedAt, early, late, ctx, extra = () => ({})) {
-    const { calendarOf, durationOf, deadlineOf, taskMap } = ctx;
+    const { calendarOf, durationOf, ownDeadlineOf, taskMap } = ctx;
     const offset = (date) => date >= projectStart
         ? getWorkingHoursBetween(projectStart, date, projectSchedule)
         : -getWorkingHoursBetween(date, projectStart, projectSchedule);
@@ -520,7 +612,7 @@ function buildAnalysis({ projectId, start: projectStart, schedule: projectSchedu
             lateFinishDate: lf.toISOString(),
             ...(calendar.id ? { scheduleId: calendar.id } : {}),
             ...allocationField(taskMap.get(id)),
-            ...milestoneFields(taskMap.get(id), deadlineOf.get(id), deadlineOf.has(id) ? slackHours(ef, deadlineOf.get(id), calendar) : undefined),
+            ...milestoneFields(taskMap.get(id), ownDeadlineOf(id), ownDeadlineOf(id) ? slackHours(ef, ownDeadlineOf(id), calendar) : undefined),
             ...extra(id)
         });
     }
@@ -555,7 +647,8 @@ export function calculatePortfolioCPM(projects, dependencies, options = {}) {
         projectId: p.projectId,
         start: startOrToday(p.projectStartDate),
         schedule: p.schedule || DEFAULT_WORK_SCHEDULE,
-        taskIds: p.tasks.map((t) => t.id)
+        // Summary tasks are not scheduled; they are added back as roll-ups
+        taskIds: p.tasks.map((t) => t.id).filter((id) => graph.taskMap.has(id))
     }));
     const result = scheduleOnDates(graph, segments, options, calculatedAt);
     // Background projects are dropped from the results; hidden ones also have their task ids redacted.
@@ -614,16 +707,21 @@ export function calculateCPM(projectId, tasks, dependencies, options = {}) {
         return calculateCalendarCPM(projectId, calculatedAt, graph, options);
     }
     // Deadlines as project-calendar hours from the start. Without a start date there is nothing to
-    // place them against, so they are ignored.
-    const deadlineHours = new Map();
+    // place them against, so they are ignored. A task's late finish is capped by its own deadline and
+    // by those of the summary tasks above it; its schedule reports its own.
+    const capHours = new Map();
+    const ownDeadline = new Map();
+    const toHours = (deadline) => deadline >= projectStartDate
+        ? getWorkingHoursBetween(projectStartDate, deadline, schedule)
+        : -getWorkingHoursBetween(deadline, projectStartDate, schedule);
     if (projectStartDate) {
-        for (const task of tasks) {
-            if (!task.deadline)
-                continue;
-            const deadline = getDeadlineInstant(task.deadline, schedule);
-            deadlineHours.set(task.id, deadline >= projectStartDate
-                ? getWorkingHoursBetween(projectStartDate, deadline, schedule)
-                : -getWorkingHoursBetween(deadline, projectStartDate, schedule));
+        for (const id of taskIds) {
+            const caps = deadlinesOf(graph, id).map((d) => toHours(getDeadlineInstant(d, schedule)));
+            if (caps.length)
+                capHours.set(id, Math.min(...caps));
+            const own = taskMap.get(id).deadline;
+            if (own)
+                ownDeadline.set(id, getDeadlineInstant(own, schedule));
         }
     }
     // --- FORWARD PASS ---
@@ -631,7 +729,7 @@ export function calculateCPM(projectId, tasks, dependencies, options = {}) {
     const earlyFinish = new Map();
     for (const id of topoOrder) {
         const task = taskMap.get(id);
-        const duration = getTaskScheduledHours(task, options.effort);
+        const duration = getTaskScheduledHours(task, options.effort, options.defaultEstimateHours);
         const prereqs = prerequisites.get(id) || new Set();
         let maxPrereqFinish = 0;
         for (const p of prereqs) {
@@ -659,7 +757,7 @@ export function calculateCPM(projectId, tasks, dependencies, options = {}) {
     for (let i = topoOrder.length - 1; i >= 0; i--) {
         const id = topoOrder[i];
         const task = taskMap.get(id);
-        const duration = getTaskScheduledHours(task, options.effort);
+        const duration = getTaskScheduledHours(task, options.effort, options.defaultEstimateHours);
         const succs = successors.get(id) || new Set();
         let minSuccLateStart = totalDurationHours;
         if (succs.size > 0) {
@@ -674,7 +772,7 @@ export function calculateCPM(projectId, tasks, dependencies, options = {}) {
                 minSuccLateStart = totalDurationHours;
             }
         }
-        const lf = Math.min(minSuccLateStart, deadlineHours.get(id) ?? Infinity);
+        const lf = Math.min(minSuccLateStart, capHours.get(id) ?? Infinity);
         const ls = lf - duration;
         lateFinish.set(id, lf);
         lateStart.set(id, ls);
@@ -694,7 +792,7 @@ export function calculateCPM(projectId, tasks, dependencies, options = {}) {
             criticalTaskIds.push(id);
         }
         const task = taskMap.get(id);
-        const duration = getTaskScheduledHours(task, options.effort);
+        const duration = getTaskScheduledHours(task, options.effort, options.defaultEstimateHours);
         const earlyStartDate = projectStartDate
             ? addWorkingHours(projectStartDate, es, schedule).toISOString()
             : undefined;
@@ -717,7 +815,7 @@ export function calculateCPM(projectId, tasks, dependencies, options = {}) {
             isCritical,
             durationHours: duration,
             ...allocationField(task),
-            ...milestoneFields(task, deadlineHours.has(id) ? getDeadlineInstant(task.deadline, schedule) : undefined, deadlineHours.has(id) ? deadlineHours.get(id) - ef : undefined),
+            ...milestoneFields(task, ownDeadline.get(id), ownDeadline.has(id) ? toHours(ownDeadline.get(id)) - ef : undefined),
             slackWorkingHours: totalSlack,
             earlyStartDate,
             earlyFinishDate,
@@ -728,7 +826,7 @@ export function calculateCPM(projectId, tasks, dependencies, options = {}) {
     const projectEndDate = projectStartDate
         ? addWorkingHours(projectStartDate, totalDurationHours, schedule).toISOString()
         : undefined;
-    return {
+    return finishAnalysis({
         projectId,
         calculatedAt,
         totalDurationHours: Math.round(totalDurationHours * 100) / 100,
@@ -739,6 +837,6 @@ export function calculateCPM(projectId, tasks, dependencies, options = {}) {
         missedDeadlineTaskIds: missedDeadlines(schedules),
         ...(graph.cyclicTaskIds.length ? { cyclicTaskIds: graph.cyclicTaskIds } : {}),
         tasks: schedules
-    };
+    }, graph, schedule, taskIds);
 }
 //# sourceMappingURL=cpm.js.map