@hed-hog/operations 0.0.330 → 0.0.332

package/src/operations.service.spec.ts

@@ -1,764 +1,988 @@
-/// <reference types="jest" />
-
-import { BadRequestException } from '@nestjs/common';
-import { OperationsService } from './operations.service';
-import { OperationsAccessService } from './services/shared/operations-access.service';
-
-describe('OperationsService proposal integration', () => {
-  let service: OperationsService;
-  let prisma: { $transaction: jest.Mock };
-  let integrationApi: { publishEvent: jest.Mock };
-
-  beforeEach(() => {
-    prisma = {
-      $transaction: jest.fn(),
-    };
-
-    integrationApi = {
-      publishEvent: jest.fn().mockResolvedValue(undefined),
-    };
-
-    service = new OperationsService(
-      prisma as any,
-      {} as any,
-      integrationApi as any,
-      {} as any,
-      {} as any,
-      new OperationsAccessService(),
-    );
-
-    jest.spyOn(service as any, 'generateContractCode').mockResolvedValue('CTR-001');
-    jest.spyOn(service as any, 'replaceContractParties').mockResolvedValue(undefined);
-    jest.spyOn(service as any, 'insertContractHistory').mockResolvedValue(undefined);
-  });
-
-  afterEach(() => {
-    jest.restoreAllMocks();
-  });
-
-  it('throws when proposalId is missing', async () => {
-    await expect(
-      service.createContractFromProposalIntegration({}),
-    ).rejects.toThrow(BadRequestException);
-  });
-
-  it('returns the existing contract when the CRM proposal was already converted', async () => {
-    const tx = {
-      $queryRawUnsafe: jest
-        .fn()
-        .mockResolvedValueOnce([])
-        .mockResolvedValueOnce([{ id: 42, code: 'CTR-EXISTING' }]),
-    };
-
-    prisma.$transaction.mockImplementation(async (callback: (client: unknown) => unknown) =>
-      callback(tx),
-    );
-
-    const result = await service.createContractFromProposalIntegration({
-      proposalId: 1001,
-      title: 'Already converted proposal',
-    });
-
-    expect(result).toEqual({
-      id: 42,
-      code: 'CTR-EXISTING',
-    });
-    expect((service as any).generateContractCode).not.toHaveBeenCalled();
-    expect((service as any).replaceContractParties).not.toHaveBeenCalled();
-    expect(integrationApi.publishEvent).not.toHaveBeenCalled();
-  });
-
-  it('creates a draft contract with CRM origin metadata and emits an event', async () => {
-    const tx = {
-      $queryRawUnsafe: jest
-        .fn()
-        .mockResolvedValueOnce([])
-        .mockResolvedValueOnce([])
-        .mockResolvedValueOnce([{ id: 77 }]),
-    };
-
-    prisma.$transaction.mockImplementation(async (callback: (client: unknown) => unknown) =>
-      callback(tx),
-    );
-
-    const payload = {
-      proposalId: 1001,
-      proposalRevisionId: 21,
-      personId: 5,
-      approvedByUserId: 9,
-      correlationId: 'proposal:1001',
-      code: 'P-1001',
-      title: 'Implementation Proposal',
-      total: 1234,
-      currency: 'USD',
-      locale: 'en',
-      commercialTerms: {
-        contractCategory: 'client' as const,
-        contractType: 'service_agreement' as const,
-        billingModel: 'monthly_retainer' as const,
-        validFrom: '2025-01-10',
-        validUntil: '2025-12-31',
-        notes: 'Annual support agreement',
-      },
-      person: {
-        id: 5,
-        name: 'Acme Contact',
-        tradeName: 'Acme Ltd',
-        email: 'ops@acme.test',
-        phone: '555-0100',
-        document: '12.345.678/0001-90',
-      },
-      revision: {
-        id: 21,
-        title: 'Revision 1',
-        summary: 'Approved commercial terms',
-        contentHtml: '<p>draft</p>',
-      },
-      items: [
-        {
-          name: 'Monthly retainer',
-          description: 'Support hours',
-          amount: 1000,
-          recurrence: 'monthly' as const,
-        },
-        {
-          name: 'Setup fee',
-          amount: 234,
-          recurrence: 'one_time' as const,
-        },
-      ],
-    };
-
-    const result = await service.createContractFromProposalIntegration(payload);
-
-    expect(result).toEqual({
-      id: 77,
-      code: 'CTR-001',
-    });
-
-    const insertCall = tx.$queryRawUnsafe.mock.calls[2];
-    expect(insertCall[0]).toContain('INSERT INTO operations_contract');
-    expect(insertCall).toContain('crm_proposal');
-    expect(insertCall).toContain('1001');
-
-    expect((service as any).replaceContractParties).toHaveBeenCalledWith(
-      tx,
-      77,
-      [
-        expect.objectContaining({
-          partyRole: 'client',
-          displayName: 'Acme Ltd',
-          isPrimary: true,
-        }),
-      ],
-    );
-    expect((service as any).insertContractHistory).toHaveBeenCalledWith(
-      tx,
-      77,
-      9,
-      'created',
-      'Draft contract generated from CRM proposal P-1001.',
-      expect.any(String),
-    );
-
-    expect(integrationApi.publishEvent).toHaveBeenCalledWith(
-      expect.objectContaining({
-        eventName: 'operations.contract.created',
-        payload: expect.objectContaining({
-          proposalId: 1001,
-          contract: expect.objectContaining({
-            id: 77,
-            originType: 'crm_proposal',
-            originId: '1001',
-            contractType: 'service_agreement',
-          }),
-        }),
-      }),
-      expect.objectContaining({
-        persistenceClient: tx,
-      }),
-    );
-  });
-});
-
-describe('OperationsService quick-entry timesheets', () => {
-  let service: OperationsService;
-
-  beforeEach(() => {
-    service = new OperationsService(
-      {
-        $transaction: jest.fn(),
-      } as any,
-      {} as any,
-      {
-        publishEvent: jest.fn().mockResolvedValue(undefined),
-      } as any,
-      {} as any,
-      {} as any,
-      new OperationsAccessService(),
-    );
-
-    jest.spyOn(service as any, 'getActorContext').mockResolvedValue({
-      userId: 15,
-      roleSlugs: ['operations-collaborator'],
-      collaboratorId: 7,
-      collaboratorName: 'Taylor Tester',
-      isDirector: false,
-      isSupervisor: false,
-      isCollaborator: true,
-      teamCollaboratorIds: [],
-      visibleCollaboratorIds: [7],
-      visibleProjectIds: [11],
-    });
-  });
-
-  afterEach(() => {
-    jest.restoreAllMocks();
-  });
-
-  it('rejects quick entries with non-positive duration', async () => {
-    await expect(
-      service.createTimesheetEntry(15, {
-        projectId: 11,
-        workDate: '2026-04-09',
-        duration: 0,
-        unit: 'minutes',
-      } as any),
-    ).rejects.toThrow(BadRequestException);
-  });
-
-  it('rejects quick entries without a work date', async () => {
-    await expect(
-      service.createTimesheetEntry(15, {
-        projectId: 11,
-        duration: 30,
-        unit: 'minutes',
-      } as any),
-    ).rejects.toThrow(BadRequestException);
-  });
-
-  it('stores quick-entry duration in minutes and keeps hours compatible', async () => {
-    const tx = {
-      $queryRawUnsafe: jest.fn().mockResolvedValue([{ id: 91 }]),
-    };
-
-    (service as any).prisma.$transaction.mockImplementation(
-      async (callback: (client: unknown) => unknown) => callback(tx),
-    );
-
-    jest.spyOn(service as any, 'resolveOwnedProjectAssignment').mockResolvedValue({
-      id: 33,
-      projectId: 11,
-      projectName: 'Project Atlas',
-      projectCode: 'OPS-11',
-      roleLabel: 'Engineer',
-    });
-    jest.spyOn(service as any, 'getOwnedTaskRecord').mockResolvedValue({
-      id: 44,
-      name: 'Implement API',
-      projectAssignmentId: 33,
-      projectId: 11,
-      projectName: 'Project Atlas',
-      projectCode: 'OPS-11',
-    });
-    jest.spyOn(service as any, 'getOrCreateTimesheetForWorkDate').mockResolvedValue(55);
-    jest.spyOn(service as any, 'refreshTimesheetTotal').mockResolvedValue(undefined);
-    jest.spyOn(service as any, 'submitTimesheetForApproval').mockResolvedValue(undefined);
-    jest.spyOn(service as any, 'getTimesheetEntryByIdForActor').mockResolvedValue({
-      id: 91,
-      durationMinutes: 90,
-      hours: 1.5,
-    });
-
-    const result = await service.createTimesheetEntry(15, {
-      projectId: 11,
-      taskId: 44,
-      workDate: '2026-04-09',
-      duration: 1.5,
-      unit: 'hours',
-      description: 'Worked on the API layer',
-    } as any);
-
-    expect(result).toEqual(
-      expect.objectContaining({
-        id: 91,
-        durationMinutes: 90,
-        hours: 1.5,
-      }),
-    );
-    expect(tx.$queryRawUnsafe).toHaveBeenCalledWith(
-      expect.stringContaining('INSERT INTO operations_timesheet_entry'),
-      55,
-      33,
-      44,
-      'Implement API',
-      '2026-04-09',
-      90,
-      1.5,
-      'Worked on the API layer',
-    );
-    expect((service as any).submitTimesheetForApproval).toHaveBeenCalledWith(
-      tx,
-      55,
-      7,
-    );
-  });
-
-  it('uses the task assignment when full timesheet entries omit projectAssignmentId', async () => {
-    const tx = {
-      $queryRawUnsafe: jest.fn().mockResolvedValue([{ id: 55 }]),
-      $executeRawUnsafe: jest.fn().mockResolvedValue(undefined),
-    };
-
-    (service as any).prisma.$transaction.mockImplementation(
-      async (callback: (client: unknown) => unknown) => callback(tx),
-    );
-
-    jest.spyOn(service as any, 'getCollaboratorById').mockResolvedValue({
-      id: 7,
-      supervisorId: 18,
-    });
-    jest.spyOn(service as any, 'getOwnedTaskRecord').mockResolvedValue({
-      id: 44,
-      name: 'Implement API',
-      projectAssignmentId: 33,
-      projectId: 11,
-      projectName: 'Project Atlas',
-      projectCode: 'OPS-11',
-    });
-    jest.spyOn(service as any, 'refreshTimesheetTotal').mockResolvedValue(undefined);
-    jest.spyOn(service as any, 'listSingleTimesheet').mockResolvedValue({
-      id: 55,
-      status: 'draft',
-    });
-
-    await service.createTimesheet(15, {
-      weekStartDate: '2026-04-06',
-      weekEndDate: '2026-04-12',
-      entries: [
-        {
-          taskId: 44,
-          workDate: '2026-04-09',
-          duration: 2,
-          unit: 'hours',
-          description: 'Worked on the API layer',
-        },
-      ],
-    } as any);
-
-    expect(tx.$executeRawUnsafe).toHaveBeenCalledWith(
-      expect.stringContaining('INSERT INTO operations_timesheet_entry'),
-      55,
-      33,
-      44,
-      'Implement API',
-      '2026-04-09',
-      120,
-      2,
-      'Worked on the API layer',
-    );
-  });
-
-  it('rejects submitting a timesheet without a resolved approver', async () => {
-    const tx = {
-      $executeRawUnsafe: jest.fn().mockResolvedValue(undefined),
-      $queryRawUnsafe: jest
-        .fn()
-        .mockResolvedValueOnce([])
-        .mockResolvedValueOnce([{ exists: true }]),
-    };
-
-    (service as any).prisma.$transaction.mockImplementation(
-      async (callback: (client: unknown) => unknown) => callback(tx),
-    );
-
-    jest.spyOn(service as any, 'getTimesheetById').mockResolvedValue({
-      id: 55,
-      collaboratorId: 7,
-      approverCollaboratorId: null,
-      status: 'draft',
-    });
-    jest.spyOn(service as any, 'getCollaboratorById').mockResolvedValue({
-      id: 7,
-      supervisorId: null,
-    });
-    jest.spyOn(service as any, 'listSingleTimesheet').mockResolvedValue({
-      id: 55,
-      status: 'submitted',
-    });
-
-    await expect(service.submitTimesheet(15, 55)).rejects.toThrow(BadRequestException);
-    expect(tx.$executeRawUnsafe).not.toHaveBeenCalled();
-  });
-
-  it('rejects submitting a timesheet without active entries', async () => {
-    const tx = {
-      $executeRawUnsafe: jest.fn().mockResolvedValue(undefined),
-      $queryRawUnsafe: jest
-        .fn()
-        .mockResolvedValueOnce([{ managerCollaboratorId: 18 }])
-        .mockResolvedValueOnce([{ exists: false }]),
-    };
-
-    (service as any).prisma.$transaction.mockImplementation(
-      async (callback: (client: unknown) => unknown) => callback(tx),
-    );
-
-    jest.spyOn(service as any, 'getTimesheetById').mockResolvedValue({
-      id: 56,
-      collaboratorId: 7,
-      approverCollaboratorId: 18,
-      status: 'draft',
-    });
-    jest.spyOn(service as any, 'getCollaboratorById').mockResolvedValue({
-      id: 7,
-      supervisorId: 18,
-    });
-    jest.spyOn(service as any, 'listSingleTimesheet').mockResolvedValue({
-      id: 56,
-      status: 'submitted',
-    });
-
-    await expect(service.submitTimesheet(15, 56)).rejects.toThrow(BadRequestException);
-    expect(tx.$executeRawUnsafe).not.toHaveBeenCalled();
-  });
-
-  it('deletes only draft quick entries and refreshes the weekly total', async () => {
-    const tx = {
-      $executeRawUnsafe: jest.fn().mockResolvedValue(undefined),
-    };
-
-    (service as any).prisma.$transaction.mockImplementation(
-      async (callback: (client: unknown) => unknown) => callback(tx),
-    );
-
-    jest.spyOn(service as any, 'getTimesheetEntryByIdForActor').mockResolvedValue({
-      id: 91,
-      timesheetId: 55,
-      collaboratorId: 7,
-      status: 'draft',
-    });
-    jest.spyOn(service as any, 'refreshTimesheetTotal').mockResolvedValue(undefined);
-
-    await expect(service.removeTimesheetEntry(15, 91)).resolves.toEqual({
-      success: true,
-    });
-
-    expect(tx.$executeRawUnsafe).toHaveBeenCalledWith(
-      expect.stringContaining('UPDATE operations_timesheet_entry'),
-      91,
-    );
-    expect((service as any).refreshTimesheetTotal).toHaveBeenCalledWith(tx, 55);
-  });
-
-  it('updates quick entries and moves them to the correct weekly timesheet', async () => {
-    const tx = {
-      $executeRawUnsafe: jest.fn().mockResolvedValue(undefined),
-      $queryRawUnsafe: jest.fn().mockResolvedValue([]),
-    };
-
-    (service as any).prisma.$transaction.mockImplementation(
-      async (callback: (client: unknown) => unknown) => callback(tx),
-    );
-
-    jest
-      .spyOn(service as any, 'getTimesheetEntryByIdForActor')
-      .mockResolvedValueOnce({
-        id: 93,
-        timesheetId: 55,
-        collaboratorId: 7,
-        projectId: 11,
-        projectAssignmentId: 33,
-        taskId: 44,
-        status: 'draft',
-        weekStartDate: '2026-04-06',
-        weekEndDate: '2026-04-12',
-        workDate: '2026-04-09',
-        hours: 1,
-        durationMinutes: 60,
-      })
-      .mockResolvedValueOnce({
-        id: 93,
-        timesheetId: 77,
-        collaboratorId: 7,
-        projectId: 12,
-        projectAssignmentId: 34,
-        taskId: 45,
-        status: 'draft',
-        weekStartDate: '2026-04-13',
-        weekEndDate: '2026-04-19',
-        workDate: '2026-04-14',
-        hours: 2,
-        durationMinutes: 120,
-        taskName: 'Review backlog',
-      });
-    jest.spyOn(service as any, 'resolveOwnedProjectAssignment').mockResolvedValue({
-      id: 34,
-      projectId: 12,
-      projectName: 'Project Boreal',
-      projectCode: 'OPS-12',
-      roleLabel: 'Engineer',
-    });
-    jest.spyOn(service as any, 'getOwnedTaskRecord').mockResolvedValue({
-      id: 45,
-      name: 'Review backlog',
-      projectAssignmentId: 34,
-      projectId: 12,
-      projectName: 'Project Boreal',
-      projectCode: 'OPS-12',
-    });
-    jest.spyOn(service as any, 'getOrCreateTimesheetForWorkDate').mockResolvedValue(77);
-    jest.spyOn(service as any, 'refreshTimesheetTotal').mockResolvedValue(undefined);
-    jest.spyOn(service as any, 'cleanupEmptyEditableTimesheet').mockResolvedValue(undefined);
-    jest.spyOn(service as any, 'submitTimesheetForApproval').mockResolvedValue(undefined);
-
-    const result = await service.updateTimesheetEntry(15, 93, {
-      projectId: 12,
-      projectAssignmentId: 34,
-      taskId: 45,
-      workDate: '2026-04-14',
-      duration: 2,
-      unit: 'hours',
-      description: 'Backlog refinement',
-    } as any);
-
-    expect(result).toEqual(
-      expect.objectContaining({
-        id: 93,
-        timesheetId: 77,
-      }),
-    );
-    expect(tx.$executeRawUnsafe).toHaveBeenCalledWith(
-      expect.stringContaining('UPDATE operations_timesheet_entry'),
-      77,
-      34,
-      45,
-      'Review backlog',
-      '2026-04-14',
-      120,
-      2,
-      'Backlog refinement',
-      93,
-    );
-    expect((service as any).refreshTimesheetTotal).toHaveBeenCalledWith(tx, 55);
-    expect((service as any).refreshTimesheetTotal).toHaveBeenCalledWith(tx, 77);
-    expect((service as any).cleanupEmptyEditableTimesheet).toHaveBeenCalledWith(
-      tx,
-      55,
-    );
-    expect((service as any).submitTimesheetForApproval).toHaveBeenCalledWith(
-      tx,
-      77,
-      7,
-    );
-  });
-
-  it('allows deleting entries from submitted timesheets until approval', async () => {
-    const tx = {
-      $executeRawUnsafe: jest.fn().mockResolvedValue(undefined),
-    };
-
-    (service as any).prisma.$transaction.mockImplementation(
-      async (callback: (client: unknown) => unknown) => callback(tx),
-    );
-
-    jest.spyOn(service as any, 'getTimesheetEntryByIdForActor').mockResolvedValue({
-      id: 92,
-      timesheetId: 56,
-      collaboratorId: 7,
-      status: 'submitted',
-    });
-    jest.spyOn(service as any, 'refreshTimesheetTotal').mockResolvedValue(undefined);
-    jest.spyOn(service as any, 'cleanupEmptyEditableTimesheet').mockResolvedValue(undefined);
-
-    await expect(service.removeTimesheetEntry(15, 92)).resolves.toEqual({
-      success: true,
-    });
-  });
-
-  it('rejects deleting entries from approved timesheets', async () => {
-    jest.spyOn(service as any, 'getTimesheetEntryByIdForActor').mockResolvedValue({
-      id: 94,
-      timesheetId: 57,
-      collaboratorId: 7,
-      status: 'approved',
-    });
-
-    await expect(service.removeTimesheetEntry(15, 94)).rejects.toThrow(
-      BadRequestException,
-    );
-  });
-});
-
-describe('OperationsService approval side effects', () => {
-  let service: OperationsService;
-
-  beforeEach(() => {
-    service = new OperationsService(
-      {
-        $transaction: jest.fn(),
-      } as any,
-      {} as any,
-      {
-        publishEvent: jest.fn().mockResolvedValue(undefined),
-      } as any,
-      {} as any,
-      {} as any,
-      new OperationsAccessService(),
-    );
-
-    jest.spyOn(service as any, 'getActorContext').mockResolvedValue({
-      userId: 22,
-      roleSlugs: ['admin-operations-supervisor'],
-      collaboratorId: 18,
-      collaboratorName: 'Sam Supervisor',
-      isDirector: false,
-      isSupervisor: true,
-      isCollaborator: false,
-      teamCollaboratorIds: [7],
-      visibleCollaboratorIds: [7, 18],
-      visibleProjectIds: [11],
-    });
-  });
-
-  afterEach(() => {
-    jest.restoreAllMocks();
-  });
-
-  it('applies approved permanent schedule adjustments to the active collaborator weekly schedule', async () => {
-    const tx = {
-      $executeRawUnsafe: jest.fn().mockResolvedValue(undefined),
-      $queryRawUnsafe: jest
-        .fn()
-        .mockResolvedValueOnce([
-          {
-            collaboratorId: 7,
-            requestScope: 'permanent',
-          },
-        ])
-        .mockResolvedValueOnce([
-          {
-            weekday: 'monday',
-            isWorkingDay: true,
-            startTime: '08:00',
-            endTime: '17:00',
-            breakMinutes: 45,
-          },
-          {
-            weekday: 'friday',
-            isWorkingDay: false,
-            startTime: null,
-            endTime: null,
-            breakMinutes: 0,
-          },
-        ]),
-    };
-
-    (service as any).prisma.$transaction.mockImplementation(
-      async (callback: (client: unknown) => unknown) => callback(tx),
-    );
-
-    jest.spyOn(service as any, 'querySingle')
-      .mockResolvedValueOnce({
-        id: 81,
-        targetType: 'schedule_adjustment_request',
-        targetId: 400,
-        requesterCollaboratorId: 7,
-        approverCollaboratorId: 18,
-        status: 'pending',
-      })
-      .mockResolvedValueOnce({
-        id: 81,
-        targetType: 'schedule_adjustment_request',
-        targetId: 400,
-        status: 'approved',
-        decidedAt: '2026-04-11T12:00:00.000Z',
-        decisionNote: 'Approved for the new weekly schedule.',
-      });
-    jest.spyOn(service as any, 'insertApprovalHistory').mockResolvedValue(undefined);
-
-    await expect(
-      service.approve(22, 81, {
-        note: 'Approved for the new weekly schedule.',
-      }),
-    ).resolves.toEqual(
-      expect.objectContaining({
-        id: 81,
-        status: 'approved',
-      }),
-    );
-
-    expect(tx.$executeRawUnsafe).toHaveBeenCalledWith(
-      expect.stringContaining('UPDATE operations_schedule_adjustment_request'),
-      'approved',
-      18,
-      400,
-    );
-    expect(tx.$executeRawUnsafe).toHaveBeenCalledWith(
-      expect.stringContaining('UPDATE operations_collaborator_schedule_day'),
-      7,
-    );
-    expect(tx.$executeRawUnsafe).toHaveBeenCalledWith(
-      expect.stringContaining('INSERT INTO operations_collaborator_schedule_day'),
-      7,
-      'monday',
-      true,
-      '08:00',
-      '17:00',
-      45,
-    );
-    expect(tx.$executeRawUnsafe).toHaveBeenCalledWith(
-      expect.stringContaining('INSERT INTO operations_collaborator_schedule_day'),
-      7,
-      'friday',
-      false,
-      null,
-      null,
-      0,
-    );
-  });
-
-  it('keeps the collaborator weekly schedule unchanged for approved temporary adjustments', async () => {
-    const tx = {
-      $executeRawUnsafe: jest.fn().mockResolvedValue(undefined),
-      $queryRawUnsafe: jest.fn().mockResolvedValueOnce([
-        {
-          collaboratorId: 7,
-          requestScope: 'temporary',
-        },
-      ]),
-    };
-
-    (service as any).prisma.$transaction.mockImplementation(
-      async (callback: (client: unknown) => unknown) => callback(tx),
-    );
-
-    jest.spyOn(service as any, 'querySingle')
-      .mockResolvedValueOnce({
-        id: 82,
-        targetType: 'schedule_adjustment_request',
-        targetId: 401,
-        requesterCollaboratorId: 7,
-        approverCollaboratorId: 18,
-        status: 'pending',
-      })
-      .mockResolvedValueOnce({
-        id: 82,
-        targetType: 'schedule_adjustment_request',
-        targetId: 401,
-        status: 'approved',
-        decidedAt: '2026-04-11T12:05:00.000Z',
-        decisionNote: 'Approved as a temporary exception.',
-      });
-    jest.spyOn(service as any, 'insertApprovalHistory').mockResolvedValue(undefined);
-
-    await service.approve(22, 82, {
-      note: 'Approved as a temporary exception.',
-    });
-
-    expect(tx.$executeRawUnsafe).not.toHaveBeenCalledWith(
-      expect.stringContaining('UPDATE operations_collaborator_schedule_day'),
-      7,
-    );
-  });
-});
+/// <reference types="jest" />
+
+import { BadRequestException } from "@nestjs/common";
+import { OperationsService } from "./operations.service";
+import { OperationsAccessService } from "./services/shared/operations-access.service";
+
+describe("OperationsService proposal integration", () => {
+  let service: OperationsService;
+  let prisma: { $transaction: jest.Mock };
+  let integrationApi: { publishEvent: jest.Mock };
+
+  beforeEach(() => {
+    prisma = {
+      $transaction: jest.fn(),
+    };
+
+    integrationApi = {
+      publishEvent: jest.fn().mockResolvedValue(undefined),
+    };
+
+    service = new OperationsService(
+      prisma as any,
+      {} as any,
+      integrationApi as any,
+      {} as any,
+      {} as any,
+      new OperationsAccessService(),
+    );
+
+    jest
+      .spyOn(service as any, "generateContractCode")
+      .mockResolvedValue("CTR-001");
+    jest
+      .spyOn(service as any, "replaceContractParties")
+      .mockResolvedValue(undefined);
+    jest
+      .spyOn(service as any, "insertContractHistory")
+      .mockResolvedValue(undefined);
+  });
+
+  afterEach(() => {
+    jest.restoreAllMocks();
+  });
+
+  it("throws when proposalId is missing", async () => {
+    await expect(
+      service.createContractFromProposalIntegration({}),
+    ).rejects.toThrow(BadRequestException);
+  });
+
+  it("returns the existing contract when the CRM proposal was already converted", async () => {
+    const tx = {
+      $queryRawUnsafe: jest
+        .fn()
+        .mockResolvedValueOnce([])
+        .mockResolvedValueOnce([{ id: 42, code: "CTR-EXISTING" }]),
+    };
+
+    prisma.$transaction.mockImplementation(
+      async (callback: (client: unknown) => unknown) => callback(tx),
+    );
+
+    const result = await service.createContractFromProposalIntegration({
+      proposalId: 1001,
+      title: "Already converted proposal",
+    });
+
+    expect(result).toEqual({
+      id: 42,
+      code: "CTR-EXISTING",
+    });
+    expect((service as any).generateContractCode).not.toHaveBeenCalled();
+    expect((service as any).replaceContractParties).not.toHaveBeenCalled();
+    expect(integrationApi.publishEvent).not.toHaveBeenCalled();
+  });
+
+  it("creates a draft contract with CRM origin metadata and emits an event", async () => {
+    const tx = {
+      $queryRawUnsafe: jest
+        .fn()
+        .mockResolvedValueOnce([])
+        .mockResolvedValueOnce([])
+        .mockResolvedValueOnce([{ id: 77 }]),
+    };
+
+    prisma.$transaction.mockImplementation(
+      async (callback: (client: unknown) => unknown) => callback(tx),
+    );
+
+    const payload = {
+      proposalId: 1001,
+      proposalRevisionId: 21,
+      personId: 5,
+      approvedByUserId: 9,
+      correlationId: "proposal:1001",
+      code: "P-1001",
+      title: "Implementation Proposal",
+      total: 1234,
+      currency: "USD",
+      locale: "en",
+      commercialTerms: {
+        contractCategory: "client" as const,
+        contractType: "service_agreement" as const,
+        billingModel: "monthly_retainer" as const,
+        validFrom: "2025-01-10",
+        validUntil: "2025-12-31",
+        notes: "Annual support agreement",
+      },
+      person: {
+        id: 5,
+        name: "Acme Contact",
+        tradeName: "Acme Ltd",
+        email: "ops@acme.test",
+        phone: "555-0100",
+        document: "12.345.678/0001-90",
+      },
+      revision: {
+        id: 21,
+        title: "Revision 1",
+        summary: "Approved commercial terms",
+        contentHtml: "<p>draft</p>",
+      },
+      items: [
+        {
+          name: "Monthly retainer",
+          description: "Support hours",
+          amount: 1000,
+          recurrence: "monthly" as const,
+        },
+        {
+          name: "Setup fee",
+          amount: 234,
+          recurrence: "one_time" as const,
+        },
+      ],
+    };
+
+    const result = await service.createContractFromProposalIntegration(payload);
+
+    expect(result).toEqual({
+      id: 77,
+      code: "CTR-001",
+    });
+
+    const insertCall = tx.$queryRawUnsafe.mock.calls[2];
+    expect(insertCall[0]).toContain("INSERT INTO operations_contract");
+    expect(insertCall).toContain("crm_proposal");
+    expect(insertCall).toContain("1001");
+
+    expect((service as any).replaceContractParties).toHaveBeenCalledWith(
+      tx,
+      77,
+      [
+        expect.objectContaining({
+          partyRole: "client",
+          displayName: "Acme Ltd",
+          isPrimary: true,
+        }),
+      ],
+    );
+    expect((service as any).insertContractHistory).toHaveBeenCalledWith(
+      tx,
+      77,
+      9,
+      "created",
+      "Draft contract generated from CRM proposal P-1001.",
+      expect.any(String),
+    );
+
+    expect(integrationApi.publishEvent).toHaveBeenCalledWith(
+      expect.objectContaining({
+        eventName: "operations.contract.created",
+        payload: expect.objectContaining({
+          proposalId: 1001,
+          contract: expect.objectContaining({
+            id: 77,
+            originType: "crm_proposal",
+            originId: "1001",
+            contractType: "service_agreement",
+          }),
+        }),
+      }),
+      expect.objectContaining({
+        persistenceClient: tx,
+      }),
+    );
+  });
+});
+
+describe("OperationsService quick-entry timesheets", () => {
+  let service: OperationsService;
+
+  beforeEach(() => {
+    service = new OperationsService(
+      {
+        $transaction: jest.fn(),
+      } as any,
+      {} as any,
+      {
+        publishEvent: jest.fn().mockResolvedValue(undefined),
+      } as any,
+      {} as any,
+      {} as any,
+      new OperationsAccessService(),
+    );
+
+    jest.spyOn(service as any, "getActorContext").mockResolvedValue({
+      userId: 15,
+      roleSlugs: ["operations-collaborator"],
+      collaboratorId: 7,
+      collaboratorName: "Taylor Tester",
+      isDirector: false,
+      isSupervisor: false,
+      isCollaborator: true,
+      teamCollaboratorIds: [],
+      visibleCollaboratorIds: [7],
+      visibleProjectIds: [11],
+    });
+  });
+
+  afterEach(() => {
+    jest.restoreAllMocks();
+  });
+
+  it("rejects quick entries with non-positive duration", async () => {
+    await expect(
+      service.createTimesheetEntry(15, {
+        projectId: 11,
+        workDate: "2026-04-09",
+        duration: 0,
+        unit: "minutes",
+      } as any),
+    ).rejects.toThrow(BadRequestException);
+  });
+
+  it("rejects quick entries without a work date", async () => {
+    await expect(
+      service.createTimesheetEntry(15, {
+        projectId: 11,
+        duration: 30,
+        unit: "minutes",
+      } as any),
+    ).rejects.toThrow(BadRequestException);
+  });
+
+  it("stores quick-entry duration in minutes and keeps hours compatible", async () => {
+    const tx = {
+      $queryRawUnsafe: jest.fn().mockResolvedValue([{ id: 91 }]),
+    };
+
+    (service as any).prisma.$transaction.mockImplementation(
+      async (callback: (client: unknown) => unknown) => callback(tx),
+    );
+
+    jest
+      .spyOn(service as any, "resolveOwnedProjectAssignment")
+      .mockResolvedValue({
+        id: 33,
+        projectId: 11,
+        projectName: "Project Atlas",
+        projectCode: "OPS-11",
+        roleLabel: "Engineer",
+      });
+    jest.spyOn(service as any, "getOwnedTaskRecord").mockResolvedValue({
+      id: 44,
+      name: "Implement API",
+      projectAssignmentId: 33,
+      projectId: 11,
+      projectName: "Project Atlas",
+      projectCode: "OPS-11",
+    });
+    jest
+      .spyOn(service as any, "getOrCreateTimesheetForWorkDate")
+      .mockResolvedValue(55);
+    jest
+      .spyOn(service as any, "refreshTimesheetTotal")
+      .mockResolvedValue(undefined);
+    jest
+      .spyOn(service as any, "submitTimesheetForApproval")
+      .mockResolvedValue(undefined);
+    jest
+      .spyOn(service as any, "getTimesheetEntryByIdForActor")
+      .mockResolvedValue({
+        id: 91,
+        durationMinutes: 90,
+        hours: 1.5,
+      });
+
+    const result = await service.createTimesheetEntry(15, {
+      projectId: 11,
+      taskId: 44,
+      workDate: "2026-04-09",
+      duration: 1.5,
+      unit: "hours",
+      description: "Worked on the API layer",
+    } as any);
+
+    expect(result).toEqual(
+      expect.objectContaining({
+        id: 91,
+        durationMinutes: 90,
+        hours: 1.5,
+      }),
+    );
+    expect(tx.$queryRawUnsafe).toHaveBeenCalledWith(
+      expect.stringContaining("INSERT INTO operations_timesheet_entry"),
+      55,
+      33,
+      44,
+      "Implement API",
+      "2026-04-09",
+      90,
+      1.5,
+      "Worked on the API layer",
+    );
+    expect((service as any).submitTimesheetForApproval).toHaveBeenCalledWith(
+      tx,
+      55,
+      7,
+    );
+  });
+
+  it("uses the task assignment when full timesheet entries omit projectAssignmentId", async () => {
+    const tx = {
+      $queryRawUnsafe: jest.fn().mockResolvedValue([{ id: 55 }]),
+      $executeRawUnsafe: jest.fn().mockResolvedValue(undefined),
+    };
+
+    (service as any).prisma.$transaction.mockImplementation(
+      async (callback: (client: unknown) => unknown) => callback(tx),
+    );
+
+    jest.spyOn(service as any, "getCollaboratorById").mockResolvedValue({
+      id: 7,
+      supervisorId: 18,
+    });
+    jest.spyOn(service as any, "getOwnedTaskRecord").mockResolvedValue({
+      id: 44,
+      name: "Implement API",
+      projectAssignmentId: 33,
+      projectId: 11,
+      projectName: "Project Atlas",
+      projectCode: "OPS-11",
+    });
+    jest
+      .spyOn(service as any, "refreshTimesheetTotal")
+      .mockResolvedValue(undefined);
+    jest.spyOn(service as any, "listSingleTimesheet").mockResolvedValue({
+      id: 55,
+      status: "draft",
+    });
+
+    await service.createTimesheet(15, {
+      weekStartDate: "2026-04-06",
+      weekEndDate: "2026-04-12",
+      entries: [
+        {
+          taskId: 44,
+          workDate: "2026-04-09",
+          duration: 2,
+          unit: "hours",
+          description: "Worked on the API layer",
+        },
+      ],
+    } as any);
+
+    expect(tx.$executeRawUnsafe).toHaveBeenCalledWith(
+      expect.stringContaining("INSERT INTO operations_timesheet_entry"),
+      55,
+      33,
+      44,
+      "Implement API",
+      "2026-04-09",
+      120,
+      2,
+      "Worked on the API layer",
+    );
+  });
+
+  it("rejects submitting a timesheet without a resolved approver", async () => {
+    const tx = {
+      $executeRawUnsafe: jest.fn().mockResolvedValue(undefined),
+      $queryRawUnsafe: jest
+        .fn()
+        .mockResolvedValueOnce([])
+        .mockResolvedValueOnce([{ exists: true }]),
+    };
+
+    (service as any).prisma.$transaction.mockImplementation(
+      async (callback: (client: unknown) => unknown) => callback(tx),
+    );
+
+    jest.spyOn(service as any, "getTimesheetById").mockResolvedValue({
+      id: 55,
+      collaboratorId: 7,
+      approverCollaboratorId: null,
+      status: "draft",
+    });
+    jest.spyOn(service as any, "getCollaboratorById").mockResolvedValue({
+      id: 7,
+      supervisorId: null,
+    });
+    jest.spyOn(service as any, "listSingleTimesheet").mockResolvedValue({
+      id: 55,
+      status: "submitted",
+    });
+
+    await expect(service.submitTimesheet(15, 55)).rejects.toThrow(
+      BadRequestException,
+    );
+    expect(tx.$executeRawUnsafe).not.toHaveBeenCalled();
+  });
+
+  it("rejects submitting a timesheet without active entries", async () => {
+    const tx = {
+      $executeRawUnsafe: jest.fn().mockResolvedValue(undefined),
+      $queryRawUnsafe: jest
+        .fn()
+        .mockResolvedValueOnce([{ managerCollaboratorId: 18 }])
+        .mockResolvedValueOnce([{ exists: false }]),
+    };
+
+    (service as any).prisma.$transaction.mockImplementation(
+      async (callback: (client: unknown) => unknown) => callback(tx),
+    );
+
+    jest.spyOn(service as any, "getTimesheetById").mockResolvedValue({
+      id: 56,
+      collaboratorId: 7,
+      approverCollaboratorId: 18,
+      status: "draft",
+    });
+    jest.spyOn(service as any, "getCollaboratorById").mockResolvedValue({
+      id: 7,
+      supervisorId: 18,
+    });
+    jest.spyOn(service as any, "listSingleTimesheet").mockResolvedValue({
+      id: 56,
+      status: "submitted",
+    });
+
+    await expect(service.submitTimesheet(15, 56)).rejects.toThrow(
+      BadRequestException,
+    );
+    expect(tx.$executeRawUnsafe).not.toHaveBeenCalled();
+  });
+
+  it("deletes only draft quick entries and refreshes the weekly total", async () => {
+    const tx = {
+      $executeRawUnsafe: jest.fn().mockResolvedValue(undefined),
+      $queryRawUnsafe: jest.fn().mockResolvedValue([]),
+    };
+
+    (service as any).prisma.$transaction.mockImplementation(
+      async (callback: (client: unknown) => unknown) => callback(tx),
+    );
+
+    jest
+      .spyOn(service as any, "getTimesheetEntryByIdForActor")
+      .mockResolvedValue({
+        id: 91,
+        timesheetId: 55,
+        collaboratorId: 7,
+        status: "draft",
+      });
+    jest
+      .spyOn(service as any, "refreshTimesheetTotal")
+      .mockResolvedValue(undefined);
+
+    await expect(service.removeTimesheetEntry(15, 91)).resolves.toEqual({
+      success: true,
+    });
+
+    expect(tx.$executeRawUnsafe).toHaveBeenCalledWith(
+      expect.stringContaining("UPDATE operations_timesheet_entry"),
+      91,
+    );
+    expect((service as any).refreshTimesheetTotal).toHaveBeenCalledWith(tx, 55);
+  });
+
+  it("updates quick entries and moves them to the correct weekly timesheet", async () => {
+    const tx = {
+      $executeRawUnsafe: jest.fn().mockResolvedValue(undefined),
+      $queryRawUnsafe: jest.fn().mockResolvedValue([]),
+    };
+
+    (service as any).prisma.$transaction.mockImplementation(
+      async (callback: (client: unknown) => unknown) => callback(tx),
+    );
+
+    jest
+      .spyOn(service as any, "getTimesheetEntryByIdForActor")
+      .mockResolvedValueOnce({
+        id: 93,
+        timesheetId: 55,
+        collaboratorId: 7,
+        projectId: 11,
+        projectAssignmentId: 33,
+        taskId: 44,
+        status: "draft",
+        weekStartDate: "2026-04-06",
+        weekEndDate: "2026-04-12",
+        workDate: "2026-04-09",
+        hours: 1,
+        durationMinutes: 60,
+      })
+      .mockResolvedValueOnce({
+        id: 93,
+        timesheetId: 77,
+        collaboratorId: 7,
+        projectId: 12,
+        projectAssignmentId: 34,
+        taskId: 45,
+        status: "draft",
+        weekStartDate: "2026-04-13",
+        weekEndDate: "2026-04-19",
+        workDate: "2026-04-14",
+        hours: 2,
+        durationMinutes: 120,
+        taskName: "Review backlog",
+      });
+    jest
+      .spyOn(service as any, "resolveOwnedProjectAssignment")
+      .mockResolvedValue({
+        id: 34,
+        projectId: 12,
+        projectName: "Project Boreal",
+        projectCode: "OPS-12",
+        roleLabel: "Engineer",
+      });
+    jest.spyOn(service as any, "getOwnedTaskRecord").mockResolvedValue({
+      id: 45,
+      name: "Review backlog",
+      projectAssignmentId: 34,
+      projectId: 12,
+      projectName: "Project Boreal",
+      projectCode: "OPS-12",
+    });
+    jest
+      .spyOn(service as any, "getOrCreateTimesheetForWorkDate")
+      .mockResolvedValue(77);
+    jest
+      .spyOn(service as any, "refreshTimesheetTotal")
+      .mockResolvedValue(undefined);
+    jest
+      .spyOn(service as any, "cleanupEmptyEditableTimesheet")
+      .mockResolvedValue(undefined);
+    jest
+      .spyOn(service as any, "submitTimesheetForApproval")
+      .mockResolvedValue(undefined);
+
+    const result = await service.updateTimesheetEntry(15, 93, {
+      projectId: 12,
+      projectAssignmentId: 34,
+      taskId: 45,
+      workDate: "2026-04-14",
+      duration: 2,
+      unit: "hours",
+      description: "Backlog refinement",
+    } as any);
+
+    expect(result).toEqual(
+      expect.objectContaining({
+        id: 93,
+        timesheetId: 77,
+      }),
+    );
+    expect(tx.$executeRawUnsafe).toHaveBeenCalledWith(
+      expect.stringContaining("UPDATE operations_timesheet_entry"),
+      77,
+      34,
+      45,
+      "Review backlog",
+      "2026-04-14",
+      120,
+      2,
+      "Backlog refinement",
+      93,
+    );
+    expect((service as any).refreshTimesheetTotal).toHaveBeenCalledWith(tx, 55);
+    expect((service as any).refreshTimesheetTotal).toHaveBeenCalledWith(tx, 77);
+    expect((service as any).cleanupEmptyEditableTimesheet).toHaveBeenCalledWith(
+      tx,
+      55,
+    );
+    expect((service as any).submitTimesheetForApproval).toHaveBeenCalledWith(
+      tx,
+      77,
+      7,
+    );
+  });
+
+  it("allows deleting entries from submitted timesheets until approval", async () => {
+    const tx = {
+      $executeRawUnsafe: jest.fn().mockResolvedValue(undefined),
+    };
+
+    (service as any).prisma.$transaction.mockImplementation(
+      async (callback: (client: unknown) => unknown) => callback(tx),
+    );
+
+    jest
+      .spyOn(service as any, "getTimesheetEntryByIdForActor")
+      .mockResolvedValue({
+        id: 92,
+        timesheetId: 56,
+        collaboratorId: 7,
+        status: "submitted",
+      });
+    jest
+      .spyOn(service as any, "refreshTimesheetTotal")
+      .mockResolvedValue(undefined);
+    jest
+      .spyOn(service as any, "cleanupEmptyEditableTimesheet")
+      .mockResolvedValue(undefined);
+
+    await expect(service.removeTimesheetEntry(15, 92)).resolves.toEqual({
+      success: true,
+    });
+  });
+
+  it("rejects deleting entries from approved timesheets", async () => {
+    jest
+      .spyOn(service as any, "getTimesheetEntryByIdForActor")
+      .mockResolvedValue({
+        id: 94,
+        timesheetId: 57,
+        collaboratorId: 7,
+        status: "approved",
+      });
+
+    await expect(service.removeTimesheetEntry(15, 94)).rejects.toThrow(
+      BadRequestException,
+    );
+  });
+});
+
+describe("OperationsService task column activity", () => {
+  let service: OperationsService;
+  let prisma: { $transaction: jest.Mock };
+  let integrationApi: { publishEvent: jest.Mock };
+
+  const baseTask = {
+    id: 44,
+    name: "Implement board",
+    description: null,
+    priority: "medium",
+    status: "todo",
+    dueDate: null,
+    estimateHours: null,
+    position: 0,
+    tags: null,
+    assigneeCollaboratorId: null,
+    projectAssignmentId: null,
+    projectId: 11,
+    projectName: "Project Atlas",
+    projectCode: "OPS-11",
+    doingStartedAt: null,
+    totalDoingMinutes: 0,
+    deletedAt: null,
+  };
+
+  beforeEach(() => {
+    prisma = {
+      $transaction: jest.fn(),
+    };
+    integrationApi = {
+      publishEvent: jest.fn().mockResolvedValue(undefined),
+    };
+    service = new OperationsService(
+      prisma as any,
+      {} as any,
+      integrationApi as any,
+      {} as any,
+      {} as any,
+      new OperationsAccessService(),
+    );
+
+    jest.spyOn(service as any, "getActorContext").mockResolvedValue({
+      userId: 15,
+      roleSlugs: ["operations-collaborator"],
+      collaboratorId: 7,
+      collaboratorName: "Taylor Tester",
+      isDirector: false,
+      isSupervisor: false,
+      isCollaborator: true,
+      teamCollaboratorIds: [],
+      visibleCollaboratorIds: [7],
+      visibleProjectIds: [11],
+    });
+    jest
+      .spyOn(service as any, "assertProjectAccess")
+      .mockResolvedValue(undefined);
+    jest.spyOn(service as any, "getProjectBoardTask").mockResolvedValue({
+      ...baseTask,
+      assigneeCollaboratorId: 7,
+      status: "doing",
+    });
+  });
+
+  afterEach(() => {
+    jest.restoreAllMocks();
+  });
+
+  function mockTransaction() {
+    const tx = {
+      $executeRawUnsafe: jest.fn().mockResolvedValue(undefined),
+    };
+    prisma.$transaction.mockImplementation(
+      async (callback: (client: unknown) => unknown) => callback(tx),
+    );
+    return tx;
+  }
+
+  it("records todo to doing and auto-assigns the actor", async () => {
+    const tx = mockTransaction();
+    jest
+      .spyOn(service as any, "getTaskRecordForActor")
+      .mockResolvedValue(baseTask);
+
+    await service.updateTask(15, 44, { status: "doing" } as any);
+
+    expect(tx.$executeRawUnsafe).toHaveBeenCalledTimes(2);
+    expect(tx.$executeRawUnsafe.mock.calls[0][0]).toContain(
+      "doing_started_at = CASE",
+    );
+    expect(tx.$executeRawUnsafe.mock.calls[0][3]).toBe(7);
+    expect(tx.$executeRawUnsafe.mock.calls[0][15]).toBe(true);
+    expect(tx.$executeRawUnsafe.mock.calls[0][16]).toBe(false);
+    expect(tx.$executeRawUnsafe.mock.calls[1][0]).toContain(
+      "INSERT INTO operations_task_activity",
+    );
+    expect(tx.$executeRawUnsafe.mock.calls[1].slice(1)).toEqual([
+      44,
+      7,
+      "status_changed",
+      "todo",
+      "doing",
+    ]);
+  });
+
+  it("records doing to review and closes accumulated doing minutes", async () => {
+    const tx = mockTransaction();
+    jest.spyOn(service as any, "getTaskRecordForActor").mockResolvedValue({
+      ...baseTask,
+      status: "doing",
+      assigneeCollaboratorId: 9,
+      doingStartedAt: "2026-05-16T10:00:00.000Z",
+      totalDoingMinutes: 15,
+    });
+
+    await service.updateTask(15, 44, { status: "review" } as any);
+
+    expect(tx.$executeRawUnsafe).toHaveBeenCalledTimes(2);
+    expect(tx.$executeRawUnsafe.mock.calls[0][3]).toBe(9);
+    expect(tx.$executeRawUnsafe.mock.calls[0][15]).toBe(false);
+    expect(tx.$executeRawUnsafe.mock.calls[0][16]).toBe(true);
+    expect(tx.$executeRawUnsafe.mock.calls[1].slice(1)).toEqual([
+      44,
+      7,
+      "status_changed",
+      "doing",
+      "review",
+    ]);
+  });
+
+  it("blocks moving advanced without a linked collaborator when no assignee exists", async () => {
+    prisma.$transaction.mockImplementation(
+      async (callback: (client: unknown) => unknown) =>
+        callback({ $executeRawUnsafe: jest.fn() }),
+    );
+    jest.spyOn(service as any, "getActorContext").mockResolvedValue({
+      userId: 15,
+      roleSlugs: ["admin"],
+      collaboratorId: null,
+      collaboratorName: null,
+      isDirector: true,
+      isSupervisor: true,
+      isCollaborator: true,
+      teamCollaboratorIds: [],
+      visibleCollaboratorIds: [],
+      visibleProjectIds: [],
+    });
+    jest
+      .spyOn(service as any, "getTaskRecordForActor")
+      .mockResolvedValue(baseTask);
+
+    await expect(
+      service.updateTask(15, 44, { status: "review" } as any),
+    ).rejects.toThrow(BadRequestException);
+  });
+
+  it("does not create activity when the status does not change", async () => {
+    const tx = mockTransaction();
+    jest
+      .spyOn(service as any, "getTaskRecordForActor")
+      .mockResolvedValue(baseTask);
+
+    await service.updateTask(15, 44, { status: "todo" } as any);
+
+    expect(tx.$executeRawUnsafe).toHaveBeenCalledTimes(1);
+    expect(tx.$executeRawUnsafe.mock.calls[0][15]).toBe(false);
+    expect(tx.$executeRawUnsafe.mock.calls[0][16]).toBe(false);
+  });
+});
+
+describe("OperationsService approval side effects", () => {
+  let service: OperationsService;
+
+  beforeEach(() => {
+    service = new OperationsService(
+      {
+        $transaction: jest.fn(),
+      } as any,
+      {} as any,
+      {
+        publishEvent: jest.fn().mockResolvedValue(undefined),
+      } as any,
+      {} as any,
+      {} as any,
+      new OperationsAccessService(),
+    );
+
+    jest.spyOn(service as any, "getActorContext").mockResolvedValue({
+      userId: 22,
+      roleSlugs: ["admin-operations-supervisor"],
+      collaboratorId: 18,
+      collaboratorName: "Sam Supervisor",
+      isDirector: false,
+      isSupervisor: true,
+      isCollaborator: false,
+      teamCollaboratorIds: [7],
+      visibleCollaboratorIds: [7, 18],
+      visibleProjectIds: [11],
+    });
+  });
+
+  afterEach(() => {
+    jest.restoreAllMocks();
+  });
+
+  it("applies approved permanent schedule adjustments to the active collaborator weekly schedule", async () => {
+    const tx = {
+      $executeRawUnsafe: jest.fn().mockResolvedValue(undefined),
+      $queryRawUnsafe: jest
+        .fn()
+        .mockResolvedValueOnce([
+          {
+            collaboratorId: 7,
+            requestScope: "permanent",
+          },
+        ])
+        .mockResolvedValueOnce([
+          {
+            weekday: "monday",
+            isWorkingDay: true,
+            startTime: "08:00",
+            endTime: "17:00",
+            breakMinutes: 45,
+          },
+          {
+            weekday: "friday",
+            isWorkingDay: false,
+            startTime: null,
+            endTime: null,
+            breakMinutes: 0,
+          },
+        ]),
+    };
+
+    (service as any).prisma.$transaction.mockImplementation(
+      async (callback: (client: unknown) => unknown) => callback(tx),
+    );
+
+    jest
+      .spyOn(service as any, "querySingle")
+      .mockResolvedValueOnce({
+        id: 81,
+        targetType: "schedule_adjustment_request",
+        targetId: 400,
+        requesterCollaboratorId: 7,
+        approverCollaboratorId: 18,
+        status: "pending",
+      })
+      .mockResolvedValueOnce({
+        id: 81,
+        targetType: "schedule_adjustment_request",
+        targetId: 400,
+        status: "approved",
+        decidedAt: "2026-04-11T12:00:00.000Z",
+        decisionNote: "Approved for the new weekly schedule.",
+      });
+    jest
+      .spyOn(service as any, "insertApprovalHistory")
+      .mockResolvedValue(undefined);
+
+    await expect(
+      service.approve(22, 81, {
+        note: "Approved for the new weekly schedule.",
+      }),
+    ).resolves.toEqual(
+      expect.objectContaining({
+        id: 81,
+        status: "approved",
+      }),
+    );
+
+    expect(tx.$executeRawUnsafe).toHaveBeenCalledWith(
+      expect.stringContaining("UPDATE operations_schedule_adjustment_request"),
+      "approved",
+      18,
+      400,
+    );
+    expect(tx.$executeRawUnsafe).toHaveBeenCalledWith(
+      expect.stringContaining("UPDATE operations_collaborator_schedule_day"),
+      7,
+    );
+    expect(tx.$executeRawUnsafe).toHaveBeenCalledWith(
+      expect.stringContaining(
+        "INSERT INTO operations_collaborator_schedule_day",
+      ),
+      7,
+      "monday",
+      true,
+      "08:00",
+      "17:00",
+      45,
+    );
+    expect(tx.$executeRawUnsafe).toHaveBeenCalledWith(
+      expect.stringContaining(
+        "INSERT INTO operations_collaborator_schedule_day",
+      ),
+      7,
+      "friday",
+      false,
+      null,
+      null,
+      0,
+    );
+  });
+
+  it("keeps the collaborator weekly schedule unchanged for approved temporary adjustments", async () => {
+    const tx = {
+      $executeRawUnsafe: jest.fn().mockResolvedValue(undefined),
+      $queryRawUnsafe: jest.fn().mockResolvedValueOnce([
+        {
+          collaboratorId: 7,
+          requestScope: "temporary",
+        },
+      ]),
+    };
+
+    (service as any).prisma.$transaction.mockImplementation(
+      async (callback: (client: unknown) => unknown) => callback(tx),
+    );
+
+    jest
+      .spyOn(service as any, "querySingle")
+      .mockResolvedValueOnce({
+        id: 82,
+        targetType: "schedule_adjustment_request",
+        targetId: 401,
+        requesterCollaboratorId: 7,
+        approverCollaboratorId: 18,
+        status: "pending",
+      })
+      .mockResolvedValueOnce({
+        id: 82,
+        targetType: "schedule_adjustment_request",
+        targetId: 401,
+        status: "approved",
+        decidedAt: "2026-04-11T12:05:00.000Z",
+        decisionNote: "Approved as a temporary exception.",
+      });
+    jest
+      .spyOn(service as any, "insertApprovalHistory")
+      .mockResolvedValue(undefined);
+
+    await service.approve(22, 82, {
+      note: "Approved as a temporary exception.",
+    });
+
+    expect(tx.$executeRawUnsafe).not.toHaveBeenCalledWith(
+      expect.stringContaining("UPDATE operations_collaborator_schedule_day"),
+      7,
+    );
+  });
+});