@hed-hog/operations 0.0.305 → 0.0.309

package/src/operations.service.ts

@@ -1,21 +1,21 @@
 import { LocaleService } from '@hed-hog/api-locale';
 import { PrismaService } from '@hed-hog/api-prisma';
 import {
-  AiService,
-  FileService,
-  IntegrationDeveloperApiService,
-  SettingService,
-  getLocaleFromContext,
+    AiService,
+    FileService,
+    IntegrationDeveloperApiService,
+    SettingService,
+    getLocaleFromContext,
 } from '@hed-hog/core';
 import {
-  BadRequestException,
-  ForbiddenException,
-  Inject,
-  Injectable,
-  InternalServerErrorException,
-  Logger,
-  NotFoundException,
-  forwardRef,
+    BadRequestException,
+    ForbiddenException,
+    Inject,
+    Injectable,
+    InternalServerErrorException,
+    Logger,
+    NotFoundException,
+    forwardRef,
 } from '@nestjs/common';
 import { OperationsAccessService } from './services/shared/operations-access.service';
 
@@ -102,11 +102,7 @@ const PARTY_ROLE_VALUES = [
   'other',
 ] as const;
 const PARTY_TYPE_VALUES = ['individual', 'company', 'internal_team', 'other'] as const;
-const SIGNATURE_ITEM_STATUS_VALUES = ['pending', 'signed', 'rejected'] as const;
-const FINANCIAL_TERM_TYPE_VALUES = ['value', 'payment', 'revenue', 'fine', 'other'] as const;
-const RECURRENCE_VALUES = ['one_time', 'monthly', 'quarterly', 'yearly', 'other'] as const;
-const REVISION_TYPE_VALUES = ['amendment', 'renewal', 'revision', 'addendum', 'other'] as const;
-const REVISION_STATUS_VALUES = ['draft', 'active', 'completed', 'cancelled'] as const;
+
 const TASK_STATUS_VALUES = ['todo', 'doing', 'review', 'done'] as const;
 
 type ApprovalAction = 'approve' | 'reject';
@@ -243,7 +239,6 @@ type ContractPayload = {
   isActive?: boolean;
   accountManagerCollaboratorId?: number | null;
   relatedCollaboratorId?: number | null;
-  contractTemplateId?: number | null;
   originType?: 'manual' | 'employee_hiring' | 'client_project' | 'crm_proposal';
   originId?: number | null;
   startDate?: string | null;
@@ -282,28 +277,6 @@ type ContractPayload = {
     phone?: string | null;
     isPrimary?: boolean;
   }>;
-  signatures?: Array<{
-    signerName: string;
-    signerRole?: string | null;
-    signerEmail?: string | null;
-    status?: 'pending' | 'signed' | 'rejected';
-    signedAt?: string | null;
-  }>;
-  financialTerms?: Array<{
-    termType?: 'value' | 'payment' | 'revenue' | 'fine' | 'other';
-    label: string;
-    amount: number;
-    recurrence?: 'one_time' | 'monthly' | 'quarterly' | 'yearly' | 'other';
-    dueDay?: number | null;
-    notes?: string | null;
-  }>;
-  revisions?: Array<{
-    revisionType?: 'amendment' | 'renewal' | 'revision' | 'addendum' | 'other';
-    title: string;
-    effectiveDate?: string | null;
-    status?: 'draft' | 'active' | 'completed' | 'cancelled';
-    summary?: string | null;
-  }>;
   replaceUploadedPdfDocument?: {
     fileId?: number | null;
     fileName: string;
@@ -315,15 +288,6 @@ type ContractPayload = {
   } | null;
 };
 
-type ContractDraftPayload = {
-  creationMode?: 'blank' | 'template' | 'upload' | 'duplicate' | null;
-  templateId?: number | null;
-  duplicateFromId?: number | null;
-  sourceFileId?: number | null;
-  sourceFileName?: string | null;
-  sourceMimeType?: string | null;
-};
-
 type ProposalApprovedEventPayload = {
   proposalId?: number;
   proposalRevisionId?: number | null;
@@ -383,53 +347,14 @@ type ProposalApprovedEventPayload = {
   items?: Array<{
     name?: string | null;
     description?: string | null;
-    termType?: ContractPayload['financialTerms'][number]['termType'];
-    recurrence?: ContractPayload['financialTerms'][number]['recurrence'];
+    termType?: 'value' | 'payment' | 'revenue' | 'fine' | 'other';
+    recurrence?: 'one_time' | 'monthly' | 'quarterly' | 'yearly' | 'other';
     dueDay?: number | null;
     amount?: number | null;
     totalAmountCents?: number | null;
   }>;
 };
 
-type ContractTemplatePayload = {
-  code?: string | null;
-  name?: string | null;
-  description?: string | null;
-  contractCategory?:
-    | 'employee'
-    | 'contractor'
-    | 'client'
-    | 'supplier'
-    | 'vendor'
-    | 'partner'
-    | 'internal'
-    | 'other';
-  contractType?:
-    | 'clt'
-    | 'pj'
-    | 'freelancer_agreement'
-    | 'service_agreement'
-    | 'fixed_term'
-    | 'recurring_service'
-    | 'nda'
-    | 'amendment'
-    | 'addendum'
-    | 'other';
-  billingModel?:
-    | 'time_and_material'
-    | 'monthly_retainer'
-    | 'fixed_price';
-  signatureStatus?:
-    | 'not_started'
-    | 'pending'
-    | 'partially_signed'
-    | 'signed'
-    | 'expired';
-  isActive?: boolean;
-  status?: 'draft' | 'active' | 'inactive' | 'archived';
-  contentHtml?: string | null;
-};
-
 type ContractExtractDraftPayload = {
   contractId?: number | null;
   fileName?: string | null;
@@ -511,10 +436,6 @@ type ContractDetailRecord = {
   billingModel: (typeof BILLING_MODEL_VALUES)[number];
   accountManagerCollaboratorId: number | null;
   relatedCollaboratorId: number | null;
-  contractTemplateId: number | null;
-  contractTemplateName: string | null;
-  contractTemplateSlug: string | null;
-  contractTemplateCode: string | null;
   originType: (typeof ORIGIN_TYPE_VALUES)[number];
   originId: number | null;
   startDate: string | null;
@@ -537,16 +458,12 @@ type ContractDetailsRecord = ContractDetailRecord & {
   projects: ContractProjectSummary[];
   scheduleSummary: ContractScheduleDay[];
   parties: NonNullable<ContractPayload['parties']>;
-  signatures: NonNullable<ContractPayload['signatures']>;
-  financialTerms: NonNullable<ContractPayload['financialTerms']>;
   documents: ContractDocumentRecord[];
-  revisions: NonNullable<ContractPayload['revisions']>;
   history: ContractHistoryRecord[];
 };
 
 type ProjectPayload = {
   contractId?: number | null;
-  contractTemplateId?: number | null;
   managerCollaboratorId?: number | null;
   clientPersonId?: number | null;
   code: string;
@@ -577,7 +494,6 @@ type ProjectPayload = {
   contractCode?: string | null;
   contractName?: string | null;
   contractDescription?: string | null;
-  autoGenerateContractDraft?: boolean;
   teamAssignments?: Array<{
     collaboratorId: number;
     projectRoleId?: number | null;
@@ -758,12 +674,114 @@ export class OperationsService {
 
   async listCollaboratorTypes(
     userId: number,
-    filters?: { active?: boolean }
+    filters: {
+      page?: number;
+      pageSize?: number;
+      search?: string;
+      sortField?: string;
+      sortOrder?: string;
+      active?: boolean;
+      status?: string;
+    } = {}
   ) {
     const actor = await this.getActorContext(userId);
     this.ensureCollaborator(actor);
 
-    return this.queryRows<{
+    const params: unknown[] = [];
+    const where: string[] = [];
+
+    if (filters.active === true || filters.status === 'active') {
+      where.push('(ct.deleted_at IS NULL AND ct.is_active = true)');
+    } else if (filters.status === 'inactive') {
+      where.push('(ct.deleted_at IS NOT NULL OR ct.is_active = false)');
+    }
+
+    const pagination = this.shouldPaginate(filters)
+      ? this.normalizePaginationParams(filters, {
+          defaultSortField: 'sortOrder',
+          defaultSortOrder: 'asc',
+          allowedSortFields: ['name', 'slug', 'category', 'sortOrder', 'createdAt'],
+        })
+      : null;
+
+    if (pagination?.search) {
+      const searchPlaceholder = this.param(params, `%${pagination.search}%`);
+      where.push(`(
+        COALESCE(ct.name, '') ILIKE ${searchPlaceholder}
+        OR COALESCE(ct.slug, '') ILIKE ${searchPlaceholder}
+        OR COALESCE(ct.description, '') ILIKE ${searchPlaceholder}
+        OR COALESCE(ct.category, '') ILIKE ${searchPlaceholder}
+      )`);
+    }
+
+    const whereClause = where.length ? `WHERE ${where.join(' AND ')}` : '';
+    const baseQuery = `SELECT ct.id,
+            ct.slug,
+            ct.name,
+            ct.description,
+            ct.category,
+            ct.is_active AS "isActive",
+            ct.sort_order AS "sortOrder",
+            CASE
+              WHEN ct.deleted_at IS NULL AND ct.is_active THEN 'active'
+              ELSE 'inactive'
+            END AS status,
+            COUNT(DISTINCT c.id)::int AS "collaboratorCount",
+            ct.created_at AS "createdAt",
+            ct.updated_at AS "updatedAt"
+       FROM operations_collaborator_type ct
+       LEFT JOIN operations_collaborator c
+         ON c.deleted_at IS NULL
+        AND c.collaborator_type_id = ct.id
+      ${whereClause}
+      GROUP BY ct.id`;
+
+    if (!pagination) {
+      return this.queryRows<{
+        id: number;
+        slug: string;
+        name: string;
+        description: string | null;
+        category: string | null;
+        isActive: boolean;
+        sortOrder: number;
+        status: 'active' | 'inactive';
+        collaboratorCount: number;
+        createdAt: string;
+        updatedAt: string;
+      }>(
+        `${baseQuery}
+         ORDER BY CASE
+                    WHEN ct.deleted_at IS NULL AND ct.is_active THEN 0
+                    ELSE 1
+                  END ASC,
+                  ct.sort_order ASC,
+                  ct.name ASC`,
+        params
+      );
+    }
+
+    const totalRow = await this.querySingle<{ total: string }>(
+      `SELECT COUNT(*)::text AS total
+         FROM operations_collaborator_type ct
+        ${whereClause}`,
+      params
+    );
+
+    const sortColumn =
+      {
+        name: 'ct.name',
+        slug: 'ct.slug',
+        category: 'ct.category',
+        sortOrder: 'ct.sort_order',
+        createdAt: 'ct.created_at',
+      }[pagination.sortField] ?? 'ct.name';
+
+    const queryParams = [...params];
+    const limitPlaceholder = this.param(queryParams, pagination.pageSize);
+    const offsetPlaceholder = this.param(queryParams, pagination.offset);
+
+    const rows = await this.queryRows<{
       id: number;
       slug: string;
       name: string;
@@ -776,33 +794,18 @@ export class OperationsService {
       createdAt: string;
       updatedAt: string;
     }>(
-      `SELECT ct.id,
-              ct.slug,
-              ct.name,
-              ct.description,
-              ct.category,
-              ct.is_active AS "isActive",
-              ct.sort_order AS "sortOrder",
-              CASE
-                WHEN ct.deleted_at IS NULL AND ct.is_active THEN 'active'
-                ELSE 'inactive'
-              END AS status,
-              COUNT(DISTINCT c.id)::int AS "collaboratorCount",
-              ct.created_at AS "createdAt",
-              ct.updated_at AS "updatedAt"
-         FROM operations_collaborator_type ct
-         LEFT JOIN operations_collaborator c
-           ON c.deleted_at IS NULL
-          AND c.collaborator_type_id = ct.id
-        WHERE ($1::boolean = false OR (ct.deleted_at IS NULL AND ct.is_active = true))
-        GROUP BY ct.id
-        ORDER BY CASE
-                   WHEN ct.deleted_at IS NULL AND ct.is_active THEN 0
-                   ELSE 1
-                 END ASC,
-                 ct.sort_order ASC,
-                 ct.name ASC`,
-      [Boolean(filters?.active)]
+      `${baseQuery}
+       ORDER BY ${sortColumn} ${pagination.sortOrder.toUpperCase()}, ct.id ASC
+       LIMIT ${limitPlaceholder}
+      OFFSET ${offsetPlaceholder}`,
+      queryParams
+    );
+
+    return this.buildPaginationResult(
+      rows,
+      Number(totalRow?.total ?? 0),
+      pagination.page,
+      pagination.pageSize
     );
   }
 
@@ -825,6 +828,10 @@ export class OperationsService {
       );
       const nextIsActive =
         data.isActive ?? (data.status ? data.status === 'active' : true);
+      const nextSortOrder =
+        data.sortOrder !== undefined && Number.isFinite(Number(data.sortOrder))
+          ? Number(data.sortOrder)
+          : await this.getNextCollaboratorTypeSortOrder(tx as any);
 
       const created = (await (tx as any).$queryRawUnsafe(
         `INSERT INTO operations_collaborator_type (
@@ -848,7 +855,7 @@ export class OperationsService {
         this.normalizeOptionalText(data.description),
         this.normalizeOptionalText(data.category),
         nextIsActive,
-        Number.isFinite(Number(data.sortOrder)) ? Number(data.sortOrder) : 0
+        nextSortOrder
       )) as { id: number }[];
 
       const createdCollaboratorTypeId = created[0]?.id;
@@ -940,6 +947,55 @@ export class OperationsService {
     });
   }
 
+  async reorderCollaboratorTypes(userId: number, ids: number[]) {
+    const actor = await this.getActorContext(userId);
+    this.ensureDirector(actor);
+
+    const normalizedIds = [
+      ...new Set(
+        ids
+          .map((value) => Number(value))
+          .filter((value) => Number.isInteger(value) && value > 0)
+      ),
+    ];
+
+    if (!normalizedIds.length) {
+      throw new BadRequestException('At least one collaborator type is required.');
+    }
+
+    return this.prisma.$transaction(async (tx) => {
+      const existingRows = (await (tx as any).$queryRawUnsafe(
+        `SELECT id
+           FROM operations_collaborator_type
+          WHERE id = ANY($1::int[])`,
+        normalizedIds
+      )) as { id: number }[];
+
+      if (existingRows.length !== normalizedIds.length) {
+        throw new NotFoundException('One or more collaborator types were not found.');
+      }
+
+      await (tx as any).$executeRawUnsafe(
+        `UPDATE operations_collaborator_type AS ct
+            SET sort_order = updates.sort_order,
+                updated_at = NOW()
+           FROM (
+             SELECT UNNEST($1::int[]) AS id,
+                    GENERATE_SERIES(1, array_length($1::int[], 1)) AS sort_order
+           ) AS updates
+          WHERE ct.id = updates.id`,
+        normalizedIds
+      );
+
+      return this.listCollaboratorTypes(userId, {
+        page: 1,
+        pageSize: Math.max(normalizedIds.length, 1),
+        sortField: 'sortOrder',
+        sortOrder: 'asc',
+      });
+    });
+  }
+
   async listProjectRoles(userId: number) {
     const actor = await this.getActorContext(userId);
     this.ensureCollaborator(actor);
@@ -1173,7 +1229,21 @@ export class OperationsService {
     };
   }
 
-  async listCollaborators(userId: number) {
+  async listCollaborators(
+    userId: number,
+    filters: {
+      page?: number;
+      pageSize?: number;
+      search?: string;
+      sortField?: string;
+      sortOrder?: string;
+      status?: string;
+      collaboratorType?: string;
+      collaboratorTypeId?: number;
+      departmentId?: number;
+      jobTitleId?: number;
+    } = {}
+  ) {
     const actor = await this.getActorContext(userId);
     this.ensureCollaborator(actor);
     const filter = this.buildIdFilter(
@@ -1181,9 +1251,55 @@ export class OperationsService {
       'c.id',
       actor.isDirector
     );
+    const pagination = this.shouldPaginate(filters)
+      ? this.normalizePaginationParams(filters, {
+          defaultSortField: 'displayName',
+          defaultSortOrder: 'asc',
+          allowedSortFields: ['displayName', 'code', 'joinedAt', 'status'],
+        })
+      : null;
 
-    return this.queryRows(
-      `SELECT c.id,
+    const params: unknown[] = [...filter.params];
+    const where = ['c.deleted_at IS NULL', filter.clause];
+
+    if (filters.status && filters.status !== 'all') {
+      where.push(`c.status::text = ${this.param(params, filters.status)}`);
+    }
+
+    if (filters.collaboratorTypeId) {
+      where.push(`c.collaborator_type_id = ${this.param(params, Number(filters.collaboratorTypeId))}`);
+    } else if (filters.collaboratorType && filters.collaboratorType !== 'all') {
+      const collaboratorTypePlaceholder = this.param(params, filters.collaboratorType);
+      where.push(`(
+        collaborator_type.slug = ${collaboratorTypePlaceholder}
+        OR collaborator_type.name = ${collaboratorTypePlaceholder}
+      )`);
+    }
+
+    if (filters.departmentId) {
+      where.push(`c.department_id = ${this.param(params, Number(filters.departmentId))}`);
+    }
+
+    if (filters.jobTitleId) {
+      where.push(`c.job_title_id = ${this.param(params, Number(filters.jobTitleId))}`);
+    }
+
+    if (pagination?.search) {
+      const searchPlaceholder = this.param(params, `%${pagination.search}%`);
+      where.push(`(
+        COALESCE(c.display_name, '') ILIKE ${searchPlaceholder}
+        OR COALESCE(person_record.name, '') ILIKE ${searchPlaceholder}
+        OR COALESCE(c.code, '') ILIKE ${searchPlaceholder}
+        OR COALESCE(department_record.name, '') ILIKE ${searchPlaceholder}
+        OR COALESCE(c.department, '') ILIKE ${searchPlaceholder}
+        OR COALESCE(job_title_record.name, '') ILIKE ${searchPlaceholder}
+        OR COALESCE(c.title, '') ILIKE ${searchPlaceholder}
+        OR COALESCE(s.display_name, '') ILIKE ${searchPlaceholder}
+      )`);
+    }
+
+    const whereClause = where.join(' AND ');
+    const baseQuery = `SELECT c.id,
               c.user_id AS "userId",
               c.person_id AS "personId",
               c.code,
@@ -1236,12 +1352,180 @@ export class OperationsService {
                      oc.created_at DESC
             LIMIT 1
          ) hiring_contract ON TRUE
-        WHERE c.deleted_at IS NULL
-          AND ${filter.clause}
+        WHERE ${whereClause}
         GROUP BY c.id, person_record.id, collaborator_type.id, department_record.id, job_title_record.id, s.id, hiring_contract.id, hiring_contract.status, hiring_contract.budget_amount
-        ORDER BY COALESCE(NULLIF(c.display_name, ''), person_record.name) ASC`,
-      filter.params
+    `;
+
+    if (!pagination) {
+      return this.queryRows(
+        `${baseQuery}
+         ORDER BY COALESCE(NULLIF(c.display_name, ''), person_record.name) ASC`,
+        params
+      );
+    }
+
+    const totalRow = await this.querySingle<{ total: string }>(
+      `SELECT COUNT(*)::text AS total
+         FROM (
+           SELECT c.id
+             FROM operations_collaborator c
+             LEFT JOIN person person_record
+               ON person_record.id = c.person_id
+             LEFT JOIN operations_collaborator_type collaborator_type
+               ON collaborator_type.id = c.collaborator_type_id
+              AND collaborator_type.deleted_at IS NULL
+             LEFT JOIN operations_department department_record
+               ON department_record.id = c.department_id
+              AND department_record.deleted_at IS NULL
+             LEFT JOIN operations_job_title job_title_record
+               ON job_title_record.id = c.job_title_id
+              AND job_title_record.deleted_at IS NULL
+             LEFT JOIN operations_collaborator s
+               ON s.id = c.supervisor_collaborator_id
+            WHERE ${whereClause}
+            GROUP BY c.id, person_record.id, collaborator_type.id, department_record.id, job_title_record.id, s.id
+         ) collaborator_rows`,
+      params
+    );
+
+    const sortColumn =
+      {
+        displayName: `COALESCE(NULLIF(c.display_name, ''), person_record.name)`,
+        code: 'c.code',
+        joinedAt: 'c.joined_at',
+        status: 'c.status',
+      }[pagination.sortField] ?? `COALESCE(NULLIF(c.display_name, ''), person_record.name)`;
+
+    const queryParams = [...params];
+    const limitPlaceholder = this.param(queryParams, pagination.pageSize);
+    const offsetPlaceholder = this.param(queryParams, pagination.offset);
+    const rows = await this.queryRows(
+      `${baseQuery}
+       ORDER BY ${sortColumn} ${pagination.sortOrder.toUpperCase()}, c.id ASC
+       LIMIT ${limitPlaceholder}
+      OFFSET ${offsetPlaceholder}`,
+      queryParams
+    );
+
+    return this.buildPaginationResult(
+      rows,
+      Number(totalRow?.total ?? 0),
+      pagination.page,
+      pagination.pageSize
+    );
+  }
+
+  async getCollaboratorStats(
+    userId: number,
+    filters: {
+      search?: string;
+      status?: string;
+      collaboratorType?: string;
+      collaboratorTypeId?: number;
+      departmentId?: number;
+      jobTitleId?: number;
+    } = {}
+  ) {
+    const actor = await this.getActorContext(userId);
+    this.ensureCollaborator(actor);
+    const filter = this.buildIdFilter(
+      actor.visibleCollaboratorIds,
+      'c.id',
+      actor.isDirector
+    );
+
+    const params: unknown[] = [...filter.params];
+    const where = ['c.deleted_at IS NULL', filter.clause];
+
+    if (filters.status && filters.status !== 'all') {
+      where.push(`c.status::text = ${this.param(params, filters.status)}`);
+    }
+
+    if (filters.collaboratorTypeId) {
+      where.push(
+        `c.collaborator_type_id = ${this.param(params, Number(filters.collaboratorTypeId))}`
+      );
+    } else if (filters.collaboratorType && filters.collaboratorType !== 'all') {
+      const collaboratorTypePlaceholder = this.param(
+        params,
+        filters.collaboratorType
+      );
+      where.push(`(
+        collaborator_type.slug = ${collaboratorTypePlaceholder}
+        OR collaborator_type.name = ${collaboratorTypePlaceholder}
+      )`);
+    }
+
+    if (filters.departmentId) {
+      where.push(
+        `c.department_id = ${this.param(params, Number(filters.departmentId))}`
+      );
+    }
+
+    if (filters.jobTitleId) {
+      where.push(
+        `c.job_title_id = ${this.param(params, Number(filters.jobTitleId))}`
+      );
+    }
+
+    const normalizedSearch = String(filters.search ?? '').trim();
+    if (normalizedSearch) {
+      const searchPlaceholder = this.param(params, `%${normalizedSearch}%`);
+      where.push(`(
+        COALESCE(c.display_name, '') ILIKE ${searchPlaceholder}
+        OR COALESCE(person_record.name, '') ILIKE ${searchPlaceholder}
+        OR COALESCE(c.code, '') ILIKE ${searchPlaceholder}
+        OR COALESCE(department_record.name, '') ILIKE ${searchPlaceholder}
+        OR COALESCE(c.department, '') ILIKE ${searchPlaceholder}
+        OR COALESCE(job_title_record.name, '') ILIKE ${searchPlaceholder}
+        OR COALESCE(c.title, '') ILIKE ${searchPlaceholder}
+        OR COALESCE(s.display_name, '') ILIKE ${searchPlaceholder}
+      )`);
+    }
+
+    const result = await this.querySingle<{
+      total: number;
+      active: number;
+      onLeave: number;
+      withContracts: number;
+    }>(
+      `SELECT COUNT(DISTINCT c.id)::int AS total,
+              COUNT(DISTINCT c.id) FILTER (WHERE c.status = 'active')::int AS active,
+              COUNT(DISTINCT c.id) FILTER (WHERE c.status = 'on_leave')::int AS "onLeave",
+              COUNT(DISTINCT c.id) FILTER (WHERE hiring_contract.id IS NOT NULL)::int AS "withContracts"
+         FROM operations_collaborator c
+         LEFT JOIN person person_record
+           ON person_record.id = c.person_id
+         LEFT JOIN operations_collaborator_type collaborator_type
+           ON collaborator_type.id = c.collaborator_type_id
+          AND collaborator_type.deleted_at IS NULL
+         LEFT JOIN operations_department department_record
+           ON department_record.id = c.department_id
+          AND department_record.deleted_at IS NULL
+         LEFT JOIN operations_job_title job_title_record
+           ON job_title_record.id = c.job_title_id
+          AND job_title_record.deleted_at IS NULL
+         LEFT JOIN operations_collaborator s
+           ON s.id = c.supervisor_collaborator_id
+         LEFT JOIN LATERAL (
+           SELECT oc.id
+             FROM operations_contract oc
+            WHERE oc.related_collaborator_id = c.id
+              AND oc.deleted_at IS NULL
+            ORDER BY CASE WHEN oc.origin_type = 'employee_hiring' THEN 0 ELSE 1 END,
+                     oc.created_at DESC
+            LIMIT 1
+         ) hiring_contract ON TRUE
+        WHERE ${where.join(' AND ')}`,
+      params
     );
+
+    return {
+      total: Number(result?.total ?? 0),
+      active: Number(result?.active ?? 0),
+      onLeave: Number(result?.onLeave ?? 0),
+      withContracts: Number(result?.withContracts ?? 0),
+    };
   }
 
   async getMyCollaborator(userId: number) {
@@ -1380,12 +1664,12 @@ export class OperationsService {
                     ''
                   ) AS "timesheetProjectNames",
                   tor.request_type AS "timeOffType",
-                  tor.start_date AS "timeOffStartDate",
-                  tor.end_date AS "timeOffEndDate",
+                  tor.start_date::text AS "timeOffStartDate",
+                  tor.end_date::text AS "timeOffEndDate",
                   tor.reason AS "timeOffReason",
                   sar.request_scope AS "scheduleRequestScope",
-                  sar.effective_start_date AS "scheduleStartDate",
-                  sar.effective_end_date AS "scheduleEndDate",
+                  sar.effective_start_date::text AS "scheduleStartDate",
+                  sar.effective_end_date::text AS "scheduleEndDate",
                   sar.reason AS "scheduleReason"
              FROM operations_approval a
              JOIN operations_collaborator requester
@@ -1420,8 +1704,8 @@ export class OperationsService {
                   tor.collaborator_id AS "collaboratorId",
                   c.display_name AS "collaboratorName",
                   tor.request_type AS "requestType",
-                  tor.start_date AS "startDate",
-                  tor.end_date AS "endDate",
+                  tor.start_date::text AS "startDate",
+                  tor.end_date::text AS "endDate",
                   tor.total_days AS "totalDays",
                   tor.status,
                   tor.reason,
@@ -1445,8 +1729,8 @@ export class OperationsService {
                   sar.collaborator_id AS "collaboratorId",
                   c.display_name AS "collaboratorName",
                   sar.request_scope AS "requestScope",
-                  sar.effective_start_date AS "effectiveStartDate",
-                  sar.effective_end_date AS "effectiveEndDate",
+                  sar.effective_start_date::text AS "effectiveStartDate",
+                  sar.effective_end_date::text AS "effectiveEndDate",
                   sar.status,
                   sar.reason,
                   sar.submitted_at AS "submittedAt",
@@ -1777,33 +2061,110 @@ export class OperationsService {
     return this.getCollaboratorByIdForUser(userId, collaboratorId);
   }
 
-  async listDepartments(userId: number) {
-    const actor = await this.getActorContext(userId);
-    this.ensureCollaborator(actor);
-
-    return this.queryRows(
-      `SELECT d.id,
-              d.slug,
-              d.code,
-              d.name,
-              d.description,
-              CASE WHEN d.deleted_at IS NULL THEN 'active' ELSE 'inactive' END AS status,
-              COUNT(DISTINCT c.id)::int AS "collaboratorCount",
-              d.created_at AS "createdAt",
-              d.updated_at AS "updatedAt"
-         FROM operations_department d
-         LEFT JOIN operations_collaborator c
-           ON c.deleted_at IS NULL
-          AND (
-            c.department_id = d.id
-            OR (
-              c.department_id IS NULL
-              AND LOWER(COALESCE(c.department, '')) = LOWER(d.name)
-            )
+  async listDepartments(
+    userId: number,
+    filters: {
+      page?: number;
+      pageSize?: number;
+      search?: string;
+      sortField?: string;
+      sortOrder?: string;
+      status?: string;
+    } = {}
+  ) {
+    const actor = await this.getActorContext(userId);
+    this.ensureCollaborator(actor);
+
+    const pagination = this.shouldPaginate(filters)
+      ? this.normalizePaginationParams(filters, {
+          defaultSortField: 'name',
+          defaultSortOrder: 'asc',
+          allowedSortFields: ['name', 'code', 'createdAt', 'updatedAt'],
+        })
+      : null;
+
+    const params: unknown[] = [];
+    const where: string[] = [];
+
+    if (filters.status === 'active') {
+      where.push('d.deleted_at IS NULL');
+    } else if (filters.status === 'inactive') {
+      where.push('d.deleted_at IS NOT NULL');
+    }
+
+    if (pagination?.search) {
+      const searchPlaceholder = this.param(params, `%${pagination.search}%`);
+      where.push(`(
+        COALESCE(d.name, '') ILIKE ${searchPlaceholder}
+        OR COALESCE(d.code, '') ILIKE ${searchPlaceholder}
+        OR COALESCE(d.description, '') ILIKE ${searchPlaceholder}
+      )`);
+    }
+
+    const whereClause = where.length ? `WHERE ${where.join(' AND ')}` : '';
+    const baseQuery = `SELECT d.id,
+            d.slug,
+            d.code,
+            d.name,
+            d.description,
+            CASE WHEN d.deleted_at IS NULL THEN 'active' ELSE 'inactive' END AS status,
+            COUNT(DISTINCT c.id)::int AS "collaboratorCount",
+            d.created_at AS "createdAt",
+            d.updated_at AS "updatedAt"
+       FROM operations_department d
+       LEFT JOIN operations_collaborator c
+         ON c.deleted_at IS NULL
+        AND (
+          c.department_id = d.id
+          OR (
+            c.department_id IS NULL
+            AND LOWER(COALESCE(c.department, '')) = LOWER(d.name)
           )
-        GROUP BY d.id
-        ORDER BY CASE WHEN d.deleted_at IS NULL THEN 0 ELSE 1 END ASC,
-                 d.name ASC`
+        )
+      ${whereClause}
+      GROUP BY d.id`;
+
+    if (!pagination) {
+      return this.queryRows(
+        `${baseQuery}
+         ORDER BY CASE WHEN d.deleted_at IS NULL THEN 0 ELSE 1 END ASC,
+                  d.name ASC`,
+        params
+      );
+    }
+
+    const totalRow = await this.querySingle<{ total: string }>(
+      `SELECT COUNT(*)::text AS total
+         FROM operations_department d
+        ${whereClause}`,
+      params
+    );
+
+    const sortColumn =
+      {
+        name: 'd.name',
+        code: 'd.code',
+        createdAt: 'd.created_at',
+        updatedAt: 'd.updated_at',
+      }[pagination.sortField] ?? 'd.name';
+
+    const queryParams = [...params];
+    const limitPlaceholder = this.param(queryParams, pagination.pageSize);
+    const offsetPlaceholder = this.param(queryParams, pagination.offset);
+
+    const rows = await this.queryRows(
+      `${baseQuery}
+       ORDER BY ${sortColumn} ${pagination.sortOrder.toUpperCase()}, d.id ASC
+       LIMIT ${limitPlaceholder}
+      OFFSET ${offsetPlaceholder}`,
+      queryParams
+    );
+
+    return this.buildPaginationResult(
+      rows,
+      Number(totalRow?.total ?? 0),
+      pagination.page,
+      pagination.pageSize
     );
   }
 
@@ -2003,7 +2364,17 @@ export class OperationsService {
     });
   }
 
-  async listProjects(userId: number) {
+  async listProjects(
+    userId: number,
+    filters: {
+      page?: number;
+      pageSize?: number;
+      search?: string;
+      sortField?: string;
+      sortOrder?: string;
+      status?: string;
+    } = {}
+  ) {
     const actor = await this.getActorContext(userId);
     const filter = this.buildIdFilter(actor.visibleProjectIds, 'p.id', actor.isDirector);
     const assignmentParams: unknown[] = [];
@@ -2018,9 +2389,34 @@ export class OperationsService {
          )} THEN pa.role_label END) AS "myRoleLabel",`
       : `NULL::int AS "myAssignmentId",
          NULL::varchar AS "myRoleLabel",`;
+    const pagination = this.shouldPaginate(filters)
+      ? this.normalizePaginationParams(filters, {
+          defaultSortField: 'name',
+          defaultSortOrder: 'asc',
+          allowedSortFields: ['name', 'code', 'clientName', 'startDate', 'endDate', 'status'],
+        })
+      : null;
 
-    return this.queryRows(
-      `SELECT p.id,
+    const params: unknown[] = [...assignmentParams, ...filter.params];
+    const where = ['p.deleted_at IS NULL', filter.clause];
+
+    if (filters.status && filters.status !== 'all') {
+      where.push(`p.status::text = ${this.param(params, filters.status)}`);
+    }
+
+    if (pagination?.search) {
+      const searchPlaceholder = this.param(params, `%${pagination.search}%`);
+      where.push(`(
+        COALESCE(p.name, '') ILIKE ${searchPlaceholder}
+        OR COALESCE(p.code, '') ILIKE ${searchPlaceholder}
+        OR COALESCE(p.client_name, '') ILIKE ${searchPlaceholder}
+        OR COALESCE(c.name, '') ILIKE ${searchPlaceholder}
+        OR COALESCE(m.display_name, '') ILIKE ${searchPlaceholder}
+      )`);
+    }
+
+    const whereClause = where.join(' AND ');
+    const baseQuery = `SELECT p.id,
               p.contract_id AS "contractId",
               p.manager_collaborator_id AS "managerCollaboratorId",
               p.code,
@@ -2045,10 +2441,49 @@ export class OperationsService {
            ON pa.project_id = p.id
           AND pa.deleted_at IS NULL
           AND pa.status IN ('planned', 'active')
-        WHERE p.deleted_at IS NULL AND ${filter.clause}
-        GROUP BY p.id, c.id, m.id
-        ORDER BY p.name ASC`,
-      [...assignmentParams, ...filter.params]
+        WHERE ${whereClause}
+        GROUP BY p.id, c.id, m.id`;
+
+    if (!pagination) {
+      return this.queryRows(`${baseQuery} ORDER BY p.name ASC`, params);
+    }
+
+    const totalRow = await this.querySingle<{ total: string }>(
+      `SELECT COUNT(*)::text AS total
+         FROM operations_project p
+         LEFT JOIN operations_contract c ON c.id = p.contract_id
+         LEFT JOIN operations_collaborator m ON m.id = p.manager_collaborator_id
+        WHERE ${whereClause}`,
+      params
+    );
+
+    const sortColumn =
+      {
+        name: 'p.name',
+        code: 'p.code',
+        clientName: 'p.client_name',
+        startDate: 'p.start_date',
+        endDate: 'p.end_date',
+        status: 'p.status',
+      }[pagination.sortField] ?? 'p.name';
+
+    const queryParams = [...params];
+    const limitPlaceholder = this.param(queryParams, pagination.pageSize);
+    const offsetPlaceholder = this.param(queryParams, pagination.offset);
+
+    const rows = await this.queryRows(
+      `${baseQuery}
+       ORDER BY ${sortColumn} ${pagination.sortOrder.toUpperCase()}, p.id ASC
+       LIMIT ${limitPlaceholder}
+      OFFSET ${offsetPlaceholder}`,
+      queryParams
+    );
+
+    return this.buildPaginationResult(
+      rows,
+      Number(totalRow?.total ?? 0),
+      pagination.page,
+      pagination.pageSize
     );
   }
 
@@ -2065,22 +2500,19 @@ export class OperationsService {
     const actor = await this.getActorContext(userId);
     this.ensureCollaborator(actor);
 
-    if (!actor.collaboratorId) {
-      throw new BadRequestException('Collaborator context is required.');
-    }
-
     const pagination = this.normalizePaginationParams(paginationParams, {
       defaultSortField: 'name',
       defaultSortOrder: 'asc',
       allowedSortFields: ['name', 'code', 'clientName', 'startDate', 'endDate'],
     });
 
-    const params: unknown[] = [actor.collaboratorId];
+    const filter = this.buildIdFilter(actor.visibleProjectIds, 'p.id', actor.isDirector);
+    const params: unknown[] = [...filter.params];
     const filters = [
       'p.deleted_at IS NULL',
       'pa.deleted_at IS NULL',
-      `pa.collaborator_id = $1`,
       `pa.status IN ('planned', 'active')`,
+      filter.clause,
     ];
 
     if (pagination.search) {
@@ -2174,23 +2606,30 @@ export class OperationsService {
     const actor = await this.getActorContext(userId);
     this.ensureCollaborator(actor);
 
-    if (!actor.collaboratorId) {
-      throw new BadRequestException('Collaborator context is required.');
-    }
-
     const pagination = this.normalizePaginationParams(paginationParams, {
       defaultSortField: 'name',
       defaultSortOrder: 'asc',
       allowedSortFields: ['name', 'projectName', 'status', 'createdAt'],
     });
 
-    const params: unknown[] = [actor.collaboratorId];
+    const projectFilter = this.buildIdFilter(
+      actor.visibleProjectIds,
+      'COALESCE(t.project_id, pa.project_id)',
+      actor.isDirector
+    );
+    const params: unknown[] = [...projectFilter.params];
     const filters = [
       't.deleted_at IS NULL',
-      'pa.deleted_at IS NULL',
       'p.deleted_at IS NULL',
-      `pa.collaborator_id = $1`,
-      `pa.status IN ('planned', 'active')`,
+      projectFilter.clause,
+      `(
+        t.project_id IS NOT NULL
+        OR (
+          pa.id IS NOT NULL
+          AND pa.deleted_at IS NULL
+          AND pa.status IN ('planned', 'active')
+        )
+      )`,
     ];
 
     if (pagination.search) {
@@ -2208,21 +2647,26 @@ export class OperationsService {
     }
 
     if (paginationParams.projectId) {
-      filters.push(`pa.project_id = ${this.param(params, paginationParams.projectId)}`);
+      filters.push(
+        `COALESCE(t.project_id, pa.project_id) = ${this.param(
+          params,
+          paginationParams.projectId
+        )}`
+      );
     }
 
     if (paginationParams.status) {
-      filters.push(`t.status = ${this.param(params, paginationParams.status)}`);
+      filters.push(`t.status::text = ${this.param(params, paginationParams.status)}`);
     }
 
     const whereClause = filters.join(' AND ');
     const totalRow = await this.querySingle<{ total: string }>(
       `SELECT COUNT(*)::text AS total
          FROM operations_task t
-         JOIN operations_project_assignment pa
+         LEFT JOIN operations_project_assignment pa
            ON pa.id = t.project_assignment_id
          JOIN operations_project p
-           ON p.id = pa.project_id
+           ON p.id = COALESCE(t.project_id, pa.project_id)
         WHERE ${whereClause}`,
       params
     );
@@ -2254,16 +2698,16 @@ export class OperationsService {
               t.name,
               t.description,
               t.status,
-              pa.project_id AS "projectId",
+              COALESCE(t.project_id, pa.project_id) AS "projectId",
               pa.id AS "projectAssignmentId",
               p.name AS "projectName",
               p.code AS "projectCode",
               t.created_at AS "createdAt"
          FROM operations_task t
-         JOIN operations_project_assignment pa
+         LEFT JOIN operations_project_assignment pa
            ON pa.id = t.project_assignment_id
          JOIN operations_project p
-           ON p.id = pa.project_id
+           ON p.id = COALESCE(t.project_id, pa.project_id)
         WHERE ${whereClause}
         ORDER BY ${sortColumn} ${pagination.sortOrder.toUpperCase()}, t.id ASC
         LIMIT ${limitPlaceholder}
@@ -2699,9 +3143,9 @@ export class OperationsService {
         ? await this.getOwnedTaskRecord(tx as any, actor.collaboratorId as number, data.taskId)
         : null;
 
-      if (resolvedTask && resolvedTask.projectAssignmentId !== assignment.id) {
+      if (resolvedTask && resolvedTask.projectId !== assignment.projectId) {
         throw new BadRequestException(
-          'The selected task does not belong to the chosen project assignment.'
+          'The selected task does not belong to the chosen project.'
         );
       }
 
@@ -2760,6 +3204,116 @@ export class OperationsService {
     return this.getTimesheetEntryByIdForActor(actor, createdEntryId);
   }
 
+  async updateTimesheetEntry(
+    userId: number,
+    entryId: number,
+    data: QuickTimesheetEntryPayload
+  ) {
+    const actor = await this.getActorContext(userId);
+    this.ensureCollaborator(actor);
+    this.requireFields(data as Record<string, unknown>, ['workDate', 'duration']);
+
+    if (!actor.collaboratorId && !actor.isDirector) {
+      throw new BadRequestException('Collaborator context is required.');
+    }
+
+    const entry = await this.getTimesheetEntryByIdForActor(actor, entryId);
+
+    if (!actor.isDirector && entry.collaboratorId !== actor.collaboratorId) {
+      throw new ForbiddenException(
+        'Only the entry owner can update this timesheet entry.'
+      );
+    }
+
+    if (!['draft', 'rejected'].includes(entry.status)) {
+      throw new BadRequestException(
+        'Only draft or rejected timesheet entries can be edited.'
+      );
+    }
+
+    const collaboratorId = actor.isDirector
+      ? entry.collaboratorId
+      : (actor.collaboratorId as number);
+    const durationMinutes = this.normalizeDurationMinutes(data.duration, data.unit);
+    const taskLabel =
+      this.normalizeOptionalText(data.taskName) ??
+      this.normalizeOptionalText(data.activityLabel);
+    const targetWeek = this.getWorkWeekRange(data.workDate);
+    const isSameWeek =
+      entry.weekStartDate === targetWeek.weekStartDate &&
+      entry.weekEndDate === targetWeek.weekEndDate;
+
+    await this.prisma.$transaction(async (tx) => {
+      const assignment = await this.resolveOwnedProjectAssignment(
+        tx as any,
+        collaboratorId,
+        {
+          projectId: data.projectId ?? null,
+          projectAssignmentId: data.projectAssignmentId ?? null,
+        }
+      );
+
+      const resolvedTask = data.taskId
+        ? await this.getOwnedTaskRecord(tx as any, collaboratorId, data.taskId)
+        : null;
+
+      if (resolvedTask && resolvedTask.projectId !== assignment.projectId) {
+        throw new BadRequestException(
+          'The selected task does not belong to the chosen project.'
+        );
+      }
+
+      const activityLabel =
+        resolvedTask?.name ?? taskLabel ?? assignment.roleLabel ?? assignment.projectName;
+
+      if (!activityLabel) {
+        throw new BadRequestException('A task is required for the timesheet entry.');
+      }
+
+      const targetTimesheetId = isSameWeek
+        ? entry.timesheetId
+        : await this.getOrCreateTimesheetForWorkDate(
+            tx as any,
+            collaboratorId,
+            data.workDate
+          );
+
+      await (tx as any).$executeRawUnsafe(
+        `UPDATE operations_timesheet_entry
+            SET timesheet_id = $1,
+                project_assignment_id = $2,
+                task_id = $3,
+                activity_label = $4,
+                work_date = $5::date,
+                duration_minutes = $6,
+                hours = $7,
+                description = $8,
+                updated_at = NOW()
+          WHERE id = $9
+            AND deleted_at IS NULL`,
+        targetTimesheetId,
+        assignment.id,
+        resolvedTask?.id ?? data.taskId ?? null,
+        activityLabel,
+        data.workDate,
+        durationMinutes,
+        Number((durationMinutes / 60).toFixed(2)),
+        this.normalizeOptionalText(data.description),
+        entryId
+      );
+
+      await this.refreshTimesheetTotal(tx as any, entry.timesheetId);
+
+      if (targetTimesheetId !== entry.timesheetId) {
+        await this.refreshTimesheetTotal(tx as any, targetTimesheetId);
+      }
+
+      await this.cleanupEmptyEditableTimesheet(tx as any, entry.timesheetId);
+    });
+
+    return this.getTimesheetEntryByIdForActor(actor, entryId);
+  }
+
   async removeTimesheetEntry(userId: number, entryId: number) {
     const actor = await this.getActorContext(userId);
     this.ensureCollaborator(actor);
@@ -2793,6 +3347,7 @@ export class OperationsService {
       );
 
       await this.refreshTimesheetTotal(tx as any, entry.timesheetId);
+      await this.cleanupEmptyEditableTimesheet(tx as any, entry.timesheetId);
     });
 
     return { success: true };
@@ -2860,38 +3415,6 @@ export class OperationsService {
         );
       }
 
-      if (!data.contractId && data.autoGenerateContractDraft !== false) {
-        const contractId = await this.createProjectContractDraft(
-          tx as any,
-          actor.userId,
-          {
-            projectId,
-            contractTemplateId: data.contractTemplateId ?? null,
-            projectCode: data.code,
-            projectName: data.name,
-            clientName: data.clientName ?? data.name,
-            managerCollaboratorId: data.managerCollaboratorId ?? null,
-            startDate: data.startDate ?? null,
-            endDate: data.endDate ?? null,
-            budgetAmount: data.budgetAmount ?? null,
-            monthlyHourCap: data.monthlyHourCap ?? null,
-            billingModel: data.billingModel ?? 'time_and_material',
-            contractCode: data.contractCode ?? null,
-            contractName: data.contractName ?? null,
-            description: data.contractDescription ?? data.summary ?? null,
-          }
-        );
-
-        await (tx as any).$executeRawUnsafe(
-          `UPDATE operations_project
-              SET contract_id = $1,
-                  updated_at = NOW()
-            WHERE id = $2`,
-          contractId,
-          projectId
-        );
-      }
-
       return projectId;
     });
 
@@ -2955,59 +3478,8 @@ export class OperationsService {
         data.contractId !== undefined
           ? data.contractId
           : (currentProject.relatedContract?.id ?? null);
-      const shouldGenerateDraft =
-        !nextContractId && data.autoGenerateContractDraft === true;
-
-      if (shouldGenerateDraft) {
-        const contractId = await this.createProjectContractDraft(
-          tx as any,
-          actor.userId,
-          {
-            projectId,
-            contractTemplateId: data.contractTemplateId ?? null,
-            projectCode: data.code ?? currentProject.code,
-            projectName: data.name ?? currentProject.name,
-            clientName:
-              data.clientName ??
-              currentProject.clientName ??
-              currentProject.name,
-            managerCollaboratorId:
-              data.managerCollaboratorId ??
-              currentProject.managerCollaboratorId ??
-              null,
-            startDate: data.startDate ?? currentProject.startDate ?? null,
-            endDate: data.endDate ?? currentProject.endDate ?? null,
-            budgetAmount: data.budgetAmount ?? currentProject.budgetAmount ?? null,
-            monthlyHourCap:
-              data.monthlyHourCap ??
-              currentProject.relatedContract?.monthlyHourCap ??
-              null,
-            billingModel:
-              data.billingModel ??
-              currentProject.relatedContract?.billingModel ??
-              'time_and_material',
-            contractCode:
-              data.contractCode ?? currentProject.relatedContract?.code ?? null,
-            contractName:
-              data.contractName ?? currentProject.relatedContract?.name ?? null,
-            description:
-              data.contractDescription ??
-              currentProject.relatedContract?.description ??
-              data.summary ??
-              currentProject.summary ??
-              null,
-          }
-        );
 
-        await (tx as any).$executeRawUnsafe(
-          `UPDATE operations_project
-              SET contract_id = $1,
-                  updated_at = NOW()
-            WHERE id = $2`,
-          contractId,
-          projectId
-        );
-      } else if (
+      if (
         nextContractId &&
         (data.monthlyHourCap !== undefined || data.billingModel !== undefined)
       ) {
@@ -3046,210 +3518,20 @@ export class OperationsService {
     return this.getProjectById(userId, projectId);
   }
 
-  async listContractTemplates(userId: number) {
-    const actor = await this.getActorContext(userId);
-    this.ensureDirector(actor);
-
-    return this.queryRows(
-      `SELECT t.id,
-              t.slug,
-              t.code,
-              t.name,
-              t.description,
-              t.contract_category AS "contractCategory",
-              t.contract_type AS "contractType",
-              t.billing_model AS "billingModel",
-              t.signature_status AS "signatureStatus",
-              t.is_active AS "isActive",
-              t.status,
-              t.content_html AS "contentHtml",
-              t.created_at AS "createdAt",
-              t.updated_at AS "updatedAt",
-              COUNT(DISTINCT c.id)::int AS "usageCount"
-         FROM operations_contract_template t
-         LEFT JOIN operations_contract c
-           ON c.contract_template_id = t.id
-          AND c.deleted_at IS NULL
-        WHERE t.deleted_at IS NULL
-        GROUP BY t.id
-        ORDER BY CASE
-                   WHEN t.status = 'active' THEN 0
-                   WHEN t.status = 'draft' THEN 1
-                   WHEN t.status = 'inactive' THEN 2
-                   ELSE 3
-                 END,
-                 t.name ASC`
-    );
-  }
-
-  async getContractTemplateById(userId: number, templateId: number) {
-    const actor = await this.getActorContext(userId);
-    this.ensureDirector(actor);
-
-    return this.getContractTemplateRecord(this.prisma as any, templateId);
-  }
-
-  async createContractTemplate(userId: number, data: ContractTemplatePayload) {
-    const actor = await this.getActorContext(userId);
-    this.ensureDirector(actor);
-
-    const name = this.normalizeOptionalText(data.name);
-    if (!name) {
-      throw new BadRequestException('Contract template name is required.');
-    }
-
-    return this.prisma.$transaction(async (tx) => {
-      await this.assertContractTemplateNameAvailable(tx as any, name);
-
-      const nextCode =
-        this.normalizeOptionalText(data.code)?.toUpperCase() ?? null;
-
-      if (nextCode) {
-        await this.assertContractTemplateCodeAvailable(tx as any, nextCode);
-      }
-
-      const nextStatus = data.status ?? 'active';
-      const isActive =
-        data.isActive ?? !['inactive', 'archived'].includes(nextStatus);
-
-      const created = (await (tx as any).$queryRawUnsafe(
-        `INSERT INTO operations_contract_template (
-          slug,
-          code,
-          name,
-          description,
-          contract_category,
-          contract_type,
-          billing_model,
-          signature_status,
-          is_active,
-          status,
-          content_html,
-          created_at,
-          updated_at
-        ) VALUES (
-          $1, $2, $3, $4,
-          $5, $6, $7, $8, $9, $10, $11,
-          NOW(), NOW()
-        )
-        RETURNING id`,
-        await this.generateUniqueContractTemplateSlug(tx as any, name),
-        nextCode,
-        name,
-        this.normalizeOptionalText(data.description),
-        data.contractCategory ?? 'client',
-        data.contractType ?? 'service_agreement',
-        data.billingModel ?? 'time_and_material',
-        data.signatureStatus ?? 'not_started',
-        isActive,
-        nextStatus,
-        this.normalizeOptionalText(data.contentHtml)
-      )) as { id: number }[];
-
-      const templateId = created[0]?.id;
-      if (!templateId) {
-        throw new BadRequestException('Unable to create the contract template.');
-      }
-
-      return this.getContractTemplateRecord(tx as any, templateId, true);
-    });
-  }
-
-  async updateContractTemplate(
-    userId: number,
-    templateId: number,
-    data: Partial<ContractTemplatePayload>
-  ) {
-    const actor = await this.getActorContext(userId);
-    this.ensureDirector(actor);
-
-    return this.prisma.$transaction(async (tx) => {
-      const current = await this.getContractTemplateRecord(
-        tx as any,
-        templateId,
-        true
-      );
-
-      const nextName =
-        data.name !== undefined
-          ? this.normalizeOptionalText(data.name)
-          : current.name;
-
-      if (!nextName) {
-        throw new BadRequestException('Contract template name is required.');
-      }
-
-      if (String(nextName).toLowerCase() !== String(current.name).toLowerCase()) {
-        await this.assertContractTemplateNameAvailable(
-          tx as any,
-          nextName,
-          templateId
-        );
-      }
-
-      const nextCode =
-        data.code !== undefined
-          ? this.normalizeOptionalText(data.code)?.toUpperCase() ?? null
-          : (current.code ?? null);
-
-      if (nextCode) {
-        await this.assertContractTemplateCodeAvailable(
-          tx as any,
-          nextCode,
-          templateId
-        );
-      }
-
-      const nextStatus = data.status ?? current.status ?? 'active';
-      const nextIsActive =
-        data.isActive ?? !['inactive', 'archived'].includes(nextStatus);
-      const nextSlug =
-        String(nextName).toLowerCase() !== String(current.name).toLowerCase()
-          ? await this.generateUniqueContractTemplateSlug(
-              tx as any,
-              nextName,
-              templateId
-            )
-          : current.slug;
-
-      await (tx as any).$executeRawUnsafe(
-        `UPDATE operations_contract_template
-            SET slug = $1,
-                code = $2,
-                name = $3,
-                description = $4,
-                contract_category = $5,
-                contract_type = $6,
-                billing_model = $7,
-                signature_status = $8,
-                is_active = $9,
-                status = $10,
-                content_html = $11,
-                updated_at = NOW()
-          WHERE id = $12`,
-        nextSlug,
-        nextCode,
-        nextName,
-        data.description !== undefined
-          ? this.normalizeOptionalText(data.description)
-          : (current.description ?? null),
-        data.contractCategory ?? current.contractCategory ?? 'client',
-        data.contractType ?? current.contractType ?? 'service_agreement',
-        data.billingModel ?? current.billingModel ?? 'time_and_material',
-        data.signatureStatus ?? current.signatureStatus ?? 'not_started',
-        nextIsActive,
-        nextStatus,
-        data.contentHtml !== undefined
-          ? this.normalizeOptionalText(data.contentHtml)
-          : (current.contentHtml ?? null),
-        templateId
-      );
-
-      return this.getContractTemplateRecord(tx as any, templateId, true);
-    });
-  }
-
-  async listContracts(userId: number) {
+  async listContracts(
+    userId: number,
+    filters: {
+      page?: number;
+      pageSize?: number;
+      search?: string;
+      sortField?: string;
+      sortOrder?: string;
+      status?: string;
+      contractCategory?: string;
+      originType?: string;
+      isActive?: string;
+    } = {}
+  ) {
     const actor = await this.getActorContext(userId);
     const params: unknown[] = [];
     const accessClause = actor.isDirector
@@ -3261,12 +3543,51 @@ export class OperationsService {
               FROM operations_project p_access
              WHERE p_access.contract_id = c.id
                AND p_access.deleted_at IS NULL
-               AND p_access.id = ANY(${this.param(params, actor.visibleProjectIds)}::int[])
+              AND p_access.id = ANY(${this.param(params, actor.visibleProjectIds)}::int[])
           )
         )`;
+    const pagination = this.shouldPaginate(filters)
+      ? this.normalizePaginationParams(filters, {
+          defaultSortField: 'name',
+          defaultSortOrder: 'asc',
+          allowedSortFields: ['name', 'code', 'clientName', 'startDate', 'endDate', 'status'],
+        })
+      : null;
+    const where = [accessClause];
 
-    return this.queryRows(
-      `SELECT c.id,
+    if (filters.status && filters.status !== 'all') {
+      where.push(`c.status::text = ${this.param(params, filters.status)}`);
+    }
+
+    if (filters.contractCategory && filters.contractCategory !== 'all') {
+      where.push(
+        `c.contract_category = ${this.param(params, filters.contractCategory)}::text::operations_contract_contract_category_70d553ea09_enum`
+      );
+    }
+
+    if (filters.originType && filters.originType !== 'all') {
+      where.push(
+        `c.origin_type = ${this.param(params, filters.originType)}::text::operations_contract_origin_type_07a7cc2b5d_enum`
+      );
+    }
+
+    if (filters.isActive === 'true' || filters.isActive === 'false') {
+      where.push(`c.is_active = ${this.param(params, filters.isActive === 'true')}`);
+    }
+
+    if (pagination?.search) {
+      const searchPlaceholder = this.param(params, `%${pagination.search}%`);
+      where.push(`(
+        COALESCE(c.name, '') ILIKE ${searchPlaceholder}
+        OR COALESCE(c.code, '') ILIKE ${searchPlaceholder}
+        OR COALESCE(c.client_name, '') ILIKE ${searchPlaceholder}
+        OR COALESCE(m.display_name, '') ILIKE ${searchPlaceholder}
+        OR COALESCE(linked.display_name, '') ILIKE ${searchPlaceholder}
+      )`);
+    }
+
+    const whereClause = where.join(' AND ');
+    const baseQuery = `SELECT c.id,
               c.code,
               c.name,
               c.contract_category AS "contractCategory",
@@ -3277,10 +3598,6 @@ export class OperationsService {
               c.billing_model AS "billingModel",
               c.account_manager_collaborator_id AS "accountManagerCollaboratorId",
               c.related_collaborator_id AS "relatedCollaboratorId",
-              c.contract_template_id AS "contractTemplateId",
-              template.name AS "contractTemplateName",
-              template.slug AS "contractTemplateSlug",
-              template.code AS "contractTemplateCode",
               c.origin_type AS "originType",
               c.origin_id AS "originId",
               c.start_date AS "startDate",
@@ -3296,17 +3613,11 @@ export class OperationsService {
               m.display_name AS "accountManagerName",
               linked.display_name AS "relatedCollaboratorName",
               MAX(COALESCE(primary_party.display_name, linked.display_name, c.client_name)) AS "mainRelatedPartyName",
-              MAX(COALESCE(financials.value_amount, 0)) AS "valueAmount",
-              MAX(COALESCE(financials.payment_amount, 0)) AS "paymentAmount",
-              MAX(COALESCE(financials.revenue_amount, 0)) AS "revenueAmount",
-              MAX(COALESCE(financials.fine_amount, 0)) AS "fineAmount",
               MAX(COALESCE(pdf_document.file_name, '')) AS "currentPdfFileName",
               COUNT(DISTINCT p.id)::int AS "projectCount"
          FROM operations_contract c
          LEFT JOIN operations_collaborator m ON m.id = c.account_manager_collaborator_id
          LEFT JOIN operations_collaborator linked ON linked.id = c.related_collaborator_id
-         LEFT JOIN operations_contract_template template
-           ON template.id = c.contract_template_id
          LEFT JOIN LATERAL (
            SELECT cp.display_name
              FROM operations_contract_party cp
@@ -3315,16 +3626,6 @@ export class OperationsService {
             ORDER BY cp.is_primary DESC, cp.id ASC
             LIMIT 1
          ) primary_party ON TRUE
-         LEFT JOIN LATERAL (
-           SELECT
-             SUM(CASE WHEN term_type = 'value' THEN amount ELSE 0 END) AS value_amount,
-             SUM(CASE WHEN term_type = 'payment' THEN amount ELSE 0 END) AS payment_amount,
-             SUM(CASE WHEN term_type = 'revenue' THEN amount ELSE 0 END) AS revenue_amount,
-             SUM(CASE WHEN term_type = 'fine' THEN amount ELSE 0 END) AS fine_amount
-           FROM operations_contract_financial_term ft
-          WHERE ft.contract_id = c.id
-            AND ft.deleted_at IS NULL
-         ) financials ON TRUE
          LEFT JOIN LATERAL (
            SELECT cd.file_name
              FROM operations_contract_document cd
@@ -3338,11 +3639,101 @@ export class OperationsService {
          LEFT JOIN operations_project p
            ON p.contract_id = c.id
           AND p.deleted_at IS NULL
-        WHERE ${accessClause}
-        GROUP BY c.id, m.id, linked.id, template.id
-        ORDER BY COALESCE(c.name, c.code, CONCAT('draft-', c.id)) ASC`,
+        WHERE ${whereClause}
+        GROUP BY c.id, m.id, linked.id`;
+
+    if (!pagination) {
+      return this.queryRows(
+        `${baseQuery}
+         ORDER BY COALESCE(c.name, c.code, CONCAT('draft-', c.id)) ASC`,
+        params
+      );
+    }
+
+    const totalRow = await this.querySingle<{ total: string }>(
+      `SELECT COUNT(*)::text AS total
+         FROM operations_contract c
+         LEFT JOIN operations_collaborator m ON m.id = c.account_manager_collaborator_id
+         LEFT JOIN operations_collaborator linked ON linked.id = c.related_collaborator_id
+        WHERE ${whereClause}`,
       params
     );
+
+    const sortColumn =
+      {
+        name: `COALESCE(c.name, c.code, CONCAT('draft-', c.id))`,
+        code: 'c.code',
+        clientName: 'c.client_name',
+        startDate: 'c.start_date',
+        endDate: 'c.end_date',
+        status: 'c.status',
+      }[pagination.sortField] ?? `COALESCE(c.name, c.code, CONCAT('draft-', c.id))`;
+
+    const queryParams = [...params];
+    const limitPlaceholder = this.param(queryParams, pagination.pageSize);
+    const offsetPlaceholder = this.param(queryParams, pagination.offset);
+    const rows = await this.queryRows(
+      `${baseQuery}
+       ORDER BY ${sortColumn} ${pagination.sortOrder.toUpperCase()}, c.id ASC
+       LIMIT ${limitPlaceholder}
+      OFFSET ${offsetPlaceholder}`,
+      queryParams
+    );
+
+    return this.buildPaginationResult(
+      rows,
+      Number(totalRow?.total ?? 0),
+      pagination.page,
+      pagination.pageSize
+    );
+  }
+
+  async getContractStats(userId: number) {
+    const actor = await this.getActorContext(userId);
+    const params: unknown[] = [];
+    const accessClause = actor.isDirector
+      ? 'c.deleted_at IS NULL'
+      : `c.deleted_at IS NULL AND (
+          c.related_collaborator_id = ANY(${this.param(params, actor.visibleCollaboratorIds)}::int[])
+          OR EXISTS (
+            SELECT 1
+              FROM operations_project p_access
+             WHERE p_access.contract_id = c.id
+               AND p_access.deleted_at IS NULL
+               AND p_access.id = ANY(${this.param(params, actor.visibleProjectIds)}::int[])
+          )
+        )`;
+
+    const stats = await this.querySingle<{
+      total: number | string;
+      active: number | string;
+      inactive: number | string;
+      withFile: number | string;
+    }>(
+      `SELECT COUNT(*)::int AS total,
+              COUNT(*) FILTER (WHERE c.is_active = true)::int AS active,
+              COUNT(*) FILTER (WHERE c.is_active = false)::int AS inactive,
+              COUNT(*) FILTER (
+                WHERE EXISTS (
+                  SELECT 1
+                    FROM operations_contract_document cd
+                   WHERE cd.contract_id = c.id
+                     AND cd.deleted_at IS NULL
+                     AND cd.is_current = true
+                     AND cd.document_type IN ('source_upload', 'generated_pdf')
+                )
+              )::int AS "withFile"
+         FROM operations_contract c
+        WHERE ${accessClause}`,
+      params
+    );
+
+    return {
+      total: Number(stats?.total ?? 0),
+      active: Number(stats?.active ?? 0),
+      inactive: Number(stats?.inactive ?? 0),
+      withFile: Number(stats?.withFile ?? 0),
+    };
   }
 
   async getContractById(
@@ -3362,10 +3753,6 @@ export class OperationsService {
               c.billing_model AS "billingModel",
               c.account_manager_collaborator_id AS "accountManagerCollaboratorId",
               c.related_collaborator_id AS "relatedCollaboratorId",
-              c.contract_template_id AS "contractTemplateId",
-              template.name AS "contractTemplateName",
-              template.slug AS "contractTemplateSlug",
-              template.code AS "contractTemplateCode",
               c.origin_type AS "originType",
               c.origin_id AS "originId",
               c.start_date AS "startDate",
@@ -3384,8 +3771,6 @@ export class OperationsService {
          FROM operations_contract c
          LEFT JOIN operations_collaborator m ON m.id = c.account_manager_collaborator_id
          LEFT JOIN operations_collaborator linked ON linked.id = c.related_collaborator_id
-         LEFT JOIN operations_contract_template template
-           ON template.id = c.contract_template_id
         WHERE c.id = $1
           AND c.deleted_at IS NULL`,
       [contractId]
@@ -3419,7 +3804,7 @@ export class OperationsService {
       }
     }
 
-    const [projects, scheduleSummary, parties, signatures, financialTerms, documents, revisions, history] =
+    const [projects, scheduleSummary, parties, documents, history] =
       await Promise.all([
         this.queryRows<ContractProjectSummary>(
           `SELECT id, code, name, status
@@ -3458,33 +3843,6 @@ export class OperationsService {
             ORDER BY is_primary DESC, id ASC`,
           [contractId]
         ),
-        this.queryRows<NonNullable<ContractPayload['signatures']>[number]>(
-          `SELECT id,
-                  signer_name AS "signerName",
-                  signer_role AS "signerRole",
-                  signer_email AS "signerEmail",
-                  signer_status AS status,
-                  signed_at AS "signedAt"
-             FROM operations_contract_signature
-            WHERE contract_id = $1
-              AND deleted_at IS NULL
-            ORDER BY id ASC`,
-          [contractId]
-        ),
-        this.queryRows<NonNullable<ContractPayload['financialTerms']>[number]>(
-          `SELECT id,
-                  term_type AS "termType",
-                  label,
-                  amount,
-                  recurrence,
-                  due_day AS "dueDay",
-                  notes
-             FROM operations_contract_financial_term
-            WHERE contract_id = $1
-              AND deleted_at IS NULL
-            ORDER BY id ASC`,
-          [contractId]
-        ),
         this.queryRows<ContractDocumentRecord>(
           `SELECT id,
                   document_type AS "documentType",
@@ -3503,19 +3861,6 @@ export class OperationsService {
             ORDER BY is_current DESC, id DESC`,
           [contractId]
         ),
-        this.queryRows<NonNullable<ContractPayload['revisions']>[number]>(
-          `SELECT id,
-                  revision_type AS "revisionType",
-                  title,
-                  effective_date AS "effectiveDate",
-                  status,
-                  summary
-             FROM operations_contract_revision
-            WHERE contract_id = $1
-              AND deleted_at IS NULL
-            ORDER BY effective_date DESC NULLS LAST, id DESC`,
-          [contractId]
-        ),
         this.queryRows<ContractHistoryRecord>(
           `SELECT id,
                   actor_user_id AS "actorUserId",
@@ -3539,10 +3884,7 @@ export class OperationsService {
       projects,
       scheduleSummary,
       parties,
-      signatures,
-      financialTerms,
       documents,
-      revisions,
       history,
     };
   }
@@ -3567,7 +3909,6 @@ export class OperationsService {
           billing_model,
           account_manager_collaborator_id,
           related_collaborator_id,
-          contract_template_id,
           origin_type,
           origin_id,
           start_date,
@@ -3593,16 +3934,15 @@ export class OperationsService {
           $8::operations_contract_billing_model_409dc7fea2_enum,
           $9,
           $10,
-          $11,
-          $12::operations_contract_origin_type_07a7cc2b5d_enum,
-          $13,
-          $14::date,
-          $15::date, $16::date, $17::date, $18, $19,
-          $20::operations_contract_status_a0395962df_enum,
-          $21::operations_contract_creation_mode_98ba669209_enum,
+          $11::operations_contract_origin_type_07a7cc2b5d_enum,
+          $12,
+          $13::date,
+          $14::date, $15::date, $16::date, $17, $18,
+          $19::operations_contract_status_a0395962df_enum,
+          $20::operations_contract_creation_mode_98ba669209_enum,
+          $21,
           $22,
           $23,
-          $24,
           NOW(), NOW()
         )
         RETURNING id`,
@@ -3610,495 +3950,50 @@ export class OperationsService {
         this.normalizeOptionalText(data.name),
         data.contractCategory ?? 'client',
         data.contractType ?? 'service_agreement',
-        this.normalizeOptionalText(data.clientName),
-        data.signatureStatus ?? 'not_started',
-        data.isActive ?? true,
-        data.billingModel ?? 'time_and_material',
-        data.accountManagerCollaboratorId ?? null,
-        data.relatedCollaboratorId ?? null,
-        data.contractTemplateId ?? null,
-        data.originType ?? 'manual',
-        data.originId ?? null,
-        this.normalizeOptionalText(data.startDate ?? null),
-        data.endDate ?? null,
-        data.signedAt ?? null,
-        data.effectiveDate ?? data.startDate ?? null,
-        data.budgetAmount ?? null,
-        data.monthlyHourCap ?? null,
-        data.status ?? 'draft',
-        data.creationMode ?? 'blank',
-        data.wizardStep ?? 0,
-        data.description ?? null,
-        data.contentHtml ?? null
-      );
-
-      const contractId = (created as { id: number }[])[0]?.id;
-      await this.replaceContractParties(tx as any, contractId, data.parties);
-      await this.replaceContractSignatures(tx as any, contractId, data.signatures);
-      await this.replaceContractFinancialTerms(
-        tx as any,
-        contractId,
-        data.financialTerms
-      );
-      await this.replaceContractRevisions(tx as any, contractId, data.revisions);
-      if (data.replaceUploadedPdfDocument) {
-        await this.replaceContractDocument(
-          tx as any,
-          contractId,
-          'source_upload',
-          data.replaceUploadedPdfDocument
-        );
-      }
-      await this.insertContractHistory(
-        tx as any,
-        contractId,
-        userId,
-        'created',
-        data.originType === 'manual'
-          ? 'Manual contract created from registry.'
-          : `Contract registered from origin ${data.originType}.`
-      );
-      return contractId;
-    });
-
-    return this.getContractById(userId, createdId);
-  }
-
-  async createContractDraft(userId: number, data: ContractDraftPayload) {
-    const actor = await this.getActorContext(userId);
-    this.ensureDirector(actor);
-
-    const creationMode = this.normalizeEnumValue(
-      data.creationMode,
-      CONTRACT_CREATION_MODE_VALUES,
-      'blank'
-    );
-    const selectedTemplate =
-      data.templateId && data.templateId > 0
-        ? await this.getContractTemplateById(userId, data.templateId)
-        : null;
-    const duplicateSource =
-      data.duplicateFromId && data.duplicateFromId > 0
-        ? await this.getContractById(userId, data.duplicateFromId)
-        : null;
-    const storedSourceFile =
-      data.sourceFileId && data.sourceFileId > 0
-        ? await this.prisma.file.findUnique({
-            where: { id: data.sourceFileId },
-            include: { file_mimetype: true },
-          })
-        : null;
-
-    if (data.sourceFileId && !storedSourceFile) {
-      throw new NotFoundException('Source contract file not found.');
-    }
-
-    const createdId = await this.prisma.$transaction(async (tx) => {
-      const generatedCode = await this.generateContractCode(tx as any);
-      const duplicateNameBase =
-        this.normalizeOptionalText(duplicateSource?.name) ??
-        this.normalizeOptionalText(duplicateSource?.code) ??
-        'Contract';
-      const created = await (tx as any).$queryRawUnsafe(
-        `INSERT INTO operations_contract (
-          code,
-          name,
-          contract_category,
-          contract_type,
-          client_name,
-          signature_status,
-          is_active,
-          billing_model,
-          account_manager_collaborator_id,
-          related_collaborator_id,
-          contract_template_id,
-          origin_type,
-          origin_id,
-          start_date,
-          end_date,
-          signed_at,
-          effective_date,
-          budget_amount,
-          monthly_hour_cap,
-          status,
-          creation_mode,
-          wizard_step,
-          description,
-          content_html,
-          created_by_user_id,
-          updated_by_user_id,
-          created_at,
-          updated_at
-        ) VALUES (
-          $1,
-          $2,
-          $3::operations_contract_contract_category_70d553ea09_enum,
-          $4::operations_contract_contract_type_48331e2ebf_enum,
-          $5,
-          $6::operations_contract_signature_status_2cb7282a7b_enum,
-          $7,
-          $8::operations_contract_billing_model_409dc7fea2_enum,
-          $9,
-          $10,
-          $11,
-          $12::operations_contract_origin_type_07a7cc2b5d_enum,
-          $13,
-          $14::date,
-          $15::date,
-          $16::date,
-          $17::date,
-          $18,
-          $19,
-          $20::operations_contract_status_a0395962df_enum,
-          $21::operations_contract_creation_mode_98ba669209_enum,
-          $22,
-          $23,
-          $24,
-          $25,
-          $25,
-          NOW(),
-          NOW()
-        )
-        RETURNING id`,
-        generatedCode,
-        creationMode === 'duplicate'
-          ? `${duplicateNameBase} Copy`
-          : this.normalizeOptionalText(selectedTemplate?.name),
-        duplicateSource?.contractCategory ??
-          selectedTemplate?.contractCategory ??
-          'client',
-        duplicateSource?.contractType ??
-          selectedTemplate?.contractType ??
-          'service_agreement',
-        this.normalizeOptionalText(duplicateSource?.clientName),
-        duplicateSource?.signatureStatus ??
-          selectedTemplate?.signatureStatus ??
-          'not_started',
-        duplicateSource?.isActive ?? true,
-        duplicateSource?.billingModel ??
-          selectedTemplate?.billingModel ??
-          'time_and_material',
-        duplicateSource?.accountManagerCollaboratorId ?? null,
-        duplicateSource?.relatedCollaboratorId ?? null,
-        duplicateSource?.contractTemplateId ?? selectedTemplate?.id ?? null,
-        duplicateSource?.originType ?? 'manual',
-        duplicateSource?.originId ?? null,
-        duplicateSource?.startDate ?? null,
-        duplicateSource?.endDate ?? null,
-        duplicateSource?.signedAt ?? null,
-        duplicateSource?.effectiveDate ?? null,
-        duplicateSource?.budgetAmount ?? null,
-        duplicateSource?.monthlyHourCap ?? null,
-        'draft',
-        creationMode,
-        creationMode === 'upload' ? 0 : creationMode === 'blank' ? 0 : 1,
-        duplicateSource?.description ?? selectedTemplate?.description ?? null,
-        duplicateSource?.contentHtml ?? selectedTemplate?.contentHtml ?? null,
-        userId
-      );
-
-      const contractId = (created as { id: number }[])[0]?.id;
-
-      if (duplicateSource) {
-        await this.replaceContractParties(
-          tx as any,
-          contractId,
-          duplicateSource.parties
-        );
-        await this.replaceContractSignatures(
-          tx as any,
-          contractId,
-          duplicateSource.signatures
-        );
-        await this.replaceContractFinancialTerms(
-          tx as any,
-          contractId,
-          duplicateSource.financialTerms
-        );
-        await this.replaceContractRevisions(
-          tx as any,
-          contractId,
-          duplicateSource.revisions
-        );
-
-        const currentSourceDocument =
-          duplicateSource.documents.find(
-            (document) => document.isCurrent && document.documentType === 'source_upload'
-          ) ?? null;
-
-        if (currentSourceDocument) {
-          await this.replaceContractDocument(
-            tx as any,
-            contractId,
-            'source_upload',
-            {
-              fileId: currentSourceDocument.fileId ?? null,
-              fileName: currentSourceDocument.fileName,
-              mimeType: currentSourceDocument.mimeType,
-              fileContentBase64: currentSourceDocument.fileContentBase64 ?? null,
-              notes: currentSourceDocument.notes ?? null,
-              extractionStatus: currentSourceDocument.extractionStatus ?? 'skipped',
-              extractionSummary: currentSourceDocument.extractionSummary ?? null,
-            }
-          );
-        }
-      }
-
-      if (storedSourceFile) {
-        await this.replaceContractDocument(tx as any, contractId, 'source_upload', {
-          fileId: storedSourceFile.id,
-          fileName:
-            this.normalizeOptionalText(data.sourceFileName) ??
-            storedSourceFile.filename,
-          mimeType:
-            this.normalizeOptionalText(data.sourceMimeType) ??
-            storedSourceFile.file_mimetype?.name ??
-            'application/pdf',
-          notes: 'Source contract document uploaded during draft creation.',
-          extractionStatus: 'pending',
-          extractionSummary: null,
-        });
-      }
-
-      await this.insertContractHistory(
-        tx as any,
-        contractId,
-        userId,
-        'draft_created',
-        `Contract draft created with mode ${creationMode}.`,
-        JSON.stringify({
-          creationMode,
-          templateId: selectedTemplate?.id ?? null,
-          duplicateFromId: duplicateSource?.id ?? null,
-          sourceFileId: storedSourceFile?.id ?? null,
-        })
-      );
-
-      return contractId;
-    });
-
-    return this.getContractById(userId, createdId);
-  }
-
-  async extractContractSource(
-    userId: number,
-    contractId: number,
-    data: Omit<ContractExtractDraftPayload, 'fileName' | 'mimeType' | 'fileContentBase64' | 'contractId'>
-  ) {
-    const actor = await this.getActorContext(userId);
-    this.ensureDirector(actor);
-
-    const contract = await this.getContractById(userId, contractId);
-    const sourceDocument = contract.documents.find(
-      (document) => document.isCurrent && document.documentType === 'source_upload'
-    );
-
-    if (!sourceDocument) {
-      throw new BadRequestException(
-        'No source document is attached to this contract draft.'
-      );
-    }
-
-    await this.prisma.$executeRawUnsafe(
-      `UPDATE operations_contract_document
-          SET extraction_status = 'processing',
-              updated_at = NOW()
-        WHERE id = $1`,
-      sourceDocument.id
-    );
-
-    try {
-      const extracted = await this.extractContractDraft(userId, {
-        contractId,
-        provider: data.provider ?? null,
-        promptMessage: data.promptMessage ?? null,
-      });
-
-      await this.prisma.$executeRawUnsafe(
-        `UPDATE operations_contract_document
-            SET extraction_status = 'completed',
-                extraction_summary = $2,
-                updated_at = NOW()
-          WHERE id = $1`,
-        sourceDocument.id,
-        extracted.summary || extracted.description || extracted.name || null
-      );
-
-      await this.insertContractHistory(
-        this.prisma,
-        contractId,
-        userId,
-        'source_extracted',
-        'Source contract document extracted with AI.'
-      );
-
-      return extracted;
-    } catch (error) {
-      await this.prisma.$executeRawUnsafe(
-        `UPDATE operations_contract_document
-            SET extraction_status = 'failed',
-                updated_at = NOW()
-          WHERE id = $1`,
-        sourceDocument.id
-      );
-      throw error;
-    }
-  }
-
-  async generateContractContent(
-    userId: number,
-    contractId: number,
-    data: ContractGenerateContentPayload = {}
-  ) {
-    const actor = await this.getActorContext(userId);
-    this.ensureDirector(actor);
-
-    const contract = await this.getContractById(userId, contractId);
-    const contentHtml = await this.generateContractContentHtml(contract, data);
-
-    await this.prisma.$transaction(async (tx) => {
-      await (tx as any).$executeRawUnsafe(
-        `UPDATE operations_contract
-            SET content_html = $2,
-                wizard_step = CASE
-                  WHEN COALESCE(wizard_step, 0) < 4 THEN 4
-                  ELSE wizard_step
-                END,
-                updated_by_user_id = $3,
-                updated_at = NOW()
-          WHERE id = $1`,
-        contractId,
-        contentHtml,
-        userId
-      );
-
-      await this.insertContractHistory(
-        tx as any,
-        contractId,
-        userId,
-        'content_generated',
-        'Contract content generated automatically for editing.',
-        JSON.stringify({
-          provider: data.provider ?? null,
-          overwrite: Boolean(data.overwrite),
-          hasPrompt: Boolean(this.normalizeOptionalText(data.promptMessage)),
-        })
+        this.normalizeOptionalText(data.clientName),
+        data.signatureStatus ?? 'not_started',
+        data.isActive ?? true,
+        data.billingModel ?? 'time_and_material',
+        data.accountManagerCollaboratorId ?? null,
+        data.relatedCollaboratorId ?? null,
+        data.originType ?? 'manual',
+        data.originId ?? null,
+        this.normalizeOptionalText(data.startDate ?? null),
+        data.endDate ?? null,
+        data.signedAt ?? null,
+        data.effectiveDate ?? data.startDate ?? null,
+        data.budgetAmount ?? null,
+        data.monthlyHourCap ?? null,
+        data.status ?? 'draft',
+        data.creationMode ?? 'blank',
+        data.wizardStep ?? 0,
+        data.description ?? null,
+        data.contentHtml ?? null
       );
-    });
-
-    return this.getContractById(userId, contractId);
-  }
-
-  async reviewContractLegally(
-    userId: number,
-    contractId: number,
-    data: ContractLegalReviewPayload = {}
-  ) {
-    const actor = await this.getActorContext(userId);
-    this.ensureDirector(actor);
-
-    const contract = await this.getContractById(userId, contractId);
-    const review = await this.buildContractLegalReview(contract, data);
-
-    await this.insertContractHistory(
-      this.prisma,
-      contractId,
-      userId,
-      'legal_reviewed',
-      'Advisory legal checklist updated for this contract.',
-      JSON.stringify(review)
-    );
-
-    return review;
-  }
-
-  async generateContractPdf(userId: number, contractId: number) {
-    const actor = await this.getActorContext(userId);
-    this.ensureDirector(actor);
-
-    const contract = await this.getContractById(userId, contractId);
-    const pdfBuffer = await this.renderContractPdfBuffer(contract);
-    const fileName = this.buildContractPdfFileName(contract);
-    const uploadedFile = await this.fileService.upload('operations/contracts/generated', {
-      fieldname: 'file',
-      originalname: fileName,
-      encoding: '7bit',
-      mimetype: 'application/pdf',
-      size: pdfBuffer.length,
-      destination: '',
-      filename: fileName,
-      path: '',
-      buffer: pdfBuffer,
-    });
-
-    await this.prisma.$transaction(async (tx) => {
-      await this.replaceContractDocument(tx as any, contractId, 'generated_pdf', {
-        fileId: uploadedFile.id,
-        fileName,
-        mimeType: 'application/pdf',
-        notes: 'PDF generated from contract rich text content.',
-        extractionStatus: 'skipped',
-        extractionSummary: null,
-      });
 
+      const contractId = (created as { id: number }[])[0]?.id;
+      await this.replaceContractParties(tx as any, contractId, data.parties);
+      if (data.replaceUploadedPdfDocument) {
+        await this.replaceContractDocument(
+          tx as any,
+          contractId,
+          'source_upload',
+          data.replaceUploadedPdfDocument
+        );
+      }
       await this.insertContractHistory(
         tx as any,
         contractId,
         userId,
-        'pdf_generated',
-        'Generated a branded PDF version of the contract.'
+        'created',
+        data.originType === 'manual'
+          ? 'Manual contract created from registry.'
+          : `Contract registered from origin ${data.originType}.`
       );
+      return contractId;
     });
 
-    return {
-      contractId,
-      fileId: uploadedFile.id,
-      fileName,
-      mimeType: 'application/pdf',
-      documentType: 'generated_pdf',
-      downloadUrl: `/file/open/${uploadedFile.id}`,
-    };
-  }
-
-  async extractContractDraft(
-    userId: number,
-    data: ContractExtractDraftPayload
-  ) {
-    const actor = await this.getActorContext(userId);
-    this.ensureDirector(actor);
-
-    const uploadFile = await this.resolveContractExtractionFile(userId, data);
-
-    const aiResult = await this.aiService.chat(
-      {
-        provider: data.provider === 'gemini' ? 'gemini' : 'openai',
-        model: data.provider === 'gemini' ? 'gemini-1.5-flash' : 'gpt-4o-mini',
-        message:
-          this.normalizeExtractionString(data.promptMessage) ||
-          'Analyze the attached contract and extract a structured draft for the contract form.',
-        systemPrompt: this.buildContractExtractionSystemPrompt(),
-      },
-      uploadFile,
-    );
-
-    const parsed = this.parseAiJsonPayload(String(aiResult?.content ?? ''));
-    const draft = this.normalizeContractExtractDraft(parsed);
-    const warnings = [...draft.warnings];
-
-    if (
-      uploadFile.mimetype === 'application/msword' ||
-      uploadFile.mimetype ===
-        'application/vnd.openxmlformats-officedocument.wordprocessingml.document'
-    ) {
-      warnings.push(
-        'Word extraction is best-effort. Review names, dates, and values before saving.'
-      );
-    }
-
-    return {
-      ...draft,
-      warnings: Array.from(new Set(warnings.filter(Boolean))),
-    };
+    return this.getContractById(userId, createdId);
   }
 
   async createContractFromProposalIntegration(
@@ -4137,37 +4032,6 @@ export class OperationsService {
     const contractName =
       this.normalizeOptionalText(proposal.title) ?? `Proposal ${sourceEntityId}`;
 
-    const financialTerms = items
-      .map((item) => ({
-        termType: this.normalizeEnumValue(
-          item.termType,
-          FINANCIAL_TERM_TYPE_VALUES,
-          'value',
-        ),
-        label: this.normalizeOptionalText(item.name) ?? 'Commercial term',
-        amount: Number(item.amount ?? Number(item.totalAmountCents || 0) / 100),
-        recurrence: this.normalizeEnumValue(
-          item.recurrence,
-          RECURRENCE_VALUES,
-          'one_time',
-        ),
-        dueDay: item.dueDay ?? null,
-        notes: this.normalizeOptionalText(item.description),
-      }))
-      .filter((term) => Number.isFinite(term.amount) && term.amount > 0);
-
-    const fallbackAmount = Number(proposal.totalAmount ?? 0);
-    if (financialTerms.length === 0 && Number.isFinite(fallbackAmount) && fallbackAmount > 0) {
-      financialTerms.push({
-        termType: 'revenue',
-        label: contractName,
-        amount: fallbackAmount,
-        recurrence: 'one_time',
-        dueDay: null,
-        notes: this.normalizeOptionalText(proposal.notes),
-      });
-    }
-
     const primaryPartyRole = ['employee', 'contractor'].includes(contractCategory)
       ? 'employee'
       : ['supplier', 'vendor'].includes(contractCategory)
@@ -4218,7 +4082,6 @@ export class OperationsService {
           billing_model,
           account_manager_collaborator_id,
           related_collaborator_id,
-          contract_template_id,
           origin_type,
           origin_id,
           start_date,
@@ -4284,7 +4147,7 @@ export class OperationsService {
         proposal.validUntil ?? null,
         null,
         proposal.validFrom ?? null,
-        fallbackAmount > 0 ? fallbackAmount : null,
+        Number(proposal.totalAmount ?? 0) > 0 ? Number(proposal.totalAmount ?? 0) : null,
         null,
         'draft',
         'blank',
@@ -4311,31 +4174,6 @@ export class OperationsService {
         },
       ]);
 
-      await this.replaceContractFinancialTerms(
-        tx as any,
-        contractId,
-        financialTerms.map((term) => ({
-          termType: term.termType as any,
-          label: term.label,
-          amount: term.amount,
-          recurrence: term.recurrence as any,
-          dueDay: term.dueDay,
-          notes: term.notes,
-        })),
-      );
-
-      await this.replaceContractRevisions(tx as any, contractId, [
-        {
-          revisionType: 'revision',
-          title: payload.revision?.title ?? contractName,
-          effectiveDate: proposal.validFrom ?? null,
-          status: 'draft',
-          summary:
-            this.normalizeOptionalText(payload.revision?.summary) ??
-            this.normalizeOptionalText(proposal.notes),
-        },
-      ]);
-
       await this.insertContractHistory(
         tx as any,
         contractId,
@@ -4375,7 +4213,6 @@ export class OperationsService {
               startDate: proposal.validFrom ?? null,
               endDate: proposal.validUntil ?? null,
               description: this.normalizeOptionalText(proposal.notes),
-              financialTerms,
             },
             payload,
             String(payload.locale || '').trim() || 'en',
@@ -4418,7 +4255,6 @@ export class OperationsService {
       startDate?: string | null;
       endDate?: string | null;
       description?: string | null;
-      financialTerms?: ContractPayload['financialTerms'];
     },
     payload: ProposalApprovedEventPayload,
     locale = 'en',
@@ -4454,7 +4290,6 @@ export class OperationsService {
         startDate: contract.startDate ?? null,
         endDate: contract.endDate ?? null,
         description: contract.description ?? null,
-        financialTerms: contract.financialTerms ?? [],
       },
       proposal: payload.proposal ?? {
         code: payload.code ?? null,
@@ -4483,7 +4318,6 @@ export class OperationsService {
       effectiveDate?: string | null;
       budgetAmount?: number | null;
       description?: string | null;
-      financialTerms?: ContractPayload['financialTerms'];
       parties?: ContractPayload['parties'];
     },
     locale = 'en',
@@ -4563,20 +4397,7 @@ export class OperationsService {
       }
     }
 
-    const financialTerms = (contract.financialTerms ?? []).map((term) => ({
-      label: term.label,
-      termType: term.termType ?? 'value',
-      amount: Number(term.amount ?? 0),
-      recurrence: term.recurrence ?? 'one_time',
-      dueDay: term.dueDay ?? null,
-      notes: term.notes ?? null,
-    }));
-
-    const totalAmount =
-      financialTerms.reduce(
-        (sum, term) => sum + (Number.isFinite(term.amount) ? term.amount : 0),
-        0,
-      ) || Number(contract.budgetAmount ?? 0);
+    const totalAmount = Number(contract.budgetAmount ?? 0);
 
     return {
       contractId: contract.id,
@@ -4609,7 +4430,6 @@ export class OperationsService {
         effectiveDate: contract.effectiveDate ?? null,
         budgetAmount: contract.budgetAmount ?? null,
         description: contract.description ?? null,
-        financialTerms,
         parties: contract.parties ?? [],
       },
       person: personRecord
@@ -4687,7 +4507,6 @@ export class OperationsService {
     );
     this.pushUpdate(updates, params, 'account_manager_collaborator_id', data.accountManagerCollaboratorId);
     this.pushUpdate(updates, params, 'related_collaborator_id', data.relatedCollaboratorId);
-    this.pushUpdate(updates, params, 'contract_template_id', data.contractTemplateId);
     this.pushUpdate(
       updates,
       params,
@@ -4735,27 +4554,6 @@ export class OperationsService {
       if (data.parties) {
         await this.replaceContractParties(tx as any, contractId, data.parties);
       }
-      if (data.signatures) {
-        await this.replaceContractSignatures(
-          tx as any,
-          contractId,
-          data.signatures
-        );
-      }
-      if (data.financialTerms) {
-        await this.replaceContractFinancialTerms(
-          tx as any,
-          contractId,
-          data.financialTerms
-        );
-      }
-      if (data.revisions) {
-        await this.replaceContractRevisions(
-          tx as any,
-          contractId,
-          data.revisions
-        );
-      }
       if (data.replaceUploadedPdfDocument) {
         await this.replaceContractDocument(
           tx as any,
@@ -4791,7 +4589,6 @@ export class OperationsService {
             effectiveDate: data.effectiveDate ?? current.effectiveDate,
             budgetAmount: data.budgetAmount ?? current.budgetAmount,
             description: data.description ?? current.description,
-            financialTerms: data.financialTerms ?? current.financialTerms,
             parties: data.parties ?? current.parties,
           },
           'en',
@@ -4880,10 +4677,7 @@ export class OperationsService {
 
       for (const tableName of [
         'operations_contract_party',
-        'operations_contract_signature',
-        'operations_contract_financial_term',
         'operations_contract_document',
-        'operations_contract_revision',
       ]) {
         await (tx as any).$executeRawUnsafe(
           `UPDATE ${tableName}
@@ -4918,9 +4712,57 @@ export class OperationsService {
     return { success: true };
   }
 
-  async listTimesheets(userId: number) {
+  async listTimesheets(
+    userId: number,
+    filters: {
+      page?: number;
+      pageSize?: number;
+      search?: string;
+      sortField?: string;
+      sortOrder?: string;
+      status?: string;
+    } = {}
+  ) {
     const actor = await this.getActorContext(userId);
     const filter = this.buildIdFilter(actor.visibleCollaboratorIds, 't.collaborator_id', actor.isDirector);
+    const pagination = this.shouldPaginate(filters)
+      ? this.normalizePaginationParams(filters, {
+          defaultSortField: 'weekStartDate',
+          defaultSortOrder: 'desc',
+          allowedSortFields: ['weekStartDate', 'weekEndDate', 'collaboratorName', 'status'],
+        })
+      : null;
+    const params: unknown[] = [...filter.params];
+    const where = ['t.deleted_at IS NULL', filter.clause];
+
+    if (filters.status && filters.status !== 'all') {
+      where.push(`t.status::text = ${this.param(params, filters.status)}`);
+    }
+
+    if (pagination?.search) {
+      const searchPlaceholder = this.param(params, `%${pagination.search}%`);
+      where.push(`(
+        COALESCE(c.display_name, '') ILIKE ${searchPlaceholder}
+        OR COALESCE(a.display_name, '') ILIKE ${searchPlaceholder}
+        OR COALESCE(t.notes, '') ILIKE ${searchPlaceholder}
+        OR COALESCE(approval.decision_note, '') ILIKE ${searchPlaceholder}
+      )`);
+    }
+
+    const whereClause = where.join(' AND ');
+    const sortColumn =
+      {
+        weekStartDate: 't.week_start_date',
+        weekEndDate: 't.week_end_date',
+        collaboratorName: 'c.display_name',
+        status: 't.status',
+      }[pagination?.sortField ?? 'weekStartDate'] ?? 't.week_start_date';
+    const headerParams = [...params];
+    const limitSql =
+      pagination
+        ? `LIMIT ${this.param(headerParams, pagination.pageSize)}
+       OFFSET ${this.param(headerParams, pagination.offset)}`
+        : '';
 
     const headers = await this.queryRows<{
       id: number;
@@ -4957,15 +4799,39 @@ export class OperationsService {
            ON approval.target_type = 'timesheet'
           AND approval.target_id = t.id
           AND approval.deleted_at IS NULL
-        WHERE t.deleted_at IS NULL AND ${filter.clause}
-        ORDER BY t.week_start_date DESC, t.id DESC`,
-      filter.params
+        WHERE ${whereClause}
+        ORDER BY ${sortColumn} ${pagination?.sortOrder?.toUpperCase() ?? 'DESC'}, t.id DESC
+        ${limitSql}`,
+      headerParams
     );
 
     if (!headers.length) {
+      if (pagination) {
+        return this.buildPaginationResult([], 0, pagination.page, pagination.pageSize);
+      }
+
       return headers;
     }
 
+    const total = pagination
+      ? Number(
+          (
+            await this.querySingle<{ total: string }>(
+              `SELECT COUNT(*)::text AS total
+                 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
+                 LEFT JOIN operations_approval approval
+                   ON approval.target_type = 'timesheet'
+                  AND approval.target_id = t.id
+                  AND approval.deleted_at IS NULL
+                WHERE ${whereClause}`,
+              params
+            )
+          )?.total ?? 0
+        )
+      : 0;
+
     const entries = await this.queryRows<{
       id: number;
       timesheetId: number;
@@ -5010,10 +4876,21 @@ export class OperationsService {
     );
 
     const grouped = this.groupBy(entries, 'timesheetId');
-    return headers.map((timesheet) => ({
+    const data = headers.map((timesheet) => ({
       ...timesheet,
       entries: grouped[timesheet.id] ?? [],
     }));
+
+    if (!pagination) {
+      return data;
+    }
+
+    return this.buildPaginationResult(
+      data,
+      total,
+      pagination.page,
+      pagination.pageSize
+    );
   }
 
   async createTimesheet(userId: number, data: TimesheetPayload) {
@@ -5126,8 +5003,26 @@ export class OperationsService {
     }
 
     const collaborator = await this.getCollaboratorById(current.collaboratorId);
+
+    const projectManagerRow = await this.querySingle<{
+      managerCollaboratorId: number | null;
+    }>(
+      `SELECT p.manager_collaborator_id AS "managerCollaboratorId"
+         FROM operations_timesheet_entry e
+         LEFT JOIN operations_project_assignment pa ON pa.id = e.project_assignment_id
+         LEFT JOIN operations_project p ON p.id = pa.project_id
+        WHERE e.timesheet_id = $1
+          AND e.deleted_at IS NULL
+          AND p.manager_collaborator_id IS NOT NULL
+        LIMIT 1`,
+      [timesheetId]
+    );
+
     const approverId =
-      current.approverCollaboratorId ?? collaborator.supervisorId ?? null;
+      projectManagerRow?.managerCollaboratorId ??
+      current.approverCollaboratorId ??
+      collaborator.supervisorId ??
+      null;
 
     if (!approverId) {
       throw new BadRequestException(
@@ -5173,19 +5068,52 @@ export class OperationsService {
     return this.listSingleTimesheet(actor, timesheetId);
   }
 
-  async listTimeOffRequests(userId: number) {
+  async listTimeOffRequests(
+    userId: number,
+    filters: {
+      page?: number;
+      pageSize?: number;
+      search?: string;
+      sortField?: string;
+      sortOrder?: string;
+      status?: string;
+    } = {}
+  ) {
     const actor = await this.getActorContext(userId);
     const filter = this.buildIdFilter(actor.visibleCollaboratorIds, 'tor.collaborator_id', actor.isDirector);
+    const pagination = this.shouldPaginate(filters)
+      ? this.normalizePaginationParams(filters, {
+          defaultSortField: 'startDate',
+          defaultSortOrder: 'desc',
+          allowedSortFields: ['startDate', 'endDate', 'collaboratorName', 'status'],
+        })
+      : null;
+    const params: unknown[] = [...filter.params];
+    const where = ['tor.deleted_at IS NULL', filter.clause];
 
-    return this.queryRows(
-      `SELECT tor.id,
+    if (filters.status && filters.status !== 'all') {
+      where.push(`tor.status::text = ${this.param(params, filters.status)}`);
+    }
+
+    if (pagination?.search) {
+      const searchPlaceholder = this.param(params, `%${pagination.search}%`);
+      where.push(`(
+        COALESCE(c.display_name, '') ILIKE ${searchPlaceholder}
+        OR COALESCE(a.display_name, '') ILIKE ${searchPlaceholder}
+        OR COALESCE(tor.reason, '') ILIKE ${searchPlaceholder}
+        OR COALESCE(tor.request_type::text, '') ILIKE ${searchPlaceholder}
+      )`);
+    }
+
+    const whereClause = where.join(' AND ');
+    const baseQuery = `SELECT tor.id,
               tor.collaborator_id AS "collaboratorId",
               c.display_name AS "collaboratorName",
               tor.approver_collaborator_id AS "approverCollaboratorId",
               a.display_name AS "approverName",
               tor.request_type AS "requestType",
-              tor.start_date AS "startDate",
-              tor.end_date AS "endDate",
+              tor.start_date::text AS "startDate",
+              tor.end_date::text AS "endDate",
               tor.total_days AS "totalDays",
               tor.status,
               tor.reason,
@@ -5199,9 +5127,49 @@ export class OperationsService {
            ON approval.target_type = 'time_off_request'
           AND approval.target_id = tor.id
           AND approval.deleted_at IS NULL
-        WHERE tor.deleted_at IS NULL AND ${filter.clause}
-        ORDER BY tor.start_date DESC, tor.id DESC`,
-      filter.params
+        WHERE ${whereClause}`;
+
+    if (!pagination) {
+      return this.queryRows(
+        `${baseQuery}
+         ORDER BY tor.start_date DESC, tor.id DESC`,
+        params
+      );
+    }
+
+    const totalRow = await this.querySingle<{ total: string }>(
+      `SELECT COUNT(*)::text AS total
+         FROM operations_time_off_request tor
+         JOIN operations_collaborator c ON c.id = tor.collaborator_id
+         LEFT JOIN operations_collaborator a ON a.id = tor.approver_collaborator_id
+        WHERE ${whereClause}`,
+      params
+    );
+
+    const sortColumn =
+      {
+        startDate: 'tor.start_date',
+        endDate: 'tor.end_date',
+        collaboratorName: 'c.display_name',
+        status: 'tor.status',
+      }[pagination.sortField] ?? 'tor.start_date';
+
+    const queryParams = [...params];
+    const limitPlaceholder = this.param(queryParams, pagination.pageSize);
+    const offsetPlaceholder = this.param(queryParams, pagination.offset);
+    const rows = await this.queryRows(
+      `${baseQuery}
+       ORDER BY ${sortColumn} ${pagination.sortOrder.toUpperCase()}, tor.id DESC
+       LIMIT ${limitPlaceholder}
+      OFFSET ${offsetPlaceholder}`,
+      queryParams
+    );
+
+    return this.buildPaginationResult(
+      rows,
+      Number(totalRow?.total ?? 0),
+      pagination.page,
+      pagination.pageSize
     );
   }
 
@@ -5271,8 +5239,8 @@ export class OperationsService {
               collaborator_id AS "collaboratorId",
               approver_collaborator_id AS "approverCollaboratorId",
               request_type AS "requestType",
-              start_date AS "startDate",
-              end_date AS "endDate",
+              start_date::text AS "startDate",
+              end_date::text AS "endDate",
               total_days AS "totalDays",
               status,
               reason,
@@ -5284,9 +5252,62 @@ export class OperationsService {
     );
   }
 
-  async listScheduleAdjustments(userId: number) {
+  async listScheduleAdjustments(
+    userId: number,
+    filters: {
+      page?: number;
+      pageSize?: number;
+      search?: string;
+      sortField?: string;
+      sortOrder?: string;
+      status?: string;
+    } = {}
+  ) {
     const actor = await this.getActorContext(userId);
     const filter = this.buildIdFilter(actor.visibleCollaboratorIds, 'sar.collaborator_id', actor.isDirector);
+    const pagination = this.shouldPaginate(filters)
+      ? this.normalizePaginationParams(filters, {
+          defaultSortField: 'effectiveStartDate',
+          defaultSortOrder: 'desc',
+          allowedSortFields: [
+            'effectiveStartDate',
+            'effectiveEndDate',
+            'collaboratorName',
+            'status',
+          ],
+        })
+      : null;
+    const params: unknown[] = [...filter.params];
+    const where = ['sar.deleted_at IS NULL', filter.clause];
+
+    if (filters.status && filters.status !== 'all') {
+      where.push(`sar.status::text = ${this.param(params, filters.status)}`);
+    }
+
+    if (pagination?.search) {
+      const searchPlaceholder = this.param(params, `%${pagination.search}%`);
+      where.push(`(
+        COALESCE(c.display_name, '') ILIKE ${searchPlaceholder}
+        OR COALESCE(a.display_name, '') ILIKE ${searchPlaceholder}
+        OR COALESCE(sar.reason, '') ILIKE ${searchPlaceholder}
+        OR COALESCE(sar.request_scope::text, '') ILIKE ${searchPlaceholder}
+      )`);
+    }
+
+    const whereClause = where.join(' AND ');
+    const sortColumn =
+      {
+        effectiveStartDate: 'sar.effective_start_date',
+        effectiveEndDate: 'sar.effective_end_date',
+        collaboratorName: 'c.display_name',
+        status: 'sar.status',
+      }[pagination?.sortField ?? 'effectiveStartDate'] ?? 'sar.effective_start_date';
+    const queryParams = [...params];
+    const limitSql =
+      pagination
+        ? `LIMIT ${this.param(queryParams, pagination.pageSize)}
+       OFFSET ${this.param(queryParams, pagination.offset)}`
+        : '';
 
     const requests = await this.queryRows<{
       id: number;
@@ -5309,8 +5330,8 @@ export class OperationsService {
               sar.approver_collaborator_id AS "approverCollaboratorId",
               a.display_name AS "approverName",
               sar.request_scope AS "requestScope",
-              sar.effective_start_date AS "effectiveStartDate",
-              sar.effective_end_date AS "effectiveEndDate",
+              sar.effective_start_date::text AS "effectiveStartDate",
+              sar.effective_end_date::text AS "effectiveEndDate",
               sar.status,
               sar.reason,
               sar.submitted_at AS "submittedAt",
@@ -5323,15 +5344,35 @@ export class OperationsService {
            ON approval.target_type = 'schedule_adjustment_request'
           AND approval.target_id = sar.id
           AND approval.deleted_at IS NULL
-        WHERE sar.deleted_at IS NULL AND ${filter.clause}
-        ORDER BY sar.effective_start_date DESC, sar.id DESC`,
-      filter.params
+        WHERE ${whereClause}
+        ORDER BY ${sortColumn} ${pagination?.sortOrder?.toUpperCase() ?? 'DESC'}, sar.id DESC
+        ${limitSql}`,
+      queryParams
     );
 
     if (!requests.length) {
+      if (pagination) {
+        return this.buildPaginationResult([], 0, pagination.page, pagination.pageSize);
+      }
+
       return requests;
     }
 
+    const total = pagination
+      ? Number(
+          (
+            await this.querySingle<{ total: string }>(
+              `SELECT COUNT(*)::text AS total
+                 FROM operations_schedule_adjustment_request sar
+                 JOIN operations_collaborator c ON c.id = sar.collaborator_id
+                 LEFT JOIN operations_collaborator a ON a.id = sar.approver_collaborator_id
+                WHERE ${whereClause}`,
+              params
+            )
+          )?.total ?? 0
+        )
+      : 0;
+
     const days = await this.queryRows<{
       requestId: number;
       weekday: string;
@@ -5360,7 +5401,8 @@ export class OperationsService {
       endTime: string | null;
       breakMinutes: number | null;
     }>(
-      `SELECT collaborator_id AS "collaboratorId",
+      `SELECT DISTINCT ON (collaborator_id, weekday)
+              collaborator_id AS "collaboratorId",
               weekday,
               is_working_day AS "isWorkingDay",
               start_time AS "startTime",
@@ -5368,7 +5410,7 @@ export class OperationsService {
               break_minutes AS "breakMinutes"
          FROM operations_collaborator_schedule_day
         WHERE collaborator_id = ANY($1::int[])
-        ORDER BY id ASC`,
+        ORDER BY collaborator_id, weekday, id DESC`,
       [this.uniqueNumbers(requests.map((item) => item.collaboratorId))]
     );
 
@@ -5377,11 +5419,22 @@ export class OperationsService {
       currentSchedule,
       'collaboratorId'
     );
-    return requests.map((request) => ({
-      ...request,
-      days: grouped[request.id] ?? [],
-      currentSchedule: currentScheduleByCollaborator[request.collaboratorId] ?? [],
-    }));
+    const data = requests.map((request) => ({
+      ...request,
+      days: grouped[request.id] ?? [],
+      currentSchedule: currentScheduleByCollaborator[request.collaboratorId] ?? [],
+    }));
+
+    if (!pagination) {
+      return data;
+    }
+
+    return this.buildPaginationResult(
+      data,
+      total,
+      pagination.page,
+      pagination.pageSize
+    );
   }
 
   async createScheduleAdjustmentRequest(
@@ -5481,8 +5534,8 @@ export class OperationsService {
               collaborator_id AS "collaboratorId",
               approver_collaborator_id AS "approverCollaboratorId",
               request_scope AS "requestScope",
-              effective_start_date AS "effectiveStartDate",
-              effective_end_date AS "effectiveEndDate",
+              effective_start_date::text AS "effectiveStartDate",
+              effective_end_date::text AS "effectiveEndDate",
               status,
               reason,
               submitted_at AS "submittedAt",
@@ -5493,7 +5546,18 @@ export class OperationsService {
     );
   }
 
-  async listApprovals(userId: number) {
+  async listApprovals(
+    userId: number,
+    filters: {
+      page?: number;
+      pageSize?: number;
+      search?: string;
+      sortField?: string;
+      sortOrder?: string;
+      status?: string;
+      targetType?: string;
+    } = {}
+  ) {
     const actor = await this.getActorContext(userId);
     this.ensureSupervisor(actor);
 
@@ -5504,9 +5568,36 @@ export class OperationsService {
           params,
           actor.collaboratorId
         )}`;
+    const pagination = this.shouldPaginate(filters)
+      ? this.normalizePaginationParams(filters, {
+          defaultSortField: 'submittedAt',
+          defaultSortOrder: 'desc',
+          allowedSortFields: ['submittedAt', 'decidedAt', 'requesterName', 'status'],
+        })
+      : null;
+    const where = [clause];
 
-    return this.queryRows(
-      `SELECT a.id,
+    if (filters.status && filters.status !== 'all') {
+      where.push(`a.status::text = ${this.param(params, filters.status)}`);
+    }
+
+    if (filters.targetType && filters.targetType !== 'all') {
+      where.push(`a.target_type = ${this.param(params, filters.targetType)}::text::operations_approval_target_type_32d3f04385_enum`);
+    }
+
+    if (pagination?.search) {
+      const searchPlaceholder = this.param(params, `%${pagination.search}%`);
+      where.push(`(
+        COALESCE(requester.display_name, '') ILIKE ${searchPlaceholder}
+        OR COALESCE(approver.display_name, '') ILIKE ${searchPlaceholder}
+        OR COALESCE(a.decision_note, '') ILIKE ${searchPlaceholder}
+        OR COALESCE(tor.reason, '') ILIKE ${searchPlaceholder}
+        OR COALESCE(sar.reason, '') ILIKE ${searchPlaceholder}
+      )`);
+    }
+
+    const whereClause = where.join(' AND ');
+    const baseQuery = `SELECT a.id,
               a.target_type AS "targetType",
               a.target_id AS "targetId",
               a.requester_collaborator_id AS "requesterCollaboratorId",
@@ -5525,12 +5616,12 @@ export class OperationsService {
                 ''
               ) AS "timesheetProjectNames",
               tor.request_type AS "timeOffType",
-              tor.start_date AS "timeOffStartDate",
-              tor.end_date AS "timeOffEndDate",
+              tor.start_date::text AS "timeOffStartDate",
+              tor.end_date::text AS "timeOffEndDate",
               tor.reason AS "timeOffReason",
               sar.request_scope AS "scheduleRequestScope",
-              sar.effective_start_date AS "scheduleStartDate",
-              sar.effective_end_date AS "scheduleEndDate",
+              sar.effective_start_date::text AS "scheduleStartDate",
+              sar.effective_end_date::text AS "scheduleEndDate",
               sar.reason AS "scheduleReason"
          FROM operations_approval a
          JOIN operations_collaborator requester
@@ -5553,11 +5644,62 @@ export class OperationsService {
          LEFT JOIN operations_schedule_adjustment_request sar
            ON a.target_type = 'schedule_adjustment_request'
           AND sar.id = a.target_id
-        WHERE ${clause}
-        GROUP BY a.id, requester.id, approver.id, t.id, tor.id, sar.id
-        ORDER BY a.submitted_at DESC, a.id DESC`,
+        WHERE ${whereClause}
+        GROUP BY a.id, requester.id, approver.id, t.id, tor.id, sar.id`;
+
+    if (!pagination) {
+      return this.queryRows(
+        `${baseQuery}
+         ORDER BY a.submitted_at DESC, a.id DESC`,
+        params
+      );
+    }
+
+    const totalRow = await this.querySingle<{ total: string }>(
+      `SELECT COUNT(*)::text AS total
+         FROM operations_approval a
+         JOIN operations_collaborator requester
+           ON requester.id = a.requester_collaborator_id
+         LEFT JOIN operations_collaborator approver
+           ON approver.id = a.approver_collaborator_id
+         LEFT JOIN operations_timesheet t
+           ON a.target_type = 'timesheet'
+          AND t.id = a.target_id
+         LEFT JOIN operations_time_off_request tor
+           ON a.target_type = 'time_off_request'
+          AND tor.id = a.target_id
+         LEFT JOIN operations_schedule_adjustment_request sar
+           ON a.target_type = 'schedule_adjustment_request'
+          AND sar.id = a.target_id
+        WHERE ${whereClause}`,
       params
     );
+
+    const sortColumn =
+      {
+        submittedAt: 'a.submitted_at',
+        decidedAt: 'a.decided_at',
+        requesterName: 'requester.display_name',
+        status: 'a.status',
+      }[pagination.sortField] ?? 'a.submitted_at';
+
+    const queryParams = [...params];
+    const limitPlaceholder = this.param(queryParams, pagination.pageSize);
+    const offsetPlaceholder = this.param(queryParams, pagination.offset);
+    const rows = await this.queryRows(
+      `${baseQuery}
+       ORDER BY ${sortColumn} ${pagination.sortOrder.toUpperCase()}, a.id DESC
+       LIMIT ${limitPlaceholder}
+      OFFSET ${offsetPlaceholder}`,
+      queryParams
+    );
+
+    return this.buildPaginationResult(
+      rows,
+      Number(totalRow?.total ?? 0),
+      pagination.page,
+      pagination.pageSize
+    );
   }
 
   async approve(userId: number, approvalId: number, data: DecisionPayload) {
@@ -5568,6 +5710,193 @@ export class OperationsService {
     return this.decideApproval(userId, approvalId, 'reject', data);
   }
 
+  async getApprovalDetail(userId: number, approvalId: number) {
+    const actor = await this.getActorContext(userId);
+    this.ensureSupervisor(actor);
+
+    const params: unknown[] = [];
+    const actorClause = actor.isDirector
+      ? 'a.deleted_at IS NULL'
+      : `a.deleted_at IS NULL AND a.approver_collaborator_id = ${this.param(params, actor.collaboratorId)}`;
+    const idPlaceholder = this.param(params, approvalId);
+
+    const row = await this.querySingle<{
+      id: number;
+      targetType: string;
+      targetId: number;
+      requesterCollaboratorId: number;
+      requesterName: string;
+      approverCollaboratorId: number | null;
+      approverName: string | null;
+      status: string;
+      submittedAt: string | null;
+      decidedAt: string | null;
+      decisionNote: string | null;
+      timesheetWeekStartDate: string | null;
+      timesheetWeekEndDate: string | null;
+      timesheetTotalHours: number | null;
+      timesheetProjectNames: string | null;
+      timeOffType: string | null;
+      timeOffStartDate: string | null;
+      timeOffEndDate: string | null;
+      timeOffReason: string | null;
+      scheduleRequestScope: string | null;
+      scheduleStartDate: string | null;
+      scheduleEndDate: string | null;
+      scheduleReason: string | null;
+    }>(
+      `SELECT a.id,
+              a.target_type AS "targetType",
+              a.target_id AS "targetId",
+              a.requester_collaborator_id AS "requesterCollaboratorId",
+              requester.display_name AS "requesterName",
+              a.approver_collaborator_id AS "approverCollaboratorId",
+              approver.display_name AS "approverName",
+              a.status,
+              a.submitted_at AS "submittedAt",
+              a.decided_at AS "decidedAt",
+              a.decision_note AS "decisionNote",
+              t.week_start_date AS "timesheetWeekStartDate",
+              t.week_end_date AS "timesheetWeekEndDate",
+              t.total_hours AS "timesheetTotalHours",
+              COALESCE(
+                STRING_AGG(DISTINCT p.name, ', ') FILTER (WHERE p.name IS NOT NULL),
+                ''
+              ) AS "timesheetProjectNames",
+              tor.request_type AS "timeOffType",
+              tor.start_date::text AS "timeOffStartDate",
+              tor.end_date::text AS "timeOffEndDate",
+              tor.reason AS "timeOffReason",
+              sar.request_scope AS "scheduleRequestScope",
+              sar.effective_start_date::text AS "scheduleStartDate",
+              sar.effective_end_date::text AS "scheduleEndDate",
+              sar.reason AS "scheduleReason"
+         FROM operations_approval a
+         JOIN operations_collaborator requester
+           ON requester.id = a.requester_collaborator_id
+         LEFT JOIN operations_collaborator approver
+           ON approver.id = a.approver_collaborator_id
+         LEFT JOIN operations_timesheet t
+           ON a.target_type = 'timesheet'
+          AND t.id = a.target_id
+         LEFT JOIN operations_timesheet_entry te
+           ON te.timesheet_id = t.id
+          AND te.deleted_at IS NULL
+         LEFT JOIN operations_project_assignment pa
+           ON pa.id = te.project_assignment_id
+         LEFT JOIN operations_project p
+           ON p.id = pa.project_id
+         LEFT JOIN operations_time_off_request tor
+           ON a.target_type = 'time_off_request'
+          AND tor.id = a.target_id
+         LEFT JOIN operations_schedule_adjustment_request sar
+           ON a.target_type = 'schedule_adjustment_request'
+          AND sar.id = a.target_id
+        WHERE ${actorClause}
+          AND a.id = ${idPlaceholder}
+        GROUP BY a.id, requester.id, approver.id, t.id, tor.id, sar.id`,
+      params
+    );
+
+    if (!row) {
+      throw new Error('Approval not found or access denied');
+    }
+
+    if (row.targetType === 'timesheet') {
+      const entries = await this.queryRows<{
+        id: number;
+        timesheetId: number;
+        projectAssignmentId: number | null;
+        projectId: number | null;
+        projectName: string | null;
+        roleLabel: string | null;
+        taskId: number | null;
+        taskName: string | null;
+        activityLabel: string | null;
+        workDate: string;
+        durationMinutes: number | null;
+        hours: number;
+        description: string | null;
+      }>(
+        `SELECT e.id,
+                e.timesheet_id AS "timesheetId",
+                e.project_assignment_id AS "projectAssignmentId",
+                pa.project_id AS "projectId",
+                p.name AS "projectName",
+                pa.role_label AS "roleLabel",
+                e.task_id AS "taskId",
+                task_record.name AS "taskName",
+                COALESCE(task_record.name, e.activity_label) AS "activityLabel",
+                e.work_date AS "workDate",
+                COALESCE(NULLIF(e.duration_minutes, 0), ROUND(COALESCE(e.hours, 0)::numeric * 60))::int AS "durationMinutes",
+                COALESCE(
+                  e.hours,
+                  ROUND((COALESCE(NULLIF(e.duration_minutes, 0), 0)::numeric / 60), 2)
+                ) AS hours,
+                e.description
+           FROM operations_timesheet_entry e
+           LEFT JOIN operations_project_assignment pa ON pa.id = e.project_assignment_id
+           LEFT JOIN operations_project p ON p.id = pa.project_id
+           LEFT JOIN operations_task task_record
+             ON task_record.id = e.task_id
+            AND task_record.deleted_at IS NULL
+          WHERE e.deleted_at IS NULL
+            AND e.timesheet_id = $1
+          ORDER BY e.work_date ASC, e.id ASC`,
+        [row.targetId]
+      );
+      return { ...row, entries };
+    }
+
+    if (row.targetType === 'schedule_adjustment_request') {
+      const days = await this.queryRows<{
+        requestId: number;
+        weekday: string;
+        isWorkingDay: boolean;
+        startTime: string | null;
+        endTime: string | null;
+        breakMinutes: number | null;
+      }>(
+        `SELECT schedule_adjustment_request_id AS "requestId",
+                weekday,
+                is_working_day AS "isWorkingDay",
+                start_time AS "startTime",
+                end_time AS "endTime",
+                break_minutes AS "breakMinutes"
+           FROM operations_schedule_adjustment_day
+          WHERE schedule_adjustment_request_id = $1
+          ORDER BY id ASC`,
+        [row.targetId]
+      );
+
+      const collaboratorIdParam: unknown[] = [row.requesterCollaboratorId];
+      const currentSchedule = await this.queryRows<{
+        collaboratorId: number;
+        weekday: string;
+        isWorkingDay: boolean;
+        startTime: string | null;
+        endTime: string | null;
+        breakMinutes: number | null;
+      }>(
+        `SELECT DISTINCT ON (collaborator_id, weekday)
+                collaborator_id AS "collaboratorId",
+                weekday,
+                is_working_day AS "isWorkingDay",
+                start_time AS "startTime",
+                end_time AS "endTime",
+                break_minutes AS "breakMinutes"
+           FROM operations_collaborator_schedule_day
+          WHERE collaborator_id = $1
+          ORDER BY collaborator_id, weekday, id DESC`,
+        collaboratorIdParam
+      );
+
+      return { ...row, days, currentSchedule };
+    }
+
+    return row;
+  }
+
   async publishAccountsPayableReference(
     userId: number,
     data: PublishAccountsPayableReferencePayload,
@@ -5821,21 +6150,51 @@ export class OperationsService {
   private async getCollaboratorByUserId(userId: number) {
     return this.querySingle<{
       id: number;
+      userId: number | null;
+      personId: number | null;
       displayName: string;
       supervisorId: number | null;
       supervisorName: string | null;
+      activeAssignments: number;
     }>(
-      `SELECT c.id,
+      `WITH linked_collaborator AS (
+         SELECT person_id
+           FROM operations_collaborator
+          WHERE user_id = $1
+            AND deleted_at IS NULL
+          ORDER BY id DESC
+          LIMIT 1
+       )
+       SELECT c.id,
+              c.user_id AS "userId",
+              c.person_id AS "personId",
               COALESCE(NULLIF(c.display_name, ''), person_record.name) AS "displayName",
               s.id AS "supervisorId",
-              s.display_name AS "supervisorName"
+              s.display_name AS "supervisorName",
+              COUNT(pa.id) FILTER (
+                WHERE pa.deleted_at IS NULL
+                  AND pa.status IN ('planned', 'active')
+              )::int AS "activeAssignments"
          FROM operations_collaborator c
          LEFT JOIN person person_record
            ON person_record.id = c.person_id
          LEFT JOIN operations_collaborator s
            ON s.id = c.supervisor_collaborator_id
-        WHERE c.user_id = $1
-          AND c.deleted_at IS NULL`,
+         LEFT JOIN operations_project_assignment pa
+           ON pa.collaborator_id = c.id
+        WHERE c.deleted_at IS NULL
+          AND (
+            c.user_id = $1
+            OR (
+              c.person_id IS NOT NULL
+              AND c.person_id = (SELECT person_id FROM linked_collaborator)
+            )
+          )
+        GROUP BY c.id, person_record.id, s.id
+        ORDER BY "activeAssignments" DESC,
+                 CASE WHEN c.user_id = $1 THEN 0 ELSE 1 END,
+                 c.id ASC
+        LIMIT 1`,
       [userId]
     );
   }
@@ -6531,175 +6890,26 @@ export class OperationsService {
 
       return collaboratorTypes[0] ?? null;
     }
-
-    const normalizedLookup = this.normalizeOptionalText(input.collaboratorTypeSlug);
-    if (!normalizedLookup) {
-      return null;
-    }
-
-    const collaboratorTypes = (await client.$queryRawUnsafe(
-      `SELECT id, slug, name
-         FROM operations_collaborator_type
-        WHERE deleted_at IS NULL
-          AND (
-            LOWER(slug) = LOWER($1)
-            OR LOWER(name) = LOWER($1)
-          )
-        ORDER BY id ASC
-        LIMIT 1`,
-      normalizedLookup
-    )) as Array<{ id: number; slug: string; name: string }>;
-
-    return collaboratorTypes[0] ?? null;
-  }
-
-  private async getContractTemplateRecord(
-    client: any,
-    templateId: number,
-    includeInactive = false
-  ): Promise<{
-    id: number;
-    slug: string;
-    code: string | null;
-    name: string;
-    description: string | null;
-    contractCategory: string | null;
-    contractType: string | null;
-    billingModel: string | null;
-    signatureStatus: string | null;
-    isActive: boolean;
-    status: string | null;
-    contentHtml: string | null;
-    usageCount: number;
-    createdAt: Date;
-    updatedAt: Date;
-  }> {
-    const template = (await client.$queryRawUnsafe(
-      `SELECT t.id,
-              t.slug,
-              t.code,
-              t.name,
-              t.description,
-              t.contract_category AS "contractCategory",
-              t.contract_type AS "contractType",
-              t.billing_model AS "billingModel",
-              t.signature_status AS "signatureStatus",
-              t.is_active AS "isActive",
-              t.status,
-              t.content_html AS "contentHtml",
-              COUNT(DISTINCT c.id)::int AS "usageCount",
-              t.created_at AS "createdAt",
-              t.updated_at AS "updatedAt"
-         FROM operations_contract_template t
-         LEFT JOIN operations_contract c
-           ON c.contract_template_id = t.id
-          AND c.deleted_at IS NULL
-        WHERE t.id = $1
-          AND ($2::boolean = true OR t.deleted_at IS NULL)
-        GROUP BY t.id
-        LIMIT 1`,
-      templateId,
-      includeInactive
-    )) as Array<{
-      id: number;
-      slug: string;
-      code: string | null;
-      name: string;
-      description: string | null;
-      contractCategory: string | null;
-      contractType: string | null;
-      billingModel: string | null;
-      signatureStatus: string | null;
-      isActive: boolean;
-      status: string | null;
-      contentHtml: string | null;
-      usageCount: number;
-      createdAt: Date;
-      updatedAt: Date;
-    }>;
-
-    const record = template[0];
-
-    if (!record) {
-      throw new NotFoundException('Contract template not found.');
-    }
-
-    return record;
-  }
-
-  private async assertContractTemplateNameAvailable(
-    client: any,
-    name: string,
-    excludeTemplateId?: number | null
-  ) {
-    const existing = (await client.$queryRawUnsafe(
-      `SELECT id
-         FROM operations_contract_template
-        WHERE LOWER(name) = LOWER($1)
-          AND deleted_at IS NULL
-          AND ($2::int IS NULL OR id <> $2)
-        LIMIT 1`,
-      name,
-      excludeTemplateId ?? null
-    )) as { id: number }[];
-
-    if (existing[0]) {
-      throw new BadRequestException(
-        'A contract template with this name already exists.'
-      );
-    }
-  }
-
-  private async assertContractTemplateCodeAvailable(
-    client: any,
-    code: string,
-    excludeTemplateId?: number | null
-  ) {
-    const existing = (await client.$queryRawUnsafe(
-      `SELECT id
-         FROM operations_contract_template
-        WHERE UPPER(COALESCE(code, '')) = UPPER($1)
-          AND deleted_at IS NULL
-          AND ($2::int IS NULL OR id <> $2)
-        LIMIT 1`,
-      code,
-      excludeTemplateId ?? null
-    )) as { id: number }[];
-
-    if (existing[0]) {
-      throw new BadRequestException(
-        'A contract template with this code already exists.'
-      );
-    }
-  }
-
-  private async generateUniqueContractTemplateSlug(
-    client: any,
-    label: string,
-    excludeTemplateId?: number | null
-  ) {
-    const baseSlug =
-      this.slugifyValue(label) || `contract-template-${Date.now().toString(36)}`;
-
-    for (let attempt = 0; attempt < 25; attempt += 1) {
-      const candidate =
-        attempt === 0 ? baseSlug : `${baseSlug}-${attempt + 1}`;
-      const existing = (await client.$queryRawUnsafe(
-        `SELECT id
-           FROM operations_contract_template
-          WHERE slug = $1
-            AND ($2::int IS NULL OR id <> $2)
-          LIMIT 1`,
-        candidate,
-        excludeTemplateId ?? null
-      )) as { id: number }[];
-
-      if (!existing.length) {
-        return candidate;
-      }
+
+    const normalizedLookup = this.normalizeOptionalText(input.collaboratorTypeSlug);
+    if (!normalizedLookup) {
+      return null;
     }
 
-    return `${baseSlug}-${Date.now().toString(36)}`;
+    const collaboratorTypes = (await client.$queryRawUnsafe(
+      `SELECT id, slug, name
+         FROM operations_collaborator_type
+        WHERE deleted_at IS NULL
+          AND (
+            LOWER(slug) = LOWER($1)
+            OR LOWER(name) = LOWER($1)
+          )
+        ORDER BY id ASC
+        LIMIT 1`,
+      normalizedLookup
+    )) as Array<{ id: number; slug: string; name: string }>;
+
+    return collaboratorTypes[0] ?? null;
   }
 
   private slugifyValue(value: string | null | undefined) {
@@ -6904,12 +7114,12 @@ export class OperationsService {
         ),
         this.querySingle<{
           activeAssignments: string;
-          billableAssignments: string;
+          completedAssignments: string;
           averageAllocation: string | null;
           totalWeeklyHours: string | null;
         }>(
           `SELECT COUNT(*) FILTER (WHERE status IN ('planned', 'active'))::text AS "activeAssignments",
-                  COUNT(*) FILTER (WHERE is_billable = true AND status IN ('planned', 'active'))::text AS "billableAssignments",
+                  COUNT(*) FILTER (WHERE status = 'completed')::text AS "completedAssignments",
                   COALESCE(AVG(allocation_percent), 0)::text AS "averageAllocation",
                   COALESCE(SUM(weekly_hours), 0)::text AS "totalWeeklyHours"
              FROM operations_project_assignment
@@ -6930,8 +7140,8 @@ export class OperationsService {
       },
       operationalIndicators: {
         activeAssignments: Number(operationalIndicators?.activeAssignments ?? 0),
-        billableAssignments: Number(
-          operationalIndicators?.billableAssignments ?? 0
+        completedAssignments: Number(
+          operationalIndicators?.completedAssignments ?? 0
         ),
         averageAllocation: Number(
           operationalIndicators?.averageAllocation ?? 0
@@ -6941,6 +7151,77 @@ export class OperationsService {
     };
   }
 
+  async getProjectStats(userId: number, projectId: number) {
+    const [weeklyVelocityRows, allocationRows, quickRadarRow] = await Promise.all([
+      this.prisma.$queryRawUnsafe<Array<{ weekStart: string; loggedHours: string }>>(
+        `SELECT TO_CHAR(DATE_TRUNC('week', e.work_date), 'DD/MM') AS "weekStart",
+                COALESCE(SUM(e.hours), 0)::text AS "loggedHours"
+           FROM operations_project_assignment pa
+           JOIN operations_timesheet_entry e ON e.project_assignment_id = pa.id AND e.deleted_at IS NULL
+          WHERE pa.project_id = $1
+            AND pa.deleted_at IS NULL
+            AND e.work_date >= NOW() - INTERVAL '7 weeks'
+          GROUP BY DATE_TRUNC('week', e.work_date)
+          ORDER BY DATE_TRUNC('week', e.work_date) ASC
+          LIMIT 7`,
+        projectId
+      ),
+      this.prisma.$queryRawUnsafe<Array<{ name: string; allocation: string }>>(
+        `SELECT c.display_name AS "name",
+                COALESCE(pa.allocation_percent, 0)::text AS "allocation"
+           FROM operations_project_assignment pa
+           JOIN operations_collaborator c ON c.id = pa.collaborator_id AND c.deleted_at IS NULL
+          WHERE pa.project_id = $1
+            AND pa.deleted_at IS NULL
+            AND pa.status IN ('planned', 'active')
+          ORDER BY c.display_name ASC
+          LIMIT 6`,
+        projectId
+      ),
+      this.prisma.$queryRawUnsafe<{ activeAssignments: string; pendingTimesheets: string; totalWeeklyHours: string }>(
+        `SELECT
+           (SELECT COUNT(*)::text
+              FROM operations_task tk
+             WHERE tk.project_id = $1
+               AND tk.deleted_at IS NULL
+               AND tk.assignee_collaborator_id IS NOT NULL
+               AND tk.status IN ('todo', 'doing', 'review')
+           ) AS "activeAssignments",
+           COUNT(DISTINCT ts.id) FILTER (WHERE ts.status = 'submitted')::text AS "pendingTimesheets",
+           COALESCE(SUM(pa.weekly_hours) FILTER (WHERE pa.status IN ('planned', 'active')), 0)::text AS "totalWeeklyHours"
+         FROM operations_project_assignment pa
+         LEFT JOIN operations_timesheet_entry e ON e.project_assignment_id = pa.id AND e.deleted_at IS NULL
+         LEFT JOIN operations_timesheet ts ON ts.id = e.timesheet_id AND ts.deleted_at IS NULL
+         WHERE pa.project_id = $1 AND pa.deleted_at IS NULL`,
+        projectId
+      ).then(rows => Array.isArray(rows) ? rows[0] : rows),
+    ]);
+
+    const getInitials = (name: string) =>
+      name
+        .split(' ')
+        .map((part) => part[0])
+        .slice(0, 2)
+        .join('')
+        .toUpperCase();
+
+    return {
+      weeklyVelocity: weeklyVelocityRows.map((row) => ({
+        weekLabel: row.weekStart,
+        loggedHours: Number(row.loggedHours),
+      })),
+      allocationByCollaborator: allocationRows.map((row) => ({
+        name: getInitials(row.name),
+        allocation: Math.round(Number(row.allocation)),
+      })),
+      quickRadar: {
+        activeAssignments: Number(quickRadarRow?.activeAssignments ?? 0),
+        pendingTimesheets: Number(quickRadarRow?.pendingTimesheets ?? 0),
+        totalWeeklyHours: Number(quickRadarRow?.totalWeeklyHours ?? 0),
+      },
+    };
+  }
+
   private async getCollaboratorDetails(collaboratorId: number) {
     const collaborator = await this.querySingle<{
       id: number;
@@ -7148,8 +7429,8 @@ export class OperationsService {
         this.queryRows(
           `SELECT id,
                   request_scope AS "requestScope",
-                  effective_start_date AS "effectiveStartDate",
-                  effective_end_date AS "effectiveEndDate",
+                  effective_start_date::text AS "effectiveStartDate",
+                  effective_end_date::text AS "effectiveEndDate",
                   status,
                   reason
              FROM operations_schedule_adjustment_request
@@ -7705,23 +7986,26 @@ export class OperationsService {
     const assignmentIds = entries
       .map((entry) => entry.projectAssignmentId)
       .filter((value): value is number => typeof value === 'number');
+    const assignmentMap = new Map<
+      number,
+      { id: number; collaboratorId: number; projectId: number }
+    >();
 
     if (assignmentIds.length) {
       const assignments = (await client.$queryRawUnsafe(
-        `SELECT id, collaborator_id AS "collaboratorId"
+        `SELECT id,
+                collaborator_id AS "collaboratorId",
+                project_id AS "projectId"
            FROM operations_project_assignment
           WHERE id = ANY($1::int[])
             AND deleted_at IS NULL`,
         assignmentIds
-      )) as { id: number; collaboratorId: number }[];
-      const assignmentMap = new Map(
-        assignments.map((assignment) => [
-          assignment.id,
-          assignment.collaboratorId,
-        ])
-      );
+      )) as { id: number; collaboratorId: number; projectId: number }[];
+      assignments.forEach((assignment) => {
+        assignmentMap.set(assignment.id, assignment);
+      });
       for (const assignmentId of assignmentIds) {
-        if (assignmentMap.get(assignmentId) !== collaboratorId) {
+        if (assignmentMap.get(assignmentId)?.collaboratorId !== collaboratorId) {
           throw new ForbiddenException(
             'Timesheet entries must use assignments owned by the target collaborator.'
           );
@@ -7735,14 +8019,17 @@ export class OperationsService {
       const resolvedTask = entry.taskId
         ? await this.getOwnedTaskRecord(client, collaboratorId, entry.taskId)
         : null;
+      const selectedAssignment = entry.projectAssignmentId
+        ? assignmentMap.get(entry.projectAssignmentId) ?? null
+        : null;
 
       if (
         resolvedTask &&
-        entry.projectAssignmentId &&
-        resolvedTask.projectAssignmentId !== entry.projectAssignmentId
+        selectedAssignment &&
+        resolvedTask.projectId !== selectedAssignment.projectId
       ) {
         throw new BadRequestException(
-          'The selected task does not belong to the chosen project assignment.'
+          'The selected task does not belong to the chosen project.'
         );
       }
 
@@ -7816,6 +8103,37 @@ export class OperationsService {
     );
   }
 
+  private async cleanupEmptyEditableTimesheet(client: any, timesheetId: number) {
+    const candidate = (await client.$queryRawUnsafe(
+      `SELECT t.id
+         FROM operations_timesheet t
+        WHERE t.id = $1
+          AND t.deleted_at IS NULL
+          AND t.status IN ('draft', 'rejected')
+          AND NOT EXISTS (
+            SELECT 1
+              FROM operations_timesheet_entry e
+             WHERE e.timesheet_id = t.id
+               AND e.deleted_at IS NULL
+          )
+        LIMIT 1`,
+      timesheetId
+    )) as Array<{ id: number }>;
+
+    if (!candidate[0]?.id) {
+      return;
+    }
+
+    await client.$executeRawUnsafe(
+      `UPDATE operations_timesheet
+          SET deleted_at = NOW(),
+              updated_at = NOW()
+        WHERE id = $1
+          AND deleted_at IS NULL`,
+      timesheetId
+    );
+  }
+
   private async upsertApproval(
     client: any,
     input: {
@@ -8130,15 +8448,14 @@ export class OperationsService {
           role_label,
           allocation_percent,
           weekly_hours,
-          is_billable,
           start_date,
           end_date,
           status,
           created_at,
           updated_at
         ) VALUES (
-          $1, $2, $3, $4, $5, $6, $7, $8::date, $9::date,
-          $10::operations_project_assignment_status_155b459bbf_enum,
+          $1, $2, $3, $4, $5, $6, $7::date, $8::date,
+          $9::operations_project_assignment_status_155b459bbf_enum,
           NOW(), NOW()
         )`,
         projectId,
@@ -8149,7 +8466,6 @@ export class OperationsService {
           'Team Member',
         assignment.allocationPercent ?? null,
         assignment.weeklyHours ?? null,
-        assignment.isBillable ?? true,
         assignment.startDate ?? null,
         assignment.endDate ?? null,
         assignment.status ?? 'active'
@@ -8523,185 +8839,6 @@ export class OperationsService {
     );
   }
 
-  private async createProjectContractDraft(
-    client: any,
-    createdByUserId: number,
-    input: {
-      projectId: number;
-      contractTemplateId: number | null;
-      projectCode: string;
-      projectName: string;
-      clientName: string;
-      managerCollaboratorId: number | null;
-      startDate: string | null;
-      endDate: string | null;
-      budgetAmount: number | null;
-      monthlyHourCap: number | null;
-      billingModel:
-        | 'time_and_material'
-        | 'monthly_retainer'
-        | 'fixed_price';
-      contractCode: string | null;
-      contractName: string | null;
-      description: string | null;
-    }
-  ) {
-    const templateRows = input.contractTemplateId
-      ? ((await client.$queryRawUnsafe(
-          `SELECT id,
-                  code,
-                  name,
-                  description,
-                  contract_category AS "contractCategory",
-                  contract_type AS "contractType",
-                  billing_model AS "billingModel",
-                  signature_status AS "signatureStatus",
-                  content_html AS "contentHtml"
-             FROM operations_contract_template
-            WHERE id = $1
-              AND deleted_at IS NULL
-            LIMIT 1`,
-          input.contractTemplateId
-        )) as Array<{
-          id: number;
-          code?: string | null;
-          name?: string | null;
-          description?: string | null;
-          contractCategory?: string | null;
-          contractType?: string | null;
-          billingModel?: string | null;
-          signatureStatus?: string | null;
-          contentHtml?: string | null;
-        }>)
-      : [];
-
-    const selectedTemplate = templateRows[0] ?? null;
-    const templateContext = {
-      project_code: input.projectCode,
-      project_name: input.projectName,
-      client_name: input.clientName,
-      start_date: input.startDate ?? '',
-      end_date: input.endDate ?? '',
-      budget_amount:
-        input.budgetAmount !== null && input.budgetAmount !== undefined
-          ? String(input.budgetAmount)
-          : '',
-      monthly_hour_cap:
-        input.monthlyHourCap !== null && input.monthlyHourCap !== undefined
-          ? String(input.monthlyHourCap)
-          : '',
-    };
-
-    const applyTemplateVariables = (value: string | null | undefined) => {
-      const source = value ?? '';
-      return Object.entries(templateContext).reduce(
-        (result, [key, replacement]) =>
-          result.split(`{{${key}}}`).join(replacement || ''),
-        source
-      );
-    };
-
-    const templateCodePrefix = this.normalizeOptionalText(selectedTemplate?.code);
-    const generatedContractCode = (
-      this.normalizeOptionalText(input.contractCode) ??
-      (templateCodePrefix
-        ? `${templateCodePrefix}-${input.projectCode}`
-        : null) ??
-      `PRJ-${input.projectCode}`
-    ).slice(0, 40);
-
-    const generatedContractName =
-      this.normalizeOptionalText(input.contractName) ??
-      this.normalizeOptionalText(applyTemplateVariables(selectedTemplate?.name)) ??
-      `${input.projectName} Service Agreement`;
-
-    const generatedDescription = this.normalizeOptionalText(
-      applyTemplateVariables(input.description ?? selectedTemplate?.description)
-    );
-
-    const generatedContentHtml = this.normalizeOptionalText(
-      applyTemplateVariables(selectedTemplate?.contentHtml)
-    );
-
-    const created = await client.$queryRawUnsafe(
-      `INSERT INTO operations_contract (
-        code,
-        name,
-        contract_category,
-        contract_type,
-        client_name,
-        signature_status,
-        is_active,
-        billing_model,
-        account_manager_collaborator_id,
-        related_collaborator_id,
-        contract_template_id,
-        origin_type,
-        origin_id,
-        start_date,
-        end_date,
-        signed_at,
-        effective_date,
-        budget_amount,
-        monthly_hour_cap,
-        status,
-        description,
-        content_html,
-        created_by_user_id,
-        updated_by_user_id,
-        created_at,
-        updated_at
-      ) VALUES (
-        $1,
-        $2,
-        $3::operations_contract_contract_category_70d553ea09_enum,
-        $4::operations_contract_contract_type_48331e2ebf_enum,
-        $5,
-        $6::operations_contract_signature_status_2cb7282a7b_enum,
-        true,
-        $7::operations_contract_billing_model_409dc7fea2_enum,
-        $8,
-        NULL,
-        $9,
-        'client_project',
-        $10,
-        $11::date,
-        $12::date,
-        NULL,
-        $11::date,
-        $13,
-        $14,
-        'draft',
-        $15,
-        $16,
-        $17,
-        $17,
-        NOW(),
-        NOW()
-      )
-      RETURNING id`,
-      generatedContractCode,
-      generatedContractName,
-      selectedTemplate?.contractCategory ?? 'client',
-      selectedTemplate?.contractType ?? 'service_agreement',
-      input.clientName,
-      selectedTemplate?.signatureStatus ?? 'not_started',
-      selectedTemplate?.billingModel ?? input.billingModel,
-      input.managerCollaboratorId,
-      selectedTemplate?.id ?? null,
-      input.projectId,
-      input.startDate ?? new Date().toISOString().slice(0, 10),
-      input.endDate ?? null,
-      input.budgetAmount ?? null,
-      input.monthlyHourCap ?? null,
-      generatedDescription,
-      generatedContentHtml,
-      createdByUserId
-    );
-
-    return (created as { id: number }[])[0]?.id;
-  }
-
   private async replaceContractParties(
     client: any,
     contractId: number,
@@ -8747,137 +8884,6 @@ export class OperationsService {
     }
   }
 
-  private async replaceContractSignatures(
-    client: any,
-    contractId: number,
-    signatures?: ContractPayload['signatures']
-  ) {
-    await client.$executeRawUnsafe(
-      `UPDATE operations_contract_signature
-          SET deleted_at = NOW(),
-              updated_at = NOW()
-        WHERE contract_id = $1
-          AND deleted_at IS NULL`,
-      contractId
-    );
-
-    for (const signature of signatures ?? []) {
-      await client.$executeRawUnsafe(
-        `INSERT INTO operations_contract_signature (
-          contract_id,
-          signer_name,
-          signer_role,
-          signer_email,
-          signer_status,
-          signed_at,
-          created_at,
-          updated_at
-        ) VALUES (
-          $1, $2, $3, $4,
-          $5::operations_contract_signature_signer_status_1e6fbe2519_enum,
-          $6::timestamp, NOW(), NOW()
-        )`,
-        contractId,
-        signature.signerName,
-        signature.signerRole ?? null,
-        signature.signerEmail ?? null,
-        signature.status ?? 'pending',
-        signature.signedAt ?? null
-      );
-    }
-  }
-
-  private async replaceContractFinancialTerms(
-    client: any,
-    contractId: number,
-    financialTerms?: ContractPayload['financialTerms']
-  ) {
-    await client.$executeRawUnsafe(
-      `UPDATE operations_contract_financial_term
-          SET deleted_at = NOW(),
-              updated_at = NOW()
-        WHERE contract_id = $1
-          AND deleted_at IS NULL`,
-      contractId
-    );
-
-    for (const term of financialTerms ?? []) {
-      await client.$executeRawUnsafe(
-        `INSERT INTO operations_contract_financial_term (
-          contract_id,
-          term_type,
-          label,
-          amount,
-          recurrence,
-          due_day,
-          notes,
-          created_at,
-          updated_at
-        ) VALUES (
-          $1,
-          $2::operations_contract_financial_term_term_type_700635c06a_enum,
-          $3,
-          $4,
-          $5::operations_contract_financial_term_recurrence_ba90bbe3bf_enum,
-          $6,
-          $7,
-          NOW(), NOW()
-        )`,
-        contractId,
-        term.termType ?? 'value',
-        term.label,
-        term.amount,
-        term.recurrence ?? 'one_time',
-        term.dueDay ?? null,
-        term.notes ?? null
-      );
-    }
-  }
-
-  private async replaceContractRevisions(
-    client: any,
-    contractId: number,
-    revisions?: ContractPayload['revisions']
-  ) {
-    await client.$executeRawUnsafe(
-      `UPDATE operations_contract_revision
-          SET deleted_at = NOW(),
-              updated_at = NOW()
-        WHERE contract_id = $1
-          AND deleted_at IS NULL`,
-      contractId
-    );
-
-    for (const revision of revisions ?? []) {
-      await client.$executeRawUnsafe(
-        `INSERT INTO operations_contract_revision (
-          contract_id,
-          revision_type,
-          title,
-          effective_date,
-          status,
-          summary,
-          created_at,
-          updated_at
-        ) VALUES (
-          $1,
-          $2::operations_contract_revision_revision_type_cf5ba1a538_enum,
-          $3,
-          $4::date,
-          $5::operations_contract_revision_status_f44f35bb66_enum,
-          $6,
-          NOW(), NOW()
-        )`,
-        contractId,
-        revision.revisionType ?? 'revision',
-        revision.title,
-        revision.effectiveDate ?? null,
-        revision.status ?? 'draft',
-        revision.summary ?? null
-      );
-    }
-  }
-
   private async replaceContractDocument(
     client: any,
     contractId: number,
@@ -8890,7 +8896,7 @@ export class OperationsService {
               updated_at = NOW()
         WHERE contract_id = $1
           AND deleted_at IS NULL
-          AND document_type = $2`,
+          AND document_type::text = $2`,
       contractId,
       documentType
     );
@@ -8910,7 +8916,7 @@ export class OperationsService {
         created_at,
         updated_at
       ) VALUES (
-        $1, $2, $3, $4, $5, $6, true, $7, $8, $9, NOW(), NOW()
+        $1, $2::operations_contract_document_document_type_15ebaff0c9_enum, $3, $4, $5, $6, true, $7::operations_contract_document_extraction_status_6d94c231f3_enum, $8, $9, NOW(), NOW()
       )`,
       contractId,
       documentType,
@@ -9098,22 +9104,6 @@ export class OperationsService {
           )
           .join('')
       : '<li><strong>No parties registered yet.</strong><span>Complete this contract later if needed.</span></li>';
-    const financialTermsHtml = (contract.financialTerms ?? []).length
-      ? contract.financialTerms
-          .map(
-            (term: any) => `
-              <li>
-                <strong>${this.escapeHtml(term.label || 'Term')}</strong>
-                <span>${this.escapeHtml(
-                  [term.termType, term.amount, term.recurrence]
-                    .filter((item) => item !== null && item !== undefined && String(item).trim())
-                    .join(' • ')
-                )}</span>
-              </li>`
-          )
-          .join('')
-      : '<li><strong>No financial terms registered yet.</strong><span>The draft is intentionally lightweight.</span></li>';
-
     return `<!DOCTYPE html>
 <html lang="en">
   <head>
@@ -9272,11 +9262,6 @@ export class OperationsService {
       <ul>${partiesHtml}</ul>
     </section>
 
-    <section>
-      <h2>Financial Terms</h2>
-      <ul>${financialTermsHtml}</ul>
-    </section>
-
     <section>
       <h2>Contract Body</h2>
       <div class="content">${contentHtml}</div>
@@ -9619,7 +9604,6 @@ export class OperationsService {
               effectiveDate: contract.effectiveDate,
               signatureStatus: contract.signatureStatus,
               parties: contract.parties,
-              financialTerms: contract.financialTerms,
             },
             null,
             2
@@ -9719,11 +9703,11 @@ export class OperationsService {
       warnings.push('Consider confirming the primary party document number.');
     }
 
-    if (!(contract.financialTerms ?? []).length && contract.budgetAmount == null) {
-      warnings.push('Commercial conditions are still generic; define prices, recurrence, and penalties.');
-      checklist.push('Attention: validate billing, adjustments, and penalties.');
+    if (contract.budgetAmount == null) {
+      warnings.push('Commercial conditions are still generic; define a budget amount before signature.');
+      checklist.push('Attention: validate billing and penalties.');
     } else {
-      checklist.push('OK: there is at least one financial reference to review.');
+      checklist.push('OK: there is a budget reference to review.');
     }
 
     if (!contentText) {
@@ -9935,54 +9919,6 @@ export class OperationsService {
           isPrimary: this.normalizeExtractionBoolean(party.isPrimary),
         }))
         .filter((party) => party.displayName),
-      signatures: this.normalizeObjectList(raw.signatures)
-        .map((signature) => ({
-          signerName: this.normalizeExtractionString(signature.signerName),
-          signerRole: this.normalizeExtractionString(signature.signerRole),
-          signerEmail: this.normalizeExtractionString(signature.signerEmail),
-          status: this.normalizeEnumValue(
-            signature.status,
-            SIGNATURE_ITEM_STATUS_VALUES,
-            'pending'
-          ),
-          signedAt: this.normalizeExtractionDate(signature.signedAt),
-        }))
-        .filter((signature) => signature.signerName),
-      financialTerms: this.normalizeObjectList(raw.financialTerms)
-        .map((term) => ({
-          label: this.normalizeExtractionString(term.label),
-          termType: this.normalizeEnumValue(
-            term.termType,
-            FINANCIAL_TERM_TYPE_VALUES,
-            'value'
-          ),
-          amount: this.normalizeExtractionNumber(term.amount),
-          recurrence: this.normalizeEnumValue(
-            term.recurrence,
-            RECURRENCE_VALUES,
-            'one_time'
-          ),
-          dueDay: this.normalizeExtractionNumber(term.dueDay),
-          notes: this.normalizeExtractionString(term.notes),
-        }))
-        .filter((term) => term.label),
-      revisions: this.normalizeObjectList(raw.revisions)
-        .map((revision) => ({
-          title: this.normalizeExtractionString(revision.title),
-          revisionType: this.normalizeEnumValue(
-            revision.revisionType,
-            REVISION_TYPE_VALUES,
-            'revision'
-          ),
-          effectiveDate: this.normalizeExtractionDate(revision.effectiveDate),
-          status: this.normalizeEnumValue(
-            revision.status,
-            REVISION_STATUS_VALUES,
-            'draft'
-          ),
-          summary: this.normalizeExtractionString(revision.summary),
-        }))
-        .filter((revision) => revision.title),
     };
 
     if (!draft.name) missingFields.push('Contract title');
@@ -10129,6 +10065,22 @@ export class OperationsService {
     };
   }
 
+  private shouldPaginate(input: {
+    page?: number;
+    pageSize?: number;
+    search?: string;
+    sortField?: string;
+    sortOrder?: string;
+  }) {
+    return [
+      input.page,
+      input.pageSize,
+      input.search,
+      input.sortField,
+      input.sortOrder,
+    ].some((value) => value !== undefined && value !== null && value !== '');
+  }
+
   private buildPaginationResult<T>(
     data: T[],
     total: number,
@@ -10323,4 +10275,13 @@ export class OperationsService {
   private async execute(sql: string, params: unknown[] = []) {
     return this.prisma.$executeRawUnsafe(sql, ...params);
   }
+
+  private async getNextCollaboratorTypeSortOrder(client: any = this.prisma) {
+    const row = (await client.$queryRawUnsafe(
+      `SELECT COALESCE(MAX(sort_order), 0) + 1 AS "nextSortOrder"
+         FROM operations_collaborator_type`
+    )) as { nextSortOrder: number }[];
+
+    return Number(row?.[0]?.nextSortOrder ?? 1);
+  }
 }