@hed-hog/operations 0.0.322 → 0.0.325

package/src/operations.service.ts

@@ -9,6 +9,7 @@ import {
 } from '@hed-hog/core';
 import {
     BadRequestException,
+    ConflictException,
     ForbiddenException,
     Inject,
     Injectable,
@@ -544,6 +545,18 @@ type TaskPayload = {
   archived?: boolean;
 };
 
+type TaskCommentRecord = {
+  id: number;
+  taskId: number;
+  content: string;
+  actorCollaboratorId: number | null;
+  actorName: string | null;
+  actorUserPhotoId: number | null;
+  actorPersonAvatarId: number | null;
+  createdAt: string;
+  updatedAt: string | null;
+};
+
 type QuickTimesheetEntryPayload = {
   projectId?: number | null;
   projectAssignmentId?: number | null;
@@ -2149,6 +2162,95 @@ export class OperationsService {
     return this.getCollaboratorByIdForUser(userId, collaboratorId);
   }
 
+  async updateCollaboratorProjectAssignment(
+    collaboratorId: number,
+    projectId: number,
+    data: {
+      projectRoleId?: number | null;
+      roleLabel?: string | null;
+      allocationPercent?: number | null;
+      weeklyHours?: number | null;
+      startDate?: string | null;
+      endDate?: string | null;
+      status?: string;
+    }
+  ) {
+    const sets: string[] = [];
+    const params: unknown[] = [collaboratorId, projectId];
+    let idx = 3;
+
+    if ('projectRoleId' in data) {
+      sets.push(`project_role_id = $${idx++}`);
+      params.push(data.projectRoleId ?? null);
+    }
+    if ('roleLabel' in data) {
+      sets.push(`role_label = $${idx++}`);
+      params.push(data.roleLabel ?? null);
+    }
+    if ('allocationPercent' in data) {
+      sets.push(`allocation_percent = $${idx++}`);
+      params.push(data.allocationPercent ?? null);
+    }
+    if ('weeklyHours' in data) {
+      sets.push(`weekly_hours = $${idx++}`);
+      params.push(data.weeklyHours ?? null);
+    }
+    if ('startDate' in data) {
+      sets.push(`start_date = $${idx++}::date`);
+      params.push(data.startDate ?? null);
+    }
+    if ('endDate' in data) {
+      sets.push(`end_date = $${idx++}::date`);
+      params.push(data.endDate ?? null);
+    }
+    if ('status' in data) {
+      sets.push(
+        `status = $${idx++}::operations_project_assignment_status_155b459bbf_enum`
+      );
+      params.push(data.status);
+    }
+
+    if (!sets.length) return { updated: false };
+
+    sets.push(`updated_at = NOW()`);
+
+    await this.prisma.$executeRawUnsafe(
+      `UPDATE operations_project_assignment
+          SET ${sets.join(', ')}
+        WHERE collaborator_id = $1
+          AND project_id = $2
+          AND deleted_at IS NULL`,
+      ...params
+    );
+
+    return { updated: true };
+  }
+
+  async addCollaboratorProjectAssignment(
+    collaboratorId: number,
+    data: { projectId: number; roleLabel?: string }
+  ) {
+    const existing = await this.querySingle<{ id: number }>(
+      `SELECT id FROM operations_project_assignment
+        WHERE collaborator_id = $1 AND project_id = $2 AND deleted_at IS NULL`,
+      [collaboratorId, data.projectId]
+    );
+
+    if (existing) {
+      return { id: existing.id, created: false };
+    }
+
+    const row = await this.querySingle<{ id: number }>(
+      `INSERT INTO operations_project_assignment
+         (collaborator_id, project_id, role_label, status)
+       VALUES ($1, $2, $3, 'active')
+       RETURNING id`,
+      [collaboratorId, data.projectId, data.roleLabel ?? '']
+    );
+
+    return { id: row!.id, created: true };
+  }
+
   async getCollaboratorCompensationHistory(
     userId: number,
     collaboratorId: number
@@ -2755,6 +2857,7 @@ export class OperationsService {
       status?: string;
       myOnly?: boolean;
       archived?: boolean;
+      collaboratorId?: number;
     }
   ) {
     const actor = await this.getActorContext(userId);
@@ -2828,6 +2931,13 @@ export class OperationsService {
       filters.push(`t.status::text = ${this.param(params, paginationParams.status)}`);
     }
 
+    if (paginationParams.collaboratorId) {
+      const colId = paginationParams.collaboratorId;
+      filters.push(
+        `(pa.collaborator_id = ${this.param(params, colId)} OR t.assignee_collaborator_id = ${this.param(params, colId)})`
+      );
+    }
+
     const whereClause = filters.join(' AND ');
     const totalRow = await this.querySingle<{ total: string }>(
       `SELECT COUNT(*)::text AS total
@@ -2868,6 +2978,8 @@ export class OperationsService {
       assigneeName: string | null;
       assigneeUserPhotoId: number | null;
       assigneePersonAvatarId: number | null;
+      commentCount: number;
+      fileCount: number;
       createdAt: string;
       deletedAt: string | null;
     }>(
@@ -2886,6 +2998,8 @@ export class OperationsService {
               ac.display_name AS "assigneeName",
               au.photo_id AS "assigneeUserPhotoId",
               ap.avatar_id AS "assigneePersonAvatarId",
+              COALESCE(task_comments.count, 0)::int AS "commentCount",
+              COALESCE(task_files.count, 0)::int AS "fileCount",
               t.created_at AS "createdAt",
               t.deleted_at AS "deletedAt"
          FROM operations_task t
@@ -2898,6 +3012,16 @@ export class OperationsService {
            ON au.id = ac.user_id
          LEFT JOIN person ap
            ON ap.id = ac.person_id
+         LEFT JOIN LATERAL (
+           SELECT COUNT(*) AS count
+             FROM operations_task_comment tc
+            WHERE tc.task_id = t.id
+         ) task_comments ON TRUE
+         LEFT JOIN LATERAL (
+           SELECT COUNT(*) AS count
+             FROM operations_task_file tf
+            WHERE tf.operations_task_id = t.id
+         ) task_files ON TRUE
          JOIN operations_project p
            ON p.id = COALESCE(t.project_id, pa.project_id)
         WHERE ${whereClause}
@@ -3262,6 +3386,183 @@ export class OperationsService {
     return { success: true };
   }
 
+  async listTaskComments(userId: number, taskId: number) {
+    const actor = await this.getActorContext(userId);
+    if (!actor.isCollaborator && !actor.isDirector && !actor.isSupervisor) {
+      throw new ForbiddenException(
+        'Operations collaborator access is required.'
+      );
+    }
+
+    const current = await this.getTaskRecordForActor(
+      this.prisma,
+      actor,
+      taskId
+    );
+    await this.assertProjectAccess(actor, current.projectId);
+
+    return this.queryRows<TaskCommentRecord>(
+      `SELECT tc.id,
+              tc.task_id AS "taskId",
+              tc.content,
+              tc.actor_collaborator_id AS "actorCollaboratorId",
+              actor.display_name AS "actorName",
+              actor_user.photo_id AS "actorUserPhotoId",
+              actor_person.avatar_id AS "actorPersonAvatarId",
+              tc.created_at AS "createdAt",
+              tc.updated_at AS "updatedAt"
+         FROM operations_task_comment tc
+         LEFT JOIN operations_collaborator actor
+           ON actor.id = tc.actor_collaborator_id
+          AND actor.deleted_at IS NULL
+         LEFT JOIN "user" actor_user
+           ON actor_user.id = actor.user_id
+         LEFT JOIN person actor_person
+           ON actor_person.id = actor.person_id
+        WHERE tc.task_id = $1
+        ORDER BY tc.created_at ASC, tc.id ASC`,
+      [taskId]
+    );
+  }
+
+  async addTaskComment(userId: number, taskId: number, content: string) {
+    const actor = await this.getActorContext(userId);
+    if (!actor.isCollaborator && !actor.isDirector && !actor.isSupervisor) {
+      throw new ForbiddenException(
+        'Operations collaborator access is required.'
+      );
+    }
+
+    const current = await this.getTaskRecordForActor(
+      this.prisma,
+      actor,
+      taskId
+    );
+    await this.assertProjectAccess(actor, current.projectId);
+
+    const normalizedContent = this.normalizeOptionalText(content);
+    if (!normalizedContent) {
+      throw new BadRequestException('Comment content is required.');
+    }
+
+    const inserted = await this.queryRows<{ id: number }>(
+      `INSERT INTO operations_task_comment (
+         task_id,
+         actor_collaborator_id,
+         content,
+         created_at,
+         updated_at
+       ) VALUES ($1, $2, $3, NOW(), NOW())
+       RETURNING id`,
+      [taskId, actor.collaboratorId ?? null, normalizedContent]
+    );
+
+    const commentId = inserted[0]?.id;
+    const comments = await this.listTaskComments(userId, taskId);
+    const createdComment = comments.find((comment) => comment.id === commentId);
+
+    if (!createdComment) {
+      throw new NotFoundException('Task comment could not be loaded.');
+    }
+
+    return createdComment;
+  }
+
+  async updateTaskComment(
+    userId: number,
+    taskId: number,
+    commentId: number,
+    content: string
+  ) {
+    const actor = await this.getActorContext(userId);
+    if (!actor.isCollaborator && !actor.isDirector && !actor.isSupervisor) {
+      throw new ForbiddenException(
+        'Operations collaborator access is required.'
+      );
+    }
+
+    const current = await this.getTaskRecordForActor(
+      this.prisma,
+      actor,
+      taskId
+    );
+    await this.assertProjectAccess(actor, current.projectId);
+
+    const normalizedContent = this.normalizeOptionalText(content);
+    if (!normalizedContent) {
+      throw new BadRequestException('Comment content is required.');
+    }
+
+    const rows = await this.queryRows<{ id: number; actorCollaboratorId: number | null }>(
+      `SELECT id, actor_collaborator_id AS "actorCollaboratorId"
+         FROM operations_task_comment
+        WHERE id = $1 AND task_id = $2`,
+      [commentId, taskId]
+    );
+
+    const row = rows[0];
+    if (!row) {
+      throw new NotFoundException('Comment not found.');
+    }
+
+    if (row.actorCollaboratorId !== actor.collaboratorId) {
+      throw new ForbiddenException('You can only edit your own comments.');
+    }
+
+    await this.queryRows(
+      `UPDATE operations_task_comment
+          SET content = $1, updated_at = NOW()
+        WHERE id = $2`,
+      [normalizedContent, commentId]
+    );
+
+    const comments = await this.listTaskComments(userId, taskId);
+    return comments.find((c) => c.id === commentId) ?? null;
+  }
+
+  async removeTaskComment(
+    userId: number,
+    taskId: number,
+    commentId: number
+  ) {
+    const actor = await this.getActorContext(userId);
+    if (!actor.isCollaborator && !actor.isDirector && !actor.isSupervisor) {
+      throw new ForbiddenException(
+        'Operations collaborator access is required.'
+      );
+    }
+
+    const current = await this.getTaskRecordForActor(
+      this.prisma,
+      actor,
+      taskId
+    );
+    await this.assertProjectAccess(actor, current.projectId);
+
+    const rows = await this.queryRows<{ id: number; actorCollaboratorId: number | null }>(
+      `SELECT id, actor_collaborator_id AS "actorCollaboratorId"
+         FROM operations_task_comment
+        WHERE id = $1 AND task_id = $2`,
+      [commentId, taskId]
+    );
+
+    const row = rows[0];
+    if (!row) {
+      throw new NotFoundException('Comment not found.');
+    }
+
+    if (row.actorCollaboratorId !== actor.collaboratorId) {
+      throw new ForbiddenException('You can only delete your own comments.');
+    }
+
+    await this.queryRows(
+      `DELETE FROM operations_task_comment WHERE id = $1`,
+      [commentId]
+    );
+
+    return { success: true };
+  }
+
   async listTimesheetEntries(
     userId: number,
     paginationParams: {
@@ -5099,6 +5400,7 @@ export class OperationsService {
       status?: string;
       dateFrom?: string;
       dateTo?: string;
+      collaboratorId?: number;
     } = {}
   ) {
     const actor = await this.getActorContext(userId);
@@ -5125,6 +5427,10 @@ export class OperationsService {
       where.push(`t.week_start_date <= ${this.param(params, filters.dateTo)}::date`);
     }
 
+    if (filters.collaboratorId) {
+      where.push(`t.collaborator_id = ${this.param(params, filters.collaboratorId)}`);
+    }
+
     if (pagination?.search) {
       const searchPlaceholder = this.param(params, `%${pagination.search}%`);
       where.push(`(
@@ -5164,6 +5470,7 @@ export class OperationsService {
       reviewedAt: string | null;
       notes: string | null;
       decisionNote: string | null;
+      approvalId: number | null;
     }>(
       `SELECT t.id,
               t.collaborator_id AS "collaboratorId",
@@ -5177,7 +5484,8 @@ export class OperationsService {
               t.submitted_at AS "submittedAt",
               t.reviewed_at AS "reviewedAt",
               t.notes,
-              approval.decision_note AS "decisionNote"
+              approval.decision_note AS "decisionNote",
+              approval.id AS "approvalId"
          FROM operations_timesheet t
          JOIN operations_collaborator c ON c.id = t.collaborator_id
          LEFT JOIN operations_collaborator a ON a.id = t.approver_collaborator_id
@@ -8026,6 +8334,7 @@ export class OperationsService {
       assigneeUserPhotoId: number | null;
       assigneePersonAvatarId: number | null;
       projectAssignmentId: number | null;
+      commentCount: number;
       createdAt: string;
     }>(
       `SELECT t.id,
@@ -8042,6 +8351,7 @@ export class OperationsService {
               au.photo_id AS "assigneeUserPhotoId",
               ap.avatar_id AS "assigneePersonAvatarId",
               t.project_assignment_id AS "projectAssignmentId",
+              COALESCE(task_comments.count, 0)::int AS "commentCount",
               t.created_at AS "createdAt"
          FROM operations_task t
          LEFT JOIN operations_collaborator ac
@@ -8050,6 +8360,11 @@ export class OperationsService {
            ON au.id = ac.user_id
          LEFT JOIN person ap
            ON ap.id = ac.person_id
+         LEFT JOIN LATERAL (
+           SELECT COUNT(*) AS count
+             FROM operations_task_comment tc
+            WHERE tc.task_id = t.id
+         ) task_comments ON TRUE
         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
@@ -8080,6 +8395,7 @@ export class OperationsService {
       assigneePersonAvatarId: number | null;
       projectAssignmentId: number | null;
       projectId: number | null;
+      commentCount: number;
       createdAt: string;
       deletedAt: string | null;
     }>(
@@ -8098,6 +8414,7 @@ export class OperationsService {
               ap.avatar_id AS "assigneePersonAvatarId",
               t.project_assignment_id AS "projectAssignmentId",
               COALESCE(t.project_id, pa.project_id) AS "projectId",
+              COALESCE(task_comments.count, 0)::int AS "commentCount",
               t.created_at AS "createdAt",
               t.deleted_at AS "deletedAt"
          FROM operations_task t
@@ -8107,6 +8424,11 @@ export class OperationsService {
          LEFT JOIN person ap ON ap.id = ac.person_id
          LEFT JOIN operations_project_assignment pa
            ON pa.id = t.project_assignment_id AND pa.deleted_at IS NULL
+         LEFT JOIN LATERAL (
+           SELECT COUNT(*) AS count
+             FROM operations_task_comment tc
+            WHERE tc.task_id = t.id
+         ) task_comments ON TRUE
         WHERE t.id = $1`,
       [taskId]
     );
@@ -11052,12 +11374,18 @@ export class OperationsService {
                 au.photo_id AS "assigneeUserPhotoId",
                 ap.avatar_id AS "assigneePersonAvatarId",
                 t.project_assignment_id AS "projectAssignmentId",
+                COALESCE(task_comments.count, 0)::int AS "commentCount",
                 t.created_at AS "createdAt"
            FROM operations_task t
            LEFT JOIN operations_collaborator ac
              ON ac.id = t.assignee_collaborator_id AND ac.deleted_at IS NULL
            LEFT JOIN "user" au ON au.id = ac.user_id
            LEFT JOIN person ap ON ap.id = ac.person_id
+           LEFT JOIN LATERAL (
+             SELECT COUNT(*) AS count
+               FROM operations_task_comment tc
+              WHERE tc.task_id = t.id
+           ) task_comments ON TRUE
           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
@@ -11121,7 +11449,9 @@ export class OperationsService {
     ];
 
     if (actor.collaboratorId) {
-      filters.push(`pa.collaborator_id = ${this.param(params, actor.collaboratorId)}`);
+      const p1 = this.param(params, actor.collaboratorId);
+      const p2 = this.param(params, actor.collaboratorId);
+      filters.push(`(pa.collaborator_id = ${p1} OR t.assignee_collaborator_id = ${p2})`);
     }
 
     if (pagination.search) {
@@ -11178,6 +11508,7 @@ export class OperationsService {
       assigneeName: string | null;
       assigneeUserPhotoId: number | null;
       assigneePersonAvatarId: number | null;
+      commentCount: number;
       createdAt: string;
       deletedAt: string | null;
     }>(
@@ -11196,6 +11527,7 @@ export class OperationsService {
               ac.display_name AS "assigneeName",
               au.photo_id AS "assigneeUserPhotoId",
               ap.avatar_id AS "assigneePersonAvatarId",
+              COALESCE(task_comments.count, 0)::int AS "commentCount",
               t.created_at AS "createdAt",
               t.deleted_at AS "deletedAt"
          FROM operations_task t
@@ -11208,6 +11540,11 @@ export class OperationsService {
            ON au.id = ac.user_id
          LEFT JOIN person ap
            ON ap.id = ac.person_id
+         LEFT JOIN LATERAL (
+           SELECT COUNT(*) AS count
+             FROM operations_task_comment tc
+            WHERE tc.task_id = t.id
+         ) task_comments ON TRUE
          JOIN operations_project p
            ON p.id = COALESCE(t.project_id, pa.project_id)
         WHERE ${whereClause}
@@ -11442,7 +11779,16 @@ export class OperationsService {
           ? { revenue: 0.9, cost: 0.96, backlog: 0.82 }
           : { revenue: 1, cost: 1, backlog: 1 };
 
-    const params: unknown[] = [from, to];
+    const fromDate = new Date(`${from}T00:00:00`);
+    const toDate = new Date(`${to}T00:00:00`);
+    const periodDays = Math.max(
+      1,
+      Math.floor((toDate.getTime() - fromDate.getTime()) / 86400000) + 1
+    );
+    const periodWeeks = Math.max(1, Math.ceil(periodDays / 7));
+    const periodMonths = periodDays / 30.4375;
+
+    const params: unknown[] = [from, to, periodMonths, periodWeeks];
     const where = [
       'p.deleted_at IS NULL',
       '(p.end_date IS NULL OR p.end_date >= $1::date)',
@@ -11469,6 +11815,8 @@ export class OperationsService {
       weeklyHours: string | null;
       actualHours: string | null;
       billableHours: string | null;
+      realizedCost: string | null;
+      allocatedCost: string | null;
       openTasks: string | null;
       backlogHours: string | null;
       futureDeliveries: string | null;
@@ -11487,6 +11835,8 @@ export class OperationsService {
               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(cost_stats.realized_cost, 0)::text AS "realizedCost",
+              COALESCE(alloc_cost_stats.allocated_cost, 0)::text AS "allocatedCost",
               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"
@@ -11515,6 +11865,146 @@ export class OperationsService {
               AND entry.deleted_at IS NULL
               AND entry.work_date BETWEEN $1::date AND $2::date
          ) time_stats ON TRUE
+         LEFT JOIN LATERAL (
+           SELECT COALESCE(
+                    SUM(
+                      entry.hours
+                      * (
+                        (
+                          COALESCE(collaborator_costs.salary_cost, 0)
+                          + COALESCE(collaborator_costs.benefits_cost, 0)
+                          + COALESCE(collaborator_costs.taxes_cost, 0)
+                          + COALESCE(collaborator_costs.tools_cost, 0)
+                        )
+                        * $3::numeric
+                        / GREATEST(
+                            COALESCE(collaborator_record.weekly_capacity_hours, 40)::numeric * $4::numeric,
+                            COALESCE(collaborator_hours.total_hours, 0),
+                            1
+                          )
+                      )
+                    ),
+                    0
+                  ) AS realized_cost
+             FROM operations_timesheet_entry entry
+             JOIN operations_project_assignment pa
+               ON pa.id = entry.project_assignment_id
+              AND pa.deleted_at IS NULL
+             JOIN operations_collaborator collaborator_record
+               ON collaborator_record.id = pa.collaborator_id
+              AND collaborator_record.deleted_at IS NULL
+             LEFT JOIN LATERAL (
+               SELECT COALESCE(NULLIF(cost_totals.salary_cost, 0), compensation_history.amount, hiring_contract.budget_amount, 0) AS salary_cost,
+                      cost_totals.benefits_cost,
+                      cost_totals.taxes_cost,
+                      cost_totals.tools_cost
+                 FROM (
+                   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 = collaborator_record.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_totals
+                 LEFT JOIN LATERAL (
+                   SELECT h.amount
+                     FROM operations_collaborator_compensation_history h
+                    WHERE h.collaborator_id = collaborator_record.id
+                      AND (h.effective_date IS NULL OR h.effective_date <= $2::date)
+                    ORDER BY h.effective_date DESC NULLS LAST, h.created_at DESC
+                    LIMIT 1
+                 ) compensation_history ON TRUE
+                 LEFT JOIN LATERAL (
+                   SELECT oc.budget_amount
+                     FROM operations_contract oc
+                    WHERE oc.related_collaborator_id = collaborator_record.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
+             ) collaborator_costs ON TRUE
+             LEFT JOIN LATERAL (
+               SELECT COALESCE(SUM(entry2.hours), 0) AS total_hours
+                 FROM operations_timesheet_entry entry2
+                 JOIN operations_project_assignment pa2
+                   ON pa2.id = entry2.project_assignment_id
+                  AND pa2.deleted_at IS NULL
+                WHERE pa2.collaborator_id = collaborator_record.id
+                  AND entry2.deleted_at IS NULL
+                  AND entry2.work_date BETWEEN $1::date AND $2::date
+             ) collaborator_hours ON TRUE
+            WHERE pa.project_id = p.id
+              AND entry.deleted_at IS NULL
+              AND entry.work_date BETWEEN $1::date AND $2::date
+         ) cost_stats ON TRUE
+         LEFT JOIN LATERAL (
+           SELECT COALESCE(
+                    SUM(
+                      pa.weekly_hours
+                      * (
+                        (
+                          COALESCE(alloc_costs.salary_cost, 0)
+                          + COALESCE(alloc_costs.benefits_cost, 0)
+                          + COALESCE(alloc_costs.taxes_cost, 0)
+                          + COALESCE(alloc_costs.tools_cost, 0)
+                        )
+                        * $3::numeric
+                        / GREATEST(
+                            COALESCE(alloc_col.weekly_capacity_hours, 40)::numeric,
+                            1
+                          )
+                      )
+                    ),
+                    0
+                  ) AS allocated_cost
+             FROM operations_project_assignment pa
+             JOIN operations_collaborator alloc_col
+               ON alloc_col.id = pa.collaborator_id
+              AND alloc_col.deleted_at IS NULL
+             LEFT JOIN LATERAL (
+               SELECT COALESCE(NULLIF(ct.salary_cost, 0), ch.amount, hc.budget_amount, 0) AS salary_cost,
+                      ct.benefits_cost,
+                      ct.taxes_cost,
+                      ct.tools_cost
+                 FROM (
+                   SELECT COALESCE(SUM(c.amount) FILTER (WHERE c.recurrence::text = 'monthly' AND ct2.slug IN ('salario-base', 'pro-labore')), 0) AS salary_cost,
+                          COALESCE(SUM(c.amount) FILTER (WHERE c.recurrence::text = 'monthly' AND ct2.slug IN ('vale-refeicao', 'vale-alimentacao', 'vale-transporte', 'plano-saude', 'plano-odontologico', 'seguro-vida')), 0) AS benefits_cost,
+                          COALESCE(SUM(c.amount) FILTER (WHERE c.recurrence::text = 'monthly' AND ct2.slug IN ('inss-patronal', 'fgts', 'rat-fap', 'terceiros-sistema-s', 'provisao-decimo-terceiro', 'provisao-ferias')), 0) AS taxes_cost,
+                          COALESCE(SUM(c.amount) FILTER (WHERE c.recurrence::text = 'monthly' AND ct2.slug IN ('software-licenca', 'equipamento')), 0) AS tools_cost
+                     FROM operations_collaborator_cost c
+                     LEFT JOIN operations_cost_type ct2
+                       ON ct2.id = c.cost_type_id
+                    WHERE c.collaborator_id = alloc_col.id
+                      AND (c.start_date IS NULL OR c.start_date <= $2::date)
+                      AND (c.end_date IS NULL OR c.end_date >= $1::date)
+                 ) ct
+                 LEFT JOIN LATERAL (
+                   SELECT h.amount
+                     FROM operations_collaborator_compensation_history h
+                    WHERE h.collaborator_id = alloc_col.id
+                      AND (h.effective_date IS NULL OR h.effective_date <= $2::date)
+                    ORDER BY h.effective_date DESC NULLS LAST, h.created_at DESC
+                    LIMIT 1
+                 ) ch ON TRUE
+                 LEFT JOIN LATERAL (
+                   SELECT oc.budget_amount
+                     FROM operations_contract oc
+                    WHERE oc.related_collaborator_id = alloc_col.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
+             ) alloc_costs ON TRUE
+            WHERE pa.project_id = p.id
+              AND pa.deleted_at IS NULL
+              AND pa.status IN ('planned', 'active')
+         ) alloc_cost_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,
@@ -11528,12 +12018,6 @@ export class OperationsService {
       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);
@@ -11541,7 +12025,12 @@ export class OperationsService {
         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 realizedCost = Number(row.realizedCost ?? 0);
+        const allocatedCost = Number(row.allocatedCost ?? 0);
+        const consumedHoursCost = realizedCost;
+        const idlenessHours = Math.max(plannedHours - actualHours, 0);
+        const idlenessRate = plannedHours > 0 ? (idlenessHours / plannedHours) * 100 : 0;
+        const idlenessCost = Math.max(allocatedCost - consumedHoursCost, 0);
         const reportStatus =
           row.status === 'paused'
             ? 'paused'
@@ -11576,7 +12065,7 @@ export class OperationsService {
           contractedRevenue,
           recognizedRevenue,
           realizedCost,
-          forecastCost: realizedCost,
+          forecastCost: realizedCost * multiplier.cost,
           teamCost: realizedCost,
           infraCost: 0,
           licenseCost: 0,
@@ -11592,6 +12081,10 @@ export class OperationsService {
           financialProgress: contractedRevenue ? (recognizedRevenue / contractedRevenue) * 100 : 0,
           backlogValue: Math.max(contractedRevenue - recognizedRevenue, 0),
           futureDeliveries: Number(row.futureDeliveries ?? 0),
+          allocatedCost,
+          consumedHoursCost,
+          idlenessRate,
+          idlenessCost,
           risk,
           recommendation:
             risk === 'alto'
@@ -11617,6 +12110,9 @@ export class OperationsService {
         acc.avgDeadline += row.physicalProgress;
         acc.avgAllocation += row.allocatedCapacity;
         acc.atRisk += row.risk === 'alto' ? 1 : 0;
+        acc.allocatedCost += row.allocatedCost;
+        acc.consumedHoursCost += row.consumedHoursCost;
+        acc.idlenessCost += row.idlenessCost;
         return acc;
       },
       {
@@ -11635,6 +12131,11 @@ export class OperationsService {
         avgAllocation: 0,
         atRisk: 0,
         burnRate: 0,
+        allocatedCost: 0,
+        consumedHoursCost: 0,
+        idlenessCost: 0,
+        idlenessRate: 0,
+        plannedProfit: 0,
       }
     );
     summary.profit = summary.recognizedRevenue - summary.realizedCost;
@@ -11642,6 +12143,10 @@ export class OperationsService {
     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;
+    summary.plannedProfit = summary.contractedRevenue - summary.allocatedCost;
+    summary.idlenessRate = summary.plannedHours > 0
+      ? Math.max(0, (summary.plannedHours - summary.actualHours) / summary.plannedHours * 100)
+      : 0;
 
     const forecast = Array.from({ length: 12 }, (_, index) => {
       const monthDate = new Date(fromDate);
@@ -11744,6 +12249,15 @@ export class OperationsService {
         : scenario === 'conservative'
           ? { revenue: 0.9, cost: 0.96, capacity: 0.94 }
           : { revenue: 1, cost: 1, capacity: 1 };
+    const fromDate = new Date(`${from}T00:00:00`);
+    const toDate = new Date(`${to}T00:00:00`);
+    const periodDays = Math.max(
+      1,
+      Math.floor((toDate.getTime() - fromDate.getTime()) / 86400000) + 1
+    );
+    const periodWeeks = Math.max(1, Math.ceil(periodDays / 7));
+    const periodMonths = periodDays / 30.4375;
+
     const params: unknown[] = [from, to];
     const where = [
       'c.deleted_at IS NULL',
@@ -11774,6 +12288,11 @@ export class OperationsService {
       taxesCost: string | null;
       toolsCost: string | null;
       billableValue: string | null;
+      plannedAllocatedHours: string | null;
+      plannedBillableHours: string | null;
+      openTaskHours: string | null;
+      openTaskBillableHours: string | null;
+      openTasks: string | null;
       allocatedHours: string | null;
       billableHours: string | null;
       projects: string | null;
@@ -11792,9 +12311,14 @@ export class OperationsService {
               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(assignment_stats.planned_allocated_hours, 0)::text AS "plannedAllocatedHours",
+              COALESCE(assignment_stats.planned_billable_hours, 0)::text AS "plannedBillableHours",
+              COALESCE(task_stats.open_task_hours, 0)::text AS "openTaskHours",
+              COALESCE(task_stats.open_task_billable_hours, 0)::text AS "openTaskBillableHours",
+              COALESCE(task_stats.open_tasks, 0)::text AS "openTasks",
               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
+              COALESCE(assignment_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
@@ -11807,16 +12331,85 @@ export class OperationsService {
            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)
+           SELECT COALESCE(NULLIF(cost_totals.salary_cost, 0), compensation_history.amount, hiring_contract.budget_amount, 0) AS salary_cost,
+                  cost_totals.benefits_cost,
+                  cost_totals.taxes_cost,
+                  cost_totals.tools_cost
+             FROM (
+               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_totals
+             LEFT JOIN LATERAL (
+               SELECT h.amount
+                 FROM operations_collaborator_compensation_history h
+                WHERE h.collaborator_id = c.id
+                  AND (h.effective_date IS NULL OR h.effective_date <= $2::date)
+                ORDER BY h.effective_date DESC NULLS LAST, h.created_at DESC
+                LIMIT 1
+             ) compensation_history ON TRUE
+             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
+             ) hiring_contract ON TRUE
          ) cost_stats ON TRUE
+         LEFT JOIN LATERAL (
+           SELECT COALESCE(
+                    SUM(
+                      COALESCE(
+                        pa.weekly_hours,
+                        COALESCE(c.weekly_capacity_hours, 40) * COALESCE(pa.allocation_percent, 0) / 100
+                      ) * GREATEST(
+                        CEIL(
+                          (
+                            LEAST(COALESCE(pa.end_date, $2::date), $2::date)
+                            - GREATEST(COALESCE(pa.start_date, $1::date), $1::date)
+                            + 1
+                          ) / 7.0
+                        ),
+                        0
+                      )
+                    ),
+                    0
+                  ) AS planned_allocated_hours,
+                  COALESCE(
+                    SUM(
+                      COALESCE(
+                        pa.weekly_hours,
+                        COALESCE(c.weekly_capacity_hours, 40) * COALESCE(pa.allocation_percent, 0) / 100
+                      ) * GREATEST(
+                        CEIL(
+                          (
+                            LEAST(COALESCE(pa.end_date, $2::date), $2::date)
+                            - GREATEST(COALESCE(pa.start_date, $1::date), $1::date)
+                            + 1
+                          ) / 7.0
+                        ),
+                        0
+                      )
+                    ) FILTER (WHERE pa.is_billable = true),
+                    0
+                  ) AS planned_billable_hours,
+                  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')
+              AND (pa.start_date IS NULL OR pa.start_date <= $2::date)
+              AND (pa.end_date IS NULL OR pa.end_date >= $1::date)
+         ) assignment_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,
@@ -11830,31 +12423,50 @@ export class OperationsService {
               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
+           SELECT COUNT(*) AS open_tasks,
+                  COALESCE(SUM(COALESCE(task.estimate_hours, 0)), 0) AS open_task_hours,
+                  COALESCE(
+                    SUM(COALESCE(task.estimate_hours, 0)) FILTER (WHERE pa.is_billable = true),
+                    0
+                  ) AS open_task_billable_hours
+             FROM operations_task task
+             LEFT JOIN operations_project_assignment pa
+               ON pa.id = task.project_assignment_id
               AND pa.deleted_at IS NULL
-              AND pa.status IN ('planned', 'active')
-         ) project_stats ON TRUE
+            WHERE task.deleted_at IS NULL
+              AND task.status IN ('todo', 'doing', 'review')
+              AND (
+                task.assignee_collaborator_id = c.id
+                OR pa.collaborator_id = c.id
+              )
+         ) task_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 salaryCost = Number(row.salaryCost ?? 0) * periodMonths;
+      const benefitsCost = Number(row.benefitsCost ?? 0) * periodMonths;
+      const taxesCost = Number(row.taxesCost ?? 0) * periodMonths;
+      const toolsCost = Number(row.toolsCost ?? 0) * periodMonths;
       const availableHours = Number(row.weeklyCapacityHours ?? 40) * periodWeeks;
-      const allocatedHours = Number(row.allocatedHours ?? 0);
-      const billableHours = Number(row.billableHours ?? 0);
+      const plannedAllocatedHours = Number(row.plannedAllocatedHours ?? 0);
+      const plannedBillableHours = Number(row.plannedBillableHours ?? 0);
+      const openTaskHours = Number(row.openTaskHours ?? 0);
+      const openTaskBillableHours = Number(row.openTaskBillableHours ?? 0);
+      const actualAllocatedHours = Number(row.allocatedHours ?? 0);
+      const actualBillableHours = Number(row.billableHours ?? 0);
+      const allocatedHours = Math.max(
+        actualAllocatedHours,
+        plannedAllocatedHours,
+        openTaskHours
+      );
+      const billableHours = Math.max(
+        actualBillableHours,
+        plannedBillableHours,
+        openTaskBillableHours
+      );
       const allocation = availableHours ? (allocatedHours / availableHours) * 100 : 0;
       const risk = allocation >= 98 ? 'alto' : allocation < 75 ? 'médio' : 'baixo';
       return {
@@ -11929,7 +12541,11 @@ export class OperationsService {
     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;
+    summary.hourlyCost = summary.allocatedHours
+      ? summary.cost / summary.allocatedHours
+      : summary.availableHours
+        ? summary.cost / summary.availableHours
+        : 0;
 
     const forecast = Array.from({ length: 12 }, (_, index) => {
       const monthDate = new Date(fromDate);
@@ -12173,4 +12789,1623 @@ export class OperationsService {
 
     return { success: true };
   }
+
+  // ──────────────────────────────────────────────────────────────────────────
+  // Project Cost Categories
+  // ──────────────────────────────────────────────────────────────────────────
+
+  async listProjectCostCategories(userId: number, filters: { search?: string; is_active?: boolean; pageSize?: number; page?: number } = {}) {
+    await this.getActorContext(userId);
+    const localeId = await this.resolvePreferredLocaleId();
+
+    const params: unknown[] = [localeId];
+    const where: string[] = ['pcc.deleted_at IS NULL'];
+
+    if (filters.is_active === true) {
+      where.push('pcc.is_active = true');
+    }
+
+    if (filters.search?.trim()) {
+      const p = this.param(params, `%${filters.search.trim()}%`);
+      where.push(`(COALESCE(pccl.name, pcc.slug) ILIKE ${p} OR COALESCE(pcc.slug, '') ILIKE ${p})`);
+    }
+
+    const whereClause = `WHERE ${where.join(' AND ')}`;
+
+    return this.queryRows<{
+      id: number;
+      slug: string;
+      name: string | null;
+      description: string | null;
+      icon: string | null;
+      color: string | null;
+      isActive: boolean;
+      sortOrder: number;
+      createdAt: string;
+    }>(
+      `SELECT pcc.id,
+              pcc.slug,
+              COALESCE(pccl.name, pcc.slug) AS name,
+              pccl.description,
+              pcc.icon,
+              pcc.color,
+              pcc.is_active AS "isActive",
+              pcc.sort_order AS "sortOrder",
+              pcc.created_at AS "createdAt"
+         FROM operations_project_cost_category pcc
+         LEFT JOIN LATERAL (
+           SELECT l.name, l.description
+             FROM operations_project_cost_category_locale l
+            WHERE l.operations_project_cost_category_id = pcc.id
+            ORDER BY CASE WHEN $1::int IS NOT NULL AND l.locale_id = $1 THEN 0 ELSE 1 END ASC,
+                     l.id ASC
+            LIMIT 1
+         ) pccl ON TRUE
+        ${whereClause}
+        ORDER BY pcc.sort_order ASC, COALESCE(pccl.name, pcc.slug) ASC`,
+      params
+    );
+  }
+
+  async createProjectCostCategory(userId: number, data: { slug: string; name?: any; description?: any; icon?: string | null; color?: string | null; is_active?: boolean; sort_order?: number }) {
+    const actor = await this.getActorContext(userId);
+    this.ensureDirector(actor);
+
+    const slug = data.slug?.trim();
+    if (!slug) {
+      throw new BadRequestException('Cost category slug is required.');
+    }
+
+    return this.prisma.$transaction(async (tx) => {
+      const localeId = await this.resolvePreferredLocaleId(tx as any);
+
+      const created = (await (tx as any).$queryRawUnsafe(
+        `INSERT INTO operations_project_cost_category (slug, icon, color, is_active, sort_order, created_at, updated_at)
+         VALUES ($1, $2, $3, $4, $5, NOW(), NOW())
+         RETURNING id`,
+        slug,
+        data.icon ?? null,
+        data.color ?? null,
+        data.is_active ?? true,
+        data.sort_order ?? 0,
+      )) as { id: number }[];
+
+      const createdId = created[0]?.id;
+      if (!createdId) {
+        throw new BadRequestException('Unable to create project cost category.');
+      }
+
+      const name = typeof data.name === 'string' ? data.name : (data.name ? JSON.stringify(data.name) : slug);
+      const description = typeof data.description === 'string' ? data.description : (data.description ? JSON.stringify(data.description) : null);
+
+      if (localeId && name) {
+        await (tx as any).$executeRawUnsafe(
+          `INSERT INTO operations_project_cost_category_locale (operations_project_cost_category_id, locale_id, name, description)
+           VALUES ($1, $2, $3, $4)`,
+          createdId,
+          localeId,
+          name,
+          description ?? null,
+        );
+      }
+
+      const rows = (await (tx as any).$queryRawUnsafe(
+        `SELECT pcc.id,
+                pcc.slug,
+                COALESCE(pccl.name, pcc.slug) AS name,
+                pccl.description,
+                pcc.icon,
+                pcc.color,
+                pcc.is_active AS "isActive",
+                pcc.sort_order AS "sortOrder",
+                pcc.created_at AS "createdAt"
+           FROM operations_project_cost_category pcc
+           LEFT JOIN operations_project_cost_category_locale pccl
+             ON pccl.operations_project_cost_category_id = pcc.id AND pccl.locale_id = $2
+          WHERE pcc.id = $1`,
+        createdId,
+        localeId,
+      )) as { id: number; slug: string; name: string; description: string | null; icon: string | null; color: string | null; isActive: boolean; sortOrder: number; createdAt: string }[];
+
+      return rows[0] ?? null;
+    });
+  }
+
+  async updateProjectCostCategory(userId: number, id: number, data: Partial<{ slug: string; name?: any; description?: any; icon?: string | null; color?: string | null; is_active?: boolean; sort_order?: number }>) {
+    const actor = await this.getActorContext(userId);
+    this.ensureDirector(actor);
+
+    const category = await this.querySingle<{ id: number }>(
+      `SELECT id FROM operations_project_cost_category WHERE id = $1 AND deleted_at IS NULL LIMIT 1`,
+      [id]
+    );
+    if (!category) {
+      throw new NotFoundException('Project cost category not found.');
+    }
+
+    const sets: string[] = [];
+    const params: unknown[] = [];
+
+    if (data.slug !== undefined) sets.push(`slug = ${this.param(params, data.slug)}`);
+    if (data.icon !== undefined) sets.push(`icon = ${this.param(params, data.icon)}`);
+    if (data.color !== undefined) sets.push(`color = ${this.param(params, data.color)}`);
+    if (data.is_active !== undefined) sets.push(`is_active = ${this.param(params, data.is_active)}`);
+    if (data.sort_order !== undefined) sets.push(`sort_order = ${this.param(params, data.sort_order)}`);
+
+    if (sets.length > 0) {
+      sets.push(`updated_at = NOW()`);
+      await this.prisma.$queryRawUnsafe(
+        `UPDATE operations_project_cost_category SET ${sets.join(', ')} WHERE id = ${this.param(params, id)}`,
+        ...params
+      );
+    }
+
+    if (data.name !== undefined || data.description !== undefined) {
+      const localeId = await this.resolvePreferredLocaleId();
+      if (localeId) {
+        const name = typeof data.name === 'string' ? data.name : (data.name ? JSON.stringify(data.name) : undefined);
+        const description = typeof data.description === 'string' ? data.description : (data.description ? JSON.stringify(data.description) : null);
+        const existing = await this.querySingle<{ id: number }>(
+          `SELECT id FROM operations_project_cost_category_locale WHERE operations_project_cost_category_id = $1 AND locale_id = $2 LIMIT 1`,
+          [id, localeId]
+        );
+        if (existing) {
+          const localeSets: string[] = [];
+          const localeParams: unknown[] = [];
+          if (name !== undefined) localeSets.push(`name = ${this.param(localeParams, name)}`);
+          if (description !== undefined) localeSets.push(`description = ${this.param(localeParams, description)}`);
+          if (localeSets.length > 0) {
+            await this.prisma.$queryRawUnsafe(
+              `UPDATE operations_project_cost_category_locale SET ${localeSets.join(', ')} WHERE operations_project_cost_category_id = ${this.param(localeParams, id)} AND locale_id = ${this.param(localeParams, localeId)}`,
+              ...localeParams
+            );
+          }
+        } else if (name) {
+          await this.prisma.$queryRawUnsafe(
+            `INSERT INTO operations_project_cost_category_locale (operations_project_cost_category_id, locale_id, name, description) VALUES ($1, $2, $3, $4)`,
+            id, localeId, name, description ?? null
+          );
+        }
+      }
+    }
+
+    return this.querySingle<{ id: number; slug: string }>(
+      `SELECT id, slug FROM operations_project_cost_category WHERE id = $1`,
+      [id]
+    );
+  }
+
+  async deleteProjectCostCategory(userId: number, id: number) {
+    const actor = await this.getActorContext(userId);
+    this.ensureDirector(actor);
+
+    const category = await this.querySingle<{ id: number }>(
+      `SELECT id FROM operations_project_cost_category WHERE id = $1 AND deleted_at IS NULL LIMIT 1`,
+      [id]
+    );
+    if (!category) {
+      throw new NotFoundException('Project cost category not found.');
+    }
+
+    await this.prisma.$queryRawUnsafe(
+      `UPDATE operations_project_cost_category SET deleted_at = NOW() WHERE id = $1`,
+      id
+    );
+
+    return { success: true };
+  }
+
+  async getProjectCostCategory(userId: number, id: number) {
+    await this.getActorContext(userId);
+    const localeId = await this.resolvePreferredLocaleId();
+
+    const row = await this.querySingle<{
+      id: number;
+      slug: string;
+      name: string | null;
+      description: string | null;
+      icon: string | null;
+      color: string | null;
+      isActive: boolean;
+      sortOrder: number;
+      createdAt: string;
+    }>(
+      `SELECT pcc.id,
+              pcc.slug,
+              COALESCE(pccl.name, pcc.slug) AS name,
+              pccl.description,
+              pcc.icon,
+              pcc.color,
+              pcc.is_active AS "isActive",
+              pcc.sort_order AS "sortOrder",
+              pcc.created_at AS "createdAt"
+         FROM operations_project_cost_category pcc
+         LEFT JOIN LATERAL (
+           SELECT l.name, l.description
+             FROM operations_project_cost_category_locale l
+            WHERE l.operations_project_cost_category_id = pcc.id
+            ORDER BY CASE WHEN $1::int IS NOT NULL AND l.locale_id = $1 THEN 0 ELSE 1 END ASC,
+                     l.id ASC
+            LIMIT 1
+         ) pccl ON TRUE
+        WHERE pcc.id = $2 AND pcc.deleted_at IS NULL`,
+      [localeId, id]
+    );
+
+    if (!row) {
+      throw new NotFoundException('Project cost category not found.');
+    }
+
+    return row;
+  }
+
+  // ──────────────────────────────────────────────────────────────────────────
+  // Project Cost Types
+  // ──────────────────────────────────────────────────────────────────────────
+
+  async listProjectCostTypes(userId: number, filters: { search?: string; category_id?: number; is_active?: boolean; default_calculation_type?: string; pageSize?: number; page?: number } = {}) {
+    await this.getActorContext(userId);
+    const localeId = await this.resolvePreferredLocaleId();
+
+    const params: unknown[] = [localeId];
+    const where: string[] = ['pct.deleted_at IS NULL'];
+
+    if (filters.is_active === true) {
+      where.push('pct.is_active = true');
+    }
+
+    if (filters.category_id) {
+      where.push(`pct.category_id = ${this.param(params, filters.category_id)}`);
+    }
+
+    if (filters.default_calculation_type) {
+      where.push(`pct.default_calculation_type = ${this.param(params, filters.default_calculation_type)}`);
+    }
+
+    if (filters.search?.trim()) {
+      const p = this.param(params, `%${filters.search.trim()}%`);
+      where.push(`(COALESCE(pctl.name, pct.slug) ILIKE ${p} OR COALESCE(pct.code, '') ILIKE ${p} OR COALESCE(pct.slug, '') ILIKE ${p})`);
+    }
+
+    const whereClause = `WHERE ${where.join(' AND ')}`;
+
+    return this.queryRows<{
+      id: number;
+      slug: string;
+      code: string;
+      name: string | null;
+      description: string | null;
+      categoryId: number | null;
+      categorySlug: string | null;
+      categoryName: string | null;
+      defaultUnit: string | null;
+      defaultCalculationType: string | null;
+      isRecurringAllowed: boolean;
+      isActive: boolean;
+      sortOrder: number;
+      createdAt: string;
+    }>(
+      `SELECT pct.id,
+              pct.slug,
+              pct.code,
+              COALESCE(pctl.name, pct.slug) AS name,
+              pctl.description,
+              pct.category_id AS "categoryId",
+              pcc.slug AS "categorySlug",
+              COALESCE(pccl.name, pcc.slug) AS "categoryName",
+              pct.default_unit AS "defaultUnit",
+              pct.default_calculation_type AS "defaultCalculationType",
+              pct.is_recurring_allowed AS "isRecurringAllowed",
+              pct.is_active AS "isActive",
+              pct.sort_order AS "sortOrder",
+              pct.created_at AS "createdAt"
+         FROM operations_project_cost_type pct
+         LEFT JOIN operations_project_cost_category pcc
+           ON pcc.id = pct.category_id AND pcc.deleted_at IS NULL
+         LEFT JOIN LATERAL (
+           SELECT l.name, l.description
+             FROM operations_project_cost_category_locale l
+            WHERE l.operations_project_cost_category_id = pcc.id
+            ORDER BY CASE WHEN $1::int IS NOT NULL AND l.locale_id = $1 THEN 0 ELSE 1 END ASC,
+                     l.id ASC
+            LIMIT 1
+         ) pccl ON TRUE
+         LEFT JOIN LATERAL (
+           SELECT l.name, l.description
+             FROM operations_project_cost_type_locale l
+            WHERE l.operations_project_cost_type_id = pct.id
+            ORDER BY CASE WHEN $1::int IS NOT NULL AND l.locale_id = $1 THEN 0 ELSE 1 END ASC,
+                     l.id ASC
+            LIMIT 1
+         ) pctl ON TRUE
+        ${whereClause}
+        ORDER BY pct.sort_order ASC, COALESCE(pctl.name, pct.slug) ASC`,
+      params
+    );
+  }
+
+  async createProjectCostType(userId: number, data: { category_id?: number; slug: string; code: string; name?: any; description?: any; default_unit?: string | null; default_calculation_type?: string | null; is_recurring_allowed?: boolean; is_active?: boolean; sort_order?: number }) {
+    const actor = await this.getActorContext(userId);
+    this.ensureDirector(actor);
+
+    const slug = data.slug?.trim();
+    if (!slug) {
+      throw new BadRequestException('Cost type slug is required.');
+    }
+
+    if (data.category_id) {
+      const category = await this.querySingle<{ id: number }>(
+        `SELECT id FROM operations_project_cost_category WHERE id = $1 AND deleted_at IS NULL LIMIT 1`,
+        [data.category_id]
+      );
+      if (!category) {
+        throw new BadRequestException(`Category with id ${data.category_id} not found.`);
+      }
+    }
+
+    const existingSlug = await this.querySingle<{ id: number }>(
+      `SELECT id FROM operations_project_cost_type WHERE slug = $1 AND deleted_at IS NULL LIMIT 1`,
+      [slug]
+    );
+    if (existingSlug) {
+      throw new ConflictException(`A cost type with slug '${slug}' already exists.`);
+    }
+
+    const code = data.code?.trim() ?? slug;
+    const existingCode = await this.querySingle<{ id: number }>(
+      `SELECT id FROM operations_project_cost_type WHERE code = $1 AND deleted_at IS NULL LIMIT 1`,
+      [code]
+    );
+    if (existingCode) {
+      throw new ConflictException(`A cost type with code '${code}' already exists.`);
+    }
+
+    return this.prisma.$transaction(async (tx) => {
+      const localeId = await this.resolvePreferredLocaleId(tx as any);
+
+      const created = (await (tx as any).$queryRawUnsafe(
+        `INSERT INTO operations_project_cost_type (category_id, slug, code, default_unit, default_calculation_type, is_recurring_allowed, is_active, sort_order, created_at, updated_at)
+         VALUES ($1, $2, $3, $4, $5, $6, $7, $8, NOW(), NOW())
+         RETURNING id`,
+        data.category_id ?? null,
+        slug,
+        data.code?.trim() ?? slug,
+        data.default_unit ?? null,
+        data.default_calculation_type ?? 'fixed',
+        data.is_recurring_allowed ?? true,
+        data.is_active ?? true,
+        data.sort_order ?? 0,
+      )) as { id: number }[];
+
+      const createdId = created[0]?.id;
+      if (!createdId) {
+        throw new BadRequestException('Unable to create project cost type.');
+      }
+
+      const name = typeof data.name === 'string' ? data.name : (data.name ? JSON.stringify(data.name) : slug);
+      const description = typeof data.description === 'string' ? data.description : (data.description ? JSON.stringify(data.description) : null);
+
+      if (localeId && name) {
+        await (tx as any).$executeRawUnsafe(
+          `INSERT INTO operations_project_cost_type_locale (operations_project_cost_type_id, locale_id, name, description)
+           VALUES ($1, $2, $3, $4)`,
+          createdId,
+          localeId,
+          name,
+          description ?? null,
+        );
+      }
+
+      const rows = (await (tx as any).$queryRawUnsafe(
+        `SELECT pct.id,
+                pct.slug,
+                pct.code,
+                COALESCE(pctl.name, pct.slug) AS name,
+                pctl.description,
+                pct.category_id AS "categoryId",
+                pct.default_unit AS "defaultUnit",
+                pct.default_calculation_type AS "defaultCalculationType",
+                pct.is_recurring_allowed AS "isRecurringAllowed",
+                pct.is_active AS "isActive",
+                pct.sort_order AS "sortOrder",
+                pct.created_at AS "createdAt"
+           FROM operations_project_cost_type pct
+           LEFT JOIN operations_project_cost_type_locale pctl
+             ON pctl.operations_project_cost_type_id = pct.id AND pctl.locale_id = $2
+          WHERE pct.id = $1`,
+        createdId,
+        localeId,
+      )) as any[];
+
+      return rows[0] ?? null;
+    });
+  }
+
+  async updateProjectCostType(userId: number, id: number, data: Partial<{ category_id: number; slug: string; code: string; name?: any; description?: any; default_unit?: string | null; default_calculation_type?: string | null; is_recurring_allowed?: boolean; is_active?: boolean; sort_order?: number }>) {
+    const actor = await this.getActorContext(userId);
+    this.ensureDirector(actor);
+
+    const costType = await this.querySingle<{ id: number }>(
+      `SELECT id FROM operations_project_cost_type WHERE id = $1 AND deleted_at IS NULL LIMIT 1`,
+      [id]
+    );
+    if (!costType) {
+      throw new NotFoundException('Project cost type not found.');
+    }
+
+    if (data.category_id !== undefined && data.category_id !== null) {
+      const category = await this.querySingle<{ id: number }>(
+        `SELECT id FROM operations_project_cost_category WHERE id = $1 AND deleted_at IS NULL LIMIT 1`,
+        [data.category_id]
+      );
+      if (!category) {
+        throw new BadRequestException(`Category with id ${data.category_id} not found.`);
+      }
+    }
+
+    if (data.slug !== undefined) {
+      const existingSlug = await this.querySingle<{ id: number }>(
+        `SELECT id FROM operations_project_cost_type WHERE slug = $1 AND id != $2 AND deleted_at IS NULL LIMIT 1`,
+        [data.slug, id]
+      );
+      if (existingSlug) {
+        throw new ConflictException(`A cost type with slug '${data.slug}' already exists.`);
+      }
+    }
+
+    if (data.code !== undefined) {
+      const existingCode = await this.querySingle<{ id: number }>(
+        `SELECT id FROM operations_project_cost_type WHERE code = $1 AND id != $2 AND deleted_at IS NULL LIMIT 1`,
+        [data.code, id]
+      );
+      if (existingCode) {
+        throw new ConflictException(`A cost type with code '${data.code}' already exists.`);
+      }
+    }
+
+    const sets: string[] = [];
+    const params: unknown[] = [];
+
+    if (data.category_id !== undefined) sets.push(`category_id = ${this.param(params, data.category_id)}`);
+    if (data.slug !== undefined) sets.push(`slug = ${this.param(params, data.slug)}`);
+    if (data.code !== undefined) sets.push(`code = ${this.param(params, data.code)}`);
+    if (data.default_unit !== undefined) sets.push(`default_unit = ${this.param(params, data.default_unit)}`);
+    if (data.default_calculation_type !== undefined) sets.push(`default_calculation_type = ${this.param(params, data.default_calculation_type)}`);
+    if (data.is_recurring_allowed !== undefined) sets.push(`is_recurring_allowed = ${this.param(params, data.is_recurring_allowed)}`);
+    if (data.is_active !== undefined) sets.push(`is_active = ${this.param(params, data.is_active)}`);
+    if (data.sort_order !== undefined) sets.push(`sort_order = ${this.param(params, data.sort_order)}`);
+
+    if (sets.length > 0) {
+      sets.push(`updated_at = NOW()`);
+      await this.prisma.$queryRawUnsafe(
+        `UPDATE operations_project_cost_type SET ${sets.join(', ')} WHERE id = ${this.param(params, id)}`,
+        ...params
+      );
+    }
+
+    if (data.name !== undefined || data.description !== undefined) {
+      const localeId = await this.resolvePreferredLocaleId();
+      if (localeId) {
+        const name = typeof data.name === 'string' ? data.name : (data.name ? JSON.stringify(data.name) : undefined);
+        const description = typeof data.description === 'string' ? data.description : (data.description ? JSON.stringify(data.description) : null);
+        const existing = await this.querySingle<{ id: number }>(
+          `SELECT id FROM operations_project_cost_type_locale WHERE operations_project_cost_type_id = $1 AND locale_id = $2 LIMIT 1`,
+          [id, localeId]
+        );
+        if (existing) {
+          const localeSets: string[] = [];
+          const localeParams: unknown[] = [];
+          if (name !== undefined) localeSets.push(`name = ${this.param(localeParams, name)}`);
+          if (description !== undefined) localeSets.push(`description = ${this.param(localeParams, description)}`);
+          if (localeSets.length > 0) {
+            await this.prisma.$queryRawUnsafe(
+              `UPDATE operations_project_cost_type_locale SET ${localeSets.join(', ')} WHERE operations_project_cost_type_id = ${this.param(localeParams, id)} AND locale_id = ${this.param(localeParams, localeId)}`,
+              ...localeParams
+            );
+          }
+        } else if (name) {
+          await this.prisma.$queryRawUnsafe(
+            `INSERT INTO operations_project_cost_type_locale (operations_project_cost_type_id, locale_id, name, description) VALUES ($1, $2, $3, $4)`,
+            id, localeId, name, description ?? null
+          );
+        }
+      }
+    }
+
+    return this.querySingle<{ id: number; slug: string }>(
+      `SELECT id, slug FROM operations_project_cost_type WHERE id = $1`,
+      [id]
+    );
+  }
+
+  async deleteProjectCostType(userId: number, id: number) {
+    const actor = await this.getActorContext(userId);
+    this.ensureDirector(actor);
+
+    const costType = await this.querySingle<{ id: number }>(
+      `SELECT id FROM operations_project_cost_type WHERE id = $1 AND deleted_at IS NULL LIMIT 1`,
+      [id]
+    );
+    if (!costType) {
+      throw new NotFoundException('Project cost type not found.');
+    }
+
+    await this.prisma.$queryRawUnsafe(
+      `UPDATE operations_project_cost_type SET deleted_at = NOW() WHERE id = $1`,
+      id
+    );
+
+    return { success: true };
+  }
+
+  async getProjectCostType(userId: number, id: number) {
+    await this.getActorContext(userId);
+    const localeId = await this.resolvePreferredLocaleId();
+
+    const row = await this.querySingle<{
+      id: number;
+      slug: string;
+      code: string;
+      name: string | null;
+      description: string | null;
+      default_unit: string | null;
+      default_calculation_type: string | null;
+      is_recurring_allowed: boolean;
+      is_active: boolean;
+      sort_order: number;
+      category_id: number | null;
+      category: { id: number; slug: string; name: string | null; color: string | null; icon: string | null } | null;
+    }>(
+      `SELECT pct.id,
+              pct.slug,
+              pct.code,
+              COALESCE(pctl.name, pct.slug) AS name,
+              pctl.description,
+              pct.default_unit,
+              pct.default_calculation_type,
+              pct.is_recurring_allowed,
+              pct.is_active,
+              pct.sort_order,
+              pct.category_id,
+              CASE WHEN pcc.id IS NOT NULL THEN
+                jsonb_build_object(
+                  'id', pcc.id,
+                  'slug', pcc.slug,
+                  'name', COALESCE(pccl.name, pcc.slug),
+                  'color', pcc.color,
+                  'icon', pcc.icon
+                )
+              ELSE NULL END AS category
+         FROM operations_project_cost_type pct
+         LEFT JOIN operations_project_cost_category pcc
+           ON pcc.id = pct.category_id AND pcc.deleted_at IS NULL
+         LEFT JOIN LATERAL (
+           SELECT l.name, l.description
+             FROM operations_project_cost_category_locale l
+            WHERE l.operations_project_cost_category_id = pcc.id
+            ORDER BY CASE WHEN $1::int IS NOT NULL AND l.locale_id = $1 THEN 0 ELSE 1 END ASC,
+                     l.id ASC
+            LIMIT 1
+         ) pccl ON TRUE
+         LEFT JOIN LATERAL (
+           SELECT l.name, l.description
+             FROM operations_project_cost_type_locale l
+            WHERE l.operations_project_cost_type_id = pct.id
+            ORDER BY CASE WHEN $1::int IS NOT NULL AND l.locale_id = $1 THEN 0 ELSE 1 END ASC,
+                     l.id ASC
+            LIMIT 1
+         ) pctl ON TRUE
+        WHERE pct.id = $2 AND pct.deleted_at IS NULL`,
+      [localeId, id]
+    );
+
+    if (!row) {
+      throw new NotFoundException('Project cost type not found.');
+    }
+
+    return row;
+  }
+
+  // ──────────────────────────────────────────────────────────────────────────
+  // Project Costs
+  // ──────────────────────────────────────────────────────────────────────────
+
+  async listProjectCosts(userId: number, projectId: number, filters: {
+    search?: string;
+    cost_type_id?: number;
+    category_id?: number;
+    recurrence_type?: string;
+    calculation_type?: string;
+    status?: string;
+    is_billable?: boolean;
+    is_reimbursable?: boolean;
+    date_from?: string;
+    date_to?: string;
+  } = {}) {
+    await this.getActorContext(userId);
+    const localeId = await this.resolvePreferredLocaleId();
+
+    const params: unknown[] = [localeId, projectId];
+    const where: string[] = ['pc.deleted_at IS NULL', 'pc.project_id = $2'];
+
+    if (filters.cost_type_id) {
+      where.push(`pc.cost_type_id = ${this.param(params, filters.cost_type_id)}`);
+    }
+
+    if (filters.category_id) {
+      where.push(`COALESCE(pc.category_id, pct.category_id) = ${this.param(params, filters.category_id)}`);
+    }
+
+    if (filters.recurrence_type) {
+      where.push(`pc.recurrence_type = ${this.param(params, filters.recurrence_type)}`);
+    }
+
+    if (filters.calculation_type) {
+      where.push(`pc.calculation_type = ${this.param(params, filters.calculation_type)}`);
+    }
+
+    if (filters.status) {
+      where.push(`pc.status = ${this.param(params, filters.status)}`);
+    }
+
+    if (filters.is_billable !== undefined) {
+      where.push(`pc.is_billable = ${this.param(params, filters.is_billable)}`);
+    }
+
+    if (filters.is_reimbursable !== undefined) {
+      where.push(`pc.is_reimbursable = ${this.param(params, filters.is_reimbursable)}`);
+    }
+
+    if (filters.date_from) {
+      where.push(`pc.cost_date >= ${this.param(params, filters.date_from)}::date`);
+    }
+
+    if (filters.date_to) {
+      where.push(`pc.cost_date <= ${this.param(params, filters.date_to)}::date`);
+    }
+
+    if (filters.search?.trim()) {
+      const p = this.param(params, `%${filters.search.trim()}%`);
+      where.push(`(COALESCE(pc.description, '') ILIKE ${p} OR COALESCE(pc.notes, '') ILIKE ${p})`);
+    }
+
+    const whereClause = `WHERE ${where.join(' AND ')}`;
+
+    const rows = await this.queryRows<{
+      id: number;
+      projectId: number;
+      costTypeId: number | null;
+      costTypeSlug: string | null;
+      costTypeCode: string | null;
+      costTypeName: string | null;
+      categoryId: number | null;
+      resolvedCategoryId: number | null;
+      categorySlug: string | null;
+      categoryName: string | null;
+      categoryColor: string | null;
+      categoryIcon: string | null;
+      description: string | null;
+      amount: string;
+      quantity: string;
+      unitAmount: string | null;
+      currency: string;
+      costDate: string | null;
+      periodStart: string | null;
+      periodEnd: string | null;
+      calculationType: string;
+      recurrenceType: string;
+      isBillable: boolean;
+      isReimbursable: boolean;
+      notes: string | null;
+      status: string;
+      createdAt: string;
+    }>(
+      `SELECT pc.id,
+              pc.project_id AS "projectId",
+              pc.cost_type_id AS "costTypeId",
+              pct.slug AS "costTypeSlug",
+              pct.code AS "costTypeCode",
+              COALESCE(pctl.name, pct.slug) AS "costTypeName",
+              pc.category_id AS "categoryId",
+              COALESCE(pc.category_id, pct.category_id) AS "resolvedCategoryId",
+              pcc.slug AS "categorySlug",
+              COALESCE(pccl.name, pcc.slug) AS "categoryName",
+              pcc.color AS "categoryColor",
+              pcc.icon AS "categoryIcon",
+              pc.description,
+              pc.amount::text AS amount,
+              pc.quantity::text AS quantity,
+              pc.unit_amount::text AS "unitAmount",
+              pc.currency,
+              TO_CHAR(pc.cost_date, 'YYYY-MM-DD') AS "costDate",
+              TO_CHAR(pc.period_start, 'YYYY-MM-DD') AS "periodStart",
+              TO_CHAR(pc.period_end, 'YYYY-MM-DD') AS "periodEnd",
+              pc.calculation_type AS "calculationType",
+              pc.recurrence_type AS "recurrenceType",
+              pc.is_billable AS "isBillable",
+              pc.is_reimbursable AS "isReimbursable",
+              pc.notes,
+              pc.status,
+              pc.created_at AS "createdAt"
+         FROM operations_project_cost pc
+         LEFT JOIN operations_project_cost_type pct
+           ON pct.id = pc.cost_type_id AND pct.deleted_at IS NULL
+         LEFT JOIN operations_project_cost_category pcc
+           ON pcc.id = COALESCE(pc.category_id, pct.category_id) AND pcc.deleted_at IS NULL
+         LEFT JOIN LATERAL (
+           SELECT l.name
+             FROM operations_project_cost_type_locale l
+            WHERE l.operations_project_cost_type_id = pct.id
+            ORDER BY CASE WHEN $1::int IS NOT NULL AND l.locale_id = $1 THEN 0 ELSE 1 END ASC,
+                     l.id ASC
+            LIMIT 1
+         ) pctl ON TRUE
+         LEFT JOIN LATERAL (
+           SELECT l.name
+             FROM operations_project_cost_category_locale l
+            WHERE l.operations_project_cost_category_id = pcc.id
+            ORDER BY CASE WHEN $1::int IS NOT NULL AND l.locale_id = $1 THEN 0 ELSE 1 END ASC,
+                     l.id ASC
+            LIMIT 1
+         ) pccl ON TRUE
+        ${whereClause}
+        ORDER BY pc.created_at DESC`,
+      params
+    );
+
+    return rows.map((row) => ({
+      id: row.id,
+      project_id: row.projectId,
+      cost_type_id: row.costTypeId,
+      category_id: row.categoryId,
+      description: row.description,
+      amount: row.amount,
+      quantity: row.quantity,
+      unit_amount: row.unitAmount,
+      currency: row.currency,
+      cost_date: row.costDate,
+      period_start: row.periodStart,
+      period_end: row.periodEnd,
+      calculation_type: row.calculationType,
+      recurrence_type: row.recurrenceType,
+      is_billable: row.isBillable,
+      is_reimbursable: row.isReimbursable,
+      notes: row.notes,
+      status: row.status,
+      created_at: row.createdAt,
+      cost_type: row.costTypeId
+        ? { id: row.costTypeId, slug: row.costTypeSlug, name: row.costTypeName, code: row.costTypeCode }
+        : null,
+      category: row.resolvedCategoryId
+        ? { id: row.resolvedCategoryId, slug: row.categorySlug, name: row.categoryName, color: row.categoryColor, icon: row.categoryIcon }
+        : null,
+    }));
+  }
+
+  async getProjectCostsSummaryGrouped(userId: number, projectId: number) {
+    const items = await this.listProjectCosts(userId, projectId, {});
+
+    // Group by resolved category
+    const categoryMap = new Map<
+      number | null,
+      {
+        category: { id: number; slug: string | null; name: string | null; color: string | null; icon: string | null } | null;
+        items: typeof items;
+        total_amount: number;
+      }
+    >();
+
+    for (const cost of items) {
+      const cat = cost.category ?? null;
+      const key = cat?.id ?? null;
+      if (!categoryMap.has(key)) {
+        categoryMap.set(key, { category: cat, items: [], total_amount: 0 });
+      }
+      const group = categoryMap.get(key)!;
+      group.items.push(cost);
+      group.total_amount += (parseFloat(String(cost.amount)) || 0) * (parseFloat(String(cost.quantity)) || 1);
+    }
+
+    const grand_total = Array.from(categoryMap.values()).reduce(
+      (sum, g) => sum + g.total_amount,
+      0,
+    );
+
+    return {
+      categories: Array.from(categoryMap.values()).map((g) => ({
+        category: g.category,
+        items: g.items,
+        total_amount: Math.round(g.total_amount * 100) / 100,
+        count: g.items.length,
+      })),
+      grand_total: Math.round(grand_total * 100) / 100,
+    };
+  }
+
+  async getProjectCost(userId: number, projectId: number, id: number) {
+    const rows = await this.listProjectCosts(userId, projectId, {});
+    const cost = rows.find((r) => r.id === id);
+    if (!cost) {
+      throw new NotFoundException('Project cost not found.');
+    }
+    return cost;
+  }
+
+  async getProjectCostsSummary(userId: number, projectId: number) {
+    await this.getActorContext(userId);
+    const localeId = await this.resolvePreferredLocaleId();
+
+    // ── 1. Verify project exists and fetch budget_amount ──────────────────
+    const project = await this.querySingle<{ id: number; budgetAmount: string | null }>(
+      `SELECT id, budget_amount::text AS "budgetAmount"
+         FROM operations_project
+        WHERE id = $1 AND deleted_at IS NULL
+        LIMIT 1`,
+      [projectId]
+    );
+    if (!project) {
+      throw new NotFoundException('Project not found.');
+    }
+
+    const budgetAmount = parseFloat(project.budgetAmount ?? '0') || 0;
+
+    // ── 2. Aggregated cost totals ─────────────────────────────────────────
+    const totals = await this.querySingle<{
+      extraCostTotal: string;
+      plannedTotal: string;
+      approvedTotal: string;
+      realizedTotal: string;
+      cancelledTotal: string;
+      billableTotal: string;
+      nonBillableTotal: string;
+      reimbursableTotal: string;
+    }>(
+      `SELECT
+         COALESCE(SUM(CASE WHEN status != 'cancelled' THEN amount * quantity ELSE 0 END), 0)::text AS "extraCostTotal",
+         COALESCE(SUM(CASE WHEN status = 'planned'   THEN amount * quantity ELSE 0 END), 0)::text AS "plannedTotal",
+         COALESCE(SUM(CASE WHEN status = 'approved'  THEN amount * quantity ELSE 0 END), 0)::text AS "approvedTotal",
+         COALESCE(SUM(CASE WHEN status = 'realized'  THEN amount * quantity ELSE 0 END), 0)::text AS "realizedTotal",
+         COALESCE(SUM(CASE WHEN status = 'cancelled' THEN amount * quantity ELSE 0 END), 0)::text AS "cancelledTotal",
+         COALESCE(SUM(CASE WHEN is_billable = true  AND status != 'cancelled' THEN amount * quantity ELSE 0 END), 0)::text AS "billableTotal",
+         COALESCE(SUM(CASE WHEN is_billable = false AND status != 'cancelled' THEN amount * quantity ELSE 0 END), 0)::text AS "nonBillableTotal",
+         COALESCE(SUM(CASE WHEN is_reimbursable = true AND status != 'cancelled' THEN amount * quantity ELSE 0 END), 0)::text AS "reimbursableTotal"
+         FROM operations_project_cost
+        WHERE deleted_at IS NULL
+          AND project_id = $1`,
+      [projectId]
+    );
+
+    const extraCostTotal    = Math.round((parseFloat(totals?.extraCostTotal    ?? '0') || 0) * 100) / 100;
+    const plannedTotal      = Math.round((parseFloat(totals?.plannedTotal      ?? '0') || 0) * 100) / 100;
+    const approvedTotal     = Math.round((parseFloat(totals?.approvedTotal     ?? '0') || 0) * 100) / 100;
+    const realizedTotal     = Math.round((parseFloat(totals?.realizedTotal     ?? '0') || 0) * 100) / 100;
+    const cancelledTotal    = Math.round((parseFloat(totals?.cancelledTotal    ?? '0') || 0) * 100) / 100;
+    const billableTotal     = Math.round((parseFloat(totals?.billableTotal     ?? '0') || 0) * 100) / 100;
+    const nonBillableTotal  = Math.round((parseFloat(totals?.nonBillableTotal  ?? '0') || 0) * 100) / 100;
+    const reimbursableTotal = Math.round((parseFloat(totals?.reimbursableTotal ?? '0') || 0) * 100) / 100;
+
+    const teamCostTotal       = 0;
+    const totalProjectCost    = Math.round((teamCostTotal + extraCostTotal) * 100) / 100;
+    const remainingBudget     = Math.round((budgetAmount - totalProjectCost) * 100) / 100;
+    const budgetUsagePercent  = budgetAmount > 0
+      ? Math.round((totalProjectCost / budgetAmount) * 10000) / 100
+      : 0;
+
+    // ── 3. cost_by_category ───────────────────────────────────────────────
+    const costByCategory = await this.queryRows<{
+      categoryId: number | null;
+      categorySlug: string | null;
+      categoryName: string | null;
+      categoryColor: string | null;
+      categoryIcon: string | null;
+      total: string;
+      count: number;
+    }>(
+      `SELECT
+         COALESCE(pc.category_id, pct.category_id) AS "categoryId",
+         pcc.slug AS "categorySlug",
+         COALESCE(pccl.name, pcc.slug) AS "categoryName",
+         pcc.color AS "categoryColor",
+         pcc.icon AS "categoryIcon",
+         SUM(pc.amount * pc.quantity)::text AS total,
+         COUNT(*)::int AS count
+         FROM operations_project_cost pc
+         LEFT JOIN operations_project_cost_type pct
+           ON pct.id = pc.cost_type_id AND pct.deleted_at IS NULL
+         LEFT JOIN operations_project_cost_category pcc
+           ON pcc.id = COALESCE(pc.category_id, pct.category_id) AND pcc.deleted_at IS NULL
+         LEFT JOIN LATERAL (
+           SELECT l.name
+             FROM operations_project_cost_category_locale l
+            WHERE l.operations_project_cost_category_id = pcc.id
+            ORDER BY CASE WHEN $1::int IS NOT NULL AND l.locale_id = $1 THEN 0 ELSE 1 END ASC,
+                     l.id ASC
+            LIMIT 1
+         ) pccl ON TRUE
+        WHERE pc.deleted_at IS NULL
+          AND pc.project_id = $2
+          AND pc.status != 'cancelled'
+        GROUP BY COALESCE(pc.category_id, pct.category_id), pcc.slug, pcc.color, pcc.icon, pccl.name
+        ORDER BY SUM(pc.amount * pc.quantity) DESC`,
+      [localeId, projectId]
+    );
+
+    // ── 4. cost_by_type ───────────────────────────────────────────────────
+    const costByType = await this.queryRows<{
+      costTypeId: number | null;
+      costTypeSlug: string | null;
+      costTypeName: string | null;
+      costTypeCode: string | null;
+      total: string;
+      count: number;
+    }>(
+      `SELECT
+         pc.cost_type_id AS "costTypeId",
+         pct.slug AS "costTypeSlug",
+         COALESCE(pctl.name, pct.slug) AS "costTypeName",
+         pct.code AS "costTypeCode",
+         SUM(pc.amount * pc.quantity)::text AS total,
+         COUNT(*)::int AS count
+         FROM operations_project_cost pc
+         LEFT JOIN operations_project_cost_type pct
+           ON pct.id = pc.cost_type_id AND pct.deleted_at IS NULL
+         LEFT JOIN LATERAL (
+           SELECT l.name
+             FROM operations_project_cost_type_locale l
+            WHERE l.operations_project_cost_type_id = pct.id
+            ORDER BY CASE WHEN $1::int IS NOT NULL AND l.locale_id = $1 THEN 0 ELSE 1 END ASC,
+                     l.id ASC
+            LIMIT 1
+         ) pctl ON TRUE
+        WHERE pc.deleted_at IS NULL
+          AND pc.project_id = $2
+          AND pc.status != 'cancelled'
+        GROUP BY pc.cost_type_id, pct.slug, pct.code, pctl.name
+        ORDER BY SUM(pc.amount * pc.quantity) DESC`,
+      [localeId, projectId]
+    );
+
+    // ── 5. cost_by_month ──────────────────────────────────────────────────
+    const costByMonth = await this.queryRows<{
+      month: string;
+      total: string;
+      count: number;
+    }>(
+      `SELECT
+         TO_CHAR(COALESCE(pc.cost_date, pc.created_at), 'YYYY-MM') AS month,
+         SUM(pc.amount * pc.quantity)::text AS total,
+         COUNT(*)::int AS count
+         FROM operations_project_cost pc
+        WHERE pc.deleted_at IS NULL
+          AND pc.project_id = $1
+          AND pc.status != 'cancelled'
+        GROUP BY TO_CHAR(COALESCE(pc.cost_date, pc.created_at), 'YYYY-MM')
+        ORDER BY month ASC`,
+      [projectId]
+    );
+
+    // ── 6. top_cost_types (top 5) ─────────────────────────────────────────
+    const topCostTypes = costByType.slice(0, 5).map((ct) => {
+      const typeTotal = Math.round((parseFloat(ct.total) || 0) * 100) / 100;
+      const percentage = extraCostTotal > 0
+        ? Math.round((typeTotal / extraCostTotal) * 10000) / 100
+        : 0;
+      return {
+        cost_type_id:   ct.costTypeId,
+        cost_type_slug: ct.costTypeSlug,
+        cost_type_name: ct.costTypeName,
+        cost_type_code: ct.costTypeCode,
+        total:          typeTotal,
+        percentage,
+      };
+    });
+
+    return {
+      project_id:           projectId,
+      budget_amount:        budgetAmount,
+      team_cost_total:      teamCostTotal,
+      extra_cost_total:     extraCostTotal,
+      total_project_cost:   totalProjectCost,
+      remaining_budget:     remainingBudget,
+      budget_usage_percent: budgetUsagePercent,
+      planned_total:        plannedTotal,
+      approved_total:       approvedTotal,
+      realized_total:       realizedTotal,
+      cancelled_total:      cancelledTotal,
+      billable_total:       billableTotal,
+      non_billable_total:   nonBillableTotal,
+      reimbursable_total:   reimbursableTotal,
+      cost_by_category: costByCategory.map((c) => ({
+        category_id:    c.categoryId,
+        category_slug:  c.categorySlug,
+        category_name:  c.categoryName,
+        category_color: c.categoryColor,
+        category_icon:  c.categoryIcon,
+        total:          Math.round((parseFloat(c.total) || 0) * 100) / 100,
+        count:          Number(c.count),
+      })),
+      cost_by_type: costByType.map((t) => ({
+        cost_type_id:   t.costTypeId,
+        cost_type_slug: t.costTypeSlug,
+        cost_type_name: t.costTypeName,
+        cost_type_code: t.costTypeCode,
+        total:          Math.round((parseFloat(t.total) || 0) * 100) / 100,
+        count:          Number(t.count),
+      })),
+      cost_by_month: costByMonth.map((m) => ({
+        month: m.month,
+        total: Math.round((parseFloat(m.total) || 0) * 100) / 100,
+        count: Number(m.count),
+      })),
+      top_cost_types: topCostTypes,
+    };
+  }
+
+  async getProjectCostReport(
+    userId: number,
+    projectId: number,
+    filters: {
+      date_from?: string;
+      date_to?: string;
+      category_id?: number;
+      cost_type_id?: number;
+      status?: string;
+      is_billable?: boolean;
+      is_reimbursable?: boolean;
+    },
+  ) {
+    await this.getActorContext(userId);
+    const localeId = await this.resolvePreferredLocaleId();
+
+    // ── Verify project ───────────────────────────────────────────────────
+    const project = await this.querySingle<{ id: number; budgetAmount: string | null }>(
+      `SELECT id, budget_amount::text AS "budgetAmount"
+         FROM operations_project
+        WHERE id = $1 AND deleted_at IS NULL
+        LIMIT 1`,
+      [projectId],
+    );
+    if (!project) {
+      throw new NotFoundException('Project not found.');
+    }
+    const budgetAmount = parseFloat(project.budgetAmount ?? '0') || 0;
+
+    // ── Build dynamic WHERE clause ────────────────────────────────────────
+    const conditions: string[] = [
+      'pc.deleted_at IS NULL',
+      'pc.project_id = $1',
+    ];
+    const params: unknown[] = [projectId];
+
+    if (filters.date_from) {
+      params.push(filters.date_from);
+      conditions.push(`COALESCE(pc.cost_date, pc.created_at::date) >= $${params.length}::date`);
+    }
+    if (filters.date_to) {
+      params.push(filters.date_to);
+      conditions.push(`COALESCE(pc.cost_date, pc.created_at::date) <= $${params.length}::date`);
+    }
+    if (filters.category_id !== undefined) {
+      params.push(filters.category_id);
+      conditions.push(
+        `(pc.category_id = $${params.length} OR (pc.category_id IS NULL AND EXISTS (
+           SELECT 1 FROM operations_project_cost_type pct2
+            WHERE pct2.id = pc.cost_type_id AND pct2.category_id = $${params.length} AND pct2.deleted_at IS NULL
+         )))`,
+      );
+    }
+    if (filters.cost_type_id !== undefined) {
+      params.push(filters.cost_type_id);
+      conditions.push(`pc.cost_type_id = $${params.length}`);
+    }
+    if (filters.status !== undefined) {
+      params.push(filters.status);
+      conditions.push(`pc.status = $${params.length}`);
+    }
+    if (filters.is_billable !== undefined) {
+      params.push(filters.is_billable);
+      conditions.push(`pc.is_billable = $${params.length}`);
+    }
+    if (filters.is_reimbursable !== undefined) {
+      params.push(filters.is_reimbursable);
+      conditions.push(`pc.is_reimbursable = $${params.length}`);
+    }
+
+    const whereClause = conditions.join(' AND ');
+
+    // ── Totals ────────────────────────────────────────────────────────────
+    const totals = await this.querySingle<{
+      grandTotal: string;
+      plannedTotal: string;
+      approvedTotal: string;
+      realizedTotal: string;
+      cancelledTotal: string;
+      billableTotal: string;
+      nonBillableTotal: string;
+      reimbursableTotal: string;
+      totalCount: number;
+    }>(
+      `SELECT
+         COALESCE(SUM(pc.amount * pc.quantity), 0)::text AS "grandTotal",
+         COALESCE(SUM(CASE WHEN pc.status = 'planned'   THEN pc.amount * pc.quantity ELSE 0 END), 0)::text AS "plannedTotal",
+         COALESCE(SUM(CASE WHEN pc.status = 'approved'  THEN pc.amount * pc.quantity ELSE 0 END), 0)::text AS "approvedTotal",
+         COALESCE(SUM(CASE WHEN pc.status = 'realized'  THEN pc.amount * pc.quantity ELSE 0 END), 0)::text AS "realizedTotal",
+         COALESCE(SUM(CASE WHEN pc.status = 'cancelled' THEN pc.amount * pc.quantity ELSE 0 END), 0)::text AS "cancelledTotal",
+         COALESCE(SUM(CASE WHEN pc.is_billable = true   THEN pc.amount * pc.quantity ELSE 0 END), 0)::text AS "billableTotal",
+         COALESCE(SUM(CASE WHEN pc.is_billable = false  THEN pc.amount * pc.quantity ELSE 0 END), 0)::text AS "nonBillableTotal",
+         COALESCE(SUM(CASE WHEN pc.is_reimbursable = true THEN pc.amount * pc.quantity ELSE 0 END), 0)::text AS "reimbursableTotal",
+         COUNT(*)::int AS "totalCount"
+         FROM operations_project_cost pc
+        WHERE ${whereClause}`,
+      params,
+    );
+
+    const round2 = (v: string | null | undefined) =>
+      Math.round((parseFloat(v ?? '0') || 0) * 100) / 100;
+
+    const grandTotal       = round2(totals?.grandTotal);
+    const plannedTotal     = round2(totals?.plannedTotal);
+    const approvedTotal    = round2(totals?.approvedTotal);
+    const realizedTotal    = round2(totals?.realizedTotal);
+    const cancelledTotal   = round2(totals?.cancelledTotal);
+    const billableTotal    = round2(totals?.billableTotal);
+    const nonBillableTotal = round2(totals?.nonBillableTotal);
+    const reimbursableTotal= round2(totals?.reimbursableTotal);
+
+    // ── By category ───────────────────────────────────────────────────────
+    const costByCategory = await this.queryRows<{
+      categoryId: number | null;
+      categorySlug: string | null;
+      categoryName: string | null;
+      categoryColor: string | null;
+      categoryIcon: string | null;
+      total: string;
+      count: number;
+      plannedSubtotal: string;
+      realizedSubtotal: string;
+    }>(
+      `SELECT
+         COALESCE(pc.category_id, pct.category_id) AS "categoryId",
+         pcc.slug AS "categorySlug",
+         COALESCE(pccl.name, pcc.slug) AS "categoryName",
+         pcc.color AS "categoryColor",
+         pcc.icon AS "categoryIcon",
+         SUM(pc.amount * pc.quantity)::text AS total,
+         COUNT(*)::int AS count,
+         COALESCE(SUM(CASE WHEN pc.status='planned'  THEN pc.amount*pc.quantity ELSE 0 END),0)::text AS "plannedSubtotal",
+         COALESCE(SUM(CASE WHEN pc.status='realized' THEN pc.amount*pc.quantity ELSE 0 END),0)::text AS "realizedSubtotal"
+         FROM operations_project_cost pc
+         LEFT JOIN operations_project_cost_type pct
+           ON pct.id = pc.cost_type_id AND pct.deleted_at IS NULL
+         LEFT JOIN operations_project_cost_category pcc
+           ON pcc.id = COALESCE(pc.category_id, pct.category_id) AND pcc.deleted_at IS NULL
+         LEFT JOIN LATERAL (
+           SELECT l.name
+             FROM operations_project_cost_category_locale l
+            WHERE l.operations_project_cost_category_id = pcc.id
+            ORDER BY CASE WHEN $1::int IS NOT NULL AND l.locale_id = $1 THEN 0 ELSE 1 END ASC, l.id ASC
+            LIMIT 1
+         ) pccl ON TRUE
+        WHERE ${whereClause.replace(/\$(\d+)/g, (m, n) => '$' + (Number(n) + 1))}
+        GROUP BY COALESCE(pc.category_id, pct.category_id), pcc.slug, pcc.color, pcc.icon, pccl.name
+        ORDER BY SUM(pc.amount * pc.quantity) DESC`,
+      [localeId, ...params],
+    );
+
+    // ── By type ───────────────────────────────────────────────────────────
+    const costByType = await this.queryRows<{
+      costTypeId: number | null;
+      costTypeSlug: string | null;
+      costTypeName: string | null;
+      costTypeCode: string | null;
+      total: string;
+      count: number;
+      plannedSubtotal: string;
+      realizedSubtotal: string;
+    }>(
+      `SELECT
+         pc.cost_type_id AS "costTypeId",
+         pct.slug AS "costTypeSlug",
+         COALESCE(pctl.name, pct.slug) AS "costTypeName",
+         pct.code AS "costTypeCode",
+         SUM(pc.amount * pc.quantity)::text AS total,
+         COUNT(*)::int AS count,
+         COALESCE(SUM(CASE WHEN pc.status='planned'  THEN pc.amount*pc.quantity ELSE 0 END),0)::text AS "plannedSubtotal",
+         COALESCE(SUM(CASE WHEN pc.status='realized' THEN pc.amount*pc.quantity ELSE 0 END),0)::text AS "realizedSubtotal"
+         FROM operations_project_cost pc
+         LEFT JOIN operations_project_cost_type pct
+           ON pct.id = pc.cost_type_id AND pct.deleted_at IS NULL
+         LEFT JOIN LATERAL (
+           SELECT l.name
+             FROM operations_project_cost_type_locale l
+            WHERE l.operations_project_cost_type_id = pct.id
+            ORDER BY CASE WHEN $1::int IS NOT NULL AND l.locale_id = $1 THEN 0 ELSE 1 END ASC, l.id ASC
+            LIMIT 1
+         ) pctl ON TRUE
+        WHERE ${whereClause.replace(/\$(\d+)/g, (m, n) => '$' + (Number(n) + 1))}
+        GROUP BY pc.cost_type_id, pct.slug, pct.code, pctl.name
+        ORDER BY SUM(pc.amount * pc.quantity) DESC`,
+      [localeId, ...params],
+    );
+
+    // ── By month ──────────────────────────────────────────────────────────
+    const costByMonth = await this.queryRows<{
+      month: string;
+      total: string;
+      plannedSubtotal: string;
+      realizedSubtotal: string;
+      count: number;
+    }>(
+      `SELECT
+         TO_CHAR(COALESCE(pc.cost_date, pc.created_at::date), 'YYYY-MM') AS month,
+         SUM(pc.amount * pc.quantity)::text AS total,
+         COALESCE(SUM(CASE WHEN pc.status='planned'  THEN pc.amount*pc.quantity ELSE 0 END),0)::text AS "plannedSubtotal",
+         COALESCE(SUM(CASE WHEN pc.status='realized' THEN pc.amount*pc.quantity ELSE 0 END),0)::text AS "realizedSubtotal",
+         COUNT(*)::int AS count
+         FROM operations_project_cost pc
+        WHERE ${whereClause}
+        GROUP BY TO_CHAR(COALESCE(pc.cost_date, pc.created_at::date), 'YYYY-MM')
+        ORDER BY month ASC`,
+      params,
+    );
+
+    // ── Top 5 individual costs ────────────────────────────────────────────
+    const top5Costs = await this.queryRows<{
+      id: number;
+      description: string | null;
+      amount: string;
+      quantity: string;
+      status: string;
+      costTypeName: string | null;
+      categoryName: string | null;
+      categoryColor: string | null;
+      costDate: string | null;
+    }>(
+      `SELECT
+         pc.id,
+         pc.description,
+         pc.amount::text,
+         pc.quantity::text,
+         pc.status,
+         pc.cost_date AS "costDate",
+         COALESCE(pctl.name, pct.slug) AS "costTypeName",
+         COALESCE(pccl.name, pcc.slug) AS "categoryName",
+         pcc.color AS "categoryColor"
+         FROM operations_project_cost pc
+         LEFT JOIN operations_project_cost_type pct
+           ON pct.id = pc.cost_type_id AND pct.deleted_at IS NULL
+         LEFT JOIN LATERAL (
+           SELECT l.name
+             FROM operations_project_cost_type_locale l
+            WHERE l.operations_project_cost_type_id = pct.id
+            ORDER BY CASE WHEN $1::int IS NOT NULL AND l.locale_id = $1 THEN 0 ELSE 1 END ASC, l.id ASC
+            LIMIT 1
+         ) pctl ON TRUE
+         LEFT JOIN operations_project_cost_category pcc
+           ON pcc.id = COALESCE(pc.category_id, pct.category_id) AND pcc.deleted_at IS NULL
+         LEFT JOIN LATERAL (
+           SELECT l.name
+             FROM operations_project_cost_category_locale l
+            WHERE l.operations_project_cost_category_id = pcc.id
+            ORDER BY CASE WHEN $1::int IS NOT NULL AND l.locale_id = $1 THEN 0 ELSE 1 END ASC, l.id ASC
+            LIMIT 1
+         ) pccl ON TRUE
+        WHERE ${whereClause.replace(/\$(\d+)/g, (m, n) => '$' + (Number(n) + 1))}
+        ORDER BY (pc.amount * pc.quantity) DESC
+        LIMIT 5`,
+      [localeId, ...params],
+    );
+
+    // ── Detailed list ─────────────────────────────────────────────────────
+    const detailedList = await this.queryRows<{
+      id: number;
+      description: string | null;
+      amount: string;
+      quantity: string;
+      unitAmount: string | null;
+      currency: string | null;
+      calculationType: string | null;
+      recurrenceType: string | null;
+      status: string;
+      isBillable: boolean;
+      isReimbursable: boolean;
+      costDate: string | null;
+      periodStart: string | null;
+      periodEnd: string | null;
+      notes: string | null;
+      costTypeId: number | null;
+      costTypeName: string | null;
+      costTypeCode: string | null;
+      categoryId: number | null;
+      categoryName: string | null;
+      categoryColor: string | null;
+      createdAt: string;
+    }>(
+      `SELECT
+         pc.id,
+         pc.description,
+         pc.amount::text,
+         pc.quantity::text,
+         pc.unit_amount::text AS "unitAmount",
+         pc.currency,
+         pc.calculation_type AS "calculationType",
+         pc.recurrence_type AS "recurrenceType",
+         pc.status,
+         pc.is_billable AS "isBillable",
+         pc.is_reimbursable AS "isReimbursable",
+         pc.cost_date AS "costDate",
+         pc.period_start AS "periodStart",
+         pc.period_end AS "periodEnd",
+         pc.notes,
+         pc.cost_type_id AS "costTypeId",
+         COALESCE(pctl.name, pct.slug) AS "costTypeName",
+         pct.code AS "costTypeCode",
+         COALESCE(pc.category_id, pct.category_id) AS "categoryId",
+         COALESCE(pccl.name, pcc.slug) AS "categoryName",
+         pcc.color AS "categoryColor",
+         pc.created_at::text AS "createdAt"
+         FROM operations_project_cost pc
+         LEFT JOIN operations_project_cost_type pct
+           ON pct.id = pc.cost_type_id AND pct.deleted_at IS NULL
+         LEFT JOIN LATERAL (
+           SELECT l.name
+             FROM operations_project_cost_type_locale l
+            WHERE l.operations_project_cost_type_id = pct.id
+            ORDER BY CASE WHEN $1::int IS NOT NULL AND l.locale_id = $1 THEN 0 ELSE 1 END ASC, l.id ASC
+            LIMIT 1
+         ) pctl ON TRUE
+         LEFT JOIN operations_project_cost_category pcc
+           ON pcc.id = COALESCE(pc.category_id, pct.category_id) AND pcc.deleted_at IS NULL
+         LEFT JOIN LATERAL (
+           SELECT l.name
+             FROM operations_project_cost_category_locale l
+            WHERE l.operations_project_cost_category_id = pcc.id
+            ORDER BY CASE WHEN $1::int IS NOT NULL AND l.locale_id = $1 THEN 0 ELSE 1 END ASC, l.id ASC
+            LIMIT 1
+         ) pccl ON TRUE
+        WHERE ${whereClause.replace(/\$(\d+)/g, (m, n) => '$' + (Number(n) + 1))}
+        ORDER BY (pc.amount * pc.quantity) DESC, pc.cost_date DESC NULLS LAST`,
+      [localeId, ...params],
+    );
+
+    return {
+      project_id:        projectId,
+      budget_amount:     budgetAmount,
+      filters_applied: {
+        date_from:      filters.date_from ?? null,
+        date_to:        filters.date_to ?? null,
+        category_id:    filters.category_id ?? null,
+        cost_type_id:   filters.cost_type_id ?? null,
+        status:         filters.status ?? null,
+        is_billable:    filters.is_billable ?? null,
+        is_reimbursable:filters.is_reimbursable ?? null,
+      },
+      totals: {
+        grand_total:        grandTotal,
+        planned_total:      plannedTotal,
+        approved_total:     approvedTotal,
+        realized_total:     realizedTotal,
+        cancelled_total:    cancelledTotal,
+        billable_total:     billableTotal,
+        non_billable_total: nonBillableTotal,
+        reimbursable_total: reimbursableTotal,
+        total_count:        Number(totals?.totalCount ?? 0),
+      },
+      cost_by_category: costByCategory.map((c) => ({
+        category_id:       c.categoryId,
+        category_slug:     c.categorySlug,
+        category_name:     c.categoryName,
+        category_color:    c.categoryColor,
+        category_icon:     c.categoryIcon,
+        total:             round2(c.total),
+        count:             Number(c.count),
+        planned_subtotal:  round2(c.plannedSubtotal),
+        realized_subtotal: round2(c.realizedSubtotal),
+      })),
+      cost_by_type: costByType.map((t) => ({
+        cost_type_id:      t.costTypeId,
+        cost_type_slug:    t.costTypeSlug,
+        cost_type_name:    t.costTypeName,
+        cost_type_code:    t.costTypeCode,
+        total:             round2(t.total),
+        count:             Number(t.count),
+        planned_subtotal:  round2(t.plannedSubtotal),
+        realized_subtotal: round2(t.realizedSubtotal),
+      })),
+      cost_by_month: costByMonth.map((m) => ({
+        month:             m.month,
+        total:             round2(m.total),
+        planned_subtotal:  round2(m.plannedSubtotal),
+        realized_subtotal: round2(m.realizedSubtotal),
+        count:             Number(m.count),
+      })),
+      top_5_costs: top5Costs.map((c) => ({
+        id:             c.id,
+        description:    c.description,
+        total:          round2(String(parseFloat(c.amount) * parseFloat(c.quantity))),
+        amount:         round2(c.amount),
+        quantity:       parseFloat(c.quantity),
+        status:         c.status,
+        cost_type_name: c.costTypeName,
+        category_name:  c.categoryName,
+        category_color: c.categoryColor,
+        cost_date:      c.costDate,
+      })),
+      detailed_list: detailedList.map((c) => ({
+        id:               c.id,
+        description:      c.description,
+        amount:           round2(c.amount),
+        quantity:         parseFloat(c.quantity),
+        unit_amount:      c.unitAmount ? round2(c.unitAmount) : null,
+        total:            round2(String(parseFloat(c.amount) * parseFloat(c.quantity))),
+        currency:         c.currency,
+        calculation_type: c.calculationType,
+        recurrence_type:  c.recurrenceType,
+        status:           c.status,
+        is_billable:      c.isBillable,
+        is_reimbursable:  c.isReimbursable,
+        cost_date:        c.costDate,
+        period_start:     c.periodStart,
+        period_end:       c.periodEnd,
+        notes:            c.notes,
+        cost_type_id:     c.costTypeId,
+        cost_type_name:   c.costTypeName,
+        cost_type_code:   c.costTypeCode,
+        category_id:      c.categoryId,
+        category_name:    c.categoryName,
+        category_color:   c.categoryColor,
+        created_at:       c.createdAt,
+      })),
+    };
+  }
+
+  async createProjectCost(userId: number, projectId: number, data: { cost_type_id?: number; category_id?: number; description?: string; amount: number; quantity?: number; unit_amount?: number; currency?: string; cost_date?: string; period_start?: string; period_end?: string; calculation_type?: string; recurrence_type?: string; is_billable?: boolean; is_reimbursable?: boolean; notes?: string; status?: string }) {
+    const actor = await this.getActorContext(userId);
+    this.ensureSupervisor(actor);
+
+    const project = await this.querySingle<{ id: number }>(
+      `SELECT id FROM operations_project WHERE id = $1 AND deleted_at IS NULL LIMIT 1`,
+      [projectId]
+    );
+    if (!project) {
+      throw new NotFoundException('Project not found.');
+    }
+
+    if (data.cost_type_id) {
+      const costType = await this.querySingle<{ id: number }>(
+        `SELECT id FROM operations_project_cost_type WHERE id = $1 AND deleted_at IS NULL LIMIT 1`,
+        [data.cost_type_id]
+      );
+      if (!costType) {
+        throw new BadRequestException(`Cost type with id ${data.cost_type_id} not found.`);
+      }
+    }
+
+    if (data.category_id) {
+      const category = await this.querySingle<{ id: number }>(
+        `SELECT id FROM operations_project_cost_category WHERE id = $1 AND deleted_at IS NULL LIMIT 1`,
+        [data.category_id]
+      );
+      if (!category) {
+        throw new BadRequestException(`Cost category with id ${data.category_id} not found.`);
+      }
+    }
+
+    const calcType = data.calculation_type ?? 'fixed';
+    let effectiveAmount = data.amount;
+    if (['unit', 'hourly', 'monthly'].includes(calcType) && data.unit_amount !== undefined && data.unit_amount !== null) {
+      const qty = data.quantity ?? 1;
+      effectiveAmount = Math.round(qty * data.unit_amount * 100) / 100;
+    }
+
+    const created = await this.querySingle<{ id: number }>(
+      `INSERT INTO operations_project_cost
+         (project_id, cost_type_id, category_id, description, amount, quantity, unit_amount, currency, cost_date, period_start, period_end, calculation_type, recurrence_type, is_billable, is_reimbursable, notes, status, created_at, updated_at)
+       VALUES ($1, $2, $3, $4, $5, $6, $7, $8, $9::date, $10::date, $11::date, $12::operations_project_cost_calculation_type_134cdfb49c_enum, $13::operations_project_cost_recurrence_type_09baf0f043_enum, $14, $15, $16, $17::operations_project_cost_status_153e8592ce_enum, NOW(), NOW())
+       RETURNING id`,
+      [
+        projectId,
+        data.cost_type_id ?? null,
+        data.category_id ?? null,
+        data.description ?? null,
+        effectiveAmount,
+        data.quantity ?? 1,
+        data.unit_amount ?? null,
+        data.currency ?? 'BRL',
+        data.cost_date ?? null,
+        data.period_start ?? null,
+        data.period_end ?? null,
+        calcType,
+        data.recurrence_type ?? 'none',
+        data.is_billable ?? false,
+        data.is_reimbursable ?? false,
+        data.notes ?? null,
+        data.status ?? 'planned',
+      ]
+    );
+
+    if (!created?.id) {
+      throw new BadRequestException('Unable to create project cost.');
+    }
+
+    const rows = await this.listProjectCosts(userId, projectId, {});
+    return rows.find((r) => r.id === created.id) ?? null;
+  }
+
+  async updateProjectCost(userId: number, id: number, data: Partial<{ cost_type_id: number; category_id: number; description: string; amount: number; quantity: number; unit_amount: number; currency: string; cost_date: string; period_start: string; period_end: string; calculation_type: string; recurrence_type: string; is_billable: boolean; is_reimbursable: boolean; notes: string; status: string }>) {
+    const actor = await this.getActorContext(userId);
+    this.ensureSupervisor(actor);
+
+    const cost = await this.querySingle<{ id: number; projectId: number; calculationType: string; unitAmount: string | null; quantity: string }>(
+      `SELECT id, project_id AS "projectId", calculation_type AS "calculationType", unit_amount::text AS "unitAmount", quantity::text AS quantity FROM operations_project_cost WHERE id = $1 AND deleted_at IS NULL LIMIT 1`,
+      [id]
+    );
+    if (!cost) {
+      throw new NotFoundException('Project cost not found.');
+    }
+
+    // Auto-calculate amount when applicable
+    const effectiveCalcType = data.calculation_type ?? cost.calculationType;
+    if (['unit', 'hourly', 'monthly'].includes(effectiveCalcType)) {
+      const ua = data.unit_amount !== undefined ? data.unit_amount : (cost.unitAmount !== null ? parseFloat(cost.unitAmount) : null);
+      const qty = data.quantity !== undefined ? data.quantity : parseFloat(cost.quantity);
+      if (ua !== null && ua !== undefined) {
+        data = { ...data, amount: Math.round(qty * ua * 100) / 100 };
+      }
+    }
+
+    const sets: string[] = [];
+    const params: unknown[] = [];
+
+    if (data.cost_type_id !== undefined) sets.push(`cost_type_id = ${this.param(params, data.cost_type_id)}`);
+    if (data.category_id !== undefined) sets.push(`category_id = ${this.param(params, data.category_id)}`);
+    if (data.description !== undefined) sets.push(`description = ${this.param(params, data.description)}`);
+    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.quantity !== undefined) sets.push(`quantity = ${this.param(params, data.quantity)}`);
+    if (data.unit_amount !== undefined) sets.push(`unit_amount = ${this.param(params, data.unit_amount)}`);
+    if (data.calculation_type !== undefined) sets.push(`calculation_type = ${this.param(params, data.calculation_type)}::operations_project_cost_calculation_type_134cdfb49c_enum`);
+    if (data.recurrence_type !== undefined) sets.push(`recurrence_type = ${this.param(params, data.recurrence_type)}::operations_project_cost_recurrence_type_09baf0f043_enum`);
+    if (data.is_billable !== undefined) sets.push(`is_billable = ${this.param(params, data.is_billable)}`);
+    if (data.is_reimbursable !== undefined) sets.push(`is_reimbursable = ${this.param(params, data.is_reimbursable)}`);
+    if (data.cost_date !== undefined) sets.push(`cost_date = ${this.param(params, data.cost_date)}::date`);
+    if (data.period_start !== undefined) sets.push(`period_start = ${this.param(params, data.period_start)}::date`);
+    if (data.period_end !== undefined) sets.push(`period_end = ${this.param(params, data.period_end)}::date`);
+    if (data.notes !== undefined) sets.push(`notes = ${this.param(params, data.notes)}`);
+    if (data.status !== undefined) sets.push(`status = ${this.param(params, data.status)}::operations_project_cost_status_153e8592ce_enum`);
+
+    if (sets.length === 0) {
+      const rows = await this.listProjectCosts(userId, cost.projectId, {});
+      return rows.find((r) => r.id === id) ?? null;
+    }
+
+    sets.push(`updated_at = NOW()`);
+    await this.prisma.$queryRawUnsafe(
+      `UPDATE operations_project_cost SET ${sets.join(', ')} WHERE id = ${this.param(params, id)}`,
+      ...params
+    );
+
+    const rows = await this.listProjectCosts(userId, cost.projectId, {});
+    return rows.find((r) => r.id === id) ?? null;
+  }
+
+  async deleteProjectCost(userId: number, id: number) {
+    const actor = await this.getActorContext(userId);
+    this.ensureSupervisor(actor);
+
+    const cost = await this.querySingle<{ id: number }>(
+      `SELECT id FROM operations_project_cost WHERE id = $1 AND deleted_at IS NULL LIMIT 1`,
+      [id]
+    );
+    if (!cost) {
+      throw new NotFoundException('Project cost not found.');
+    }
+
+    await this.prisma.$queryRawUnsafe(
+      `UPDATE operations_project_cost SET deleted_at = NOW() WHERE id = $1`,
+      id
+    );
+
+    return { success: true };
+  }
 }