@task-mcp/shared 1.0.19 → 1.0.21

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@task-mcp/shared",
-  "version": "1.0.19",
+  "version": "1.0.21",
   "description": "Shared utilities for task-mcp: types, algorithms, and natural language parsing",
   "type": "module",
   "main": "./dist/index.js",
@@ -12,11 +12,6 @@
       "types": "./dist/index.d.ts"
     }
   },
-  "files": [
-    "src",
-    "dist",
-    "README.md"
-  ],
   "scripts": {
     "build": "tsc",
     "dev": "tsc --watch",

package/src/schemas/task.ts

@@ -26,22 +26,68 @@ export const Dependency = z.object({
 });
 export type Dependency = z.infer<typeof Dependency>;
 
-// Time estimation
-export const TimeEstimate = z.object({
-  optimistic: z.number().optional(), // minutes
-  expected: z.number().optional(), // minutes
-  pessimistic: z.number().optional(), // minutes
-  confidence: z.enum(["low", "medium", "high"]).optional(),
-});
+// Time estimation (values in minutes, max 10080 = 1 week)
+export const TimeEstimate = z
+  .object({
+    optimistic: z.number().min(0).max(10080).optional(), // minutes
+    expected: z.number().min(0).max(10080).optional(), // minutes
+    pessimistic: z.number().min(0).max(10080).optional(), // minutes
+    confidence: z.enum(["low", "medium", "high"]).optional(),
+  })
+  .refine(
+    (data) => {
+      const { optimistic, expected, pessimistic } = data;
+      if (
+        optimistic !== undefined &&
+        expected !== undefined &&
+        optimistic > expected
+      ) {
+        return false;
+      }
+      if (
+        expected !== undefined &&
+        pessimistic !== undefined &&
+        expected > pessimistic
+      ) {
+        return false;
+      }
+      if (
+        optimistic !== undefined &&
+        pessimistic !== undefined &&
+        optimistic > pessimistic
+      ) {
+        return false;
+      }
+      return true;
+    },
+    { message: "Time estimates must satisfy: optimistic <= expected <= pessimistic" }
+  );
 export type TimeEstimate = z.infer<typeof TimeEstimate>;
 
-// Recurrence pattern
-export const Recurrence = z.object({
-  pattern: z.enum(["daily", "weekly", "monthly", "after_completion"]),
-  interval: z.number().optional(), // every N days/weeks/months
-  daysOfWeek: z.array(z.number()).optional(), // 0-6 for weekly
-  endDate: z.string().optional(),
-});
+// Recurrence pattern (discriminated union for type-safe pattern handling)
+export const Recurrence = z.discriminatedUnion("pattern", [
+  z.object({
+    pattern: z.literal("daily"),
+    interval: z.number().min(1).optional(), // every N days
+    endDate: z.string().optional(),
+  }),
+  z.object({
+    pattern: z.literal("weekly"),
+    interval: z.number().min(1).optional(), // every N weeks
+    daysOfWeek: z.array(z.number().min(0).max(6)).optional(), // 0-6 for weekly
+    endDate: z.string().optional(),
+  }),
+  z.object({
+    pattern: z.literal("monthly"),
+    interval: z.number().min(1).optional(), // every N months
+    endDate: z.string().optional(),
+  }),
+  z.object({
+    pattern: z.literal("after_completion"),
+    interval: z.number().min(1), // Required: days after completion
+    endDate: z.string().optional(),
+  }),
+]);
 export type Recurrence = z.infer<typeof Recurrence>;
 
 // Complexity factors that contribute to task difficulty

package/src/utils/date.ts

@@ -28,6 +28,15 @@ export type DateParseResult =
   | { success: true; date: Date }
   | { success: false; error: string; reason: DateParseErrorReason };
 
+/**
+ * Result type for isWithinDaysSafe operation
+ */
+export interface IsWithinDaysResult {
+  success: boolean;
+  withinDays?: boolean;
+  error?: string;
+}
+
 /**
  * Get current ISO timestamp
  */
@@ -351,3 +360,34 @@ export function isWithinDays(date: Date | string, days: number): boolean {
   future.setDate(future.getDate() + days);
   return d >= today && d <= future;
 }
+
+/**
+ * Safe version of isWithinDays that returns a Result type
+ * Allows distinguishing between errors and actual out-of-range results
+ */
+export function isWithinDaysSafe(date: Date | string, days: number): IsWithinDaysResult {
+  if (typeof days !== "number" || !Number.isFinite(days) || days < 0) {
+    return { success: false, error: `Invalid days parameter: ${days}` };
+  }
+
+  let targetDate: Date;
+  if (typeof date === "string") {
+    targetDate = new Date(date);
+    if (isNaN(targetDate.getTime())) {
+      return { success: false, error: `Invalid date string: ${date}` };
+    }
+  } else if (date instanceof Date) {
+    if (isNaN(date.getTime())) {
+      return { success: false, error: "Invalid Date object" };
+    }
+    targetDate = date;
+  } else {
+    return { success: false, error: `Invalid date type: ${typeof date}` };
+  }
+
+  const now = new Date();
+  const diffMs = targetDate.getTime() - now.getTime();
+  const diffDays = diffMs / (1000 * 60 * 60 * 24);
+
+  return { success: true, withinDays: diffDays >= 0 && diffDays <= days };
+}

package/src/utils/hierarchy.ts

@@ -34,7 +34,8 @@ export function getTaskLevel(tasks: Task[], taskId: string): number {
   while (currentTask.parentId) {
     const parent = taskMap.get(currentTask.parentId);
     if (!parent) {
-      break; // Parent not found, stop traversal
+      console.warn(`[task-mcp] Orphaned parent reference: task "${currentTask.id}" references non-existent parent "${currentTask.parentId}"`);
+      break;
     }
     level++;
     currentTask = parent;
@@ -239,3 +240,64 @@ export function buildTaskTree(
   const rootTasks = tasks.filter((t) => !t.parentId);
   return rootTasks.map((task) => buildNode(task, 0, new Set()));
 }
+
+/**
+ * Result of hierarchy validation.
+ */
+export interface HierarchyValidationResult {
+  valid: boolean;
+  orphanedReferences: { taskId: string; parentId: string }[];
+  circularReferences: string[];
+  maxDepthExceeded: { taskId: string; depth: number }[];
+}
+
+/**
+ * Validates the hierarchy integrity of a task list.
+ *
+ * Checks for:
+ * - Orphaned parent references (task references non-existent parent)
+ * - Circular references (task is its own ancestor)
+ * - Tasks exceeding maximum hierarchy depth
+ *
+ * @param tasks - Array of all tasks to validate
+ * @returns Validation result with details of any issues found
+ */
+export function validateHierarchy(tasks: Task[]): HierarchyValidationResult {
+  const taskMap = new Map(tasks.map((t) => [t.id, t]));
+  const result: HierarchyValidationResult = {
+    valid: true,
+    orphanedReferences: [],
+    circularReferences: [],
+    maxDepthExceeded: [],
+  };
+
+  for (const task of tasks) {
+    // Check for orphaned parent references
+    if (task.parentId && !taskMap.has(task.parentId)) {
+      result.orphanedReferences.push({ taskId: task.id, parentId: task.parentId });
+      result.valid = false;
+    }
+
+    // Check for circular references
+    const visited = new Set<string>();
+    let current: Task | undefined = task;
+    while (current?.parentId) {
+      if (visited.has(current.id)) {
+        result.circularReferences.push(task.id);
+        result.valid = false;
+        break;
+      }
+      visited.add(current.id);
+      current = taskMap.get(current.parentId);
+    }
+
+    // Check for max depth exceeded
+    const level = getTaskLevel(tasks, task.id);
+    if (level > MAX_HIERARCHY_DEPTH) {
+      result.maxDepthExceeded.push({ taskId: task.id, depth: level });
+      result.valid = false;
+    }
+  }
+
+  return result;
+}

package/src/utils/index.ts

@@ -24,10 +24,12 @@ export {
   isToday,
   isPastDue,
   isWithinDays,
+  isWithinDaysSafe,
   isValidDate,
   DateParseError,
   type DateParseErrorReason,
   type DateParseResult,
+  type IsWithinDaysResult,
 } from "./date.js";
 export { parseTaskInput, parseInboxInput, parseInput, type ParseTarget, type ParsedInput } from "./natural-language.js";
 export {

package/src/utils/natural-language.ts

@@ -110,6 +110,12 @@ export function parseInboxInput(input: string): InboxCreateInput {
   // Clean up and set content
   result.content = remaining.replace(/\s+/g, " ").trim();
 
+  if (!result.content) {
+    throw new InputValidationError(
+      "Content cannot be empty after parsing. Input contained only metadata (tags)."
+    );
+  }
+
   return result;
 }
 
@@ -223,6 +229,12 @@ export function parseTaskInput(input: string): TaskCreateInput {
   // Clean up extra spaces
   result.title = remaining.replace(/\s+/g, " ").trim();
 
+  if (!result.title) {
+    throw new InputValidationError(
+      "Task title cannot be empty after parsing. Input contained only metadata."
+    );
+  }
+
   return result;
 }
 

package/src/utils/projection.ts

@@ -16,6 +16,14 @@ import type {
   PaginatedResponse,
 } from "../schemas/response-format.js";
 
+/**
+ * Exhaustiveness check helper for switch statements.
+ * TypeScript will error if a case is not handled.
+ */
+function assertNever(value: never): never {
+  throw new Error(`Unexpected value: ${value}`);
+}
+
 /**
  * Project a single task to the specified format
  */
@@ -42,8 +50,9 @@ export function projectTask(task: Task, format: ResponseFormat): TaskSummary | T
       };
 
     case "detailed":
-    default:
       return task;
+    default:
+      return assertNever(format);
   }
 }
 
@@ -106,8 +115,9 @@ export function projectInboxItem(
       };
 
     case "detailed":
-    default:
       return item;
+    default:
+      return assertNever(format);
   }
 }
 
@@ -226,8 +236,9 @@ export function sortTasks(
       }
 
       case "updatedAt":
-      default:
         return new Date(b.updatedAt).getTime() - new Date(a.updatedAt).getTime();
+      default:
+        return assertNever(secondarySort);
     }
   });
 }

package/dist/algorithms/critical-path.d.ts

@@ -1,46 +0,0 @@
-import type { Task } from "../schemas/task.js";
-/**
- * Task with computed CPM (Critical Path Method) values
- */
-export interface CPMTask extends Task {
-    earliestStart: number;
-    earliestFinish: number;
-    latestStart: number;
-    latestFinish: number;
-    slack: number;
-    isCritical: boolean;
-    dependentCount: number;
-}
-/**
- * Result of critical path analysis
- */
-export interface CPMResult {
-    tasks: CPMTask[];
-    criticalPath: CPMTask[];
-    projectDuration: number;
-    bottlenecks: CPMTask[];
-}
-/**
- * Perform Critical Path Method analysis
- *
- * CPM calculates:
- * - Earliest Start (ES): Earliest a task can start
- * - Earliest Finish (EF): ES + duration
- * - Latest Finish (LF): Latest a task can finish without delaying project
- * - Latest Start (LS): LF - duration
- * - Slack: LS - ES (or LF - EF)
- * - Critical Path: Tasks with slack = 0
- */
-export declare function criticalPathAnalysis(tasks: Task[]): CPMResult;
-/**
- * Find tasks that can be executed in parallel (no dependencies between them)
- */
-export declare function findParallelTasks(tasks: Task[]): Task[][];
-/**
- * Suggest the next best task to work on
- */
-export declare function suggestNextTask(tasks: Task[], options?: {
-    contexts?: string[];
-    maxMinutes?: number;
-}): Task | null;
-//# sourceMappingURL=critical-path.d.ts.map

package/dist/algorithms/critical-path.d.ts.map

@@ -1 +0,0 @@
-{"version":3,"file":"critical-path.d.ts","sourceRoot":"","sources":["../../src/algorithms/critical-path.ts"],"names":[],"mappings":"AAAA,OAAO,KAAK,EAAE,IAAI,EAAE,MAAM,oBAAoB,CAAC;AAO/C;;GAEG;AACH,MAAM,WAAW,OAAQ,SAAQ,IAAI;IAEnC,aAAa,EAAE,MAAM,CAAC;IACtB,cAAc,EAAE,MAAM,CAAC;IACvB,WAAW,EAAE,MAAM,CAAC;IACpB,YAAY,EAAE,MAAM,CAAC;IACrB,KAAK,EAAE,MAAM,CAAC;IACd,UAAU,EAAE,OAAO,CAAC;IACpB,cAAc,EAAE,MAAM,CAAC;CACxB;AAED;;GAEG;AACH,MAAM,WAAW,SAAS;IACxB,KAAK,EAAE,OAAO,EAAE,CAAC;IACjB,YAAY,EAAE,OAAO,EAAE,CAAC;IACxB,eAAe,EAAE,MAAM,CAAC;IACxB,WAAW,EAAE,OAAO,EAAE,CAAC;CACxB;AA8ND;;;;;;;;;;GAUG;AACH,wBAAgB,oBAAoB,CAAC,KAAK,EAAE,IAAI,EAAE,GAAG,SAAS,CAmD7D;AAED;;GAEG;AACH,wBAAgB,iBAAiB,CAAC,KAAK,EAAE,IAAI,EAAE,GAAG,IAAI,EAAE,EAAE,CAiDzD;AAED;;GAEG;AACH,wBAAgB,eAAe,CAC7B,KAAK,EAAE,IAAI,EAAE,EACb,OAAO,GAAE;IACP,QAAQ,CAAC,EAAE,MAAM,EAAE,CAAC;IACpB,UAAU,CAAC,EAAE,MAAM,CAAC;CAChB,GACL,IAAI,GAAG,IAAI,CAyDb"}

package/dist/algorithms/critical-path.js

@@ -1,320 +0,0 @@
-import { topologicalSort, priorityToNumber, } from "./topological-sort.js";
-/** Default task duration if no estimate provided */
-const DEFAULT_DURATION = 30;
-/**
- * Get task duration with fallback to default
- */
-function getTaskDuration(task) {
-    return task.estimate?.expected ?? DEFAULT_DURATION;
-}
-/**
- * Get blocked_by dependencies for a task
- */
-function getBlockedByDeps(task) {
-    return (task.dependencies ?? [])
-        .filter((d) => d.type === "blocked_by")
-        .map((d) => d.taskId);
-}
-/**
- * Initialize CPM tasks with default values
- */
-function initializeCPMTasks(sortedTasks) {
-    const taskMap = new Map();
-    for (const task of sortedTasks) {
-        const duration = getTaskDuration(task);
-        taskMap.set(task.id, {
-            ...task,
-            earliestStart: 0,
-            earliestFinish: duration,
-            latestStart: Infinity,
-            latestFinish: Infinity,
-            slack: 0,
-            isCritical: false,
-            dependentCount: 0,
-        });
-    }
-    return taskMap;
-}
-/**
- * Forward pass: Calculate earliest start/finish times
- * ES = max(EF of all predecessors)
- * EF = ES + duration
- */
-function forwardPass(sortedTasks, taskMap) {
-    for (const task of sortedTasks) {
-        const cpmTask = taskMap.get(task.id);
-        if (!cpmTask)
-            continue;
-        const duration = getTaskDuration(task);
-        const deps = getBlockedByDeps(task);
-        // Find maximum EF among predecessors
-        let maxPredecessorEF = 0;
-        for (const depId of deps) {
-            const dep = taskMap.get(depId);
-            if (dep) {
-                maxPredecessorEF = Math.max(maxPredecessorEF, dep.earliestFinish);
-            }
-        }
-        cpmTask.earliestStart = maxPredecessorEF;
-        cpmTask.earliestFinish = cpmTask.earliestStart + duration;
-    }
-}
-/**
- * Calculate project duration (maximum earliest finish)
- */
-function calculateProjectDuration(taskMap) {
-    return Math.max(...Array.from(taskMap.values()).map((t) => t.earliestFinish));
-}
-/**
- * Build successor index: maps taskId -> list of tasks that depend on it
- * This is O(n * d) where d is average dependencies, done once upfront
- * Allows O(1) successor lookup instead of O(n) per task
- */
-function buildSuccessorIndex(sortedTasks, taskMap) {
-    const successorIndex = new Map();
-    // Initialize empty arrays for all tasks
-    for (const task of sortedTasks) {
-        successorIndex.set(task.id, []);
-    }
-    // Build the index: if task A is blocked_by task B, then A is a successor of B
-    for (const task of sortedTasks) {
-        const deps = getBlockedByDeps(task);
-        const cpmTask = taskMap.get(task.id);
-        if (!cpmTask)
-            continue;
-        for (const depId of deps) {
-            const successors = successorIndex.get(depId);
-            if (successors) {
-                successors.push(cpmTask);
-            }
-        }
-    }
-    return successorIndex;
-}
-/**
- * Find tasks that have successors (are dependencies of other tasks)
- */
-function findTasksWithSuccessors(successorIndex) {
-    const tasksWithSuccessors = new Set();
-    for (const [taskId, successors] of successorIndex) {
-        if (successors.length > 0) {
-            tasksWithSuccessors.add(taskId);
-        }
-    }
-    return tasksWithSuccessors;
-}
-/**
- * Backward pass: Calculate latest start/finish times
- * LF = min(LS of all successors) or projectDuration for end tasks
- * LS = LF - duration
- */
-function backwardPass(sortedTasks, taskMap, successorIndex, projectDuration) {
-    const tasksWithSuccessors = findTasksWithSuccessors(successorIndex);
-    // Initialize end tasks (tasks with no successors)
-    for (const task of taskMap.values()) {
-        if (!tasksWithSuccessors.has(task.id)) {
-            const duration = getTaskDuration(task);
-            task.latestFinish = projectDuration;
-            task.latestStart = task.latestFinish - duration;
-        }
-    }
-    // Process in reverse topological order
-    const reverseSorted = [...sortedTasks].reverse();
-    for (const task of reverseSorted) {
-        const cpmTask = taskMap.get(task.id);
-        if (!cpmTask)
-            continue;
-        const duration = getTaskDuration(task);
-        const successors = successorIndex.get(task.id) ?? [];
-        if (successors.length > 0) {
-            // LF = min(LS of all successors)
-            cpmTask.latestFinish = Math.min(...successors.map((s) => s.latestStart));
-            cpmTask.latestStart = cpmTask.latestFinish - duration;
-        }
-    }
-}
-/**
- * Calculate slack and mark critical tasks
- * Slack = LS - ES (or LF - EF)
- * Critical = slack ≈ 0
- */
-function calculateSlackAndCritical(taskMap) {
-    const FLOAT_TOLERANCE = 0.001;
-    for (const task of taskMap.values()) {
-        task.slack = task.latestStart - task.earliestStart;
-        task.isCritical = Math.abs(task.slack) < FLOAT_TOLERANCE;
-    }
-}
-/**
- * Count dependents for bottleneck detection using successor index
- * Uses dynamic programming: dependentCount = direct successors + their dependentCounts
- * O(n) instead of O(n³) with findDependents
- */
-function countDependents(sortedTasks, taskMap, successorIndex) {
-    // Process in reverse topological order so we compute children before parents
-    const reverseSorted = [...sortedTasks].reverse();
-    for (const task of reverseSorted) {
-        const cpmTask = taskMap.get(task.id);
-        if (!cpmTask)
-            continue;
-        const successors = successorIndex.get(task.id) ?? [];
-        // dependentCount = number of direct successors + sum of their dependentCounts
-        let count = successors.length;
-        for (const successor of successors) {
-            count += successor.dependentCount;
-        }
-        cpmTask.dependentCount = count;
-    }
-}
-/**
- * Extract critical path tasks in topological order
- */
-function extractCriticalPath(sortedTasks, taskMap) {
-    return sortedTasks
-        .map((t) => taskMap.get(t.id))
-        .filter((t) => t !== undefined && t.isCritical);
-}
-/**
- * Find top bottlenecks (critical tasks blocking the most downstream work)
- */
-function findBottlenecks(criticalPath, limit = 5) {
-    return [...criticalPath]
-        .sort((a, b) => b.dependentCount - a.dependentCount)
-        .slice(0, limit);
-}
-/**
- * Perform Critical Path Method analysis
- *
- * CPM calculates:
- * - Earliest Start (ES): Earliest a task can start
- * - Earliest Finish (EF): ES + duration
- * - Latest Finish (LF): Latest a task can finish without delaying project
- * - Latest Start (LS): LF - duration
- * - Slack: LS - ES (or LF - EF)
- * - Critical Path: Tasks with slack = 0
- */
-export function criticalPathAnalysis(tasks) {
-    // Filter to only pending/in_progress tasks
-    const activeTasks = tasks.filter((t) => t.status === "pending" || t.status === "in_progress");
-    if (activeTasks.length === 0) {
-        return {
-            tasks: [],
-            criticalPath: [],
-            projectDuration: 0,
-            bottlenecks: [],
-        };
-    }
-    // Sort topologically
-    const sortedTasks = topologicalSort(activeTasks);
-    // Initialize CPM tasks
-    const taskMap = initializeCPMTasks(sortedTasks);
-    // Build successor index once (O(n*d)) for O(1) lookups
-    const successorIndex = buildSuccessorIndex(sortedTasks, taskMap);
-    // Forward pass: Calculate earliest start/finish
-    forwardPass(sortedTasks, taskMap);
-    // Calculate project duration
-    const projectDuration = calculateProjectDuration(taskMap);
-    // Backward pass: Calculate latest start/finish (uses successorIndex)
-    backwardPass(sortedTasks, taskMap, successorIndex, projectDuration);
-    // Calculate slack and mark critical tasks
-    calculateSlackAndCritical(taskMap);
-    // Count dependents for bottleneck detection (uses successorIndex, O(n))
-    countDependents(sortedTasks, taskMap, successorIndex);
-    // Extract critical path
-    const criticalPath = extractCriticalPath(sortedTasks, taskMap);
-    // Find bottlenecks
-    const bottlenecks = findBottlenecks(criticalPath);
-    return {
-        tasks: sortedTasks.map((t) => taskMap.get(t.id)),
-        criticalPath,
-        projectDuration,
-        bottlenecks,
-    };
-}
-/**
- * Find tasks that can be executed in parallel (no dependencies between them)
- */
-export function findParallelTasks(tasks) {
-    const activeTasks = tasks.filter((t) => t.status === "pending" || t.status === "in_progress");
-    if (activeTasks.length === 0)
-        return [];
-    // Find tasks with no uncompleted dependencies
-    const completedIds = new Set(tasks.filter((t) => t.status === "completed").map((t) => t.id));
-    const available = activeTasks.filter((task) => {
-        const deps = getBlockedByDeps(task);
-        return deps.every((depId) => completedIds.has(depId));
-    });
-    if (available.length <= 1)
-        return [available];
-    // Group tasks that don't depend on each other
-    const groups = [];
-    const processed = new Set();
-    for (const task of available) {
-        if (processed.has(task.id))
-            continue;
-        const group = [task];
-        processed.add(task.id);
-        for (const other of available) {
-            if (processed.has(other.id))
-                continue;
-            // Check if these tasks are independent
-            const taskDeps = (task.dependencies ?? []).map((d) => d.taskId);
-            const otherDeps = (other.dependencies ?? []).map((d) => d.taskId);
-            const independent = !taskDeps.includes(other.id) && !otherDeps.includes(task.id);
-            if (independent) {
-                group.push(other);
-                processed.add(other.id);
-            }
-        }
-        groups.push(group);
-    }
-    return groups;
-}
-/**
- * Suggest the next best task to work on
- */
-export function suggestNextTask(tasks, options = {}) {
-    const activeTasks = tasks.filter((t) => t.status === "pending" || t.status === "in_progress");
-    if (activeTasks.length === 0)
-        return null;
-    // Get CPM analysis
-    const cpm = criticalPathAnalysis(tasks);
-    // Filter by availability (all dependencies completed)
-    const completedIds = new Set(tasks.filter((t) => t.status === "completed").map((t) => t.id));
-    let candidates = cpm.tasks.filter((task) => {
-        const deps = getBlockedByDeps(task);
-        return deps.every((depId) => completedIds.has(depId));
-    });
-    // Filter by context if specified
-    if (options.contexts?.length) {
-        const contextSet = new Set(options.contexts);
-        const contextFiltered = candidates.filter((t) => (t.contexts ?? []).some((c) => contextSet.has(c)));
-        if (contextFiltered.length > 0) {
-            candidates = contextFiltered;
-        }
-    }
-    // Filter by time if specified
-    if (options.maxMinutes) {
-        const timeFiltered = candidates.filter((t) => getTaskDuration(t) <= options.maxMinutes);
-        if (timeFiltered.length > 0) {
-            candidates = timeFiltered;
-        }
-    }
-    if (candidates.length === 0)
-        return null;
-    // Score and rank candidates
-    // Priority: Critical path > High priority > Most dependents > Shortest duration
-    const scored = candidates.map((task) => {
-        let score = 0;
-        if (task.isCritical)
-            score += 1000;
-        score += task.dependentCount * 100;
-        score += priorityToNumber(task.priority) * 10;
-        // Prefer shorter tasks (quick wins)
-        score += Math.max(0, 100 - getTaskDuration(task));
-        return { task, score };
-    });
-    scored.sort((a, b) => b.score - a.score);
-    return scored[0]?.task ?? null;
-}
-//# sourceMappingURL=critical-path.js.map