@hed-hog/operations 0.0.304 → 0.0.306

package/src/operations.service.ts

@@ -107,7 +107,7 @@ const FINANCIAL_TERM_TYPE_VALUES = ['value', 'payment', 'revenue', 'fine', 'othe
 const RECURRENCE_VALUES = ['one_time', 'monthly', 'quarterly', 'yearly', 'other'] as const;
 const REVISION_TYPE_VALUES = ['amendment', 'renewal', 'revision', 'addendum', 'other'] as const;
 const REVISION_STATUS_VALUES = ['draft', 'active', 'completed', 'cancelled'] as const;
-const TASK_STATUS_VALUES = ['active', 'completed', 'archived'] as const;
+const TASK_STATUS_VALUES = ['todo', 'doing', 'review', 'done'] as const;
 
 type ApprovalAction = 'approve' | 'reject';
 type ApprovalTargetType =
@@ -548,6 +548,7 @@ type ProjectPayload = {
   contractId?: number | null;
   contractTemplateId?: number | null;
   managerCollaboratorId?: number | null;
+  clientPersonId?: number | null;
   code: string;
   name: string;
   clientName?: string | null;
@@ -606,9 +607,15 @@ type TimesheetEntryPayload = {
 type TaskPayload = {
   projectId?: number | null;
   projectAssignmentId?: number | null;
+  assigneeCollaboratorId?: number | null;
   name?: string | null;
   description?: string | null;
+  priority?: 'low' | 'medium' | 'high';
   status?: (typeof TASK_STATUS_VALUES)[number];
+  dueDate?: string | null;
+  estimateHours?: number | null;
+  position?: number;
+  tags?: string | null;
 };
 
 type QuickTimesheetEntryPayload = {
@@ -1743,6 +1750,28 @@ export class OperationsService {
           data.equityParticipation
         );
       }
+
+      if (
+        data.compensationAmount !== undefined ||
+        data.contractDescription !== undefined ||
+        data.autoGenerateContractDraft !== undefined ||
+        data.joinedAt !== undefined ||
+        data.weeklyCapacityHours !== undefined ||
+        data.supervisorCollaboratorId !== undefined ||
+        data.collaboratorType !== undefined ||
+        data.collaboratorTypeId !== undefined ||
+        data.collaboratorTypeSlug !== undefined ||
+        data.code !== undefined ||
+        data.personId !== undefined ||
+        data.displayName !== undefined
+      ) {
+        await this.syncHiringContractDraft(
+          tx as any,
+          actor.userId,
+          collaboratorId,
+          data
+        );
+      }
     });
 
     return this.getCollaboratorByIdForUser(userId, collaboratorId);
@@ -2002,8 +2031,8 @@ export class OperationsService {
               p.progress_percent AS "progressPercent",
               p.delivery_model AS "deliveryModel",
               p.budget_amount AS "budgetAmount",
-              p.start_date AS "startDate",
-              p.end_date AS "endDate",
+              TO_CHAR(p.start_date, 'YYYY-MM-DD') AS "startDate",
+              TO_CHAR(p.end_date, 'YYYY-MM-DD') AS "endDate",
               c.name AS "contractName",
               c.status AS "contractStatus",
               m.display_name AS "managerName",
@@ -2036,22 +2065,19 @@ export class OperationsService {
     const actor = await this.getActorContext(userId);
     this.ensureCollaborator(actor);
 
-    if (!actor.collaboratorId) {
-      throw new BadRequestException('Collaborator context is required.');
-    }
-
     const pagination = this.normalizePaginationParams(paginationParams, {
       defaultSortField: 'name',
       defaultSortOrder: 'asc',
       allowedSortFields: ['name', 'code', 'clientName', 'startDate', 'endDate'],
     });
 
-    const params: unknown[] = [actor.collaboratorId];
+    const filter = this.buildIdFilter(actor.visibleProjectIds, 'p.id', actor.isDirector);
+    const params: unknown[] = [...filter.params];
     const filters = [
       'p.deleted_at IS NULL',
       'pa.deleted_at IS NULL',
-      `pa.collaborator_id = $1`,
       `pa.status IN ('planned', 'active')`,
+      filter.clause,
     ];
 
     if (pagination.search) {
@@ -2105,8 +2131,8 @@ export class OperationsService {
               MAX(pa.id)::int AS "projectAssignmentId",
               MAX(pa.role_label) AS "roleLabel",
               p.status,
-              p.start_date AS "startDate",
-              p.end_date AS "endDate"
+              TO_CHAR(p.start_date, 'YYYY-MM-DD') AS "startDate",
+              TO_CHAR(p.end_date, 'YYYY-MM-DD') AS "endDate"
          FROM operations_project_assignment pa
          JOIN operations_project p
            ON p.id = pa.project_id
@@ -2145,23 +2171,30 @@ export class OperationsService {
     const actor = await this.getActorContext(userId);
     this.ensureCollaborator(actor);
 
-    if (!actor.collaboratorId) {
-      throw new BadRequestException('Collaborator context is required.');
-    }
-
     const pagination = this.normalizePaginationParams(paginationParams, {
       defaultSortField: 'name',
       defaultSortOrder: 'asc',
       allowedSortFields: ['name', 'projectName', 'status', 'createdAt'],
     });
 
-    const params: unknown[] = [actor.collaboratorId];
+    const projectFilter = this.buildIdFilter(
+      actor.visibleProjectIds,
+      'COALESCE(t.project_id, pa.project_id)',
+      actor.isDirector
+    );
+    const params: unknown[] = [...projectFilter.params];
     const filters = [
       't.deleted_at IS NULL',
-      'pa.deleted_at IS NULL',
       'p.deleted_at IS NULL',
-      `pa.collaborator_id = $1`,
-      `pa.status IN ('planned', 'active')`,
+      projectFilter.clause,
+      `(
+        t.project_id IS NOT NULL
+        OR (
+          pa.id IS NOT NULL
+          AND pa.deleted_at IS NULL
+          AND pa.status IN ('planned', 'active')
+        )
+      )`,
     ];
 
     if (pagination.search) {
@@ -2179,7 +2212,12 @@ export class OperationsService {
     }
 
     if (paginationParams.projectId) {
-      filters.push(`pa.project_id = ${this.param(params, paginationParams.projectId)}`);
+      filters.push(
+        `COALESCE(t.project_id, pa.project_id) = ${this.param(
+          params,
+          paginationParams.projectId
+        )}`
+      );
     }
 
     if (paginationParams.status) {
@@ -2190,10 +2228,10 @@ export class OperationsService {
     const totalRow = await this.querySingle<{ total: string }>(
       `SELECT COUNT(*)::text AS total
          FROM operations_task t
-         JOIN operations_project_assignment pa
+         LEFT JOIN operations_project_assignment pa
            ON pa.id = t.project_assignment_id
          JOIN operations_project p
-           ON p.id = pa.project_id
+           ON p.id = COALESCE(t.project_id, pa.project_id)
         WHERE ${whereClause}`,
       params
     );
@@ -2225,16 +2263,16 @@ export class OperationsService {
               t.name,
               t.description,
               t.status,
-              pa.project_id AS "projectId",
+              COALESCE(t.project_id, pa.project_id) AS "projectId",
               pa.id AS "projectAssignmentId",
               p.name AS "projectName",
               p.code AS "projectCode",
               t.created_at AS "createdAt"
          FROM operations_task t
-         JOIN operations_project_assignment pa
+         LEFT JOIN operations_project_assignment pa
            ON pa.id = t.project_assignment_id
          JOIN operations_project p
-           ON p.id = pa.project_id
+           ON p.id = COALESCE(t.project_id, pa.project_id)
         WHERE ${whereClause}
         ORDER BY ${sortColumn} ${pagination.sortOrder.toUpperCase()}, t.id ASC
         LIMIT ${limitPlaceholder}
@@ -2255,54 +2293,92 @@ export class OperationsService {
 
   async createTask(userId: number, data: TaskPayload) {
     const actor = await this.getActorContext(userId);
-    this.ensureCollaborator(actor);
+    if (!actor.isCollaborator && !actor.isDirector && !actor.isSupervisor) {
+      throw new ForbiddenException(
+        'Operations collaborator access is required.'
+      );
+    }
     this.requireFields(data as Record<string, unknown>, ['name']);
 
-    if (!actor.collaboratorId) {
-      throw new BadRequestException('Collaborator context is required.');
+    let assignmentId: number | null = null;
+    let projectId: number | null = null;
+
+    if (data.projectId || data.projectAssignmentId) {
+      const assignment = await this.resolveProjectAssignmentForActor(
+        this.prisma,
+        actor,
+        {
+          projectId: data.projectId ?? null,
+          projectAssignmentId: data.projectAssignmentId ?? null,
+        }
+      );
+      await this.assertProjectAccess(actor, assignment.projectId);
+      assignmentId = assignment.id;
+      projectId = assignment.projectId;
+    } else if (data.projectId) {
+      projectId = data.projectId;
+      await this.assertProjectAccess(actor, projectId);
+    } else {
+      throw new BadRequestException('Either projectId or projectAssignmentId is required.');
     }
 
-    const assignment = await this.resolveOwnedProjectAssignment(
-      this.prisma,
-      actor.collaboratorId,
-      {
-        projectId: data.projectId ?? null,
-        projectAssignmentId: data.projectAssignmentId ?? null,
-      }
-    );
-    await this.assertProjectAccess(actor, assignment.projectId);
+    if (!projectId) {
+      projectId = data.projectId ?? null;
+    }
 
     const name = this.normalizeOptionalText(data.name);
     if (!name) {
       throw new BadRequestException('Field "name" is required.');
     }
 
+    const maxPositionRow = await this.querySingle<{ max_pos: number | null }>(
+      `SELECT MAX(position) AS max_pos
+         FROM operations_task
+        WHERE project_id = $1
+          AND status = $2::operations_task_status_574c143dbe_enum
+          AND deleted_at IS NULL`,
+      [projectId, data.status ?? 'todo']
+    );
+    const nextPosition = ((maxPositionRow?.max_pos ?? -1) as number) + 1;
+
     const created = await this.querySingle<{ id: number }>(
       `INSERT INTO operations_task (
+        project_id,
         project_assignment_id,
+        assignee_collaborator_id,
         name,
         description,
+        priority,
         status,
+        due_date,
+        estimate_hours,
+        position,
+        tags,
         created_at,
         updated_at
       ) VALUES (
-        $1,
-        $2,
-        $3,
-        $4,
-        NOW(),
-        NOW()
+        $1, $2, $3, $4, $5,
+        $6::operations_task_priority_394ab327eb_enum,
+        $7::operations_task_status_574c143dbe_enum,
+        $8::date, $9::decimal, $10, $11, NOW(), NOW()
       )
       RETURNING id`,
       [
-        assignment.id,
+        projectId,
+        assignmentId,
+        data.assigneeCollaboratorId ?? null,
         name,
         this.normalizeOptionalText(data.description),
-        data.status ?? 'active',
+        data.priority ?? 'medium',
+        data.status ?? 'todo',
+        data.dueDate ?? null,
+        data.estimateHours ?? null,
+        data.position ?? nextPosition,
+        data.tags ?? null,
       ]
     );
 
-    return this.getTaskOptionById(actor.collaboratorId, created?.id ?? 0);
+    return this.getProjectBoardTask(created?.id ?? 0);
   }
 
   async updateTask(
@@ -2311,15 +2387,15 @@ export class OperationsService {
     data: Partial<TaskPayload>
   ) {
     const actor = await this.getActorContext(userId);
-    this.ensureCollaborator(actor);
-
-    if (!actor.collaboratorId) {
-      throw new BadRequestException('Collaborator context is required.');
+    if (!actor.isCollaborator && !actor.isDirector && !actor.isSupervisor) {
+      throw new ForbiddenException(
+        'Operations collaborator access is required.'
+      );
     }
 
-    const current = await this.getOwnedTaskRecord(
+    const current = await this.getTaskRecordForActor(
       this.prisma,
-      actor.collaboratorId,
+      actor,
       taskId
     );
     await this.assertProjectAccess(actor, current.projectId);
@@ -2334,56 +2410,72 @@ export class OperationsService {
     }
 
     await this.prisma.$transaction(async (tx) => {
-      const nextAssignment =
-        data.projectId !== undefined || data.projectAssignmentId !== undefined
-          ? await this.resolveOwnedProjectAssignment(
-              tx as any,
-              actor.collaboratorId as number,
-              {
-                projectId: data.projectId ?? null,
-                projectAssignmentId: data.projectAssignmentId ?? null,
-              }
-            )
-          : {
-              id: current.projectAssignmentId,
-              projectId: current.projectId,
-            };
+      let nextAssignmentId = current.projectAssignmentId;
+      let nextProjectId = current.projectId;
 
-      await this.assertProjectAccess(actor, nextAssignment.projectId);
+      if (data.projectId !== undefined || data.projectAssignmentId !== undefined) {
+        const nextAssignment = await this.resolveProjectAssignmentForActor(
+          tx as any,
+          actor,
+          {
+            projectId: data.projectId ?? null,
+            projectAssignmentId: data.projectAssignmentId ?? null,
+          }
+        );
+        await this.assertProjectAccess(actor, nextAssignment.projectId);
+        nextAssignmentId = nextAssignment.id;
+        nextProjectId = nextAssignment.projectId;
+      }
 
       await (tx as any).$executeRawUnsafe(
         `UPDATE operations_task
-            SET project_assignment_id = $1,
-                name = $2,
-                description = $3,
-                status = $4,
+            SET project_id = $1,
+                project_assignment_id = $2,
+                assignee_collaborator_id = $3,
+                name = $4,
+                description = $5,
+                priority = $6::operations_task_priority_394ab327eb_enum,
+                status = $7::operations_task_status_574c143dbe_enum,
+                due_date = $8::date,
+                estimate_hours = $9::decimal,
+                position = $10,
+                tags = $11,
                 updated_at = NOW()
-          WHERE id = $5
+          WHERE id = $12
             AND deleted_at IS NULL`,
-        nextAssignment.id,
+        nextProjectId,
+        nextAssignmentId,
+        data.assigneeCollaboratorId !== undefined
+          ? (data.assigneeCollaboratorId ?? null)
+          : current.assigneeCollaboratorId,
         nextName,
         data.description !== undefined
           ? this.normalizeOptionalText(data.description)
           : (current.description ?? null),
+        data.priority ?? current.priority,
         data.status ?? current.status,
+        data.dueDate !== undefined ? (data.dueDate ?? null) : current.dueDate,
+        data.estimateHours !== undefined ? (data.estimateHours ?? null) : current.estimateHours,
+        data.position !== undefined ? data.position : current.position,
+        data.tags !== undefined ? (data.tags ?? null) : current.tags,
         taskId
       );
     });
 
-    return this.getTaskOptionById(actor.collaboratorId, taskId);
+    return this.getProjectBoardTask(taskId);
   }
 
   async removeTask(userId: number, taskId: number) {
     const actor = await this.getActorContext(userId);
-    this.ensureCollaborator(actor);
-
-    if (!actor.collaboratorId) {
-      throw new BadRequestException('Collaborator context is required.');
+    if (!actor.isCollaborator && !actor.isDirector && !actor.isSupervisor) {
+      throw new ForbiddenException(
+        'Operations collaborator access is required.'
+      );
     }
 
-    const current = await this.getOwnedTaskRecord(
+    const current = await this.getTaskRecordForActor(
       this.prisma,
-      actor.collaboratorId,
+      actor,
       taskId
     );
     await this.assertProjectAccess(actor, current.projectId);
@@ -2392,7 +2484,6 @@ export class OperationsService {
       await (tx as any).$executeRawUnsafe(
         `UPDATE operations_task
             SET deleted_at = COALESCE(deleted_at, NOW()),
-                status = 'archived',
                 updated_at = NOW()
           WHERE id = $1
             AND deleted_at IS NULL`,
@@ -2617,9 +2708,9 @@ export class OperationsService {
         ? await this.getOwnedTaskRecord(tx as any, actor.collaboratorId as number, data.taskId)
         : null;
 
-      if (resolvedTask && resolvedTask.projectAssignmentId !== assignment.id) {
+      if (resolvedTask && resolvedTask.projectId !== assignment.projectId) {
         throw new BadRequestException(
-          'The selected task does not belong to the chosen project assignment.'
+          'The selected task does not belong to the chosen project.'
         );
       }
 
@@ -2678,6 +2769,116 @@ export class OperationsService {
     return this.getTimesheetEntryByIdForActor(actor, createdEntryId);
   }
 
+  async updateTimesheetEntry(
+    userId: number,
+    entryId: number,
+    data: QuickTimesheetEntryPayload
+  ) {
+    const actor = await this.getActorContext(userId);
+    this.ensureCollaborator(actor);
+    this.requireFields(data as Record<string, unknown>, ['workDate', 'duration']);
+
+    if (!actor.collaboratorId && !actor.isDirector) {
+      throw new BadRequestException('Collaborator context is required.');
+    }
+
+    const entry = await this.getTimesheetEntryByIdForActor(actor, entryId);
+
+    if (!actor.isDirector && entry.collaboratorId !== actor.collaboratorId) {
+      throw new ForbiddenException(
+        'Only the entry owner can update this timesheet entry.'
+      );
+    }
+
+    if (!['draft', 'rejected'].includes(entry.status)) {
+      throw new BadRequestException(
+        'Only draft or rejected timesheet entries can be edited.'
+      );
+    }
+
+    const collaboratorId = actor.isDirector
+      ? entry.collaboratorId
+      : (actor.collaboratorId as number);
+    const durationMinutes = this.normalizeDurationMinutes(data.duration, data.unit);
+    const taskLabel =
+      this.normalizeOptionalText(data.taskName) ??
+      this.normalizeOptionalText(data.activityLabel);
+    const targetWeek = this.getWorkWeekRange(data.workDate);
+    const isSameWeek =
+      entry.weekStartDate === targetWeek.weekStartDate &&
+      entry.weekEndDate === targetWeek.weekEndDate;
+
+    await this.prisma.$transaction(async (tx) => {
+      const assignment = await this.resolveOwnedProjectAssignment(
+        tx as any,
+        collaboratorId,
+        {
+          projectId: data.projectId ?? null,
+          projectAssignmentId: data.projectAssignmentId ?? null,
+        }
+      );
+
+      const resolvedTask = data.taskId
+        ? await this.getOwnedTaskRecord(tx as any, collaboratorId, data.taskId)
+        : null;
+
+      if (resolvedTask && resolvedTask.projectId !== assignment.projectId) {
+        throw new BadRequestException(
+          'The selected task does not belong to the chosen project.'
+        );
+      }
+
+      const activityLabel =
+        resolvedTask?.name ?? taskLabel ?? assignment.roleLabel ?? assignment.projectName;
+
+      if (!activityLabel) {
+        throw new BadRequestException('A task is required for the timesheet entry.');
+      }
+
+      const targetTimesheetId = isSameWeek
+        ? entry.timesheetId
+        : await this.getOrCreateTimesheetForWorkDate(
+            tx as any,
+            collaboratorId,
+            data.workDate
+          );
+
+      await (tx as any).$executeRawUnsafe(
+        `UPDATE operations_timesheet_entry
+            SET timesheet_id = $1,
+                project_assignment_id = $2,
+                task_id = $3,
+                activity_label = $4,
+                work_date = $5::date,
+                duration_minutes = $6,
+                hours = $7,
+                description = $8,
+                updated_at = NOW()
+          WHERE id = $9
+            AND deleted_at IS NULL`,
+        targetTimesheetId,
+        assignment.id,
+        resolvedTask?.id ?? data.taskId ?? null,
+        activityLabel,
+        data.workDate,
+        durationMinutes,
+        Number((durationMinutes / 60).toFixed(2)),
+        this.normalizeOptionalText(data.description),
+        entryId
+      );
+
+      await this.refreshTimesheetTotal(tx as any, entry.timesheetId);
+
+      if (targetTimesheetId !== entry.timesheetId) {
+        await this.refreshTimesheetTotal(tx as any, targetTimesheetId);
+      }
+
+      await this.cleanupEmptyEditableTimesheet(tx as any, entry.timesheetId);
+    });
+
+    return this.getTimesheetEntryByIdForActor(actor, entryId);
+  }
+
   async removeTimesheetEntry(userId: number, entryId: number) {
     const actor = await this.getActorContext(userId);
     this.ensureCollaborator(actor);
@@ -2711,6 +2912,7 @@ export class OperationsService {
       );
 
       await this.refreshTimesheetTotal(tx as any, entry.timesheetId);
+      await this.cleanupEmptyEditableTimesheet(tx as any, entry.timesheetId);
     });
 
     return { success: true };
@@ -2732,6 +2934,7 @@ export class OperationsService {
         `INSERT INTO operations_project (
           contract_id,
           manager_collaborator_id,
+          client_person_id,
           code,
           name,
           client_name,
@@ -2745,15 +2948,16 @@ export class OperationsService {
           created_at,
           updated_at
         ) VALUES (
-          $1, $2, $3, $4, $5, $6,
-          $7::operations_project_status_965e8d4b2d_enum,
-          $8,
-          $9::operations_project_delivery_model_75ee11b3b7_enum,
-          $10, $11::date, $12::date, NOW(), NOW()
+          $1, $2, $3, $4, $5, $6, $7,
+          $8::operations_project_status_965e8d4b2d_enum,
+          $9,
+          $10::operations_project_delivery_model_75ee11b3b7_enum,
+          $11, $12::date, $13::date, NOW(), NOW()
         )
         RETURNING id`,
         data.contractId ?? null,
         data.managerCollaboratorId ?? null,
+        data.clientPersonId ?? null,
         data.code,
         data.name,
         data.clientName ?? null,
@@ -2823,6 +3027,7 @@ export class OperationsService {
     const params: unknown[] = [];
     this.pushUpdate(updates, params, 'contract_id', data.contractId);
     this.pushUpdate(updates, params, 'manager_collaborator_id', data.managerCollaboratorId);
+    this.pushUpdate(updates, params, 'client_person_id', data.clientPersonId);
     this.pushUpdate(updates, params, 'code', data.code);
     this.pushUpdate(updates, params, 'name', data.name);
     this.pushUpdate(updates, params, 'client_name', data.clientName);
@@ -2839,7 +3044,7 @@ export class OperationsService {
       updates,
       params,
       'delivery_model',
-      data.deliveryModel,
+      (data.deliveryModel as string | null | undefined) === '' ? null : data.deliveryModel,
       'operations_project_delivery_model_75ee11b3b7_enum'
     );
     this.pushUpdate(updates, params, 'budget_amount', data.budgetAmount);
@@ -2869,7 +3074,7 @@ export class OperationsService {
       const nextContractId =
         data.contractId !== undefined
           ? data.contractId
-          : (currentProject.contractId ?? null);
+          : (currentProject.relatedContract?.id ?? null);
       const shouldGenerateDraft =
         !nextContractId && data.autoGenerateContractDraft === true;
 
@@ -2922,6 +3127,39 @@ export class OperationsService {
           contractId,
           projectId
         );
+      } else if (
+        nextContractId &&
+        (data.monthlyHourCap !== undefined || data.billingModel !== undefined)
+      ) {
+        const contractUpdates: string[] = [];
+        const contractParams: unknown[] = [];
+
+        this.pushUpdate(
+          contractUpdates,
+          contractParams,
+          'monthly_hour_cap',
+          data.monthlyHourCap
+        );
+        this.pushUpdate(
+          contractUpdates,
+          contractParams,
+          'billing_model',
+          (data.billingModel as string | null | undefined) === ''
+            ? null
+            : data.billingModel,
+          'operations_contract_billing_model_409dc7fea2_enum'
+        );
+
+        if (contractUpdates.length) {
+          contractParams.push(nextContractId);
+          await (tx as any).$executeRawUnsafe(
+            `UPDATE operations_contract
+                SET ${contractUpdates.join(', ')},
+                    updated_at = NOW()
+              WHERE id = $${contractParams.length}`,
+            ...contractParams
+          );
+        }
       }
     });
 
@@ -3011,7 +3249,11 @@ export class OperationsService {
           updated_at
         ) VALUES (
           $1, $2, $3, $4,
-          $5, $6, $7, $8, $9, $10, $11,
+          $5::text::operations_contract_template_contract_category_49bb07a713_enum,
+          $6::text::operations_contract_template_contract_type_3962dbda6a_enum,
+          $7::text::operations_contract_template_billing_model_384a7c60e2_enum,
+          $8::text::operations_contract_template_signature_status_56cb6d625b_enum,
+          $9, $10::text::operations_contract_template_status_c9d2e90231_enum, $11,
           NOW(), NOW()
         )
         RETURNING id`,
@@ -3100,12 +3342,12 @@ export class OperationsService {
                 code = $2,
                 name = $3,
                 description = $4,
-                contract_category = $5,
-                contract_type = $6,
-                billing_model = $7,
-                signature_status = $8,
+                contract_category = $5::text::operations_contract_template_contract_category_49bb07a713_enum,
+                contract_type = $6::text::operations_contract_template_contract_type_3962dbda6a_enum,
+                billing_model = $7::text::operations_contract_template_billing_model_384a7c60e2_enum,
+                signature_status = $8::text::operations_contract_template_signature_status_56cb6d625b_enum,
                 is_active = $9,
-                status = $10,
+                status = $10::text::operations_contract_template_status_c9d2e90231_enum,
                 content_html = $11,
                 updated_at = NOW()
           WHERE id = $12`,
@@ -5008,8 +5250,26 @@ export class OperationsService {
     }
 
     const collaborator = await this.getCollaboratorById(current.collaboratorId);
+
+    const projectManagerRow = await this.querySingle<{
+      managerCollaboratorId: number | null;
+    }>(
+      `SELECT p.manager_collaborator_id AS "managerCollaboratorId"
+         FROM operations_timesheet_entry e
+         LEFT JOIN operations_project_assignment pa ON pa.id = e.project_assignment_id
+         LEFT JOIN operations_project p ON p.id = pa.project_id
+        WHERE e.timesheet_id = $1
+          AND e.deleted_at IS NULL
+          AND p.manager_collaborator_id IS NOT NULL
+        LIMIT 1`,
+      [timesheetId]
+    );
+
     const approverId =
-      current.approverCollaboratorId ?? collaborator.supervisorId ?? null;
+      projectManagerRow?.managerCollaboratorId ??
+      current.approverCollaboratorId ??
+      collaborator.supervisorId ??
+      null;
 
     if (!approverId) {
       throw new BadRequestException(
@@ -5242,7 +5502,8 @@ export class OperationsService {
       endTime: string | null;
       breakMinutes: number | null;
     }>(
-      `SELECT collaborator_id AS "collaboratorId",
+      `SELECT DISTINCT ON (collaborator_id, weekday)
+              collaborator_id AS "collaboratorId",
               weekday,
               is_working_day AS "isWorkingDay",
               start_time AS "startTime",
@@ -5250,7 +5511,7 @@ export class OperationsService {
               break_minutes AS "breakMinutes"
          FROM operations_collaborator_schedule_day
         WHERE collaborator_id = ANY($1::int[])
-        ORDER BY id ASC`,
+        ORDER BY collaborator_id, weekday, id DESC`,
       [this.uniqueNumbers(requests.map((item) => item.collaboratorId))]
     );
 
@@ -5703,21 +5964,51 @@ export class OperationsService {
   private async getCollaboratorByUserId(userId: number) {
     return this.querySingle<{
       id: number;
+      userId: number | null;
+      personId: number | null;
       displayName: string;
       supervisorId: number | null;
       supervisorName: string | null;
+      activeAssignments: number;
     }>(
-      `SELECT c.id,
+      `WITH linked_collaborator AS (
+         SELECT person_id
+           FROM operations_collaborator
+          WHERE user_id = $1
+            AND deleted_at IS NULL
+          ORDER BY id DESC
+          LIMIT 1
+       )
+       SELECT c.id,
+              c.user_id AS "userId",
+              c.person_id AS "personId",
               COALESCE(NULLIF(c.display_name, ''), person_record.name) AS "displayName",
               s.id AS "supervisorId",
-              s.display_name AS "supervisorName"
+              s.display_name AS "supervisorName",
+              COUNT(pa.id) FILTER (
+                WHERE pa.deleted_at IS NULL
+                  AND pa.status IN ('planned', 'active')
+              )::int AS "activeAssignments"
          FROM operations_collaborator c
          LEFT JOIN person person_record
            ON person_record.id = c.person_id
          LEFT JOIN operations_collaborator s
            ON s.id = c.supervisor_collaborator_id
-        WHERE c.user_id = $1
-          AND c.deleted_at IS NULL`,
+         LEFT JOIN operations_project_assignment pa
+           ON pa.collaborator_id = c.id
+        WHERE c.deleted_at IS NULL
+          AND (
+            c.user_id = $1
+            OR (
+              c.person_id IS NOT NULL
+              AND c.person_id = (SELECT person_id FROM linked_collaborator)
+            )
+          )
+        GROUP BY c.id, person_record.id, s.id
+        ORDER BY "activeAssignments" DESC,
+                 CASE WHEN c.user_id = $1 THEN 0 ELSE 1 END,
+                 c.id ASC
+        LIMIT 1`,
       [userId]
     );
   }
@@ -6608,6 +6899,8 @@ export class OperationsService {
       id: number;
       contractId: number | null;
       managerCollaboratorId: number | null;
+      clientPersonId: number | null;
+      clientAvatarId: number | null;
       code: string;
       name: string;
       clientName: string | null;
@@ -6629,6 +6922,8 @@ export class OperationsService {
       `SELECT p.id,
               p.contract_id AS "contractId",
               p.manager_collaborator_id AS "managerCollaboratorId",
+              p.client_person_id AS "clientPersonId",
+              client_person.avatar_id AS "clientAvatarId",
               p.code,
               p.name,
               p.client_name AS "clientName",
@@ -6637,8 +6932,8 @@ export class OperationsService {
               p.progress_percent AS "progressPercent",
               p.delivery_model AS "deliveryModel",
               p.budget_amount AS "budgetAmount",
-              p.start_date AS "startDate",
-              p.end_date AS "endDate",
+              TO_CHAR(p.start_date, 'YYYY-MM-DD') AS "startDate",
+              TO_CHAR(p.end_date, 'YYYY-MM-DD') AS "endDate",
               c.name AS "contractName",
               c.status AS "contractStatus",
               c.contract_category AS "contractCategory",
@@ -6649,6 +6944,7 @@ export class OperationsService {
          FROM operations_project p
          LEFT JOIN operations_contract c ON c.id = p.contract_id
          LEFT JOIN operations_collaborator m ON m.id = p.manager_collaborator_id
+         LEFT JOIN person client_person ON client_person.id = p.client_person_id
          LEFT JOIN operations_project_assignment pa
            ON pa.project_id = p.id
           AND pa.deleted_at IS NULL
@@ -6664,7 +6960,7 @@ export class OperationsService {
          ) project_role_locale ON TRUE
         WHERE p.id = $1
           AND p.deleted_at IS NULL
-        GROUP BY p.id, c.id, m.id`,
+        GROUP BY p.id, c.id, m.id, client_person.id`,
       [projectId, actorCollaboratorId ?? null]
     );
 
@@ -6677,6 +6973,9 @@ export class OperationsService {
         this.queryRows<{
           id: number;
           collaboratorId: number;
+          userId: number | null;
+          personAvatarId: number | null;
+          userPhotoId: number | null;
           collaboratorName: string;
           projectRoleId: number | null;
           roleLabel: string | null;
@@ -6689,17 +6988,22 @@ export class OperationsService {
         }>(
           `SELECT pa.id,
                   pa.collaborator_id AS "collaboratorId",
+              c.user_id AS "userId",
+              person_record.avatar_id AS "personAvatarId",
+              collaborator_user.photo_id AS "userPhotoId",
                   c.display_name AS "collaboratorName",
                   pa.project_role_id AS "projectRoleId",
                   COALESCE(project_role_locale.name, pa.role_label) AS "roleLabel",
                   pa.allocation_percent AS "allocationPercent",
                   pa.weekly_hours AS "weeklyHours",
                   pa.is_billable AS "isBillable",
-                  pa.start_date AS "startDate",
-                  pa.end_date AS "endDate",
+                  TO_CHAR(pa.start_date, 'YYYY-MM-DD') AS "startDate",
+                  TO_CHAR(pa.end_date, 'YYYY-MM-DD') AS "endDate",
                   pa.status
              FROM operations_project_assignment pa
              JOIN operations_collaborator c ON c.id = pa.collaborator_id
+             LEFT JOIN person person_record ON person_record.id = c.person_id
+             LEFT JOIN "user" collaborator_user ON collaborator_user.id = c.user_id
              LEFT JOIN operations_project_role project_role
                ON project_role.id = pa.project_role_id
               AND project_role.deleted_at IS NULL
@@ -6739,8 +7043,8 @@ export class OperationsService {
                       contract_category AS "contractCategory",
                       billing_model AS "billingModel",
                       status,
-                      start_date AS "startDate",
-                      end_date AS "endDate",
+                      TO_CHAR(start_date, 'YYYY-MM-DD') AS "startDate",
+                      TO_CHAR(end_date, 'YYYY-MM-DD') AS "endDate",
                       budget_amount AS "budgetAmount",
                       monthly_hour_cap AS "monthlyHourCap",
                       description,
@@ -6951,7 +7255,8 @@ export class OperationsService {
              FROM operations_contract c
             WHERE c.related_collaborator_id = $1
               AND c.deleted_at IS NULL
-            ORDER BY c.created_at DESC`,
+            ORDER BY CASE WHEN c.origin_type = 'employee_hiring' THEN 0 ELSE 1 END,
+                     c.created_at DESC`,
           [collaboratorId]
         ),
         this.queryRows(
@@ -7137,6 +7442,69 @@ export class OperationsService {
     return assignment[0];
   }
 
+  private async resolveProjectAssignmentForActor(
+    client: any,
+    actor: ActorContext,
+    input: {
+      projectId?: number | null;
+      projectAssignmentId?: number | null;
+    }
+  ) {
+    if (actor.collaboratorId && !actor.isDirector && !actor.isSupervisor) {
+      return this.resolveOwnedProjectAssignment(
+        client,
+        actor.collaboratorId,
+        input
+      );
+    }
+
+    if (!input.projectId && !input.projectAssignmentId) {
+      throw new BadRequestException(
+        'Either projectId or projectAssignmentId is required.'
+      );
+    }
+
+    const params: unknown[] = [];
+    const filters = ['pa.deleted_at IS NULL', 'p.deleted_at IS NULL'];
+
+    if (input.projectAssignmentId) {
+      filters.push(`pa.id = ${this.param(params, input.projectAssignmentId)}`);
+    }
+
+    if (input.projectId) {
+      filters.push(`pa.project_id = ${this.param(params, input.projectId)}`);
+    }
+
+    const assignment = (await client.$queryRawUnsafe(
+      `SELECT pa.id,
+              pa.project_id AS "projectId",
+              p.name AS "projectName",
+              p.code AS "projectCode",
+              pa.role_label AS "roleLabel"
+         FROM operations_project_assignment pa
+         JOIN operations_project p
+           ON p.id = pa.project_id
+        WHERE ${filters.join(' AND ')}
+        ORDER BY CASE WHEN pa.status = 'active' THEN 0 ELSE 1 END,
+                 pa.start_date DESC NULLS LAST,
+                 pa.id DESC
+        LIMIT 1`,
+      ...params
+    )) as Array<{
+      id: number;
+      projectId: number;
+      projectName: string;
+      projectCode: string | null;
+      roleLabel: string | null;
+    }>;
+
+    if (!assignment[0]) {
+      throw new NotFoundException('Project assignment not found.');
+    }
+
+    return assignment[0];
+  }
+
   private async getOwnedTaskRecord(
     client: any,
     collaboratorId: number,
@@ -7146,21 +7514,33 @@ export class OperationsService {
       `SELECT t.id,
               t.name,
               t.description,
+              t.priority,
               t.status,
+              t.due_date AS "dueDate",
+              t.estimate_hours AS "estimateHours",
+              t.position,
+              t.tags,
+              t.assignee_collaborator_id AS "assigneeCollaboratorId",
               t.project_assignment_id AS "projectAssignmentId",
-              pa.project_id AS "projectId",
+              COALESCE(t.project_id, pa.project_id) AS "projectId",
               p.name AS "projectName",
               p.code AS "projectCode"
          FROM operations_task t
-         JOIN operations_project_assignment pa
+         LEFT JOIN operations_project_assignment pa
            ON pa.id = t.project_assignment_id
           AND pa.deleted_at IS NULL
-         JOIN operations_project p
-           ON p.id = pa.project_id
+         LEFT JOIN operations_project p
+           ON p.id = COALESCE(t.project_id, pa.project_id)
           AND p.deleted_at IS NULL
         WHERE t.id = $1
           AND t.deleted_at IS NULL
-          AND pa.collaborator_id = $2
+          AND (
+            pa.collaborator_id = $2
+            OR t.project_id IN (
+              SELECT pa2.project_id FROM operations_project_assignment pa2
+               WHERE pa2.collaborator_id = $2 AND pa2.deleted_at IS NULL
+            )
+          )
         LIMIT 1`,
       taskId,
       collaboratorId
@@ -7168,8 +7548,14 @@ export class OperationsService {
       id: number;
       name: string;
       description: string | null;
+      priority: string;
       status: string;
-      projectAssignmentId: number;
+      dueDate: string | null;
+      estimateHours: number | null;
+      position: number;
+      tags: string | null;
+      assigneeCollaboratorId: number | null;
+      projectAssignmentId: number | null;
       projectId: number;
       projectName: string;
       projectCode: string | null;
@@ -7184,12 +7570,127 @@ export class OperationsService {
     return task[0];
   }
 
-  private async getTaskOptionById(collaboratorId: number, taskId: number) {
-    const task = await this.getOwnedTaskRecord(this.prisma, collaboratorId, taskId);
-    return {
-      ...task,
-      label: [task.name, task.projectName].filter(Boolean).join(' • '),
-    };
+  private async getTaskRecordForActor(
+    client: any,
+    actor: ActorContext,
+    taskId: number
+  ) {
+    if (actor.collaboratorId && !actor.isDirector && !actor.isSupervisor) {
+      return this.getOwnedTaskRecord(client, actor.collaboratorId, taskId);
+    }
+
+    const task = await this.getProjectBoardTask(taskId);
+    if (!task?.projectId) {
+      throw new NotFoundException('Task not found.');
+    }
+
+    return task;
+  }
+
+  async listProjectBoardTasks(userId: number, projectId: number) {
+    const actor = await this.getActorContext(userId);
+    this.ensureCollaborator(actor);
+    await this.assertProjectAccess(actor, projectId);
+
+    const rows = await this.queryRows<{
+      id: number;
+      name: string;
+      description: string | null;
+      priority: string;
+      status: string;
+      dueDate: string | null;
+      estimateHours: number | null;
+      position: number;
+      tags: string | null;
+      assigneeCollaboratorId: number | null;
+      assigneeName: string | null;
+      assigneeUserPhotoId: number | null;
+      assigneePersonAvatarId: number | null;
+      projectAssignmentId: number | null;
+      createdAt: string;
+    }>(
+      `SELECT t.id,
+              t.name,
+              t.description,
+              t.priority,
+              t.status,
+              t.due_date AS "dueDate",
+              t.estimate_hours AS "estimateHours",
+              t.position,
+              t.tags,
+              t.assignee_collaborator_id AS "assigneeCollaboratorId",
+              ac.display_name AS "assigneeName",
+              au.photo_id AS "assigneeUserPhotoId",
+              ap.avatar_id AS "assigneePersonAvatarId",
+              t.project_assignment_id AS "projectAssignmentId",
+              t.created_at AS "createdAt"
+         FROM operations_task t
+         LEFT JOIN operations_collaborator ac
+           ON ac.id = t.assignee_collaborator_id AND ac.deleted_at IS NULL
+         LEFT JOIN "user" au
+           ON au.id = ac.user_id
+         LEFT JOIN person ap
+           ON ap.id = ac.person_id
+        WHERE COALESCE(t.project_id, (
+                SELECT pa.project_id FROM operations_project_assignment pa
+                 WHERE pa.id = t.project_assignment_id AND pa.deleted_at IS NULL
+                 LIMIT 1
+              )) = $1
+          AND t.deleted_at IS NULL
+        ORDER BY t.status ASC, t.position ASC, t.id ASC`,
+      [projectId]
+    );
+
+    return rows;
+  }
+
+  private async getProjectBoardTask(taskId: number) {
+    const rows = await this.queryRows<{
+      id: number;
+      name: string;
+      description: string | null;
+      priority: string;
+      status: string;
+      dueDate: string | null;
+      estimateHours: number | null;
+      position: number;
+      tags: string | null;
+      assigneeCollaboratorId: number | null;
+      assigneeName: string | null;
+      assigneeUserPhotoId: number | null;
+      assigneePersonAvatarId: number | null;
+      projectAssignmentId: number | null;
+      projectId: number | null;
+      createdAt: string;
+    }>(
+      `SELECT t.id,
+              t.name,
+              t.description,
+              t.priority,
+              t.status,
+              t.due_date AS "dueDate",
+              t.estimate_hours AS "estimateHours",
+              t.position,
+              t.tags,
+              t.assignee_collaborator_id AS "assigneeCollaboratorId",
+              ac.display_name AS "assigneeName",
+              au.photo_id AS "assigneeUserPhotoId",
+              ap.avatar_id AS "assigneePersonAvatarId",
+              t.project_assignment_id AS "projectAssignmentId",
+              COALESCE(t.project_id, pa.project_id) AS "projectId",
+              t.created_at AS "createdAt"
+         FROM operations_task t
+         LEFT JOIN operations_collaborator ac
+           ON ac.id = t.assignee_collaborator_id AND ac.deleted_at IS NULL
+         LEFT JOIN "user" au ON au.id = ac.user_id
+         LEFT JOIN person ap ON ap.id = ac.person_id
+         LEFT JOIN operations_project_assignment pa
+           ON pa.id = t.project_assignment_id AND pa.deleted_at IS NULL
+        WHERE t.id = $1`,
+      [taskId]
+    );
+
+    return rows[0] ?? null;
   }
 
   private async getOrCreateTimesheetForWorkDate(
@@ -7377,23 +7878,26 @@ export class OperationsService {
     const assignmentIds = entries
       .map((entry) => entry.projectAssignmentId)
       .filter((value): value is number => typeof value === 'number');
+    const assignmentMap = new Map<
+      number,
+      { id: number; collaboratorId: number; projectId: number }
+    >();
 
     if (assignmentIds.length) {
       const assignments = (await client.$queryRawUnsafe(
-        `SELECT id, collaborator_id AS "collaboratorId"
+        `SELECT id,
+                collaborator_id AS "collaboratorId",
+                project_id AS "projectId"
            FROM operations_project_assignment
           WHERE id = ANY($1::int[])
             AND deleted_at IS NULL`,
         assignmentIds
-      )) as { id: number; collaboratorId: number }[];
-      const assignmentMap = new Map(
-        assignments.map((assignment) => [
-          assignment.id,
-          assignment.collaboratorId,
-        ])
-      );
+      )) as { id: number; collaboratorId: number; projectId: number }[];
+      assignments.forEach((assignment) => {
+        assignmentMap.set(assignment.id, assignment);
+      });
       for (const assignmentId of assignmentIds) {
-        if (assignmentMap.get(assignmentId) !== collaboratorId) {
+        if (assignmentMap.get(assignmentId)?.collaboratorId !== collaboratorId) {
           throw new ForbiddenException(
             'Timesheet entries must use assignments owned by the target collaborator.'
           );
@@ -7407,14 +7911,17 @@ export class OperationsService {
       const resolvedTask = entry.taskId
         ? await this.getOwnedTaskRecord(client, collaboratorId, entry.taskId)
         : null;
+      const selectedAssignment = entry.projectAssignmentId
+        ? assignmentMap.get(entry.projectAssignmentId) ?? null
+        : null;
 
       if (
         resolvedTask &&
-        entry.projectAssignmentId &&
-        resolvedTask.projectAssignmentId !== entry.projectAssignmentId
+        selectedAssignment &&
+        resolvedTask.projectId !== selectedAssignment.projectId
       ) {
         throw new BadRequestException(
-          'The selected task does not belong to the chosen project assignment.'
+          'The selected task does not belong to the chosen project.'
         );
       }
 
@@ -7488,6 +7995,37 @@ export class OperationsService {
     );
   }
 
+  private async cleanupEmptyEditableTimesheet(client: any, timesheetId: number) {
+    const candidate = (await client.$queryRawUnsafe(
+      `SELECT t.id
+         FROM operations_timesheet t
+        WHERE t.id = $1
+          AND t.deleted_at IS NULL
+          AND t.status IN ('draft', 'rejected')
+          AND NOT EXISTS (
+            SELECT 1
+              FROM operations_timesheet_entry e
+             WHERE e.timesheet_id = t.id
+               AND e.deleted_at IS NULL
+          )
+        LIMIT 1`,
+      timesheetId
+    )) as Array<{ id: number }>;
+
+    if (!candidate[0]?.id) {
+      return;
+    }
+
+    await client.$executeRawUnsafe(
+      `UPDATE operations_timesheet
+          SET deleted_at = NOW(),
+              updated_at = NOW()
+        WHERE id = $1
+          AND deleted_at IS NULL`,
+      timesheetId
+    );
+  }
+
   private async upsertApproval(
     client: any,
     input: {
@@ -8055,6 +8593,146 @@ export class OperationsService {
     );
   }
 
+  private async syncHiringContractDraft(
+    client: any,
+    updatedByUserId: number,
+    collaboratorId: number,
+    data: Partial<CollaboratorPayload>
+  ) {
+    const collaborator = await client.$queryRawUnsafe(
+      `SELECT c.id,
+              c.code,
+              COALESCE(NULLIF(c.display_name, ''), person_record.name) AS "displayName",
+              collaborator_type.slug AS "collaboratorTypeSlug",
+              c.supervisor_collaborator_id AS "supervisorCollaboratorId",
+              c.joined_at AS "joinedAt",
+              c.weekly_capacity_hours AS "weeklyCapacityHours"
+         FROM operations_collaborator c
+         LEFT JOIN person person_record
+           ON person_record.id = c.person_id
+         LEFT JOIN operations_collaborator_type collaborator_type
+           ON collaborator_type.id = c.collaborator_type_id
+          AND collaborator_type.deleted_at IS NULL
+        WHERE c.id = $1
+          AND c.deleted_at IS NULL
+        LIMIT 1`,
+      collaboratorId
+    ) as Array<{
+      id: number;
+      code: string | null;
+      displayName: string | null;
+      collaboratorTypeSlug: string | null;
+      supervisorCollaboratorId: number | null;
+      joinedAt: string | null;
+      weeklyCapacityHours: number | null;
+    }>;
+
+    const currentCollaborator = collaborator[0] ?? null;
+
+    if (!currentCollaborator) {
+      throw new NotFoundException('Collaborator not found.');
+    }
+
+    const hiringContracts = (await client.$queryRawUnsafe(
+      `SELECT id,
+              budget_amount AS "budgetAmount",
+              description
+         FROM operations_contract
+        WHERE related_collaborator_id = $1
+          AND origin_type = 'employee_hiring'
+          AND deleted_at IS NULL
+        ORDER BY created_at DESC
+        LIMIT 1`,
+      collaboratorId
+    )) as Array<{
+      id: number;
+      budgetAmount: number | null;
+      description: string | null;
+    }>;
+
+    const hiringContract = hiringContracts[0] ?? null;
+    const collaboratorCode =
+      this.normalizeOptionalText(currentCollaborator.code) ??
+      `COL-${collaboratorId}`;
+    const displayName =
+      this.normalizeOptionalText(currentCollaborator.displayName) ??
+      `Collaborator ${collaboratorId}`;
+    const collaboratorTypeSlug =
+      this.normalizeOptionalText(currentCollaborator.collaboratorTypeSlug) ??
+      'other';
+    const startDate =
+      data.joinedAt !== undefined
+        ? data.joinedAt ?? null
+        : currentCollaborator.joinedAt ?? null;
+    const weeklyCapacityHours =
+      data.weeklyCapacityHours !== undefined
+        ? data.weeklyCapacityHours ?? null
+        : currentCollaborator.weeklyCapacityHours ?? null;
+    const compensationAmount =
+      data.compensationAmount !== undefined
+        ? data.compensationAmount ?? null
+        : hiringContract?.budgetAmount ?? null;
+    const description =
+      data.contractDescription !== undefined
+        ? this.normalizeOptionalText(data.contractDescription)
+        : hiringContract?.description ?? null;
+    const supervisorCollaboratorId =
+      data.supervisorCollaboratorId !== undefined
+        ? data.supervisorCollaboratorId ?? null
+        : currentCollaborator.supervisorCollaboratorId ?? null;
+
+    if (!hiringContract) {
+      if (data.autoGenerateContractDraft === false) {
+        return;
+      }
+
+      await this.createHiringContractDraft(client, updatedByUserId, {
+        collaboratorId,
+        collaboratorCode,
+        displayName,
+        collaboratorType: collaboratorTypeSlug,
+        supervisorCollaboratorId,
+        startDate,
+        weeklyCapacityHours,
+        compensationAmount,
+        description,
+      });
+      return;
+    }
+
+    await client.$executeRawUnsafe(
+      `UPDATE operations_contract
+          SET code = $1,
+              name = $2,
+              contract_category = $3::operations_contract_contract_category_70d553ea09_enum,
+              contract_type = $4::operations_contract_contract_type_48331e2ebf_enum,
+              client_name = $5,
+              billing_model = $6::operations_contract_billing_model_409dc7fea2_enum,
+              account_manager_collaborator_id = $7,
+              start_date = $8::date,
+              effective_date = $8::date,
+              budget_amount = $9,
+              monthly_hour_cap = $10,
+              description = $11,
+              updated_by_user_id = $12,
+              updated_at = NOW()
+        WHERE id = $13`,
+      `HIR-${collaboratorCode}`,
+      this.buildHiringContractName(displayName, collaboratorTypeSlug),
+      this.mapContractCategoryForCollaboratorType(collaboratorTypeSlug),
+      this.mapContractTypeForCollaboratorType(collaboratorTypeSlug),
+      displayName,
+      this.mapBillingModelForCollaboratorType(collaboratorTypeSlug),
+      supervisorCollaboratorId,
+      startDate ?? new Date().toISOString().slice(0, 10),
+      compensationAmount,
+      weeklyCapacityHours ? Math.round(Number(weeklyCapacityHours) * 4) : null,
+      description,
+      updatedByUserId,
+      hiringContract.id
+    );
+  }
+
   private async createProjectContractDraft(
     client: any,
     createdByUserId: number,