digital-tasks 2.1.3 → 2.4.0

package/src/markdown.ts

@@ -49,6 +49,7 @@ import type {
   ParallelGroup,
   SequentialGroup,
   ExecutionMode,
+  CreateProjectOptions,
 } from './project.js'
 import { task, parallel, sequential, createProject } from './project.js'
 
@@ -61,8 +62,8 @@ import { task, parallel, sequential, createProject } from './project.js'
  */
 const STATUS_MARKERS: Record<string, TaskStatus> = {
   ' ': 'pending',
-  'x': 'completed',
-  'X': 'completed',
+  x: 'completed',
+  X: 'completed',
   '-': 'in_progress',
   '~': 'blocked',
   '!': 'failed',
@@ -93,7 +94,7 @@ const PRIORITY_MARKERS: Record<string, TaskPriority> = {
   '!': 'urgent',
   '^': 'high',
   '': 'normal',
-  'v': 'low',
+  v: 'low',
 }
 
 // ============================================================================
@@ -135,20 +136,23 @@ function parseLine(line: string): ParsedLine {
   const raw = line
 
   // Count leading spaces for indent (2 spaces = 1 level)
-  const leadingSpaces = line.match(/^(\s*)/)?.[1].length || 0
+  const leadingSpacesMatch = line.match(/^(\s*)/)
+  const leadingSpaces = leadingSpacesMatch?.[1]?.length ?? 0
   const indent = Math.floor(leadingSpaces / 2)
   const trimmed = line.slice(leadingSpaces)
 
   // Check for heading
   const headingMatch = trimmed.match(/^(#{1,6})\s+(.+)$/)
   if (headingMatch) {
+    const matchedHashes = headingMatch[1]!
+    const matchedTitle = headingMatch[2]!
     return {
       indent,
       isTask: false,
       isOrdered: false,
-      title: headingMatch[2].trim(),
+      title: matchedTitle.trim(),
       isHeading: true,
-      headingLevel: headingMatch[1].length,
+      headingLevel: matchedHashes.length,
       raw,
     }
   }
@@ -156,8 +160,8 @@ function parseLine(line: string): ParsedLine {
   // Check for unordered task: - [ ] or - [x] etc.
   const unorderedMatch = trimmed.match(/^[-*]\s+\[([^\]]*)\]\s*(.*)$/)
   if (unorderedMatch) {
-    const marker = unorderedMatch[1]
-    let title = unorderedMatch[2].trim()
+    const marker = unorderedMatch[1]!
+    let title = unorderedMatch[2]!.trim()
     let priority: TaskPriority = 'normal'
 
     // Check for priority marker at start of title
@@ -179,7 +183,7 @@ function parseLine(line: string): ParsedLine {
       indent,
       isTask: true,
       isOrdered: false,
-      status: STATUS_MARKERS[marker] || 'pending',
+      status: STATUS_MARKERS[marker] ?? 'pending',
       priority,
       title,
       isHeading: false,
@@ -190,8 +194,9 @@ function parseLine(line: string): ParsedLine {
   // Check for ordered task: 1. [ ] or 1. [x] etc.
   const orderedMatch = trimmed.match(/^(\d+)\.\s+\[([^\]]*)\]\s*(.*)$/)
   if (orderedMatch) {
-    const marker = orderedMatch[2]
-    let title = orderedMatch[3].trim()
+    const orderNum = orderedMatch[1]!
+    const marker = orderedMatch[2]!
+    let title = orderedMatch[3]!.trim()
     let priority: TaskPriority = 'normal'
 
     // Check for priority marker
@@ -213,8 +218,8 @@ function parseLine(line: string): ParsedLine {
       indent,
       isTask: true,
       isOrdered: true,
-      orderNumber: parseInt(orderedMatch[1], 10),
-      status: STATUS_MARKERS[marker] || 'pending',
+      orderNumber: parseInt(orderNum, 10),
+      status: STATUS_MARKERS[marker] ?? 'pending',
       priority,
       title,
       isHeading: false,
@@ -247,7 +252,7 @@ function parseTasksAtIndent(
   let modeSet = false
 
   while (index < lines.length) {
-    const line = lines[index]
+    const line = lines[index]!
 
     // Stop if we've gone back to a lower indent level
     if (line.indent < baseIndent && (line.isTask || line.isHeading)) {
@@ -269,20 +274,21 @@ function parseTasksAtIndent(
       }
 
       // Parse subtasks
-      const { tasks: subtasks, nextIndex } = parseTasksAtIndent(
-        lines,
-        index + 1,
-        baseIndent + 1
-      )
-
-      const taskDef = task(line.title, {
-        priority: line.priority,
-        subtasks: subtasks.length > 0 ? subtasks : undefined,
+      const { tasks: subtasks, nextIndex } = parseTasksAtIndent(lines, index + 1, baseIndent + 1)
+
+      const taskOptions: Partial<Omit<TaskDefinition, '__type' | 'title'>> = {
         metadata: {
           _originalStatus: line.status,
           _lineNumber: index,
         },
-      })
+      }
+      if (line.priority !== undefined) {
+        taskOptions.priority = line.priority
+      }
+      if (subtasks.length > 0) {
+        taskOptions.subtasks = subtasks
+      }
+      const taskDef = task(line.title, taskOptions)
 
       tasks.push(taskDef)
       index = nextIndex
@@ -324,9 +330,9 @@ export function parseMarkdown(markdown: string): Project {
   const allTasks: TaskNode[] = []
 
   // Find project name from first h1
-  const h1Index = lines.findIndex(l => l.isHeading && l.headingLevel === 1)
+  const h1Index = lines.findIndex((l) => l.isHeading && l.headingLevel === 1)
   if (h1Index !== -1) {
-    projectName = lines[h1Index].title
+    projectName = lines[h1Index]!.title
   }
 
   // Process sections and tasks
@@ -334,7 +340,7 @@ export function parseMarkdown(markdown: string): Project {
   let index = 0
 
   while (index < lines.length) {
-    const line = lines[index]
+    const line = lines[index]!
 
     // New section (h2)
     if (line.isHeading && line.headingLevel === 2) {
@@ -353,7 +359,7 @@ export function parseMarkdown(markdown: string): Project {
 
       const modeMatch = sectionName.match(/\((parallel|sequential)\)\s*$/i)
       if (modeMatch) {
-        sectionMode = modeMatch[1].toLowerCase() as ExecutionMode
+        sectionMode = modeMatch[1]!.toLowerCase() as ExecutionMode
         sectionName = sectionName.replace(/\s*\((parallel|sequential)\)\s*$/i, '')
       }
 
@@ -396,11 +402,15 @@ export function parseMarkdown(markdown: string): Project {
     }
   }
 
-  return createProject({
+  const projectOptions: CreateProjectOptions = {
     name: projectName,
-    description: projectDescription,
     tasks: allTasks,
-  })
+  }
+  if (projectDescription !== undefined) {
+    projectOptions.description = projectDescription
+  }
+
+  return createProject(projectOptions)
 }
 
 // ============================================================================
@@ -435,13 +445,13 @@ function serializeTaskNode(
 
   if (node.__type === 'task') {
     const taskDef = node as TaskDefinition
-    const status = (taskDef.metadata?._originalStatus as TaskStatus) || 'pending'
+    const status = (taskDef.metadata?.['_originalStatus'] as TaskStatus) || 'pending'
     const marker = options.includeStatus !== false ? STATUS_TO_MARKER[status] : ' '
 
     let prefix: string
     if (isSequential) {
       // Use numbered list for sequential
-      const num = (taskDef.metadata?._sequenceNumber as number) || 1
+      const num = (taskDef.metadata?.['_sequenceNumber'] as number) || 1
       prefix = `${num}. [${marker}]`
     } else {
       // Use bullet for parallel
@@ -450,11 +460,16 @@ function serializeTaskNode(
 
     let title = taskDef.title
     if (options.includePriority && taskDef.priority && taskDef.priority !== 'normal') {
-      const priorityMarker = taskDef.priority === 'critical' ? '!!'
-        : taskDef.priority === 'urgent' ? '!'
-        : taskDef.priority === 'high' ? '^'
-        : taskDef.priority === 'low' ? 'v'
-        : ''
+      const priorityMarker =
+        taskDef.priority === 'critical'
+          ? '!!'
+          : taskDef.priority === 'urgent'
+          ? '!'
+          : taskDef.priority === 'high'
+          ? '^'
+          : taskDef.priority === 'low'
+          ? 'v'
+          : ''
       title = `${priorityMarker}${title}`
     }
 
@@ -471,7 +486,7 @@ function serializeTaskNode(
     let seqNum = 1
     for (const child of group.tasks) {
       if (child.__type === 'task') {
-        (child as TaskDefinition).metadata = {
+        ;(child as TaskDefinition).metadata = {
           ...(child as TaskDefinition).metadata,
           _sequenceNumber: seqNum++,
         }
@@ -483,7 +498,7 @@ function serializeTaskNode(
     let seqNum = 1
     for (const child of group.tasks) {
       if (child.__type === 'task') {
-        (child as TaskDefinition).metadata = {
+        ;(child as TaskDefinition).metadata = {
           ...(child as TaskDefinition).metadata,
           _sequenceNumber: seqNum++,
         }
@@ -558,10 +573,7 @@ export function toMarkdown(project: Project, options: SerializeOptions = {}): st
  * Update task statuses in a project from markdown
  * (Useful for syncing when markdown is edited externally)
  */
-export function syncStatusFromMarkdown(
-  project: Project,
-  markdown: string
-): Project {
+export function syncStatusFromMarkdown(project: Project, markdown: string): Project {
   const parsed = parseMarkdown(markdown)
 
   // Build a map of task titles to statuses from parsed markdown
@@ -570,7 +582,7 @@ export function syncStatusFromMarkdown(
   function collectStatuses(node: TaskNode) {
     if (node.__type === 'task') {
       const taskDef = node as TaskDefinition
-      const status = taskDef.metadata?._originalStatus as TaskStatus
+      const status = taskDef.metadata?.['_originalStatus'] as TaskStatus
       if (status) {
         statusMap.set(taskDef.title, status)
       }
@@ -590,14 +602,17 @@ export function syncStatusFromMarkdown(
     if (node.__type === 'task') {
       const taskDef = node as TaskDefinition
       const newStatus = statusMap.get(taskDef.title)
-      return {
+      const result: TaskDefinition = {
         ...taskDef,
         metadata: {
           ...taskDef.metadata,
-          _originalStatus: newStatus || taskDef.metadata?._originalStatus,
+          _originalStatus: newStatus || taskDef.metadata?.['_originalStatus'],
         },
-        subtasks: taskDef.subtasks?.map(updateStatuses),
       }
+      if (taskDef.subtasks) {
+        result.subtasks = taskDef.subtasks.map(updateStatuses)
+      }
+      return result
     } else if (node.__type === 'parallel') {
       const group = node as ParallelGroup
       return {

package/src/project.ts

@@ -59,10 +59,7 @@ export type ExecutionMode = 'parallel' | 'sequential'
 /**
  * Task node in a workflow - can be a single task or a group
  */
-export type TaskNode =
-  | TaskDefinition
-  | ParallelGroup
-  | SequentialGroup
+export type TaskNode = TaskDefinition | ParallelGroup | SequentialGroup
 
 /**
  * Function type for the DSL
@@ -107,12 +104,7 @@ export interface SequentialGroup {
 /**
  * Project status
  */
-export type ProjectStatus =
-  | 'draft'
-  | 'active'
-  | 'paused'
-  | 'completed'
-  | 'cancelled'
+export type ProjectStatus = 'draft' | 'active' | 'paused' | 'completed' | 'cancelled'
 
 /**
  * Project definition
@@ -261,19 +253,28 @@ function generateProjectId(): string {
  */
 export function createProject(options: CreateProjectOptions): Project {
   const now = new Date()
-  return {
+  const project: Project = {
     id: generateProjectId(),
     name: options.name,
-    description: options.description,
     status: 'draft',
     tasks: options.tasks || [],
     defaultMode: options.defaultMode || 'sequential',
-    owner: options.owner,
-    tags: options.tags,
     createdAt: now,
     updatedAt: now,
-    metadata: options.metadata,
   }
+  if (options.description !== undefined) {
+    project.description = options.description
+  }
+  if (options.owner !== undefined) {
+    project.owner = options.owner
+  }
+  if (options.tags !== undefined) {
+    project.tags = options.tags
+  }
+  if (options.metadata !== undefined) {
+    project.metadata = options.metadata
+  }
+  return project
 }
 
 // ============================================================================
@@ -325,7 +326,10 @@ export function workflow(name: string, description?: string) {
      */
     then(...nodes: TaskNode[]) {
       if (nodes.length === 1) {
-        tasks.push(nodes[0])
+        const node = nodes[0]
+        if (node !== undefined) {
+          tasks.push(node)
+        }
       } else {
         tasks.push(sequential(...nodes))
       }
@@ -344,12 +348,15 @@ export function workflow(name: string, description?: string) {
      * Build the project
      */
     build(options?: Partial<Omit<CreateProjectOptions, 'name' | 'tasks'>>): Project {
-      return createProject({
+      const projectOptions: CreateProjectOptions = {
         name,
-        description,
         tasks,
         ...options,
-      })
+      }
+      if (description !== undefined) {
+        projectOptions.description = description
+      }
+      return createProject(projectOptions)
     },
   }
 
@@ -380,9 +387,7 @@ export async function materializeProject(
       const taskId = `${project.id}_task_${taskIndex++}`
 
       // Create dependencies based on mode (as string array for CreateTaskOptions)
-      const dependencies = mode === 'sequential' && previousIds.length > 0
-        ? previousIds
-        : undefined
+      const dependencies = mode === 'sequential' && previousIds.length > 0 ? previousIds : undefined
 
       // Create a FunctionDefinition from the task definition
       // Default to generative function type for DSL tasks
@@ -394,19 +399,28 @@ export async function materializeProject(
         output: 'string',
       } as FunctionDefinition
 
-      const newTask = await createBaseTask({
-        function: functionDef,
+      const createTaskOptions: CreateTaskOptions = {
+        tool: functionDef,
         priority: taskDef.priority || 'normal',
-        assignTo: taskDef.assignTo,
-        tags: taskDef.tags,
-        parentId,
         projectId: project.id,
-        dependencies,
         metadata: {
           ...taskDef.metadata,
           _taskNodeIndex: taskIndex - 1,
         },
-      })
+      }
+      if (taskDef.assignTo !== undefined) {
+        createTaskOptions.assignTo = taskDef.assignTo
+      }
+      if (taskDef.tags !== undefined) {
+        createTaskOptions.tags = taskDef.tags
+      }
+      if (parentId !== undefined) {
+        createTaskOptions.parentId = parentId
+      }
+      if (dependencies !== undefined) {
+        createTaskOptions.dependencies = dependencies
+      }
+      const newTask = await createBaseTask(createTaskOptions)
 
       // Override the generated ID with our predictable one
       ;(newTask as AnyTask).id = taskId
@@ -455,7 +469,12 @@ export async function materializeProject(
   // Process all root-level tasks
   let previousIds: string[] = []
   for (const node of project.tasks) {
-    previousIds = await processNode(node, undefined, previousIds, project.defaultMode || 'sequential')
+    previousIds = await processNode(
+      node,
+      undefined,
+      previousIds,
+      project.defaultMode || 'sequential'
+    )
   }
 
   return { project, tasks }
@@ -469,8 +488,8 @@ export async function materializeProject(
  * Get all tasks that depend on a given task (dependants)
  */
 export function getDependants(taskId: string, allTasks: AnyTask[]): AnyTask[] {
-  return allTasks.filter(t =>
-    t.dependencies?.some(d => d.taskId === taskId && d.type === 'blocked_by')
+  return allTasks.filter((t) =>
+    t.dependencies?.some((d) => d.taskId === taskId && d.type === 'blocked_by')
   )
 }
 
@@ -480,25 +499,21 @@ export function getDependants(taskId: string, allTasks: AnyTask[]): AnyTask[] {
 export function getDependencies(task: AnyTask, allTasks: AnyTask[]): AnyTask[] {
   if (!task.dependencies) return []
 
-  const depIds = task.dependencies
-    .filter(d => d.type === 'blocked_by')
-    .map(d => d.taskId)
+  const depIds = task.dependencies.filter((d) => d.type === 'blocked_by').map((d) => d.taskId)
 
-  return allTasks.filter(t => depIds.includes(t.id))
+  return allTasks.filter((t) => depIds.includes(t.id))
 }
 
 /**
  * Get tasks that are ready to execute (no unsatisfied dependencies)
  */
 export function getReadyTasks(allTasks: AnyTask[]): AnyTask[] {
-  return allTasks.filter(t => {
+  return allTasks.filter((t) => {
     if (t.status !== 'queued' && t.status !== 'pending') return false
 
     if (!t.dependencies || t.dependencies.length === 0) return true
 
-    return t.dependencies
-      .filter(d => d.type === 'blocked_by')
-      .every(d => d.satisfied)
+    return t.dependencies.filter((d) => d.type === 'blocked_by').every((d) => d.satisfied)
   })
 }
 
@@ -513,7 +528,7 @@ export function hasCycles(allTasks: AnyTask[]): boolean {
     visited.add(taskId)
     recStack.add(taskId)
 
-    const task = allTasks.find(t => t.id === taskId)
+    const task = allTasks.find((t) => t.id === taskId)
     if (task?.dependencies) {
       for (const dep of task.dependencies) {
         if (dep.type === 'blocked_by') {
@@ -554,7 +569,7 @@ export function sortTasks(allTasks: AnyTask[]): AnyTask[] {
     if (task.dependencies) {
       for (const dep of task.dependencies) {
         if (dep.type === 'blocked_by') {
-          const depTask = allTasks.find(t => t.id === dep.taskId)
+          const depTask = allTasks.find((t) => t.id === dep.taskId)
           if (depTask) visit(depTask)
         }
       }

package/src/queue.ts

@@ -49,12 +49,14 @@ class InMemoryTaskQueue implements TaskQueue {
   }
 
   async add(task: AnyTask): Promise<void> {
+    // Read the underlying Tool, tolerating the legacy `function` alias.
+    const tool = task.tool ?? task.function
     // Add created event
     const event: TaskEvent = {
       id: `evt_${Date.now()}`,
       type: 'created',
       timestamp: new Date(),
-      message: `Task created: ${task.function.name}`,
+      message: `Task created: ${tool?.name ?? task.id}`,
     }
 
     const taskWithEvent = {
@@ -88,10 +90,16 @@ class InMemoryTaskQueue implements TaskQueue {
     if (options.status && options.status !== task.status) {
       events.push({
         id: `evt_${Date.now()}_status`,
-        type: options.status === 'completed' ? 'completed' :
-              options.status === 'failed' ? 'failed' :
-              options.status === 'in_progress' ? 'started' :
-              options.status === 'blocked' ? 'blocked' : 'progress',
+        type:
+          options.status === 'completed'
+            ? 'completed'
+            : options.status === 'failed'
+            ? 'failed'
+            : options.status === 'in_progress'
+            ? 'started'
+            : options.status === 'blocked'
+            ? 'blocked'
+            : 'progress',
         timestamp: new Date(),
         message: `Status changed from ${task.status} to ${options.status}`,
       })
@@ -102,12 +110,25 @@ class InMemoryTaskQueue implements TaskQueue {
     if (options.progress) {
       progressUpdate = {
         percent: options.progress.percent ?? task.progress?.percent ?? 0,
-        step: options.progress.step ?? task.progress?.step,
-        totalSteps: options.progress.totalSteps ?? task.progress?.totalSteps,
-        currentStep: options.progress.currentStep ?? task.progress?.currentStep,
-        estimatedTimeRemaining: options.progress.estimatedTimeRemaining ?? task.progress?.estimatedTimeRemaining,
         updatedAt: new Date(),
       }
+      const step = options.progress.step ?? task.progress?.step
+      if (step !== undefined) {
+        progressUpdate.step = step
+      }
+      const totalSteps = options.progress.totalSteps ?? task.progress?.totalSteps
+      if (totalSteps !== undefined) {
+        progressUpdate.totalSteps = totalSteps
+      }
+      const currentStep = options.progress.currentStep ?? task.progress?.currentStep
+      if (currentStep !== undefined) {
+        progressUpdate.currentStep = currentStep
+      }
+      const estTime =
+        options.progress.estimatedTimeRemaining ?? task.progress?.estimatedTimeRemaining
+      if (estTime !== undefined) {
+        progressUpdate.estimatedTimeRemaining = estTime
+      }
     }
 
     const updated: AnyTask = {
@@ -145,9 +166,9 @@ class InMemoryTaskQueue implements TaskQueue {
       results = results.filter((t) => priorities.includes(t.priority))
     }
 
-    // Filter by function type
+    // Filter by function type (reads `tool` with fallback to legacy `function`)
     if (options.functionType) {
-      results = results.filter((t) => t.function.type === options.functionType)
+      results = results.filter((t) => (t.tool ?? t.function)?.type === options.functionType)
     }
 
     // Filter by assigned worker
@@ -157,9 +178,7 @@ class InMemoryTaskQueue implements TaskQueue {
 
     // Filter by tags
     if (options.tags && options.tags.length > 0) {
-      results = results.filter(
-        (t) => t.tags && options.tags!.some((tag) => t.tags!.includes(tag))
-      )
+      results = results.filter((t) => t.tags && options.tags!.some((tag) => t.tags!.includes(tag)))
     }
 
     // Filter by project
@@ -172,14 +191,17 @@ class InMemoryTaskQueue implements TaskQueue {
       results = results.filter((t) => t.parentId === options.parentId)
     }
 
-    // Text search
+    // Text search (reads `tool` with fallback to legacy `function`)
     if (options.search) {
       const search = options.search.toLowerCase()
-      results = results.filter(
-        (t) =>
-          t.function.name.toLowerCase().includes(search) ||
-          t.function.description?.toLowerCase().includes(search)
-      )
+      results = results.filter((t) => {
+        const tool = t.tool ?? t.function
+        if (!tool) return false
+        return (
+          tool.name.toLowerCase().includes(search) ||
+          tool.description?.toLowerCase().includes(search)
+        )
+      })
     }
 
     // Sort
@@ -232,7 +254,11 @@ class InMemoryTaskQueue implements TaskQueue {
     // Find first task the worker can handle
     for (const task of queuedTasks) {
       // Check if worker type is allowed
-      if (task.allowedWorkers && !task.allowedWorkers.includes(worker.type) && !task.allowedWorkers.includes('any')) {
+      if (
+        task.allowedWorkers &&
+        !task.allowedWorkers.includes(worker.type) &&
+        !task.allowedWorkers.includes('any')
+      ) {
         continue
       }
 
@@ -289,14 +315,17 @@ class InMemoryTaskQueue implements TaskQueue {
     const task = await this.get(taskId)
     if (!task) return
 
+    const event: Omit<TaskEvent, 'id' | 'timestamp'> = {
+      type: 'completed',
+      message: 'Task completed successfully',
+      data: { output },
+    }
+    if (task.assignment?.worker !== undefined) {
+      event.actor = task.assignment.worker
+    }
     await this.update(taskId, {
       status: 'completed',
-      event: {
-        type: 'completed',
-        actor: task.assignment?.worker,
-        message: 'Task completed successfully',
-        data: { output },
-      },
+      event,
     })
 
     // Update task output separately since it's not in UpdateTaskOptions
@@ -328,7 +357,9 @@ class InMemoryTaskQueue implements TaskQueue {
           })
 
           // Unblock if all dependencies satisfied
-          const allSatisfied = updatedDeps.filter((d) => d.type === 'blocked_by').every((d) => d.satisfied)
+          const allSatisfied = updatedDeps
+            .filter((d) => d.type === 'blocked_by')
+            .every((d) => d.satisfied)
           if (allSatisfied && otherTask.status === 'blocked') {
             await this.update(otherTask.id, {
               status: 'queued',
@@ -347,14 +378,17 @@ class InMemoryTaskQueue implements TaskQueue {
     const task = await this.get(taskId)
     if (!task) return
 
+    const event: Omit<TaskEvent, 'id' | 'timestamp'> = {
+      type: 'failed',
+      message: `Task failed: ${error}`,
+      data: { error },
+    }
+    if (task.assignment?.worker !== undefined) {
+      event.actor = task.assignment.worker
+    }
     await this.update(taskId, {
       status: 'failed',
-      event: {
-        type: 'failed',
-        actor: task.assignment?.worker,
-        message: `Task failed: ${error}`,
-        data: { error },
-      },
+      event,
     })
   }
 
@@ -401,13 +435,18 @@ class InMemoryTaskQueue implements TaskQueue {
       }
     }
 
-    return {
+    const stats: TaskQueueStats = {
       total: tasks.length,
       byStatus,
       byPriority,
-      avgWaitTime: waitTimeCount > 0 ? totalWaitTime / waitTimeCount : undefined,
-      avgCompletionTime: completionTimeCount > 0 ? totalCompletionTime / completionTimeCount : undefined,
     }
+    if (waitTimeCount > 0) {
+      stats.avgWaitTime = totalWaitTime / waitTimeCount
+    }
+    if (completionTimeCount > 0) {
+      stats.avgCompletionTime = totalCompletionTime / completionTimeCount
+    }
+    return stats
   }
 }