@hed-hog/operations 0.0.332 → 0.0.338

package/src/operations.service.spec.ts

@@ -1,988 +1,1006 @@
-/// <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,
-    );
-  });
-});
+/// <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][0]).toContain(
+      '$3::"operations_task_activity_action_bd50457330_enum"',
+    );
+    expect(tx.$executeRawUnsafe.mock.calls[1][0]).toContain(
+      '$4::"operations_task_activity_from_status_3a69262de6_enum"',
+    );
+    expect(tx.$executeRawUnsafe.mock.calls[1][0]).toContain(
+      '$5::"operations_task_activity_to_status_1fd99321c8_enum"',
+    );
+    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][0]).toContain(
+      '$3::"operations_task_activity_action_bd50457330_enum"',
+    );
+    expect(tx.$executeRawUnsafe.mock.calls[1][0]).toContain(
+      '$4::"operations_task_activity_from_status_3a69262de6_enum"',
+    );
+    expect(tx.$executeRawUnsafe.mock.calls[1][0]).toContain(
+      '$5::"operations_task_activity_to_status_1fd99321c8_enum"',
+    );
+    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,
+    );
+  });
+});