@hed-hog/operations 0.0.317 → 0.0.319

package/src/operations.service.ts

@@ -132,7 +132,6 @@ type CollaboratorPayload = {
   collaboratorTypeId?: number | null;
   collaboratorTypeSlug?: string | null;
   collaboratorType?: string | null;
-  department?: string | null;
   departmentId?: number | null;
   jobTitleId?: number | null;
   title?: string | null;
@@ -286,6 +285,16 @@ type ContractPayload = {
     extractionStatus?: 'pending' | 'processing' | 'completed' | 'failed' | 'skipped';
     extractionSummary?: string | null;
   } | null;
+  additionalUploadedDocuments?: Array<{
+    fileId?: number | null;
+    fileName: string;
+    mimeType: string;
+    fileContentBase64?: string | null;
+    notes?: string | null;
+    extractionStatus?: 'pending' | 'processing' | 'completed' | 'failed' | 'skipped';
+    extractionSummary?: string | null;
+  }> | null;
+  deletedDocumentIds?: number[] | null;
 };
 
 type ProposalApprovedEventPayload = {
@@ -532,6 +541,7 @@ type TaskPayload = {
   estimateHours?: number | null;
   position?: number;
   tags?: string | null;
+  archived?: boolean;
 };
 
 type QuickTimesheetEntryPayload = {
@@ -1291,7 +1301,6 @@ export class OperationsService {
         OR COALESCE(person_record.name, '') ILIKE ${searchPlaceholder}
         OR COALESCE(c.code, '') ILIKE ${searchPlaceholder}
         OR COALESCE(department_record.name, '') ILIKE ${searchPlaceholder}
-        OR COALESCE(c.department, '') ILIKE ${searchPlaceholder}
         OR COALESCE(job_title_record.name, '') ILIKE ${searchPlaceholder}
         OR COALESCE(c.title, '') ILIKE ${searchPlaceholder}
         OR COALESCE(s.display_name, '') ILIKE ${searchPlaceholder}
@@ -1310,7 +1319,7 @@ export class OperationsService {
               person_record.name AS "personName",
               person_record.avatar_id AS "personAvatarId",
               c.department_id AS "departmentId",
-              COALESCE(NULLIF(department_record.name, ''), NULLIF(c.department, '')) AS "department",
+              department_record.name AS "department",
               c.job_title_id AS "jobTitleId",
               COALESCE(NULLIF(job_title_record.name, ''), NULLIF(c.title, '')) AS "title",
               c.level_label AS "levelLabel",
@@ -1476,47 +1485,104 @@ export class OperationsService {
         OR COALESCE(person_record.name, '') ILIKE ${searchPlaceholder}
         OR COALESCE(c.code, '') ILIKE ${searchPlaceholder}
         OR COALESCE(department_record.name, '') ILIKE ${searchPlaceholder}
-        OR COALESCE(c.department, '') ILIKE ${searchPlaceholder}
         OR COALESCE(job_title_record.name, '') ILIKE ${searchPlaceholder}
         OR COALESCE(c.title, '') ILIKE ${searchPlaceholder}
         OR COALESCE(s.display_name, '') ILIKE ${searchPlaceholder}
       )`);
     }
 
+    const baseWhere = where.slice(0, 2); // access control only: deleted_at + visibility
+
     const result = await this.querySingle<{
       total: number;
       active: number;
       onLeave: number;
       withContracts: number;
+      totalSalary: string;
+      totalCosts: string;
+      avgSalaryPlusCosts: string;
+      avgSalaryPlusCostsPerCollaborator: string;
     }>(
-      `SELECT COUNT(DISTINCT c.id)::int AS total,
-              COUNT(DISTINCT c.id) FILTER (WHERE c.status = 'active')::int AS active,
-              COUNT(DISTINCT c.id) FILTER (WHERE c.status = 'on_leave')::int AS "onLeave",
-              COUNT(DISTINCT c.id) FILTER (WHERE hiring_contract.id IS NOT NULL)::int AS "withContracts"
-         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
-         LEFT JOIN operations_department department_record
-           ON department_record.id = c.department_id
-          AND department_record.deleted_at IS NULL
-         LEFT JOIN operations_job_title job_title_record
-           ON job_title_record.id = c.job_title_id
-          AND job_title_record.deleted_at IS NULL
-         LEFT JOIN operations_collaborator s
-           ON s.id = c.supervisor_collaborator_id
-         LEFT JOIN LATERAL (
-           SELECT oc.id
-             FROM operations_contract oc
-            WHERE oc.related_collaborator_id = c.id
-              AND oc.deleted_at IS NULL
-            ORDER BY CASE WHEN oc.origin_type = 'employee_hiring' THEN 0 ELSE 1 END,
-                     oc.created_at DESC
-            LIMIT 1
-         ) hiring_contract ON TRUE
-        WHERE ${where.join(' AND ')}`,
+      `WITH filtered AS (
+         SELECT DISTINCT c.id
+           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
+           LEFT JOIN operations_department department_record
+             ON department_record.id = c.department_id
+            AND department_record.deleted_at IS NULL
+           LEFT JOIN operations_job_title job_title_record
+             ON job_title_record.id = c.job_title_id
+            AND job_title_record.deleted_at IS NULL
+           LEFT JOIN operations_collaborator s
+             ON s.id = c.supervisor_collaborator_id
+          WHERE ${where.join(' AND ')}
+       ),
+       global_filtered AS (
+         SELECT DISTINCT c.id,
+                COALESCE(hc.budget_amount, 0) AS salary
+           FROM operations_collaborator c
+           LEFT JOIN LATERAL (
+             SELECT oc.budget_amount
+               FROM operations_contract oc
+              WHERE oc.related_collaborator_id = c.id
+                AND oc.deleted_at IS NULL
+              ORDER BY CASE WHEN oc.origin_type = 'employee_hiring' THEN 0 ELSE 1 END,
+                       oc.created_at DESC
+              LIMIT 1
+           ) hc ON TRUE
+          WHERE ${baseWhere.join(' AND ')}
+       ),
+       global_cost_totals AS (
+         SELECT cc.collaborator_id,
+                COALESCE(SUM(cc.amount), 0) AS total_cost
+           FROM operations_collaborator_cost cc
+          WHERE cc.collaborator_id IN (SELECT id FROM global_filtered)
+          GROUP BY cc.collaborator_id
+       ),
+       global_count AS (
+         SELECT COUNT(*)::int AS cnt FROM global_filtered
+       ),
+       agg AS (
+         SELECT
+           (SELECT COUNT(*)::int FROM filtered) AS total,
+           COUNT(DISTINCT c.id) FILTER (WHERE c.status = 'active')::int AS active,
+           COUNT(DISTINCT c.id) FILTER (WHERE c.status = 'on_leave')::int AS "onLeave",
+           COUNT(DISTINCT c.id) FILTER (WHERE hc.id IS NOT NULL)::int AS "withContracts"
+           FROM operations_collaborator c
+           LEFT JOIN LATERAL (
+             SELECT oc.id
+               FROM operations_contract oc
+              WHERE oc.related_collaborator_id = c.id
+                AND oc.deleted_at IS NULL
+              ORDER BY CASE WHEN oc.origin_type = 'employee_hiring' THEN 0 ELSE 1 END,
+                       oc.created_at DESC
+              LIMIT 1
+           ) hc ON TRUE
+          WHERE c.id IN (SELECT id FROM filtered)
+       )
+       SELECT
+         agg.total,
+         agg.active,
+         agg."onLeave",
+         agg."withContracts",
+         COALESCE((SELECT SUM(f.salary) FROM global_filtered f), 0)::text AS "totalSalary",
+         COALESCE((SELECT SUM(ct.total_cost) FROM global_cost_totals ct), 0)::text AS "totalCosts",
+         (
+           COALESCE((SELECT SUM(f.salary) FROM global_filtered f), 0) +
+           COALESCE((SELECT SUM(ct.total_cost) FROM global_cost_totals ct), 0)
+         )::text AS "avgSalaryPlusCosts",
+         CASE WHEN (SELECT cnt FROM global_count) > 0
+           THEN (
+             COALESCE((SELECT SUM(f.salary) FROM global_filtered f), 0) +
+             COALESCE((SELECT SUM(ct.total_cost) FROM global_cost_totals ct), 0)
+           ) / (SELECT cnt FROM global_count)
+           ELSE 0
+         END::text AS "avgSalaryPlusCostsPerCollaborator"
+       FROM agg`,
       params
     );
 
@@ -1525,6 +1591,10 @@ export class OperationsService {
       active: Number(result?.active ?? 0),
       onLeave: Number(result?.onLeave ?? 0),
       withContracts: Number(result?.withContracts ?? 0),
+      totalSalary: Number(result?.totalSalary ?? 0),
+      totalCosts: Number(result?.totalCosts ?? 0),
+      avgSalaryPlusCosts: Number(result?.avgSalaryPlusCosts ?? 0),
+      avgSalaryPlusCostsPerCollaborator: Number(result?.avgSalaryPlusCostsPerCollaborator ?? 0),
     };
   }
 
@@ -1575,7 +1645,7 @@ export class OperationsService {
               person_record.name AS "personName",
               person_record.avatar_id AS "personAvatarId",
               c.department_id AS "departmentId",
-              COALESCE(NULLIF(department_record.name, ''), NULLIF(c.department, '')) AS "department",
+              department_record.name AS "department",
               c.job_title_id AS "jobTitleId",
               COALESCE(NULLIF(job_title_record.name, ''), NULLIF(c.title, '')) AS "title",
               c.status,
@@ -1805,7 +1875,6 @@ export class OperationsService {
         tx as any,
         {
           departmentId: data.departmentId ?? null,
-          departmentName: data.department,
         }
       );
       const resolvedJobTitle = await this.resolveJobTitleReference(tx as any, {
@@ -1829,7 +1898,6 @@ export class OperationsService {
           code,
           collaborator_type_id,
           display_name,
-          department,
           department_id,
           job_title_id,
           title,
@@ -1843,9 +1911,9 @@ export class OperationsService {
           updated_at
         ) VALUES (
           $1, $2, $3, $4, $5,
-          $6, $7, $8, $9, $10, $11, $12,
-          $13::operations_collaborator_status_ef779877d4_enum,
-          $14::date, $15::date, $16, NOW(), NOW()
+          $6, $7, $8, $9, $10, $11,
+          $12::operations_collaborator_status_ef779877d4_enum,
+          $13::date, $14::date, $15, NOW(), NOW()
         )
         RETURNING id`,
         data.userId ?? null,
@@ -1854,7 +1922,6 @@ export class OperationsService {
         normalizedCode,
         resolvedCollaboratorType?.id ?? null,
         resolvedDisplayName,
-        resolvedDepartment?.name ?? null,
         resolvedDepartment?.id ?? null,
         resolvedJobTitle?.id ?? null,
         resolvedJobTitle?.name ?? this.normalizeOptionalText(data.title),
@@ -1894,6 +1961,16 @@ export class OperationsService {
         });
       }
 
+      if (data.compensationAmount != null) {
+        await this.insertCollaboratorCompensationHistory(
+          tx as any,
+          createdCollaboratorId,
+          Number(data.compensationAmount),
+          actor.userId,
+          null
+        );
+      }
+
       return createdCollaboratorId;
     });
 
@@ -1967,16 +2044,14 @@ export class OperationsService {
         );
       }
 
-      if (data.department !== undefined || data.departmentId !== undefined) {
+      if (data.departmentId !== undefined) {
         const resolvedDepartment = await this.resolveDepartmentReference(
           tx as any,
           {
             departmentId: data.departmentId ?? null,
-            departmentName: data.department,
           }
         );
 
-        this.pushUpdate(updates, params, 'department', resolvedDepartment?.name ?? null);
         this.pushUpdate(
           updates,
           params,
@@ -2055,12 +2130,59 @@ export class OperationsService {
           collaboratorId,
           data
         );
+
+        if (
+          data.compensationAmount !== undefined &&
+          data.compensationAmount !== null
+        ) {
+          await this.insertCollaboratorCompensationHistory(
+            tx as any,
+            collaboratorId,
+            Number(data.compensationAmount),
+            actor.userId,
+            null
+          );
+        }
       }
     });
 
     return this.getCollaboratorByIdForUser(userId, collaboratorId);
   }
 
+  async getCollaboratorCompensationHistory(
+    userId: number,
+    collaboratorId: number
+  ) {
+    const actor = await this.getActorContext(userId);
+    this.ensureDirector(actor);
+    await this.getCollaboratorById(collaboratorId);
+
+    return this.queryRows<{
+      id: number;
+      collaboratorId: number;
+      amount: string;
+      effectiveDate: string | null;
+      actorUserId: number | null;
+      actorName: string | null;
+      notes: string | null;
+      createdAt: string;
+    }>(
+      `SELECT h.id,
+              h.collaborator_id AS "collaboratorId",
+              h.amount::text AS amount,
+              h.effective_date::text AS "effectiveDate",
+              h.actor_user_id AS "actorUserId",
+              u.name AS "actorName",
+              h.notes,
+              h.created_at AS "createdAt"
+         FROM operations_collaborator_compensation_history h
+         LEFT JOIN "user" u ON u.id = h.actor_user_id
+        WHERE h.collaborator_id = $1
+        ORDER BY h.created_at DESC`,
+      [collaboratorId]
+    );
+  }
+
   async listDepartments(
     userId: number,
     filters: {
@@ -2114,13 +2236,7 @@ export class OperationsService {
        FROM operations_department d
        LEFT JOIN operations_collaborator c
          ON c.deleted_at IS NULL
-        AND (
-          c.department_id = d.id
-          OR (
-            c.department_id IS NULL
-            AND LOWER(COALESCE(c.department, '')) = LOWER(d.name)
-          )
-        )
+        AND c.department_id = d.id
       ${whereClause}
       GROUP BY d.id`;
 
@@ -2373,10 +2489,22 @@ export class OperationsService {
       sortField?: string;
       sortOrder?: string;
       status?: string;
+      myOnly?: boolean;
     } = {}
   ) {
     const actor = await this.getActorContext(userId);
-    const filter = this.buildIdFilter(actor.visibleProjectIds, 'p.id', actor.isDirector);
+    const myOnly = filters.myOnly === true;
+    // When myOnly=true: restrict to projects the current collaborator is assigned to.
+    // Otherwise (general list): show all projects in the system regardless of role scope.
+    const filter = myOnly
+      ? this.buildIdFilter(
+          actor.collaboratorId
+            ? await this.getAssignedProjectIds([actor.collaboratorId])
+            : [],
+          'p.id',
+          false
+        )
+      : this.buildIdFilter([], 'p.id', true);
     const assignmentParams: unknown[] = [];
     const ownAssignmentSelect = actor.collaboratorId
       ? `MAX(CASE WHEN pa.collaborator_id = ${this.param(
@@ -2398,14 +2526,26 @@ export class OperationsService {
       : null;
 
     const params: unknown[] = [...assignmentParams, ...filter.params];
-    const where = ['p.deleted_at IS NULL', filter.clause];
+    const totalParams: unknown[] = [...filter.params];
+    const where = [
+      'p.deleted_at IS NULL',
+      this.shiftSqlPlaceholders(filter.clause, assignmentParams.length),
+    ];
+    const totalWhere = ['p.deleted_at IS NULL', filter.clause];
 
     if (filters.status && filters.status !== 'all') {
       where.push(`p.status::text = ${this.param(params, filters.status)}`);
+      totalWhere.push(
+        `p.status::text = ${this.param(totalParams, filters.status)}`
+      );
     }
 
     if (pagination?.search) {
       const searchPlaceholder = this.param(params, `%${pagination.search}%`);
+      const totalSearchPlaceholder = this.param(
+        totalParams,
+        `%${pagination.search}%`
+      );
       where.push(`(
         COALESCE(p.name, '') ILIKE ${searchPlaceholder}
         OR COALESCE(p.code, '') ILIKE ${searchPlaceholder}
@@ -2413,9 +2553,17 @@ export class OperationsService {
         OR COALESCE(c.name, '') ILIKE ${searchPlaceholder}
         OR COALESCE(m.display_name, '') ILIKE ${searchPlaceholder}
       )`);
+      totalWhere.push(`(
+        COALESCE(p.name, '') ILIKE ${totalSearchPlaceholder}
+        OR COALESCE(p.code, '') ILIKE ${totalSearchPlaceholder}
+        OR COALESCE(p.client_name, '') ILIKE ${totalSearchPlaceholder}
+        OR COALESCE(c.name, '') ILIKE ${totalSearchPlaceholder}
+        OR COALESCE(m.display_name, '') ILIKE ${totalSearchPlaceholder}
+      )`);
     }
 
     const whereClause = where.join(' AND ');
+    const totalWhereClause = totalWhere.join(' AND ');
     const baseQuery = `SELECT p.id,
               p.contract_id AS "contractId",
               p.manager_collaborator_id AS "managerCollaboratorId",
@@ -2453,8 +2601,8 @@ 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
-        WHERE ${whereClause}`,
-      params
+        WHERE ${totalWhereClause}`,
+      totalParams
     );
 
     const sortColumn =
@@ -2601,25 +2749,40 @@ export class OperationsService {
       projectId?: number;
       projectAssignmentId?: number;
       status?: string;
+      myOnly?: boolean;
+      archived?: boolean;
     }
   ) {
     const actor = await this.getActorContext(userId);
     this.ensureCollaborator(actor);
 
+    const myOnly = paginationParams.myOnly === true;
+    const archivedOnly = paginationParams.archived === true;
+
     const pagination = this.normalizePaginationParams(paginationParams, {
       defaultSortField: 'name',
       defaultSortOrder: 'asc',
       allowedSortFields: ['name', 'projectName', 'status', 'createdAt'],
     });
 
-    const projectFilter = this.buildIdFilter(
-      actor.visibleProjectIds,
-      'COALESCE(t.project_id, pa.project_id)',
-      actor.isDirector
-    );
+    // When myOnly=true: restrict to tasks linked to the current collaborator's assignment.
+    // Otherwise (general list): show all tasks in the system regardless of role scope.
+    const projectFilter = myOnly
+      ? this.buildIdFilter(
+          actor.collaboratorId
+            ? await this.getAssignedProjectIds([actor.collaboratorId])
+            : [],
+          'COALESCE(t.project_id, pa.project_id)',
+          false
+        )
+      : this.buildIdFilter(
+          [],
+          'COALESCE(t.project_id, pa.project_id)',
+          true
+        );
     const params: unknown[] = [...projectFilter.params];
     const filters = [
-      't.deleted_at IS NULL',
+      archivedOnly ? 't.deleted_at IS NOT NULL' : 't.deleted_at IS NULL',
       'p.deleted_at IS NULL',
       projectFilter.clause,
       `(
@@ -2644,6 +2807,8 @@ export class OperationsService {
 
     if (paginationParams.projectAssignmentId) {
       filters.push(`pa.id = ${this.param(params, paginationParams.projectAssignmentId)}`);
+    } else if (myOnly && actor.collaboratorId) {
+      filters.push(`pa.collaborator_id = ${this.param(params, actor.collaboratorId)}`);
     }
 
     if (paginationParams.projectId) {
@@ -2688,24 +2853,47 @@ export class OperationsService {
       name: string;
       description: string | null;
       status: string;
+      priority: string;
       projectId: number;
-      projectAssignmentId: number;
+      projectAssignmentId: number | null;
       projectName: string;
       projectCode: string | null;
+      dueDate: string | null;
+      estimateHours: number | null;
+      tags: string | null;
+      assigneeName: string | null;
+      assigneeUserPhotoId: number | null;
+      assigneePersonAvatarId: number | null;
       createdAt: string;
+      deletedAt: string | null;
     }>(
       `SELECT t.id,
               t.name,
               t.description,
               t.status,
+              t.priority,
               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"
+              t.due_date AS "dueDate",
+              t.estimate_hours AS "estimateHours",
+              t.tags,
+              ac.display_name AS "assigneeName",
+              au.photo_id AS "assigneeUserPhotoId",
+              ap.avatar_id AS "assigneePersonAvatarId",
+              t.created_at AS "createdAt",
+              t.deleted_at AS "deletedAt"
          FROM operations_task t
          LEFT JOIN operations_project_assignment pa
            ON pa.id = t.project_assignment_id
+         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
          JOIN operations_project p
            ON p.id = COALESCE(t.project_id, pa.project_id)
         WHERE ${whereClause}
@@ -2801,7 +2989,7 @@ export class OperationsService {
       [
         projectId,
         assignmentId,
-        data.assigneeCollaboratorId ?? null,
+        data.assigneeCollaboratorId ?? actor.collaboratorId ?? null,
         name,
         this.normalizeOptionalText(data.description),
         data.priority ?? 'medium',
@@ -2847,6 +3035,14 @@ export class OperationsService {
     await this.prisma.$transaction(async (tx) => {
       let nextAssignmentId = current.projectAssignmentId;
       let nextProjectId = current.projectId;
+      const nextArchived =
+        data.archived !== undefined ? data.archived : Boolean(current.deletedAt);
+      const nextStatus =
+        data.status !== undefined
+          ? data.status
+          : current.deletedAt && data.archived === false
+            ? 'todo'
+            : current.status;
 
       if (data.projectId !== undefined || data.projectAssignmentId !== undefined) {
         const nextAssignment = await this.resolveProjectAssignmentForActor(
@@ -2875,9 +3071,13 @@ export class OperationsService {
                 estimate_hours = $9::decimal,
                 position = $10,
                 tags = $11,
+                deleted_at = CASE
+                  WHEN $12::boolean THEN COALESCE(deleted_at, NOW())
+                  ELSE NULL
+                END,
                 updated_at = NOW()
-          WHERE id = $12
-            AND deleted_at IS NULL`,
+          WHERE id = $13
+            AND ($14::boolean = true OR deleted_at IS NULL)`,
         nextProjectId,
         nextAssignmentId,
         data.assigneeCollaboratorId !== undefined
@@ -2888,19 +3088,21 @@ export class OperationsService {
           ? this.normalizeOptionalText(data.description)
           : (current.description ?? null),
         data.priority ?? current.priority,
-        data.status ?? current.status,
+        nextStatus,
         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
+        nextArchived,
+        taskId,
+        Boolean(current.deletedAt)
       );
     });
 
     return this.getProjectBoardTask(taskId);
   }
 
-  async removeTask(userId: number, taskId: number) {
+  async removeTask(userId: number, taskId: number, permanent = false) {
     const actor = await this.getActorContext(userId);
     if (!actor.isCollaborator && !actor.isDirector && !actor.isSupervisor) {
       throw new ForbiddenException(
@@ -2916,6 +3118,15 @@ export class OperationsService {
     await this.assertProjectAccess(actor, current.projectId);
 
     await this.prisma.$transaction(async (tx) => {
+      if (permanent) {
+        await (tx as any).$executeRawUnsafe(
+          `DELETE FROM operations_task
+            WHERE id = $1`,
+          taskId
+        );
+        return;
+      }
+
       await (tx as any).$executeRawUnsafe(
         `UPDATE operations_task
             SET deleted_at = COALESCE(deleted_at, NOW()),
@@ -3198,6 +3409,11 @@ export class OperationsService {
       )) as { id: number }[];
 
       await this.refreshTimesheetTotal(tx as any, timesheetId);
+      await this.submitTimesheetForApproval(
+        tx as any,
+        timesheetId,
+        actor.collaboratorId as number
+      );
       return created[0]?.id ?? 0;
     });
 
@@ -3225,9 +3441,9 @@ export class OperationsService {
       );
     }
 
-    if (!['draft', 'rejected'].includes(entry.status)) {
+    if (entry.status === 'approved') {
       throw new BadRequestException(
-        'Only draft or rejected timesheet entries can be edited.'
+        'Approved timesheet entries can no longer be edited.'
       );
     }
 
@@ -3309,6 +3525,11 @@ export class OperationsService {
       }
 
       await this.cleanupEmptyEditableTimesheet(tx as any, entry.timesheetId);
+      await this.submitTimesheetForApproval(
+        tx as any,
+        targetTimesheetId,
+        collaboratorId
+      );
     });
 
     return this.getTimesheetEntryByIdForActor(actor, entryId);
@@ -3330,9 +3551,9 @@ export class OperationsService {
       );
     }
 
-    if (!['draft', 'rejected'].includes(entry.status)) {
+    if (entry.status === 'approved') {
       throw new BadRequestException(
-        'Only draft or rejected timesheet entries can be deleted.'
+        'Approved timesheet entries can no longer be deleted.'
       );
     }
 
@@ -3981,6 +4202,14 @@ export class OperationsService {
           data.replaceUploadedPdfDocument
         );
       }
+      if (data.additionalUploadedDocuments?.length) {
+        await this.appendContractDocuments(
+          tx as any,
+          contractId,
+          'attachment',
+          data.additionalUploadedDocuments
+        );
+      }
       await this.insertContractHistory(
         tx as any,
         contractId,
@@ -4562,6 +4791,21 @@ export class OperationsService {
           data.replaceUploadedPdfDocument
         );
       }
+      if (data.additionalUploadedDocuments?.length) {
+        await this.appendContractDocuments(
+          tx as any,
+          contractId,
+          'attachment',
+          data.additionalUploadedDocuments
+        );
+      }
+      if (data.deletedDocumentIds?.length) {
+        await this.softDeleteContractDocuments(
+          tx as any,
+          contractId,
+          data.deletedDocumentIds
+        );
+      }
 
       await this.insertContractHistory(
         tx as any,
@@ -4571,6 +4815,16 @@ export class OperationsService {
         'Contract registry data updated.'
       );
 
+      if (data.deletedDocumentIds?.length) {
+        await this.insertContractHistory(
+          tx as any,
+          contractId,
+          userId,
+          'updated',
+          'Contract documents removed.'
+        );
+      }
+
       if (shouldPublishSigned || shouldPublishActivation) {
         const contractEventPayload = await this.buildContractActivatedEventPayload(
           {
@@ -4721,6 +4975,8 @@ export class OperationsService {
       sortField?: string;
       sortOrder?: string;
       status?: string;
+      dateFrom?: string;
+      dateTo?: string;
     } = {}
   ) {
     const actor = await this.getActorContext(userId);
@@ -4739,6 +4995,14 @@ export class OperationsService {
       where.push(`t.status::text = ${this.param(params, filters.status)}`);
     }
 
+    if (filters.dateFrom) {
+      where.push(`t.week_start_date >= ${this.param(params, filters.dateFrom)}::date`);
+    }
+
+    if (filters.dateTo) {
+      where.push(`t.week_start_date <= ${this.param(params, filters.dateTo)}::date`);
+    }
+
     if (pagination?.search) {
       const searchPlaceholder = this.param(params, `%${pagination.search}%`);
       where.push(`(
@@ -4784,8 +5048,8 @@ export class OperationsService {
               c.display_name AS "collaboratorName",
               t.approver_collaborator_id AS "approverCollaboratorId",
               a.display_name AS "approverName",
-              t.week_start_date AS "weekStartDate",
-              t.week_end_date AS "weekEndDate",
+              TO_CHAR(t.week_start_date, 'YYYY-MM-DD') AS "weekStartDate",
+              TO_CHAR(t.week_end_date, 'YYYY-MM-DD') AS "weekEndDate",
               t.total_hours AS "totalHours",
               t.status,
               t.submitted_at AS "submittedAt",
@@ -4955,8 +5219,8 @@ export class OperationsService {
     if (!actor.isDirector && current.collaboratorId !== actor.collaboratorId) {
       throw new ForbiddenException('You can only update your own timesheets.');
     }
-    if (!actor.isDirector && !['draft', 'rejected'].includes(current.status)) {
-      throw new BadRequestException('Only draft or rejected timesheets can be edited.');
+    if (!actor.isDirector && current.status === 'approved') {
+      throw new BadRequestException('Approved timesheets can no longer be edited.');
     }
 
     await this.prisma.$transaction(async (tx) => {
@@ -4998,71 +5262,17 @@ export class OperationsService {
     if (!actor.isDirector && current.collaboratorId !== actor.collaboratorId) {
       throw new ForbiddenException('You can only submit your own timesheets.');
     }
-    if (!actor.isDirector && !['draft', 'rejected'].includes(current.status)) {
-      throw new BadRequestException('Only draft or rejected timesheets can be submitted.');
-    }
-
-    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 =
-      projectManagerRow?.managerCollaboratorId ??
-      current.approverCollaboratorId ??
-      collaborator.supervisorId ??
-      null;
-
-    if (!approverId) {
-      throw new BadRequestException(
-        'An approver is required before submitting a timesheet.'
-      );
-    }
-
-    const activeEntries = await this.querySingle<{ exists: boolean }>(
-      `SELECT EXISTS (
-          SELECT 1
-            FROM operations_timesheet_entry
-           WHERE timesheet_id = $1
-             AND deleted_at IS NULL
-        ) AS exists`,
-      [timesheetId]
-    );
-
-    if (!activeEntries?.exists) {
-      throw new BadRequestException(
-        'Cannot submit a timesheet without active entries.'
-      );
+    if (!actor.isDirector && current.status === 'approved') {
+      throw new BadRequestException('Approved timesheets can no longer be submitted.');
     }
 
     await this.prisma.$transaction(async (tx) => {
-      await (tx as any).$executeRawUnsafe(
-        `UPDATE operations_timesheet
-            SET status = 'submitted',
-                approver_collaborator_id = $1,
-                submitted_at = NOW(),
-                updated_at = NOW()
-          WHERE id = $2`,
-        approverId,
-        timesheetId
+      await this.submitTimesheetForApproval(
+        tx as any,
+        timesheetId,
+        current.collaboratorId,
+        current.approverCollaboratorId
       );
-      await this.upsertApproval(tx as any, {
-        targetType: 'timesheet',
-        targetId: timesheetId,
-        requesterCollaboratorId: current.collaboratorId,
-        approverCollaboratorId: approverId,
-      });
     });
 
     return this.listSingleTimesheet(actor, timesheetId);
@@ -5556,6 +5766,8 @@ export class OperationsService {
       sortOrder?: string;
       status?: string;
       targetType?: string;
+      dateFrom?: string;
+      dateTo?: string;
     } = {}
   ) {
     const actor = await this.getActorContext(userId);
@@ -5585,6 +5797,22 @@ export class OperationsService {
       where.push(`a.target_type = ${this.param(params, filters.targetType)}::text::operations_approval_target_type_32d3f04385_enum`);
     }
 
+    if (filters.dateFrom) {
+      where.push(`(
+        (a.target_type = 'timesheet' AND t.week_start_date >= ${this.param(params, filters.dateFrom)}::date)
+        OR (a.target_type = 'time_off_request' AND tor.start_date >= ${this.param(params, filters.dateFrom)}::date)
+        OR (a.target_type = 'schedule_adjustment_request' AND sar.effective_start_date >= ${this.param(params, filters.dateFrom)}::date)
+      )`);
+    }
+
+    if (filters.dateTo) {
+      where.push(`(
+        (a.target_type = 'timesheet' AND t.week_start_date <= ${this.param(params, filters.dateTo)}::date)
+        OR (a.target_type = 'time_off_request' AND tor.start_date <= ${this.param(params, filters.dateTo)}::date)
+        OR (a.target_type = 'schedule_adjustment_request' AND sar.effective_start_date <= ${this.param(params, filters.dateTo)}::date)
+      )`);
+    }
+
     if (pagination?.search) {
       const searchPlaceholder = this.param(params, `%${pagination.search}%`);
       where.push(`(
@@ -5608,8 +5836,8 @@ export class OperationsService {
               a.submitted_at AS "submittedAt",
               a.decided_at AS "decidedAt",
               a.decision_note AS "decisionNote",
-              t.week_start_date AS "timesheetWeekStartDate",
-              t.week_end_date AS "timesheetWeekEndDate",
+              TO_CHAR(t.week_start_date, 'YYYY-MM-DD') AS "timesheetWeekStartDate",
+              TO_CHAR(t.week_end_date, 'YYYY-MM-DD') AS "timesheetWeekEndDate",
               t.total_hours AS "timesheetTotalHours",
               COALESCE(
                 STRING_AGG(DISTINCT p.name, ', ') FILTER (WHERE p.name IS NOT NULL),
@@ -5756,8 +5984,8 @@ export class OperationsService {
               a.submitted_at AS "submittedAt",
               a.decided_at AS "decidedAt",
               a.decision_note AS "decisionNote",
-              t.week_start_date AS "timesheetWeekStartDate",
-              t.week_end_date AS "timesheetWeekEndDate",
+              TO_CHAR(t.week_start_date, 'YYYY-MM-DD') AS "timesheetWeekStartDate",
+              TO_CHAR(t.week_end_date, 'YYYY-MM-DD') AS "timesheetWeekEndDate",
               t.total_hours AS "timesheetTotalHours",
               COALESCE(
                 STRING_AGG(DISTINCT p.name, ', ') FILTER (WHERE p.name IS NOT NULL),
@@ -6116,7 +6344,7 @@ export class OperationsService {
       );
     }
 
-    const collaboratorId = collaborator?.id ?? null;
+    const collaboratorId = this.normalizeIntegerId(collaborator?.id);
     const teamCollaboratorIds =
       isSupervisor && collaboratorId
         ? await this.getDirectReportIds(collaboratorId)
@@ -6328,53 +6556,8 @@ export class OperationsService {
     client: any,
     input: {
       departmentId?: number | null;
-      departmentName?: string | null;
     }
   ) {
-    if (input.departmentName !== undefined) {
-      const normalizedDepartmentName = this.normalizeOptionalText(
-        input.departmentName
-      );
-
-      if (!normalizedDepartmentName) {
-        return null;
-      }
-
-      const existingByName = (await client.$queryRawUnsafe(
-        `SELECT id, name
-           FROM operations_department
-          WHERE deleted_at IS NULL
-            AND LOWER(name) = LOWER($1)
-          ORDER BY id ASC
-          LIMIT 1`,
-        normalizedDepartmentName
-      )) as { id: number; name: string }[];
-
-      if (existingByName[0]) {
-        return existingByName[0];
-      }
-
-      const slug = await this.generateUniqueDepartmentSlug(
-        client,
-        normalizedDepartmentName
-      );
-      const created = (await client.$queryRawUnsafe(
-        `INSERT INTO operations_department (
-          slug,
-          code,
-          name,
-          description,
-          created_at,
-          updated_at
-        ) VALUES ($1, NULL, $2, NULL, NOW(), NOW())
-        RETURNING id, name`,
-        slug,
-        normalizedDepartmentName
-      )) as { id: number; name: string }[];
-
-      return created[0] ?? null;
-    }
-
     if (
       typeof input.departmentId === 'number' &&
       Number.isInteger(input.departmentId) &&
@@ -7262,7 +7445,7 @@ export class OperationsService {
               collaborator_type.name AS "collaboratorType",
               COALESCE(NULLIF(c.display_name, ''), person_record.name) AS "displayName",
               c.department_id AS "departmentId",
-              COALESCE(NULLIF(department_record.name, ''), NULLIF(c.department, '')) AS "department",
+              department_record.name AS "department",
               c.job_title_id AS "jobTitleId",
               COALESCE(NULLIF(job_title_record.name, ''), NULLIF(c.title, '')) AS "title",
               c.level_label AS "levelLabel",
@@ -7462,8 +7645,9 @@ export class OperationsService {
   }
 
   private async getDirectReportIds(collaboratorId: number) {
-    return (
-      await this.queryRows<{ id: number }>(
+    return this.uniqueNumbers(
+      (
+        await this.queryRows<{ id: number | bigint | string }>(
         `SELECT id
            FROM operations_collaborator
           WHERE supervisor_collaborator_id = $1
@@ -7471,21 +7655,25 @@ export class OperationsService {
           ORDER BY id ASC`,
         [collaboratorId]
       )
-    ).map((row) => row.id);
+      ).map((row) => row.id)
+    );
   }
 
   private async getAssignedProjectIds(collaboratorIds: number[]) {
-    if (!collaboratorIds.length) return [];
-    return (
-      await this.queryRows<{ projectId: number }>(
+    const normalizedCollaboratorIds = this.uniqueNumbers(collaboratorIds);
+    if (!normalizedCollaboratorIds.length) return [];
+    return this.uniqueNumbers(
+      (
+        await this.queryRows<{ projectId: number | bigint | string }>(
         `SELECT DISTINCT project_id AS "projectId"
            FROM operations_project_assignment
           WHERE deleted_at IS NULL
             AND status IN ('planned', 'active')
             AND collaborator_id = ANY($1::int[])`,
-        [collaboratorIds]
+        [normalizedCollaboratorIds]
       )
-    ).map((row) => row.projectId);
+      ).map((row) => row.projectId)
+    );
   }
 
   private async resolveOwnedProjectAssignment(
@@ -7632,7 +7820,8 @@ export class OperationsService {
               t.project_assignment_id AS "projectAssignmentId",
               COALESCE(t.project_id, pa.project_id) AS "projectId",
               p.name AS "projectName",
-              p.code AS "projectCode"
+              p.code AS "projectCode",
+              t.deleted_at AS "deletedAt"
          FROM operations_task t
          LEFT JOIN operations_project_assignment pa
            ON pa.id = t.project_assignment_id
@@ -7641,7 +7830,6 @@ export class OperationsService {
            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
             OR t.project_id IN (
@@ -7667,6 +7855,7 @@ export class OperationsService {
       projectId: number;
       projectName: string;
       projectCode: string | null;
+      deletedAt: string | null;
     }>;
 
     if (!task[0]) {
@@ -7770,6 +7959,7 @@ export class OperationsService {
       projectAssignmentId: number | null;
       projectId: number | null;
       createdAt: string;
+      deletedAt: string | null;
     }>(
       `SELECT t.id,
               t.name,
@@ -7786,7 +7976,8 @@ export class OperationsService {
               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"
+              t.created_at AS "createdAt",
+              t.deleted_at AS "deletedAt"
          FROM operations_task t
          LEFT JOIN operations_collaborator ac
            ON ac.id = t.assignee_collaborator_id AND ac.deleted_at IS NULL
@@ -7807,7 +7998,8 @@ export class OperationsService {
     workDate: string
   ) {
     const normalizedWorkDate = this.normalizeDateOnly(workDate);
-    const { weekStartDate, weekEndDate } = this.getWorkWeekRange(normalizedWorkDate);
+    const { weekStartDate, weekEndDate } =
+      this.getWorkWeekRange(normalizedWorkDate);
 
     const existing = (await client.$queryRawUnsafe(
       `SELECT id, status
@@ -7824,9 +8016,9 @@ export class OperationsService {
     )) as Array<{ id: number; status: string }>;
 
     if (existing[0]) {
-      if (!['draft', 'rejected'].includes(existing[0].status)) {
+      if (existing[0].status === 'approved') {
         throw new BadRequestException(
-          'The timesheet for this week has already been submitted or approved.'
+          'The timesheet for this week has already been approved.'
         );
       }
 
@@ -8105,11 +8297,12 @@ export class OperationsService {
 
   private async cleanupEmptyEditableTimesheet(client: any, timesheetId: number) {
     const candidate = (await client.$queryRawUnsafe(
-      `SELECT t.id
+      `SELECT t.id,
+              t.status
          FROM operations_timesheet t
         WHERE t.id = $1
           AND t.deleted_at IS NULL
-          AND t.status IN ('draft', 'rejected')
+          AND t.status IN ('draft', 'rejected', 'submitted')
           AND NOT EXISTS (
             SELECT 1
               FROM operations_timesheet_entry e
@@ -8118,7 +8311,7 @@ export class OperationsService {
           )
         LIMIT 1`,
       timesheetId
-    )) as Array<{ id: number }>;
+    )) as Array<{ id: number; status: string }>;
 
     if (!candidate[0]?.id) {
       return;
@@ -8132,13 +8325,93 @@ export class OperationsService {
           AND deleted_at IS NULL`,
       timesheetId
     );
+
+    if (candidate[0].status === 'submitted') {
+      await client.$executeRawUnsafe(
+        `UPDATE operations_approval
+            SET deleted_at = NOW(),
+                updated_at = NOW()
+          WHERE target_type = 'timesheet'::operations_approval_target_type_32d3f04385_enum
+            AND target_id = $1
+            AND deleted_at IS NULL`,
+        timesheetId
+      );
+    }
   }
 
-  private async upsertApproval(
+  private async submitTimesheetForApproval(
     client: any,
-    input: {
-      targetType: ApprovalTargetType;
-      targetId: number;
+    timesheetId: number,
+    collaboratorId: number,
+    currentApproverCollaboratorId?: number | null
+  ) {
+    const collaborator = await this.getCollaboratorById(collaboratorId);
+
+    const projectManagerRow = await (client as any).$queryRawUnsafe(
+      `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
+    ) as Array<{ managerCollaboratorId: number | null }>;
+
+    const approverId =
+      projectManagerRow[0]?.managerCollaboratorId ??
+      currentApproverCollaboratorId ??
+      collaborator.supervisorId ??
+      null;
+
+    if (!approverId) {
+      throw new BadRequestException(
+        'An approver is required before submitting a timesheet.'
+      );
+    }
+
+    const activeEntries = await (client as any).$queryRawUnsafe(
+      `SELECT EXISTS (
+          SELECT 1
+            FROM operations_timesheet_entry
+           WHERE timesheet_id = $1
+             AND deleted_at IS NULL
+        ) AS exists`,
+      timesheetId
+    ) as Array<{ exists: boolean }>;
+
+    if (!activeEntries[0]?.exists) {
+      throw new BadRequestException(
+        'Cannot submit a timesheet without active entries.'
+      );
+    }
+
+    await (client as any).$executeRawUnsafe(
+      `UPDATE operations_timesheet
+          SET status = 'submitted',
+              approver_collaborator_id = $1,
+              submitted_at = NOW(),
+              updated_at = NOW()
+        WHERE id = $2
+          AND deleted_at IS NULL`,
+      approverId,
+      timesheetId
+    );
+
+    await this.upsertApproval(client, {
+      targetType: 'timesheet',
+      targetId: timesheetId,
+      requesterCollaboratorId: collaboratorId,
+      approverCollaboratorId: approverId,
+    });
+  }
+
+  private async upsertApproval(
+    client: any,
+    input: {
+      targetType: ApprovalTargetType;
+      targetId: number;
       requesterCollaboratorId: number;
       approverCollaboratorId: number | null;
     }
@@ -8930,6 +9203,73 @@ export class OperationsService {
     );
   }
 
+  private async appendContractDocuments(
+    client: any,
+    contractId: number,
+    documentType: (typeof CONTRACT_DOCUMENT_TYPE_VALUES)[number],
+    documents: NonNullable<ContractPayload['additionalUploadedDocuments']>
+  ) {
+    for (const document of documents) {
+      await client.$executeRawUnsafe(
+        `INSERT INTO operations_contract_document (
+          contract_id,
+          document_type,
+          file_id,
+          file_name,
+          mime_type,
+          file_content_base64,
+          is_current,
+          extraction_status,
+          extraction_summary,
+          notes,
+          created_at,
+          updated_at
+        ) VALUES (
+          $1, $2::operations_contract_document_document_type_15ebaff0c9_enum, $3, $4, $5, $6, false, $7::operations_contract_document_extraction_status_6d94c231f3_enum, $8, $9, NOW(), NOW()
+        )`,
+        contractId,
+        documentType,
+        document.fileId ?? null,
+        document.fileName,
+        document.mimeType,
+        document.fileContentBase64 ?? null,
+        document.extractionStatus ?? 'skipped',
+        document.extractionSummary ?? null,
+        document.notes ?? null
+      );
+    }
+  }
+
+  private async softDeleteContractDocuments(
+    client: any,
+    contractId: number,
+    documentIds: number[]
+  ) {
+    const normalizedIds = Array.from(
+      new Set(
+        documentIds.filter(
+          (value) => Number.isInteger(value) && Number(value) > 0
+        )
+      )
+    );
+
+    if (!normalizedIds.length) {
+      return;
+    }
+
+    await client.$executeRawUnsafe(
+      `UPDATE operations_contract_document
+          SET deleted_at = NOW(),
+              updated_at = NOW(),
+              is_current = false
+        WHERE contract_id = $1
+          AND id = ANY($2::int[])
+          AND deleted_at IS NULL`,
+      contractId,
+      normalizedIds
+    );
+  }
+
   private async resolveContractExtractionFile(
     userId: number,
     data: ContractExtractDraftPayload
@@ -9357,6 +9697,30 @@ export class OperationsService {
     );
   }
 
+  private async insertCollaboratorCompensationHistory(
+    client: any,
+    collaboratorId: number,
+    amount: number,
+    actorUserId: number | null,
+    notes: string | null
+  ) {
+    await client.$executeRawUnsafe(
+      `INSERT INTO operations_collaborator_compensation_history (
+        collaborator_id,
+        amount,
+        actor_user_id,
+        notes,
+        created_at
+      ) VALUES (
+        $1, $2, $3, $4, NOW()
+      )`,
+      collaboratorId,
+      amount,
+      actorUserId,
+      notes ?? null
+    );
+  }
+
   private async generateCollaboratorCode(client: any) {
     for (let attempt = 0; attempt < 5; attempt += 1) {
       const candidate = `COL-${Date.now().toString(36).toUpperCase()}${Math.random()
@@ -10012,19 +10376,9 @@ export class OperationsService {
   }
 
   private getWorkWeekRange(workDate: string) {
-    const date = this.parseDateOnly(workDate);
-    const day = date.getUTCDay();
-    const diffToMonday = day === 0 ? -6 : 1 - day;
-
-    const weekStart = new Date(date);
-    weekStart.setUTCDate(weekStart.getUTCDate() + diffToMonday);
-
-    const weekEnd = new Date(weekStart);
-    weekEnd.setUTCDate(weekStart.getUTCDate() + 6);
-
     return {
-      weekStartDate: this.formatDateOnly(weekStart),
-      weekEndDate: this.formatDateOnly(weekEnd),
+      weekStartDate: workDate,
+      weekEndDate: workDate,
     };
   }
 
@@ -10207,27 +10561,55 @@ export class OperationsService {
     }
   }
 
-  private buildIdFilter(ids: number[], column: string, allowAll: boolean) {
+  private buildIdFilter(
+    ids: Array<number | bigint | string | null | undefined>,
+    column: string,
+    allowAll: boolean
+  ) {
+    const normalizedIds = this.uniqueNumbers(ids);
+
     if (allowAll) {
       return { clause: '1 = 1', params: [] as unknown[] };
     }
-    if (!ids.length) {
+    if (!normalizedIds.length) {
       return { clause: '1 = 0', params: [] as unknown[] };
     }
     return {
       clause: `${column} = ANY($1::int[])`,
-      params: [ids] as unknown[],
+      params: [normalizedIds] as unknown[],
     };
   }
 
-  private uniqueNumbers(values: Array<number | null | undefined>) {
+  private uniqueNumbers(
+    values: Array<number | bigint | string | null | undefined>
+  ) {
     return [
       ...new Set(
-        values.filter((value): value is number => typeof value === 'number')
+        values
+          .map((value) => this.normalizeIntegerId(value))
+          .filter((value): value is number => value !== null)
       ),
     ];
   }
 
+  private normalizeIntegerId(value: unknown) {
+    if (typeof value === 'number' && Number.isInteger(value)) {
+      return value;
+    }
+
+    if (typeof value === 'bigint') {
+      const normalized = Number(value);
+      return Number.isSafeInteger(normalized) ? normalized : null;
+    }
+
+    if (typeof value === 'string') {
+      const normalized = Number(value);
+      return Number.isInteger(normalized) ? normalized : null;
+    }
+
+    return null;
+  }
+
   private pushUpdate(
     updates: string[],
     params: unknown[],
@@ -10276,6 +10658,16 @@ export class OperationsService {
     return this.prisma.$executeRawUnsafe(sql, ...params);
   }
 
+  private shiftSqlPlaceholders(sql: string, offset: number) {
+    if (offset <= 0) {
+      return sql;
+    }
+
+    return sql.replace(/\$(\d+)/g, (_match, index: string) => {
+      return `$${Number(index) + offset}`;
+    });
+  }
+
   private async getNextCollaboratorTypeSortOrder(client: any = this.prisma) {
     const row = (await client.$queryRawUnsafe(
       `SELECT COALESCE(MAX(sort_order), 0) + 1 AS "nextSortOrder"
@@ -10284,4 +10676,1379 @@ export class OperationsService {
 
     return Number(row?.[0]?.nextSortOrder ?? 1);
   }
+
+  // ─── Collaborator-scoped endpoints (no scope manipulation) ─────────────────
+
+  async listMyProjects(
+    userId: number,
+    filters: {
+      page?: number;
+      pageSize?: number;
+      search?: string;
+      sortField?: string;
+      sortOrder?: string;
+      status?: string;
+    } = {}
+  ) {
+    const actor = await this.getActorContext(userId);
+
+    const filter = this.buildIdFilter(
+      actor.collaboratorId
+        ? await this.getAssignedProjectIds([actor.collaboratorId])
+        : [],
+      'p.id',
+      false
+    );
+    const assignmentParams: unknown[] = [];
+    const ownAssignmentSelect = actor.collaboratorId
+      ? `MAX(CASE WHEN pa.collaborator_id = ${this.param(
+          assignmentParams,
+          actor.collaboratorId
+        )} THEN pa.id END)::int AS "myAssignmentId",
+         MAX(CASE WHEN pa.collaborator_id = ${this.param(
+           assignmentParams,
+           actor.collaboratorId
+         )} THEN pa.role_label END) AS "myRoleLabel",`
+      : `NULL::int AS "myAssignmentId",
+         NULL::varchar AS "myRoleLabel",`;
+
+    const pagination = this.shouldPaginate(filters)
+      ? this.normalizePaginationParams(filters, {
+          defaultSortField: 'name',
+          defaultSortOrder: 'asc',
+          allowedSortFields: ['name', 'code', 'clientName', 'startDate', 'endDate', 'status'],
+        })
+      : null;
+
+    const params: unknown[] = [...assignmentParams, ...filter.params];
+    const totalParams: unknown[] = [...filter.params];
+    const where = [
+      'p.deleted_at IS NULL',
+      this.shiftSqlPlaceholders(filter.clause, assignmentParams.length),
+    ];
+    const totalWhere = ['p.deleted_at IS NULL', filter.clause];
+
+    if (filters.status && filters.status !== 'all') {
+      where.push(`p.status::text = ${this.param(params, filters.status)}`);
+      totalWhere.push(
+        `p.status::text = ${this.param(totalParams, filters.status)}`
+      );
+    }
+
+    if (pagination?.search) {
+      const searchPlaceholder = this.param(params, `%${pagination.search}%`);
+      const totalSearchPlaceholder = this.param(
+        totalParams,
+        `%${pagination.search}%`
+      );
+      where.push(`(
+        COALESCE(p.name, '') ILIKE ${searchPlaceholder}
+        OR COALESCE(p.code, '') ILIKE ${searchPlaceholder}
+        OR COALESCE(p.client_name, '') ILIKE ${searchPlaceholder}
+        OR COALESCE(c.name, '') ILIKE ${searchPlaceholder}
+        OR COALESCE(m.display_name, '') ILIKE ${searchPlaceholder}
+      )`);
+      totalWhere.push(`(
+        COALESCE(p.name, '') ILIKE ${totalSearchPlaceholder}
+        OR COALESCE(p.code, '') ILIKE ${totalSearchPlaceholder}
+        OR COALESCE(p.client_name, '') ILIKE ${totalSearchPlaceholder}
+        OR COALESCE(c.name, '') ILIKE ${totalSearchPlaceholder}
+        OR COALESCE(m.display_name, '') ILIKE ${totalSearchPlaceholder}
+      )`);
+    }
+
+    const whereClause = where.join(' AND ');
+    const totalWhereClause = totalWhere.join(' AND ');
+    const baseQuery = `SELECT p.id,
+              p.contract_id AS "contractId",
+              p.manager_collaborator_id AS "managerCollaboratorId",
+              p.code,
+              p.name,
+              p.client_name AS "clientName",
+              p.summary,
+              p.status,
+              p.progress_percent AS "progressPercent",
+              p.delivery_model AS "deliveryModel",
+              TO_CHAR(p.start_date, 'YYYY-MM-DD') AS "startDate",
+              TO_CHAR(p.end_date, 'YYYY-MM-DD') AS "endDate",
+              m.display_name AS "managerName",
+              ${ownAssignmentSelect}
+              COUNT(DISTINCT pa.id)::int AS "teamSize"
+         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 operations_project_assignment pa
+           ON pa.project_id = p.id
+          AND pa.deleted_at IS NULL
+          AND pa.status IN ('planned', 'active')
+        WHERE ${whereClause}
+        GROUP BY p.id, c.id, m.id`;
+
+    if (!pagination) {
+      return this.queryRows(`${baseQuery} ORDER BY p.name ASC`, params);
+    }
+
+    const totalRow = await this.querySingle<{ total: string }>(
+      `SELECT COUNT(*)::text AS total
+         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
+        WHERE ${totalWhereClause}`,
+      totalParams
+    );
+
+    const sortColumn =
+      {
+        name: 'p.name',
+        code: 'p.code',
+        clientName: 'p.client_name',
+        startDate: 'p.start_date',
+        endDate: 'p.end_date',
+        status: 'p.status',
+      }[pagination.sortField] ?? 'p.name';
+
+    const queryParams = [...params];
+    const limitPlaceholder = this.param(queryParams, pagination.pageSize);
+    const offsetPlaceholder = this.param(queryParams, pagination.offset);
+
+    const rows = await this.queryRows(
+      `${baseQuery}
+       ORDER BY ${sortColumn} ${pagination.sortOrder.toUpperCase()}, p.id ASC
+       LIMIT ${limitPlaceholder}
+      OFFSET ${offsetPlaceholder}`,
+      queryParams
+    );
+
+    return this.buildPaginationResult(
+      rows,
+      Number(totalRow?.total ?? 0),
+      pagination.page,
+      pagination.pageSize
+    );
+  }
+
+  async getMyProjectSummary(userId: number, projectId: number) {
+    const actor = await this.getActorContext(userId);
+    await this.assertProjectAccess(actor, projectId);
+
+    const projectParams: unknown[] = [];
+    const myCollaboratorId = actor.collaboratorId ?? null;
+    const collaboratorPlaceholder = this.param(projectParams, myCollaboratorId);
+
+    const project = await this.querySingle<{
+      id: number;
+      code: string;
+      name: string;
+      status: string;
+      summary: string | null;
+      startDate: string | null;
+      endDate: string | null;
+      myAssignmentId: number | null;
+      myRoleLabel: string | null;
+    }>(
+      `SELECT p.id,
+              p.code,
+              p.name,
+              p.status,
+              p.summary,
+              TO_CHAR(p.start_date, 'YYYY-MM-DD') AS "startDate",
+              TO_CHAR(p.end_date, 'YYYY-MM-DD') AS "endDate",
+              MAX(CASE WHEN pa.collaborator_id = ${collaboratorPlaceholder} THEN pa.id END)::int AS "myAssignmentId",
+              MAX(CASE WHEN pa.collaborator_id = ${collaboratorPlaceholder} THEN COALESCE(project_role_locale.name, pa.role_label) END) AS "myRoleLabel"
+         FROM operations_project p
+         LEFT JOIN operations_project_assignment pa
+           ON pa.project_id = p.id
+          AND pa.deleted_at IS NULL
+         LEFT JOIN operations_project_role project_role
+           ON project_role.id = pa.project_role_id
+          AND project_role.deleted_at IS NULL
+         LEFT JOIN LATERAL (
+           SELECT prl.name
+             FROM operations_project_role_locale prl
+            WHERE prl.operations_project_role_id = project_role.id
+            ORDER BY prl.id ASC
+            LIMIT 1
+         ) project_role_locale ON TRUE
+        WHERE p.id = ${this.param(projectParams, projectId)}
+          AND p.deleted_at IS NULL
+        GROUP BY p.id`,
+      projectParams
+    );
+
+    if (!project) {
+      throw new NotFoundException('Project not found.');
+    }
+
+    const [assignments, tasks] = await Promise.all([
+      this.queryRows<{
+        id: number;
+        collaboratorId: number;
+        collaboratorName: string;
+        roleLabel: string | null;
+        status: string;
+        avatarId: number | null;
+        userPhotoId: number | null;
+      }>(
+        `SELECT pa.id,
+                pa.collaborator_id AS "collaboratorId",
+                c.display_name AS "collaboratorName",
+                COALESCE(project_role_locale.name, pa.role_label) AS "roleLabel",
+                pa.status,
+                person_record.avatar_id AS "avatarId",
+                collaborator_user.photo_id AS "userPhotoId"
+           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
+           LEFT JOIN LATERAL (
+             SELECT prl.name
+               FROM operations_project_role_locale prl
+              WHERE prl.operations_project_role_id = project_role.id
+              ORDER BY prl.id ASC
+              LIMIT 1
+           ) project_role_locale ON TRUE
+          WHERE pa.project_id = $1
+            AND pa.deleted_at IS NULL
+          ORDER BY c.display_name ASC`,
+        [projectId]
+      ),
+      this.queryRows(
+        `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 {
+      ...project,
+      assignments,
+      tasks,
+    };
+  }
+
+  async listMyTasks(
+    userId: number,
+    paginationParams: {
+      page?: number;
+      pageSize?: number;
+      search?: string;
+      sortField?: string;
+      sortOrder?: string;
+      status?: string;
+      archived?: boolean;
+    } = {}
+  ) {
+    const actor = await this.getActorContext(userId);
+    this.ensureCollaborator(actor);
+
+    const pagination = this.normalizePaginationParams(paginationParams, {
+      defaultSortField: 'name',
+      defaultSortOrder: 'asc',
+      allowedSortFields: ['name', 'projectName', 'status', 'createdAt'],
+    });
+
+    const projectFilter = this.buildIdFilter(
+      actor.collaboratorId
+        ? await this.getAssignedProjectIds([actor.collaboratorId])
+        : [],
+      'COALESCE(t.project_id, pa.project_id)',
+      false
+    );
+    const params: unknown[] = [...projectFilter.params];
+    const archivedOnly = paginationParams.archived === true;
+    const filters = [
+      archivedOnly ? 't.deleted_at IS NOT NULL' : 't.deleted_at IS NULL',
+      'p.deleted_at IS NULL',
+      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 (actor.collaboratorId) {
+      filters.push(`pa.collaborator_id = ${this.param(params, actor.collaboratorId)}`);
+    }
+
+    if (pagination.search) {
+      const searchPlaceholder = this.param(params, `%${pagination.search}%`);
+      filters.push(`(
+        COALESCE(t.name, '') ILIKE ${searchPlaceholder}
+        OR COALESCE(t.description, '') ILIKE ${searchPlaceholder}
+        OR COALESCE(p.name, '') ILIKE ${searchPlaceholder}
+        OR COALESCE(p.code, '') ILIKE ${searchPlaceholder}
+      )`);
+    }
+
+    if (paginationParams.status) {
+      filters.push(`t.status::text = ${this.param(params, paginationParams.status)}`);
+    }
+
+    const whereClause = filters.join(' AND ');
+    const totalRow = await this.querySingle<{ total: string }>(
+      `SELECT COUNT(*)::text AS total
+         FROM operations_task t
+         LEFT JOIN operations_project_assignment pa
+           ON pa.id = t.project_assignment_id
+         JOIN operations_project p
+           ON p.id = COALESCE(t.project_id, pa.project_id)
+        WHERE ${whereClause}`,
+      params
+    );
+
+    const sortColumn =
+      {
+        name: 't.name',
+        projectName: 'p.name',
+        status: 't.status',
+        createdAt: 't.created_at',
+      }[pagination.sortField] ?? 't.name';
+
+    const queryParams = [...params];
+    const limitPlaceholder = this.param(queryParams, pagination.pageSize);
+    const offsetPlaceholder = this.param(queryParams, pagination.offset);
+
+    const rows = await this.queryRows<{
+      id: number;
+      name: string;
+      description: string | null;
+      status: string;
+      priority: string;
+      projectId: number;
+      projectAssignmentId: number | null;
+      projectName: string;
+      projectCode: string | null;
+      dueDate: string | null;
+      estimateHours: number | null;
+      tags: string | null;
+      assigneeName: string | null;
+      assigneeUserPhotoId: number | null;
+      assigneePersonAvatarId: number | null;
+      createdAt: string;
+      deletedAt: string | null;
+    }>(
+      `SELECT t.id,
+              t.name,
+              t.description,
+              t.status,
+              t.priority,
+              COALESCE(t.project_id, pa.project_id) AS "projectId",
+              pa.id AS "projectAssignmentId",
+              p.name AS "projectName",
+              p.code AS "projectCode",
+              t.due_date AS "dueDate",
+              t.estimate_hours AS "estimateHours",
+              t.tags,
+              ac.display_name AS "assigneeName",
+              au.photo_id AS "assigneeUserPhotoId",
+              ap.avatar_id AS "assigneePersonAvatarId",
+              t.created_at AS "createdAt",
+              t.deleted_at AS "deletedAt"
+         FROM operations_task t
+         LEFT JOIN operations_project_assignment pa
+           ON pa.id = t.project_assignment_id
+         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
+         JOIN operations_project p
+           ON p.id = COALESCE(t.project_id, pa.project_id)
+        WHERE ${whereClause}
+        ORDER BY ${sortColumn} ${pagination.sortOrder.toUpperCase()}, t.id ASC
+        LIMIT ${limitPlaceholder}
+       OFFSET ${offsetPlaceholder}`,
+      queryParams
+    );
+
+    return this.buildPaginationResult(
+      rows.map((row) => ({
+        ...row,
+        label: [row.name, row.projectName].filter(Boolean).join(' • '),
+      })),
+      Number(totalRow?.total ?? 0),
+      pagination.page,
+      pagination.pageSize
+    );
+  }
+
+  // ──────────────────────────────────────────────────────────────────────────
+  // Cost Types
+  // ──────────────────────────────────────────────────────────────────────────
+
+  async listCostTypes(userId: number, filters: { search?: string; active?: boolean; pageSize?: number; page?: number } = {}) {
+    await this.getActorContext(userId);
+
+    const params: unknown[] = [];
+    const where: string[] = [];
+
+    if (filters.active === true) {
+      where.push('ct.is_active = true');
+    }
+
+    if (filters.search?.trim()) {
+      const p = this.param(params, `%${filters.search.trim()}%`);
+      where.push(`(COALESCE(ct.name, '') ILIKE ${p} OR COALESCE(ct.slug, '') ILIKE ${p} OR COALESCE(ct.code, '') ILIKE ${p} OR COALESCE(ct.category, '') ILIKE ${p})`);
+    }
+
+    const whereClause = where.length ? `WHERE ${where.join(' AND ')}` : '';
+
+    const rows = await this.queryRows<{
+      id: number;
+      slug: string;
+      name: string;
+      code: string | null;
+      category: string | null;
+      description: string | null;
+      defaultRecurrence: string | null;
+      isAllocatable: boolean | null;
+      isDepreciable: boolean | null;
+      isActive: boolean;
+      createdAt: string;
+    }>(
+      `SELECT ct.id,
+              ct.slug,
+              ct.name,
+              ct.code,
+              ct.category,
+              ct.description,
+              ct.default_recurrence AS "defaultRecurrence",
+              ct.is_allocatable AS "isAllocatable",
+              ct.is_depreciable AS "isDepreciable",
+              ct.is_active AS "isActive",
+              ct.created_at AS "createdAt"
+         FROM operations_cost_type ct
+        ${whereClause}
+        ORDER BY ct.name ASC`,
+      params
+    );
+
+    return rows;
+  }
+
+  async createCostType(userId: number, data: { name: string; slug?: string | null; code?: string | null; category?: string | null; description?: string | null; defaultRecurrence?: string | null; isAllocatable?: boolean | null; isDepreciable?: boolean | null; isActive?: boolean }) {
+    const actor = await this.getActorContext(userId);
+    this.ensureDirector(actor);
+
+    const name = this.normalizeOptionalText(data.name);
+    if (!name) {
+      throw new BadRequestException('Cost type name is required.');
+    }
+
+    const baseSlug = data.slug?.trim() || name.toLowerCase().replace(/\s+/g, '-').replace(/[^a-z0-9-]/g, '');
+    const existing = await this.querySingle<{ id: number }>(
+      `SELECT id FROM operations_cost_type WHERE slug = $1 LIMIT 1`,
+      [baseSlug]
+    );
+    const finalSlug = existing
+      ? `${baseSlug}-${Date.now()}`
+      : baseSlug;
+
+    const created = await this.querySingle<{ id: number }>(
+      `INSERT INTO operations_cost_type (slug, name, code, category, description, default_recurrence, is_allocatable, is_depreciable, is_active, created_at, updated_at)
+       VALUES ($1, $2, $3, $4, $5, $6::operations_cost_type_default_recurrence_82bb00323e_enum, $7, $8, $9, NOW(), NOW())
+       RETURNING id`,
+      [
+        finalSlug,
+        name,
+        this.normalizeOptionalText(data.code),
+        this.normalizeOptionalText(data.category),
+        this.normalizeOptionalText(data.description),
+        data.defaultRecurrence ?? null,
+        data.isAllocatable ?? null,
+        data.isDepreciable ?? null,
+        data.isActive ?? true,
+      ]
+    );
+
+    if (!created?.id) {
+      throw new BadRequestException('Unable to create cost type.');
+    }
+
+    return this.querySingle<{ id: number; slug: string; name: string; code: string | null; category: string | null; description: string | null; defaultRecurrence: string | null; isAllocatable: boolean | null; isDepreciable: boolean | null; isActive: boolean }>(
+      `SELECT id, slug, name, code, category, description, default_recurrence AS "defaultRecurrence", is_allocatable AS "isAllocatable", is_depreciable AS "isDepreciable", is_active AS "isActive" FROM operations_cost_type WHERE id = $1`,
+      [created.id]
+    );
+  }
+
+  // ──────────────────────────────────────────────────────────────────────────
+  // Collaborator Costs
+  // ──────────────────────────────────────────────────────────────────────────
+
+  async listCollaboratorCosts(userId: number, collaboratorId: number) {
+    await this.getActorContext(userId);
+
+    return this.queryRows<{
+      id: number;
+      collaboratorId: number;
+      costTypeId: number;
+      costTypeName: string;
+      costTypeSlug: string;
+      amount: string;
+      currency: string;
+      recurrence: string;
+      allocatable: boolean;
+      referenceDate: string | null;
+      startDate: string | null;
+      endDate: string | null;
+      depreciationMonths: number | null;
+      description: string | null;
+      notes: string | null;
+      createdAt: string;
+    }>(
+      `SELECT cc.id,
+              cc.collaborator_id AS "collaboratorId",
+              cc.cost_type_id AS "costTypeId",
+              ct.name AS "costTypeName",
+              ct.slug AS "costTypeSlug",
+              cc.amount::text AS amount,
+              cc.currency,
+              cc.recurrence,
+              cc.allocatable,
+              cc.reference_date::text AS "referenceDate",
+              cc.start_date::text AS "startDate",
+              cc.end_date::text AS "endDate",
+              cc.depreciation_months AS "depreciationMonths",
+              cc.description,
+              cc.notes,
+              cc.created_at AS "createdAt"
+         FROM operations_collaborator_cost cc
+         JOIN operations_cost_type ct ON ct.id = cc.cost_type_id
+        WHERE cc.collaborator_id = $1
+        ORDER BY cc.created_at DESC`,
+      [collaboratorId]
+    );
+  }
+
+  async getCollaboratorCostsSummary(userId: number, collaboratorId: number) {
+    await this.getActorContext(userId);
+    const costs = await this.listCollaboratorCosts(userId, collaboratorId);
+
+    let monthlyTotal = 0;
+    let allocatableTotal = 0;
+
+    for (const c of costs) {
+      const amount = parseFloat(c.amount);
+      let monthly = 0;
+      if (c.recurrence === 'one_time') {
+        monthly = c.depreciationMonths && c.depreciationMonths > 0 ? amount / c.depreciationMonths : 0;
+      } else if (c.recurrence === 'monthly') {
+        monthly = amount;
+      } else if (c.recurrence === 'yearly') {
+        monthly = amount / 12;
+      } else if (c.recurrence === 'quarterly') {
+        monthly = amount / 3;
+      } else {
+        monthly = amount;
+      }
+      monthlyTotal += monthly;
+      if (c.allocatable !== false) {
+        allocatableTotal += monthly;
+      }
+    }
+
+    return {
+      monthlyTotal: Math.round(monthlyTotal * 100) / 100,
+      allocatableTotal: Math.round(allocatableTotal * 100) / 100,
+      nonAllocatableTotal: Math.round((monthlyTotal - allocatableTotal) * 100) / 100,
+      count: costs.length,
+    };
+  }
+
+  async getProjectsReport(
+    userId: number,
+    filters: {
+      from?: string;
+      to?: string;
+      status?: string;
+      client?: string;
+      scenario?: string;
+    } = {}
+  ) {
+    const actor = await this.getActorContext(userId);
+    this.ensureDirector(actor);
+
+    const currentYear = new Date().getFullYear();
+    const from = /^\d{4}-\d{2}-\d{2}$/.test(String(filters.from ?? ''))
+      ? String(filters.from)
+      : `${currentYear}-01-01`;
+    const to = /^\d{4}-\d{2}-\d{2}$/.test(String(filters.to ?? ''))
+      ? String(filters.to)
+      : `${currentYear}-12-31`;
+    const scenario =
+      filters.scenario === 'growth' || filters.scenario === 'conservative'
+        ? filters.scenario
+        : 'base';
+    const multiplier =
+      scenario === 'growth'
+        ? { revenue: 1.16, cost: 1.09, backlog: 1.22 }
+        : scenario === 'conservative'
+          ? { revenue: 0.9, cost: 0.96, backlog: 0.82 }
+          : { revenue: 1, cost: 1, backlog: 1 };
+
+    const params: unknown[] = [from, to];
+    const where = [
+      'p.deleted_at IS NULL',
+      '(p.end_date IS NULL OR p.end_date >= $1::date)',
+      '(p.start_date IS NULL OR p.start_date <= $2::date)',
+    ];
+    if (filters.client && filters.client !== 'all') {
+      where.push(
+        `COALESCE(NULLIF(p.client_name, ''), NULLIF(contract_record.client_name, ''), '-') = ${this.param(params, filters.client)}`
+      );
+    }
+
+    const dbRows = await this.queryRows<{
+      id: number;
+      name: string;
+      client: string | null;
+      manager: string | null;
+      squad: string | null;
+      status: string;
+      contractType: string | null;
+      startDate: string | null;
+      endDate: string | null;
+      contractedRevenue: string | null;
+      progressPercent: string | null;
+      weeklyHours: string | null;
+      actualHours: string | null;
+      billableHours: string | null;
+      openTasks: string | null;
+      backlogHours: string | null;
+      futureDeliveries: string | null;
+    }>(
+      `SELECT p.id,
+              p.name,
+              COALESCE(NULLIF(p.client_name, ''), NULLIF(contract_record.client_name, ''), '-') AS client,
+              COALESCE(NULLIF(manager_record.display_name, ''), '-') AS manager,
+              COALESCE(NULLIF(p.delivery_model::text, ''), '-') AS squad,
+              p.status::text AS status,
+              COALESCE(contract_record.billing_model::text, p.delivery_model::text, 'fixed_price') AS "contractType",
+              TO_CHAR(p.start_date, 'YYYY-MM-DD') AS "startDate",
+              TO_CHAR(p.end_date, 'YYYY-MM-DD') AS "endDate",
+              COALESCE(p.budget_amount, contract_record.budget_amount, 0)::text AS "contractedRevenue",
+              COALESCE(p.progress_percent, 0)::text AS "progressPercent",
+              COALESCE(assignment_stats.weekly_hours, 0)::text AS "weeklyHours",
+              COALESCE(time_stats.actual_hours, 0)::text AS "actualHours",
+              COALESCE(time_stats.billable_hours, 0)::text AS "billableHours",
+              COALESCE(task_stats.open_tasks, 0)::text AS "openTasks",
+              COALESCE(task_stats.backlog_hours, 0)::text AS "backlogHours",
+              COALESCE(task_stats.future_deliveries, 0)::text AS "futureDeliveries"
+         FROM operations_project p
+         LEFT JOIN operations_contract contract_record
+           ON contract_record.id = p.contract_id
+          AND contract_record.deleted_at IS NULL
+         LEFT JOIN operations_collaborator manager_record
+           ON manager_record.id = p.manager_collaborator_id
+          AND manager_record.deleted_at IS NULL
+         LEFT JOIN LATERAL (
+           SELECT COALESCE(SUM(pa.weekly_hours), 0) AS weekly_hours
+             FROM operations_project_assignment pa
+            WHERE pa.project_id = p.id
+              AND pa.deleted_at IS NULL
+              AND pa.status IN ('planned', 'active')
+         ) assignment_stats ON TRUE
+         LEFT JOIN LATERAL (
+           SELECT COALESCE(SUM(entry.hours), 0) AS actual_hours,
+                  COALESCE(SUM(entry.hours) FILTER (WHERE pa.is_billable = true), 0) AS billable_hours
+             FROM operations_timesheet_entry entry
+             JOIN operations_project_assignment pa
+               ON pa.id = entry.project_assignment_id
+              AND pa.deleted_at IS NULL
+            WHERE pa.project_id = p.id
+              AND entry.deleted_at IS NULL
+              AND entry.work_date BETWEEN $1::date AND $2::date
+         ) time_stats ON TRUE
+         LEFT JOIN LATERAL (
+           SELECT COUNT(*) FILTER (WHERE task.status IN ('todo', 'doing', 'review')) AS open_tasks,
+                  COALESCE(SUM(task.estimate_hours) FILTER (WHERE task.status IN ('todo', 'doing', 'review')), 0) AS backlog_hours,
+                  COUNT(*) FILTER (WHERE task.due_date > $2::date AND task.status IN ('todo', 'doing', 'review')) AS future_deliveries
+             FROM operations_task task
+            WHERE task.project_id = p.id
+              AND task.deleted_at IS NULL
+         ) task_stats ON TRUE
+        WHERE ${where.join(' AND ')}
+        ORDER BY p.name ASC`,
+      params
+    );
+
+    const fromDate = new Date(`${from}T00:00:00`);
+    const toDate = new Date(`${to}T00:00:00`);
+    const periodWeeks = Math.max(
+      1,
+      Math.ceil((toDate.getTime() - fromDate.getTime()) / 604800000)
+    );
+    const rows = dbRows
+      .map((row) => {
+        const progress = Number(row.progressPercent ?? 0);
+        const contractedRevenue = Number(row.contractedRevenue ?? 0);
+        const recognizedRevenue = contractedRevenue * (progress / 100);
+        const actualHours = Number(row.actualHours ?? 0);
+        const plannedHours = Math.max(Number(row.weeklyHours ?? 0) * periodWeeks, actualHours);
+        const realizedCost = 0;
+        const reportStatus =
+          row.status === 'paused'
+            ? 'paused'
+            : row.status === 'at_risk'
+              ? 'attention'
+              : row.endDate && new Date(`${row.endDate}T00:00:00`) < new Date() && progress < 100
+                ? 'late'
+                : 'on_track';
+        const risk =
+          reportStatus === 'late' || (plannedHours && actualHours / plannedHours > 1)
+            ? 'alto'
+            : reportStatus === 'attention'
+              ? 'médio'
+              : 'baixo';
+
+        return {
+          id: Number(row.id),
+          name: row.name,
+          client: row.client ?? '-',
+          manager: row.manager ?? '-',
+          squad: String(row.squad ?? '-').replace(/_/g, ' '),
+          status: reportStatus,
+          contractType:
+            row.contractType === 'monthly_retainer'
+              ? 'retainer'
+              : row.contractType === 'time_and_material'
+                ? 'time_materials'
+                : 'fixed_price',
+          priority: risk === 'alto' ? 'alta' : risk === 'médio' ? 'média' : 'baixa',
+          startDate: row.startDate,
+          endDate: row.endDate,
+          contractedRevenue,
+          recognizedRevenue,
+          realizedCost,
+          forecastCost: realizedCost,
+          teamCost: realizedCost,
+          infraCost: 0,
+          licenseCost: 0,
+          thirdPartyCost: 0,
+          reworkCost: 0,
+          plannedHours,
+          actualHours,
+          billableHours: Number(row.billableHours ?? 0),
+          reworkHours: 0,
+          internalHours: Math.max(actualHours - Number(row.billableHours ?? 0), 0),
+          allocatedCapacity: plannedHours ? (actualHours / plannedHours) * 100 : 0,
+          physicalProgress: progress,
+          financialProgress: contractedRevenue ? (recognizedRevenue / contractedRevenue) * 100 : 0,
+          backlogValue: Math.max(contractedRevenue - recognizedRevenue, 0),
+          futureDeliveries: Number(row.futureDeliveries ?? 0),
+          risk,
+          recommendation:
+            risk === 'alto'
+              ? 'Revisar escopo, prazo ou capacidade alocada.'
+              : risk === 'médio'
+                ? 'Acompanhar margem, entregas e consumo de horas.'
+                : 'Manter ritmo e proteger capacidade planejada.',
+        };
+      })
+      .filter((row) => !filters.status || filters.status === 'all' || row.status === filters.status);
+
+    const summary = rows.reduce(
+      (acc, row) => {
+        acc.contractedRevenue += row.contractedRevenue;
+        acc.recognizedRevenue += row.recognizedRevenue;
+        acc.realizedCost += row.realizedCost;
+        acc.forecastCost += row.forecastCost;
+        acc.plannedHours += row.plannedHours;
+        acc.actualHours += row.actualHours;
+        acc.billableHours += row.billableHours;
+        acc.reworkHours += row.reworkHours;
+        acc.backlogValue += row.backlogValue;
+        acc.avgDeadline += row.physicalProgress;
+        acc.avgAllocation += row.allocatedCapacity;
+        acc.atRisk += row.risk === 'alto' ? 1 : 0;
+        return acc;
+      },
+      {
+        contractedRevenue: 0,
+        recognizedRevenue: 0,
+        realizedCost: 0,
+        forecastCost: 0,
+        profit: 0,
+        margin: 0,
+        plannedHours: 0,
+        actualHours: 0,
+        billableHours: 0,
+        reworkHours: 0,
+        backlogValue: 0,
+        avgDeadline: 0,
+        avgAllocation: 0,
+        atRisk: 0,
+        burnRate: 0,
+      }
+    );
+    summary.profit = summary.recognizedRevenue - summary.realizedCost;
+    summary.margin = summary.recognizedRevenue ? (summary.profit / summary.recognizedRevenue) * 100 : 0;
+    summary.avgDeadline = rows.length ? summary.avgDeadline / rows.length : 0;
+    summary.avgAllocation = rows.length ? summary.avgAllocation / rows.length : 0;
+    summary.burnRate = summary.plannedHours ? (summary.actualHours / summary.plannedHours) * 100 : 0;
+
+    const forecast = Array.from({ length: 12 }, (_, index) => {
+      const monthDate = new Date(fromDate);
+      monthDate.setMonth(fromDate.getMonth() + index);
+      const revenue = Math.round((summary.recognizedRevenue / 12) * multiplier.revenue);
+      const cost = Math.round((summary.realizedCost / 12) * multiplier.cost);
+      const profit = revenue - cost;
+      return {
+        month: monthDate.toLocaleDateString('pt-BR', { month: 'short' }).replace('.', ''),
+        revenue,
+        cost,
+        profit,
+        backlog: Math.round(Math.max(profit, 0) * multiplier.backlog),
+        planned: Math.round(summary.plannedHours / 12),
+        actual: Math.round(summary.actualHours / 12),
+      };
+    });
+
+    return {
+      filters: {
+        from,
+        to,
+        status: filters.status ?? 'all',
+        client: filters.client ?? 'all',
+        scenario,
+        clients: [...new Set(dbRows.map((row) => row.client ?? '-'))].sort(),
+      },
+      summary,
+      forecast,
+      costComposition: [
+        { name: 'Equipe', value: summary.realizedCost },
+        { name: 'Infraestrutura', value: 0 },
+        { name: 'Licenças', value: 0 },
+        { name: 'Terceiros', value: 0 },
+        { name: 'Retrabalho', value: 0 },
+      ],
+      hoursByProject: rows.map((row) => ({
+        project: row.name.split(' ').slice(0, 2).join(' '),
+        Faturável: row.billableHours,
+        Interno: row.internalHours,
+        Retrabalho: row.reworkHours,
+        Livre: Math.max(row.plannedHours - row.actualHours, 0),
+      })),
+      health: rows.map((row) => ({
+        project: row.name.split(' ').slice(0, 2).join(' '),
+        margem: Math.max(row.recognizedRevenue ? ((row.recognizedRevenue - row.realizedCost) / row.recognizedRevenue) * 100 : 0, 0),
+        prazo: row.physicalProgress,
+        alocacao: row.allocatedCapacity,
+        saude: Math.max(100 - (row.risk === 'alto' ? 28 : row.risk === 'médio' ? 14 : 0), 35),
+      })),
+      ranking: rows
+        .map((row) => ({
+          name: row.name.split(' ').slice(0, 2).join(' '),
+          Lucro: row.recognizedRevenue - row.realizedCost,
+          Custo: row.realizedCost,
+        }))
+        .sort((a, b) => b.Lucro - a.Lucro),
+      progress: forecast.map((row) => ({
+        month: row.month,
+        Planejado: row.planned,
+        Realizado: row.actual,
+      })),
+      planningCards: [
+        { title: 'Acelerar críticas', value: String(summary.atRisk), description: 'Projetos com risco alto devem receber revisão de prazo e capacidade.' },
+        { title: 'Renegociar escopo', value: Math.round(summary.backlogValue).toString(), description: 'Backlog financeiro ainda não reconhecido no período.' },
+        { title: 'Realocar equipe', value: Math.round(Math.max(summary.plannedHours - summary.actualHours, 0)).toString(), description: 'Horas planejadas ainda não consumidas.' },
+        { title: 'Priorizar margem', value: rows.filter((row) => row.recognizedRevenue > row.realizedCost).length.toString(), description: 'Projetos com contribuição positiva no recorte.' },
+      ],
+      rows,
+    };
+  }
+
+  async getCollaboratorsReport(
+    userId: number,
+    filters: {
+      from?: string;
+      to?: string;
+      department?: string;
+      contractType?: string;
+      scenario?: string;
+    } = {}
+  ) {
+    const actor = await this.getActorContext(userId);
+    this.ensureDirector(actor);
+
+    const currentYear = new Date().getFullYear();
+    const from = /^\d{4}-\d{2}-\d{2}$/.test(String(filters.from ?? ''))
+      ? String(filters.from)
+      : `${currentYear}-01-01`;
+    const to = /^\d{4}-\d{2}-\d{2}$/.test(String(filters.to ?? ''))
+      ? String(filters.to)
+      : `${currentYear}-12-31`;
+    const scenario =
+      filters.scenario === 'growth' || filters.scenario === 'conservative'
+        ? filters.scenario
+        : 'base';
+    const multiplier =
+      scenario === 'growth'
+        ? { revenue: 1.18, cost: 1.11, capacity: 1.08 }
+        : scenario === 'conservative'
+          ? { revenue: 0.9, cost: 0.96, capacity: 0.94 }
+          : { revenue: 1, cost: 1, capacity: 1 };
+    const params: unknown[] = [from, to];
+    const where = [
+      'c.deleted_at IS NULL',
+      '(c.joined_at IS NULL OR c.joined_at <= $2::date)',
+      '(c.left_at IS NULL OR c.left_at >= $1::date)',
+    ];
+
+    if (filters.department && filters.department !== 'all') {
+      where.push(`COALESCE(department_record.name, '-') = ${this.param(params, filters.department)}`);
+    }
+
+    if (filters.contractType && filters.contractType !== 'all') {
+      where.push(`COALESCE(collaborator_type.name, collaborator_type.slug, '-') = ${this.param(params, filters.contractType)}`);
+    }
+
+    const dbRows = await this.queryRows<{
+      id: number;
+      name: string;
+      role: string | null;
+      seniority: string | null;
+      department: string | null;
+      contractType: string | null;
+      startDate: string | null;
+      endDate: string | null;
+      weeklyCapacityHours: string | null;
+      salaryCost: string | null;
+      benefitsCost: string | null;
+      taxesCost: string | null;
+      toolsCost: string | null;
+      billableValue: string | null;
+      allocatedHours: string | null;
+      billableHours: string | null;
+      projects: string | null;
+    }>(
+      `SELECT c.id,
+              COALESCE(NULLIF(c.display_name, ''), person_record.name, c.code) AS name,
+              COALESCE(job_title_record.name, c.title, '-') AS role,
+              COALESCE(c.level_label, '-') AS seniority,
+              COALESCE(department_record.name, '-') AS department,
+              COALESCE(collaborator_type.name, collaborator_type.slug, '-') AS "contractType",
+              TO_CHAR(c.joined_at, 'YYYY-MM-DD') AS "startDate",
+              TO_CHAR(c.left_at, 'YYYY-MM-DD') AS "endDate",
+              COALESCE(c.weekly_capacity_hours, 40)::text AS "weeklyCapacityHours",
+              COALESCE(cost_stats.salary_cost, 0)::text AS "salaryCost",
+              COALESCE(cost_stats.benefits_cost, 0)::text AS "benefitsCost",
+              COALESCE(cost_stats.taxes_cost, 0)::text AS "taxesCost",
+              COALESCE(cost_stats.tools_cost, 0)::text AS "toolsCost",
+              COALESCE(value_stats.billable_value, 0)::text AS "billableValue",
+              COALESCE(value_stats.allocated_hours, 0)::text AS "allocatedHours",
+              COALESCE(value_stats.billable_hours, 0)::text AS "billableHours",
+              COALESCE(project_stats.projects, 0)::text AS projects
+         FROM operations_collaborator c
+         LEFT JOIN person person_record ON person_record.id = c.person_id
+         LEFT JOIN operations_department department_record
+           ON department_record.id = c.department_id
+          AND department_record.deleted_at IS NULL
+         LEFT JOIN operations_job_title job_title_record
+           ON job_title_record.id = c.job_title_id
+          AND job_title_record.deleted_at IS NULL
+         LEFT JOIN operations_collaborator_type collaborator_type
+           ON collaborator_type.id = c.collaborator_type_id
+          AND collaborator_type.deleted_at IS NULL
+         LEFT JOIN LATERAL (
+           SELECT COALESCE(SUM(cost.amount) FILTER (WHERE cost.recurrence::text = 'monthly' AND cost_type.slug IN ('salario-base', 'pro-labore')), 0) AS salary_cost,
+                  COALESCE(SUM(cost.amount) FILTER (WHERE cost.recurrence::text = 'monthly' AND cost_type.slug IN ('vale-refeicao', 'vale-alimentacao', 'vale-transporte', 'plano-saude', 'plano-odontologico', 'seguro-vida')), 0) AS benefits_cost,
+                  COALESCE(SUM(cost.amount) FILTER (WHERE cost.recurrence::text = 'monthly' AND cost_type.slug IN ('inss-patronal', 'fgts', 'rat-fap', 'terceiros-sistema-s', 'provisao-decimo-terceiro', 'provisao-ferias')), 0) AS taxes_cost,
+                  COALESCE(SUM(cost.amount) FILTER (WHERE cost.recurrence::text = 'monthly' AND cost_type.slug IN ('software-licenca', 'equipamento')), 0) AS tools_cost
+             FROM operations_collaborator_cost cost
+             LEFT JOIN operations_cost_type cost_type ON cost_type.id = cost.cost_type_id
+            WHERE cost.collaborator_id = c.id
+              AND (cost.start_date IS NULL OR cost.start_date <= $2::date)
+              AND (cost.end_date IS NULL OR cost.end_date >= $1::date)
+         ) cost_stats ON TRUE
+         LEFT JOIN LATERAL (
+           SELECT COALESCE(SUM(entry.hours), 0) AS allocated_hours,
+                  COALESCE(SUM(entry.hours) FILTER (WHERE pa.is_billable = true), 0) AS billable_hours,
+                  COALESCE(SUM(entry.hours) FILTER (WHERE pa.is_billable = true) * 120, 0) AS billable_value
+             FROM operations_timesheet_entry entry
+             JOIN operations_project_assignment pa
+               ON pa.id = entry.project_assignment_id
+              AND pa.deleted_at IS NULL
+            WHERE pa.collaborator_id = c.id
+              AND entry.deleted_at IS NULL
+              AND entry.work_date BETWEEN $1::date AND $2::date
+         ) value_stats ON TRUE
+         LEFT JOIN LATERAL (
+           SELECT COUNT(DISTINCT pa.project_id) AS projects
+             FROM operations_project_assignment pa
+            WHERE pa.collaborator_id = c.id
+              AND pa.deleted_at IS NULL
+              AND pa.status IN ('planned', 'active')
+         ) project_stats ON TRUE
+        WHERE ${where.join(' AND ')}
+        ORDER BY name ASC`,
+      params
+    );
+
+    const fromDate = new Date(`${from}T00:00:00`);
+    const toDate = new Date(`${to}T00:00:00`);
+    const periodWeeks = Math.max(
+      1,
+      Math.ceil((toDate.getTime() - fromDate.getTime()) / 604800000)
+    );
+    const rows = dbRows.map((row) => {
+      const salaryCost = Number(row.salaryCost ?? 0);
+      const benefitsCost = Number(row.benefitsCost ?? 0);
+      const taxesCost = Number(row.taxesCost ?? 0);
+      const toolsCost = Number(row.toolsCost ?? 0);
+      const availableHours = Number(row.weeklyCapacityHours ?? 40) * periodWeeks;
+      const allocatedHours = Number(row.allocatedHours ?? 0);
+      const billableHours = Number(row.billableHours ?? 0);
+      const allocation = availableHours ? (allocatedHours / availableHours) * 100 : 0;
+      const risk = allocation >= 98 ? 'alto' : allocation < 75 ? 'médio' : 'baixo';
+      return {
+        id: Number(row.id),
+        name: row.name,
+        role: row.role ?? '-',
+        seniority: row.seniority ?? '-',
+        department: row.department ?? '-',
+        contractType: row.contractType ?? '-',
+        startDate: row.startDate,
+        endDate: row.endDate,
+        salaryCost,
+        benefitsCost,
+        taxesCost,
+        toolsCost,
+        billableValue: Number(row.billableValue ?? 0),
+        availableHours,
+        allocatedHours,
+        billableHours,
+        internalHours: Math.max(allocatedHours - billableHours, 0),
+        overtimeHours: Math.max(allocatedHours - availableHours, 0),
+        projects: Number(row.projects ?? 0),
+        risk,
+        recommendation:
+          risk === 'alto'
+            ? 'Reduzir sobrecarga ou redistribuir entregas.'
+            : risk === 'médio'
+              ? 'Acompanhar alocação e buscar maior aproveitamento faturável.'
+              : 'Manter alocação e proteger margem.',
+      };
+    });
+
+    const summary = rows.reduce(
+      (acc, row) => {
+        acc.cost += row.salaryCost + row.benefitsCost + row.taxesCost + row.toolsCost;
+        acc.salary += row.salaryCost;
+        acc.benefits += row.benefitsCost;
+        acc.taxes += row.taxesCost;
+        acc.tools += row.toolsCost;
+        acc.billableValue += row.billableValue;
+        acc.availableHours += row.availableHours;
+        acc.allocatedHours += row.allocatedHours;
+        acc.billableHours += row.billableHours;
+        acc.internalHours += row.internalHours;
+        acc.overtimeHours += row.overtimeHours;
+        acc.overloadCount += row.risk === 'alto' ? 1 : 0;
+        return acc;
+      },
+      {
+        cost: 0,
+        salary: 0,
+        benefits: 0,
+        taxes: 0,
+        tools: 0,
+        billableValue: 0,
+        profit: 0,
+        margin: 0,
+        availableHours: 0,
+        allocatedHours: 0,
+        billableHours: 0,
+        internalHours: 0,
+        overtimeHours: 0,
+        freeHours: 0,
+        allocation: 0,
+        utilization: 0,
+        overloadCount: 0,
+        hourlyCost: 0,
+      }
+    );
+    summary.profit = summary.billableValue - summary.cost;
+    summary.margin = summary.billableValue ? (summary.profit / summary.billableValue) * 100 : 0;
+    summary.freeHours = Math.max(summary.availableHours - summary.allocatedHours, 0);
+    summary.allocation = summary.availableHours ? (summary.allocatedHours / summary.availableHours) * 100 : 0;
+    summary.utilization = summary.availableHours ? (summary.billableHours / summary.availableHours) * 100 : 0;
+    summary.hourlyCost = summary.allocatedHours ? summary.cost / summary.allocatedHours : 0;
+
+    const forecast = Array.from({ length: 12 }, (_, index) => {
+      const monthDate = new Date(fromDate);
+      monthDate.setMonth(fromDate.getMonth() + index);
+      const revenue = Math.round((summary.billableValue / 12) * multiplier.revenue);
+      const cost = Math.round((summary.cost / 12) * multiplier.cost);
+      const profit = revenue - cost;
+      return {
+        month: monthDate.toLocaleDateString('pt-BR', { month: 'short' }).replace('.', ''),
+        revenue,
+        cost,
+        profit,
+        margin: revenue ? Math.round((profit / revenue) * 100) : 0,
+        capacity: Math.round((summary.allocatedHours / 12) * multiplier.capacity),
+      };
+    });
+    const departments = [...new Set(dbRows.map((row) => row.department ?? '-'))].sort();
+
+    return {
+      filters: {
+        from,
+        to,
+        department: filters.department ?? 'all',
+        contractType: filters.contractType ?? 'all',
+        scenario,
+        departments,
+        contractTypes: [...new Set(dbRows.map((row) => row.contractType ?? '-'))].sort(),
+      },
+      summary,
+      forecast,
+      costComposition: [
+        { name: 'Salários / Contratos', value: summary.salary },
+        { name: 'Benefícios', value: summary.benefits },
+        { name: 'Encargos', value: summary.taxes },
+        { name: 'Ferramentas', value: summary.tools },
+      ],
+      capacityByDepartment: departments.map((department) => {
+        const departmentRows = rows.filter((row) => row.department === department);
+        const available = departmentRows.reduce((sum, row) => sum + row.availableHours, 0);
+        const allocated = departmentRows.reduce((sum, row) => sum + row.allocatedHours, 0);
+        return {
+          department,
+          Faturável: departmentRows.reduce((sum, row) => sum + row.billableHours, 0),
+          Interno: departmentRows.reduce((sum, row) => sum + row.internalHours, 0),
+          Livre: Math.max(available - allocated, 0),
+          Sobrecarga: Math.max(allocated - available, 0),
+        };
+      }),
+      health: departments.map((department) => {
+        const departmentRows = rows.filter((row) => row.department === department);
+        const value = departmentRows.reduce((sum, row) => sum + row.billableValue, 0);
+        const cost = departmentRows.reduce((sum, row) => sum + row.salaryCost + row.benefitsCost + row.taxesCost + row.toolsCost, 0);
+        const available = departmentRows.reduce((sum, row) => sum + row.availableHours, 0);
+        const allocated = departmentRows.reduce((sum, row) => sum + row.allocatedHours, 0);
+        const billable = departmentRows.reduce((sum, row) => sum + row.billableHours, 0);
+        return {
+          department,
+          margem: Math.max(value ? ((value - cost) / value) * 100 : 0, 0),
+          alocacao: available ? (allocated / available) * 100 : 0,
+          utilizacao: available ? (billable / available) * 100 : 0,
+          saude: Math.max(100 - departmentRows.filter((row) => row.risk === 'alto').length * 12, 45),
+        };
+      }),
+      ranking: rows
+        .map((row) => ({
+          name: row.name.split(' ')[0],
+          Custo: row.salaryCost + row.benefitsCost + row.taxesCost + row.toolsCost,
+          Lucro: row.billableValue - (row.salaryCost + row.benefitsCost + row.taxesCost + row.toolsCost),
+        }))
+        .sort((a, b) => b.Lucro - a.Lucro),
+      planningCards: [
+        { title: 'Contratar', value: String(summary.overloadCount), description: 'Pessoas em sobrecarga no recorte.' },
+        { title: 'Realocar', value: Math.round(summary.freeHours).toString(), description: 'Horas livres estimadas no período.' },
+        { title: 'Reduzir sobrecarga', value: Math.round(summary.overtimeHours).toString(), description: 'Horas acima da capacidade cadastrada.' },
+        { title: 'Aumentar venda', value: Math.round(summary.utilization).toString(), description: 'Percentual de utilização faturável.' },
+      ],
+      rows,
+    };
+  }
+
+  async deleteCollaboratorCostById(userId: number, costId: number) {
+    const actor = await this.getActorContext(userId);
+    this.ensureDirector(actor);
+
+    const cost = await this.querySingle<{ id: number; collaboratorId: number }>(
+      `SELECT id, collaborator_id AS "collaboratorId" FROM operations_collaborator_cost WHERE id = $1 LIMIT 1`,
+      [costId]
+    );
+    if (!cost) {
+      throw new NotFoundException('Collaborator cost not found.');
+    }
+
+    await this.prisma.$queryRawUnsafe(
+      `DELETE FROM operations_collaborator_cost WHERE id = $1`,
+      costId
+    );
+
+    return { success: true };
+  }
+
+  async createCollaboratorCost(
+    userId: number,
+    collaboratorId: number,
+    data: { costTypeId: number; amount: number; currency?: string; recurrence?: string; allocatable?: boolean; referenceDate?: string | null; startDate?: string | null; endDate?: string | null; depreciationMonths?: number | null; description?: string | null; notes?: string | null }
+  ) {
+    const actor = await this.getActorContext(userId);
+    this.ensureDirector(actor);
+
+    const collaborator = await this.querySingle<{ id: number }>(
+      `SELECT id FROM operations_collaborator WHERE id = $1 AND deleted_at IS NULL LIMIT 1`,
+      [collaboratorId]
+    );
+    if (!collaborator) {
+      throw new NotFoundException('Collaborator not found.');
+    }
+
+    const costType = await this.querySingle<{ id: number }>(
+      `SELECT id FROM operations_cost_type WHERE id = $1 AND is_active = true LIMIT 1`,
+      [data.costTypeId]
+    );
+    if (!costType) {
+      throw new BadRequestException('Cost type not found or inactive.');
+    }
+
+    const created = await this.querySingle<{ id: number }>(
+      `INSERT INTO operations_collaborator_cost
+         (collaborator_id, cost_type_id, amount, currency, recurrence, allocatable, reference_date, start_date, end_date, depreciation_months, description, notes, created_at, updated_at)
+       VALUES ($1, $2, $3, $4, $5::operations_collaborator_cost_recurrence_56fbe60170_enum, $6, $7::date, $8::date, $9::date, $10, $11, $12, NOW(), NOW())
+       RETURNING id`,
+      [
+        collaboratorId,
+        data.costTypeId,
+        data.amount,
+        data.currency ?? 'BRL',
+        data.recurrence ?? 'monthly',
+        data.allocatable ?? true,
+        data.referenceDate ?? data.startDate ?? null,
+        data.startDate ?? null,
+        data.endDate ?? null,
+        data.depreciationMonths ?? null,
+        data.description ?? null,
+        data.notes ?? null,
+      ]
+    );
+
+    if (!created?.id) {
+      throw new BadRequestException('Unable to create collaborator cost.');
+    }
+
+    const rows = await this.listCollaboratorCosts(userId, collaboratorId);
+    return rows.find((r) => r.id === created.id) ?? null;
+  }
+
+  async updateCollaboratorCost(
+    userId: number,
+    collaboratorId: number,
+    costId: number,
+    data: Partial<{ costTypeId: number; amount: number; currency: string; recurrence: string; allocatable: boolean; referenceDate: string | null; startDate: string | null; endDate: string | null; depreciationMonths: number | null; description: string | null; notes: string | null }>
+  ) {
+    const actor = await this.getActorContext(userId);
+    this.ensureDirector(actor);
+
+    const cost = await this.querySingle<{ id: number; collaboratorId: number }>(
+      `SELECT id, collaborator_id AS "collaboratorId" FROM operations_collaborator_cost WHERE id = $1 ${collaboratorId ? 'AND collaborator_id = $2' : ''} LIMIT 1`,
+      collaboratorId ? [costId, collaboratorId] : [costId]
+    );
+    if (!cost) {
+      throw new NotFoundException('Collaborator cost not found.');
+    }
+
+    const resolvedCollaboratorId = collaboratorId || cost.collaboratorId;
+
+    const sets: string[] = [];
+    const params: unknown[] = [];
+
+    if (data.costTypeId !== undefined) {
+      sets.push(`cost_type_id = ${this.param(params, data.costTypeId)}`);
+    }
+    if (data.amount !== undefined) {
+      sets.push(`amount = ${this.param(params, data.amount)}`);
+    }
+    if (data.currency !== undefined) {
+      sets.push(`currency = ${this.param(params, data.currency)}`);
+    }
+    if (data.recurrence !== undefined) {
+      sets.push(`recurrence = ${this.param(params, data.recurrence)}::operations_collaborator_cost_recurrence_56fbe60170_enum`);
+    }
+    if (data.allocatable !== undefined) {
+      sets.push(`allocatable = ${this.param(params, data.allocatable)}`);
+    }
+    if ('referenceDate' in data) {
+      sets.push(`reference_date = ${this.param(params, data.referenceDate ?? null)}::date`);
+    }
+    if ('startDate' in data) {
+      sets.push(`start_date = ${this.param(params, data.startDate ?? null)}::date`);
+    }
+    if ('endDate' in data) {
+      sets.push(`end_date = ${this.param(params, data.endDate ?? null)}::date`);
+    }
+    if ('depreciationMonths' in data) {
+      sets.push(`depreciation_months = ${this.param(params, data.depreciationMonths ?? null)}`);
+    }
+    if ('description' in data) {
+      sets.push(`description = ${this.param(params, data.description ?? null)}`);
+    }
+    if ('notes' in data) {
+      sets.push(`notes = ${this.param(params, data.notes ?? null)}`);
+    }
+
+    if (sets.length === 0) {
+      const rows = await this.listCollaboratorCosts(userId, resolvedCollaboratorId);
+      return rows.find((r) => r.id === costId) ?? null;
+    }
+
+    sets.push(`updated_at = NOW()`);
+    await this.prisma.$queryRawUnsafe(
+      `UPDATE operations_collaborator_cost SET ${sets.join(', ')} WHERE id = ${this.param(params, costId)}`,
+      ...params
+    );
+
+    const rows = await this.listCollaboratorCosts(userId, resolvedCollaboratorId);
+    return rows.find((r) => r.id === costId) ?? null;
+  }
+
+  async deleteCollaboratorCost(userId: number, collaboratorId: number, costId: number) {
+    const actor = await this.getActorContext(userId);
+    this.ensureDirector(actor);
+
+    const cost = await this.querySingle<{ id: number }>(
+      `SELECT id FROM operations_collaborator_cost WHERE id = $1 AND collaborator_id = $2 LIMIT 1`,
+      [costId, collaboratorId]
+    );
+    if (!cost) {
+      throw new NotFoundException('Collaborator cost not found.');
+    }
+
+    await this.prisma.$queryRawUnsafe(
+      `DELETE FROM operations_collaborator_cost WHERE id = $1`,
+      costId
+    );
+
+    return { success: true };
+  }
 }