contrat nad booking modification

2026-08-26 18:42:49 +00:00 · 2026-07-20 12:24:58 +00:00
parent eb532399d9
commit b90afadfba
55 changed files with 1210 additions and 1373 deletions
--- a/apps/edr-freight-api/src/common/freight-permission.util.ts
+++ b/apps/edr-freight-api/src/common/freight-permission.util.ts
@@ -7,16 +7,23 @@ const SUPER_ADMIN_ROLE = 'super_admin';
 const ORGANIZATION_ADMIN_ROLE = 'organization_admin';

 type PermissionLike = { key?: string };
+type PositionTypeLike = { key?: string };
 type MeLikeUser = {
  roles?: { key?: string }[];
  permissions?: PermissionLike[];
  employee?:
    | {
-        position?: { permissions?: PermissionLike[] };
+        position?: {
+          permissions?: PermissionLike[];
+          positionType?: PositionTypeLike | null;
+        };
        delegatedPositions?: { permissions?: PermissionLike[] }[];
      }
    | {
-        positions?: { permissions?: PermissionLike[] }[];
+        positions?: {
+          permissions?: PermissionLike[];
+          positionType?: PositionTypeLike | null;
+        }[];
      }[]
    | null;
 };
@@ -90,12 +97,110 @@ export function assertFreightPermission(
  throw new ForbiddenException(`Missing permission: ${permissionKey}`);
 }

+/**
+ * The caller's IAM position-type keys (`iam.position_types.key`). A position
+ * type is the platform's notion of a role — it is what carries permissions via
+ * `iam.position_type_permissions` — and it is the vocabulary contract approval
+ * chains are configured in.
+ *
+ * Mirrors `collectPermissionKeys`' handling of both JWT shapes: `employee` is
+ * an object on some tokens and an array on others.
+ *
+ * Note delegated positions carry no `positionType` in the token, so a delegate
+ * is not reachable here — they authorize through the permission arm of
+ * `assertCanApproveContractStep` instead.
+ */
+export function collectPositionTypeKeys(
+  user: MeLikeUser | null | undefined,
+): string[] {
+  const employee = user?.employee;
+  if (!employee) return [];
+
+  const keys = new Set<string>();
+
+  if (Array.isArray(employee)) {
+    for (const emp of employee) {
+      for (const pos of emp.positions ?? []) {
+        if (pos.positionType?.key) keys.add(pos.positionType.key);
+      }
+    }
+    return [...keys];
+  }
+
+  if (employee.position?.positionType?.key) {
+    keys.add(employee.position.positionType.key);
+  }
+  return [...keys];
+}
+
+/**
+ * Legacy chain roles predate position types. Historical `approval_rules` and
+ * in-flight `contract_approval_steps` rows still carry them, so map each to the
+ * position types that stand in for it. Without this, an approver holding a
+ * modern position type could not action an older step.
+ */
+const LEGACY_ROLE_POSITION_TYPES: Record<string, string[]> = {
+  LINE_STAFF: ['employee', 'teamLeader', 'officeHead', 'recordOfficer'],
+  DIRECTOR: ['director', 'operation-director'],
+  CEO: ['chief', 'deputy'],
+};
+
 const APPROVE_ROLE_PERMISSION: Record<string, string> = {
  LINE_STAFF: FREIGHT_PERMS.bookings.approveLineStaff,
  DIRECTOR: FREIGHT_PERMS.bookings.approveDirector,
  CEO: FREIGHT_PERMS.bookings.approveCeo,
 };

+const CONTRACT_APPROVE_ROLE_PERMISSION: Record<string, string> = {
+  LINE_STAFF: FREIGHT_PERMS.contracts.approveLineStaff,
+  DIRECTOR: FREIGHT_PERMS.contracts.approveDirector,
+  CEO: FREIGHT_PERMS.contracts.approveCeo,
+};
+
+const ANY_CONTRACT_APPROVE_PERMISSION = [
+  FREIGHT_PERMS.contracts.approveLineStaff,
+  FREIGHT_PERMS.contracts.approveDirector,
+  FREIGHT_PERMS.contracts.approveCeo,
+];
+
+/**
+ * May this caller action a contract approval step requiring `requiredRole`?
+ *
+ * `requiredRole` is an `iam.position_types.key` for chains configured by an
+ * admin, or one of the legacy LINE_STAFF/DIRECTOR/CEO strings for older rows.
+ * A caller passes when any of these hold:
+ *
+ *  - they are a super/organization admin (blanket bypass);
+ *  - their position type matches the step, directly or via a legacy alias;
+ *  - they hold the approve permission the legacy role maps to;
+ *  - they hold any contract approve permission — this covers delegates (whose
+ *    position type is absent from the token) and staff whose IAM position has
+ *    no position type assigned yet.
+ */
+export function assertCanApproveContractStep(
+  user: TCurrentUser | MeLikeUser | null | undefined,
+  requiredRole: string,
+): void {
+  if (isFreightApprovalAdmin(user)) return;
+
+  const positionTypes = collectPositionTypeKeys(user);
+  if (positionTypes.includes(requiredRole)) return;
+
+  const aliases = LEGACY_ROLE_POSITION_TYPES[requiredRole] ?? [];
+  if (aliases.some((alias) => positionTypes.includes(alias))) return;
+
+  const legacyPermission = CONTRACT_APPROVE_ROLE_PERMISSION[requiredRole];
+  if (legacyPermission && hasFreightPermission(user, legacyPermission)) return;
+
+  if (ANY_CONTRACT_APPROVE_PERMISSION.some((p) => hasFreightPermission(user, p))) {
+    return;
+  }
+
+  throw new ForbiddenException(
+    `You are not the required approver (${requiredRole}) for this step.`,
+  );
+}
+
 export function assertCanApproveBookingStep(
  user: TCurrentUser | MeLikeUser | null | undefined,
  requiredRole: string,
--- a/apps/edr-freight-api/src/migrations/2410000000000-DropBookingApprovalWidenRoles.ts
+++ b/apps/edr-freight-api/src/migrations/2410000000000-DropBookingApprovalWidenRoles.ts
@@ -0,0 +1,43 @@
+import { MigrationInterface, QueryRunner } from 'typeorm';
+
+/**
+ * Bookings no longer run an approval chain — accepting an intake approves the
+ * booking outright and generates its contract. The approval chain is now a
+ * contract-only concern, so `freight.approval_rules` is read by contracts alone.
+ *
+ * Also widens the role columns: chain steps now reference IAM position-type
+ * keys (`iam.position_types.key`), and real keys run past the old varchar(30)
+ * (e.g. '-marketing-manager-/-general-manager' is 38 chars), which would fail
+ * on insert.
+ */
+export class DropBookingApprovalWidenRoles2410000000000
+  implements MigrationInterface
+{
+  name = 'DropBookingApprovalWidenRoles2410000000000';
+
+  public async up(queryRunner: QueryRunner): Promise<void> {
+    await queryRunner.query(
+      `DROP TABLE IF EXISTS freight.booking_approval_step;`,
+    );
+
+    for (const [table, column] of [
+      ['approval_rules', 'required_role'],
+      ['approval_rules', 'blocks_role'],
+      ['contract_approval_steps', 'required_role'],
+      ['contract_approval_steps', 'blocks_role'],
+    ] as const) {
+      await queryRunner.query(
+        `ALTER TABLE freight.${table} ALTER COLUMN ${column} TYPE varchar(64);`,
+      );
+    }
+  }
+
+  /**
+   * No-op: the booking approval chain is retired, so re-creating the table
+   * would leave dead schema behind. Narrowing the role columns again would
+   * truncate any position-type key already stored.
+   */
+  public async down(): Promise<void> {
+    // intentionally empty
+  }
+}
--- a/apps/edr-freight-api/src/migrations/2420000000000-CreateContractDocumentRevisions.ts
+++ b/apps/edr-freight-api/src/migrations/2420000000000-CreateContractDocumentRevisions.ts
@@ -0,0 +1,40 @@
+import { MigrationInterface, QueryRunner } from 'typeorm';
+
+/**
+ * Audit trail for contract document edits. The document stays editable through
+ * the whole approval chain (each approver may edit on their turn), so the
+ * contract itself only ever holds the current snapshot — this table records who
+ * changed which article, and when.
+ */
+export class CreateContractDocumentRevisions2420000000000
+  implements MigrationInterface
+{
+  name = 'CreateContractDocumentRevisions2420000000000';
+
+  public async up(queryRunner: QueryRunner): Promise<void> {
+    await queryRunner.query(`
+      CREATE TABLE IF NOT EXISTS freight.contract_document_revisions (
+        id uuid PRIMARY KEY DEFAULT gen_random_uuid(),
+        created_at timestamptz NOT NULL DEFAULT now(),
+        updated_at timestamptz NOT NULL DEFAULT now(),
+        deleted_at timestamptz,
+        contract_id uuid NOT NULL REFERENCES freight.contracts(id) ON DELETE CASCADE,
+        actor_id uuid,
+        actor_role varchar(64),
+        step_id uuid,
+        summary varchar(255),
+        changes jsonb NOT NULL DEFAULT '[]'::jsonb
+      );
+    `);
+    await queryRunner.query(`
+      CREATE INDEX IF NOT EXISTS idx_contract_document_revisions_contract
+        ON freight.contract_document_revisions (contract_id, created_at DESC);
+    `);
+  }
+
+  public async down(queryRunner: QueryRunner): Promise<void> {
+    await queryRunner.query(
+      `DROP TABLE IF EXISTS freight.contract_document_revisions;`,
+    );
+  }
+}
--- a/apps/edr-freight-api/src/modules/bookings/booking-next-step.util.ts
+++ b/apps/edr-freight-api/src/modules/bookings/booking-next-step.util.ts
@@ -1,4 +1,3 @@
-import { BookingApprovalStep } from './entities/booking-approval-step.entity';
 import { Booking } from './entities/booking.entity';

 export interface BookingNextStep {
@@ -9,7 +8,11 @@ export interface BookingNextStep {

 export function computeNextStep(
  booking: Pick<Booking, 'status' | 'paymentCurrency'>,
-  nextPendingStep?: Pick<BookingApprovalStep, 'requiredRole' | 'stepOrder'> | null,
+  /**
+   * Retained for call-site compatibility — bookings no longer run an approval
+   * chain, so this is always null. Approvals are a contract-only concern.
+   */
+  nextPendingStep?: { requiredRole: string; stepOrder: number } | null,
 ): BookingNextStep | null {
  const { status } = booking;

--- a/apps/edr-freight-api/src/modules/bookings/booking-transition.accept.spec.ts
+++ b/apps/edr-freight-api/src/modules/bookings/booking-transition.accept.spec.ts
@@ -22,14 +22,17 @@ describe('BookingTransitionService — acceptIntake validity window', () => {
      findById: jest.fn().mockResolvedValue(booking),
    };
    const ruleEngineService = {
-      instantiateApprovalSteps: jest.fn().mockResolvedValue([]),
+      assertNoHardBlocks: jest.fn(),
+    };
+    const contractService = {
+      generateContract: jest.fn().mockResolvedValue({ id: 'b-1' }),
    };

    const service = new BookingTransitionService(
      bookingsRepository as never,
      ruleEngineService as never,
      {} as never, // pricingService
-      {} as never, // contractService
+      contractService as never,
      {} as never, // filesService
      {} as never, // fileUploadSettingsService
      {} as never, // bookingBatchService
@@ -57,7 +60,7 @@ describe('BookingTransitionService — acceptIntake validity window', () => {
        dutySlipUploadedToStaff: jest.fn(),
      } as never, // notifier
    );
-    return { service, bookingsRepository, ruleEngineService };
+    return { service, bookingsRepository, ruleEngineService, contractService };
  }

  it('rejects accept when validity days is missing or non-positive', async () => {
@@ -81,7 +84,7 @@ describe('BookingTransitionService — acceptIntake validity window', () => {
    const [id, updates] = bookingsRepository.update.mock.calls[0];
    expect(id).toBe('b-1');
    expect(updates).toMatchObject({
-      status: 'PENDING_APPROVAL',
+      status: 'APPROVED',
      approvedByStaffId: 'staff-1',
      contractValidityDays: 10,
    });
@@ -96,12 +99,9 @@ describe('BookingTransitionService — acceptIntake validity window', () => {
    expect((updates.approvedByStaffAt as Date).getTime()).toBe(from.getTime());
  });

-  it('instantiates the approval chain when accepting', async () => {
-    const { service, ruleEngineService } = makeService();
+  it('approves outright and generates the contract (no approval chain)', async () => {
+    const { service, contractService } = makeService();
    await service.acceptIntake('b-1', 'staff-1', 30);
-    expect(ruleEngineService.instantiateApprovalSteps).toHaveBeenCalledWith(
-      'b-1',
-      expect.objectContaining({ freightType: 'CONTAINER' }),
-    );
+    expect(contractService.generateContract).toHaveBeenCalledWith('b-1');
  });
 });
--- a/apps/edr-freight-api/src/modules/bookings/booking-transition.service.ts
+++ b/apps/edr-freight-api/src/modules/bookings/booking-transition.service.ts
@@ -7,9 +7,7 @@ import {
  Logger,
  Optional,
 } from "@nestjs/common";
-import type { TCurrentUser } from "@tria-plc/api-common/modules/auth/types/current-user.type";

-import { assertCanApproveBookingStep } from '../../common/freight-permission.util';
 import { BookingBatchService } from '../train-scheduling/booking-batch.service';
 import { eatDay } from '../train-scheduling/batch-window.util';
 import { isRoadService } from './road.util';
@@ -248,16 +246,6 @@ export class BookingTransitionService {
    return fresh;
  }

-  /** Auto-create booking approval steps from system rules when none exist yet. */
-  private async ensureBookingApprovalSteps(booking: Booking): Promise<void> {
-    if ((booking.approvalSteps?.length ?? 0) > 0) return;
-
-    await this.ruleEngineService.instantiateApprovalSteps(booking.id, {
-      freightType: booking.freightType as "CONTAINER" | "BULK",
-      cargoTypeId: booking.cargoTypeId,
-    });
-  }
-
  async acceptIntake(
    bookingId: string,
    actorId: string,
@@ -283,21 +271,33 @@ export class BookingTransitionService {
    const validUntil = new Date(validFrom);
    validUntil.setDate(validUntil.getDate() + validityDays);

-    await this.ruleEngineService.instantiateApprovalSteps(bookingId, {
-      freightType: booking.freightType as "CONTAINER" | "BULK",
-      cargoTypeId: booking.cargoTypeId,
-    });
-
-    const updated = await this.bookingsRepository.update(bookingId, {
-      status: "PENDING_APPROVAL",
+    // Bookings no longer run a multi-step approval chain — accepting the intake
+    // approves the booking outright and generates its contract. (The approval
+    // chain is a contract-only concern now; see contract-transition.service.)
+    await this.bookingsRepository.update(bookingId, {
+      status: "APPROVED",
      approvedByStaffId: actorId,
      approvedByStaffAt: validFrom,
      contractValidityDays: validityDays,
      contractValidFrom: validFrom,
      contractValidUntil: validUntil,
    } as never);
-    const fresh = await this.bookingsService.findById(updated!.id);
+
+    // Generating the contract is best-effort: the acceptance is already
+    // committed, so a failure here must not roll it back. The booking stays
+    // APPROVED and staff can retry generation from the booking page.
+    try {
+      await this.contractService.generateContract(bookingId);
+    } catch (err) {
+      this.logger.warn(
+        `Contract generation failed after accepting booking ${bookingId}: ${err}. ` +
+          `The booking is APPROVED — retry generation from the booking page.`,
+      );
+    }
+
+    const fresh = await this.bookingsService.findById(bookingId);
    this.notifier.accepted(fresh);
+    this.notifier.approved(fresh);
    return fresh;
  }

@@ -324,140 +324,6 @@ export class BookingTransitionService {
    return fresh;
  }

-  async approveStep(
-    bookingId: string,
-    stepId: string,
-    actorId: string,
-    requiredRole: string,
-    authUser?: TCurrentUser,
-  ): Promise<Booking> {
-    if (authUser) {
-      assertCanApproveBookingStep(authUser, requiredRole);
-    }
-
-    let booking = await this.bookingsService.findById(bookingId);
-    assertBookingStatus(booking, [
-      "PENDING_APPROVAL",
-      "APPROVED_PENDING_SIGNATURE",
-    ]);
-
-    if ((booking.approvalSteps?.length ?? 0) === 0) {
-      await this.ensureBookingApprovalSteps(booking);
-      booking = await this.bookingsService.findById(bookingId);
-    }
-
-    const step = await this.bookingsRepository.findApprovalStepById(
-      bookingId,
-      stepId,
-    );
-    if (!step || step.status !== "PENDING") {
-      throw new BadRequestException(
-        "Approval step not found or already actioned",
-      );
-    }
-
-    const next =
-      await this.bookingsRepository.findNextPendingApprovalStep(bookingId);
-    if (!next || next.id !== step.id) {
-      throw new BadRequestException(
-        "Approval steps must be completed in order",
-      );
-    }
-
-    if (step.requiredRole !== requiredRole) {
-      throw new BadRequestException(
-        `Step requires role ${step.requiredRole}, not ${requiredRole}`,
-      );
-    }
-
-    const blocksRole = step.blocksRole;
-    if (blocksRole && blocksRole === requiredRole) {
-      throw new BadRequestException(
-        `Role ${requiredRole} is blocked for this step`,
-      );
-    }
-
-    await this.bookingsRepository.completeApprovalStep(
-      step.id,
-      actorId,
-      "APPROVED",
-    );
-
-    const updates: Record<string, unknown> = {};
-    const now = new Date();
-
-    if (requiredRole === "LINE_STAFF") {
-      updates.status = "APPROVED_PENDING_SIGNATURE";
-      updates.approvedByStaffId = actorId;
-      updates.approvedByStaffAt = now;
-    } else if (requiredRole === "DIRECTOR") {
-      updates.signedByDirectorId = actorId;
-      updates.signedByDirectorAt = now;
-    } else if (requiredRole === "CEO") {
-      updates.signedByCeoId = actorId;
-      updates.signedByCeoAt = now;
-    }
-
-    const allDone =
-      await this.bookingsRepository.allApprovalStepsComplete(bookingId);
-    if (allDone) {
-      updates.status = "APPROVED";
-    }
-
-    if (Object.keys(updates).length > 0) {
-      await this.bookingsRepository.update(bookingId, updates as never);
-    }
-
-    if (allDone) {
-      const generated = await this.contractService.generateContract(bookingId);
-      const fresh = await this.bookingsService.findById(generated.id);
-      this.notifier.approved(fresh);
-      return fresh;
-    }
-
-    return this.bookingsService.findById(bookingId);
-  }
-
-  async rejectStep(
-    bookingId: string,
-    stepId: string,
-    actorId: string,
-    reason: string,
-  ): Promise<Booking> {
-    const booking = await this.bookingsService.findById(bookingId);
-    assertBookingStatus(booking, [
-      "PENDING_APPROVAL",
-      "APPROVED_PENDING_SIGNATURE",
-    ]);
-
-    const step = await this.bookingsRepository.findApprovalStepById(
-      bookingId,
-      stepId,
-    );
-    if (!step) throw new BadRequestException("Approval step not found");
-
-    await this.bookingsRepository.completeApprovalStep(
-      step.id,
-      actorId,
-      "REJECTED",
-      reason,
-    );
-
-    await this.bookingsRepository.createReviewNote(
-      bookingId,
-      reason,
-      "REJECTION",
-      actorId,
-    );
-
-    const updated = await this.bookingsRepository.update(bookingId, {
-      status: "REJECTED",
-    } as never);
-    const fresh = await this.bookingsService.findById(updated!.id);
-    this.notifier.rejected(fresh, reason);
-    return fresh;
-  }
-
  async customerSign(bookingId: string): Promise<Booking> {
    const booking = await this.bookingsService.findById(bookingId);
    assertBookingStatus(booking, ["CONTRACT_READY"]);
@@ -1298,12 +1164,9 @@ export class BookingTransitionService {
    }
    let nextStep: BookingNextStep | null = null;
    try {
-      const nextPending =
-        booking.status === "PENDING_APPROVAL" ||
-          booking.status === "APPROVED_PENDING_SIGNATURE"
-          ? await this.bookingsRepository.findNextPendingApprovalStep(booking.id)
-          : null;
-      nextStep = computeNextStep(booking, nextPending);
+      // Bookings no longer carry an approval chain, so there is never a pending
+      // approval step to hint at.
+      nextStep = computeNextStep(booking, null);
    } catch (err) {
      this.logger.warn(
        `enrichBookingResponse: next-step lookup failed for ${booking.id}: ${(err as Error).message}`,
--- a/apps/edr-freight-api/src/modules/bookings/bookings.controller.ts
+++ b/apps/edr-freight-api/src/modules/bookings/bookings.controller.ts
@@ -52,10 +52,8 @@ import { GeneratePriceResponseDto } from './dto/generate-price-response.dto';
 import { SubmitBookingResponseDto } from './dto/submit-booking-response.dto';
 import {
  AcceptIntakeDto,
-  ApproveStepDto,
  CancelBookingDto,
  RejectBookingDto,
-  RejectStepDto,
  RequestChangesDto,
  ReviewDocumentDto,
  RequestOperationDto,
@@ -1023,47 +1021,6 @@ export class BookingsController {
    return this.transitionService.enrichBookingResponse(booking);
  }

-  @Post(":id/approval-steps/:stepId/approve")
-  @BookingStaff([
-    FREIGHT_PERMS.bookings.approveLineStaff,
-    FREIGHT_PERMS.bookings.approveDirector,
-    FREIGHT_PERMS.bookings.approveCeo,
-  ])
-  @ApiOperation({ summary: "Approve one approval step in sequence" })
-  async approveStep(
-    @Param("id", ParseUUIDPipe) id: string,
-    @Param("stepId", ParseUUIDPipe) stepId: string,
-    @Body() dto: ApproveStepDto,
-    @CurrentUser() user: TCurrentUser,
-  ) {
-    const booking = await this.transitionService.approveStep(
-      id,
-      stepId,
-      resolveAuthUserId(user),
-      dto.requiredRole,
-      user,
-    );
-    return this.transitionService.enrichBookingResponse(booking);
-  }
-
-  @Post(":id/approval-steps/:stepId/reject")
-  @BookingStaff(FREIGHT_PERMS.bookings.rejectApproval)
-  @ApiOperation({ summary: "Reject at approval step" })
-  async rejectStep(
-    @Param("id", ParseUUIDPipe) id: string,
-    @Param("stepId", ParseUUIDPipe) stepId: string,
-    @Body() dto: RejectStepDto,
-    @CurrentUser() user: AuthUserPayload,
-  ) {
-    const booking = await this.transitionService.rejectStep(
-      id,
-      stepId,
-      resolveAuthUserId(user),
-      dto.reason,
-    );
-    return this.transitionService.enrichBookingResponse(booking);
-  }
-
  @Post(":id/contract/generate")
  @BookingStaff(FREIGHT_PERMS.bookings.generateContract)
  @ApiOperation({ summary: "Generate contract PDF from template" })
--- a/apps/edr-freight-api/src/modules/bookings/bookings.module.ts
+++ b/apps/edr-freight-api/src/modules/bookings/bookings.module.ts
@@ -30,7 +30,6 @@ import { BookingsRepository } from './bookings.repository';
 import { ConsolidationService } from './consolidation.service';
 import { ContainerValidationService } from './container-validation.service';
 import { BookingsService } from './bookings.service';
-import { BookingApprovalStep } from './entities/booking-approval-step.entity';
 import { BookingCargoModifier } from './entities/booking-cargo-modifier.entity';
 import { BookingDocumentReview } from './entities/booking-document-review.entity';
 import { BookingContainer } from './entities/booking-container.entity';
@@ -60,7 +59,6 @@ import { VehiclesModule } from "../vehicles/vehicles.module";
      Booking,
      BookingContainer,
      BookingCargoModifier,
-      BookingApprovalStep,
      BookingDocumentReview,
      BookingRateSnapshot,
      BookingReviewNote,
--- a/apps/edr-freight-api/src/modules/bookings/bookings.repository.ts
+++ b/apps/edr-freight-api/src/modules/bookings/bookings.repository.ts
@@ -9,7 +9,6 @@ import { ContainerType } from '../rule-engine/entities/container-type.entity';
 import { Contract } from '../contracts/entities/contract.entity';
 import { ContractRateSnapshot } from '../contracts/entities/contract-rate-snapshot.entity';
 import { ContractRoute } from '../contracts/entities/contract-route.entity';
-import { BookingApprovalStep } from './entities/booking-approval-step.entity';
 import { BookingCargoModifier } from './entities/booking-cargo-modifier.entity';
 import {
  BookingDocumentReview,
@@ -114,7 +113,6 @@ export class BookingsRepository extends BaseRepository<Booking> {
      .leftJoinAndSelect('booking.originYard', 'oy')
      .leftJoinAndSelect('booking.destinationYard', 'dy')
      .leftJoinAndSelect('booking.shippingLine', 'sl')
-      .leftJoinAndSelect('booking.approvalSteps', 'steps')
      .leftJoinAndSelect('booking.rateSnapshots', 'snapshots')
      .leftJoinAndSelect('booking.cargoModifiers', 'modifiers')
      .leftJoinAndSelect('booking.reviewNotes', 'reviewNotes')
@@ -435,58 +433,6 @@ export class BookingsRepository extends BaseRepository<Booking> {
    await this.dataSource.getRepository(BookingContainer).delete({ bookingId });
  }

-  /** Lowest-order pending approval step (sequential enforcement). */
-  async findNextPendingApprovalStep(
-    bookingId: string,
-  ): Promise<BookingApprovalStep | null> {
-    return this.dataSource.getRepository(BookingApprovalStep).findOne({
-      where: { bookingId, status: 'PENDING' },
-      order: { stepOrder: 'ASC' },
-    });
-  }
-
-  async findApprovalStepById(
-    bookingId: string,
-    stepId: string,
-  ): Promise<BookingApprovalStep | null> {
-    return this.dataSource.getRepository(BookingApprovalStep).findOne({
-      where: { bookingId, id: stepId },
-    });
-  }
-
-  /** Get pending approval step for a role (must match next in sequence). */
-  async findPendingApprovalStep(
-    bookingId: string,
-    requiredRole: string,
-  ): Promise<BookingApprovalStep | null> {
-    const next = await this.findNextPendingApprovalStep(bookingId);
-    if (!next || next.requiredRole !== requiredRole) return null;
-    return next;
-  }
-
-  /** Mark an approval step complete. */
-  async completeApprovalStep(
-    stepId: string,
-    actorId: string,
-    status: 'APPROVED' | 'REJECTED',
-    remarks?: string,
-  ): Promise<void> {
-    await this.dataSource.getRepository(BookingApprovalStep).update(stepId, {
-      status,
-      actionedByStaffId: actorId,
-      actionedAt: new Date(),
-      remarks,
-    });
-  }
-
-  /** Check if all approval steps are approved. */
-  async allApprovalStepsComplete(bookingId: string): Promise<boolean> {
-    const pending = await this.dataSource.getRepository(BookingApprovalStep).count({
-      where: { bookingId, status: 'PENDING' },
-    });
-    return pending === 0;
-  }
-
  // ── Clearance document reviews ────────────────────────────────────────────

  findDocumentReviews(bookingId: string): Promise<BookingDocumentReview[]> {
@@ -673,7 +619,6 @@ export class BookingsRepository extends BaseRepository<Booking> {
      .leftJoinAndSelect('booking.destinationYard', 'destinationYard')
      .leftJoinAndSelect('booking.cargoType', 'cargo')
      .leftJoinAndSelect('booking.serviceType', 'serviceType')
-      .leftJoinAndSelect('booking.approvalSteps', 'approvalSteps')
      .where('booking.status IN (:...statuses)', { statuses });

    if (options.excludeBulk) {
@@ -722,7 +667,6 @@ export class BookingsRepository extends BaseRepository<Booking> {
      .leftJoinAndSelect('booking.originYard', 'originYard')
      .leftJoinAndSelect('booking.destinationYard', 'destinationYard')
      .leftJoinAndSelect('booking.serviceType', 'serviceType')
-      .leftJoinAndSelect('booking.approvalSteps', 'approvalSteps')
      .leftJoinAndSelect('booking.consolidationPartner', 'consolidationPartner')
      // Contract reference for the list column + search (no entity relation on
      // Booking → contract, so join the entity by id and select just the
--- a/apps/edr-freight-api/src/modules/bookings/entities/booking-approval-step.entity.ts
+++ b/apps/edr-freight-api/src/modules/bookings/entities/booking-approval-step.entity.ts
@@ -1,48 +0,0 @@
-import { BaseEntity } from '@edr/api-common';
-import { Column, Entity, Index, JoinColumn, ManyToOne } from 'typeorm';
-import { ApprovalRule } from '../../rule-engine/entities/approval-rule.entity';
-import { Booking } from './booking.entity';
-
-export const APPROVAL_STEP_STATUSES = ['PENDING', 'APPROVED', 'REJECTED', 'SKIPPED'] as const;
-export type ApprovalStepStatus = typeof APPROVAL_STEP_STATUSES[number];
-
-@Entity({ schema: 'freight', name: 'booking_approval_step' })
-@Index(['bookingId'])
-@Index(['status'])
-@Index(['bookingId', 'stepOrder'])
-export class BookingApprovalStep extends BaseEntity {
-  @Column({ name: 'booking_id', type: 'uuid' })
-  bookingId!: string;
-
-  @ManyToOne(() => Booking, (b) => b.approvalSteps, { onDelete: 'CASCADE' })
-  @JoinColumn({ name: 'booking_id' })
-  booking?: Booking;
-
-  @Column({ name: 'approval_rule_id', type: 'uuid' })
-  approvalRuleId!: string;
-
-  @ManyToOne(() => ApprovalRule)
-  @JoinColumn({ name: 'approval_rule_id' })
-  approvalRule?: ApprovalRule;
-
-  @Column({ name: 'step_order', type: 'smallint' })
-  stepOrder!: number;
-
-  @Column({ name: 'required_role', type: 'varchar', length: 30 })
-  requiredRole!: string;
-
-  @Column({ name: 'blocks_role', type: 'varchar', length: 30, nullable: true })
-  blocksRole?: string | null;
-
-  @Column({ name: 'status', type: 'varchar', length: 20, default: 'PENDING' })
-  status!: ApprovalStepStatus;
-
-  @Column({ name: 'actioned_by_staff_id', type: 'uuid', nullable: true })
-  actionedByStaffId?: string | null;
-
-  @Column({ name: 'actioned_at', type: 'timestamptz', nullable: true })
-  actionedAt?: Date | null;
-
-  @Column({ name: 'remarks', type: 'text', nullable: true })
-  remarks?: string | null;
-}
--- a/apps/edr-freight-api/src/modules/bookings/entities/booking.entity.ts
+++ b/apps/edr-freight-api/src/modules/bookings/entities/booking.entity.ts
@@ -10,7 +10,6 @@ import { ShippingLine } from '../../rule-engine/entities/shipping-line.entity';
 import { Yard } from '../../rule-engine/entities/yard.entity';
 import { Train } from '../../trains/entities/train.entity';
 import { FileRecord } from '../../files/entities/file.entity';
-import { BookingApprovalStep } from './booking-approval-step.entity';
 import { BookingCargoModifier } from './booking-cargo-modifier.entity';
 import { BookingContainer } from './booking-container.entity';
 import { BookingContainerAllocation } from './booking-container-allocation.entity';
@@ -557,8 +556,6 @@ export class Booking extends BaseEntity {
  @OneToMany(() => BookingCargoModifier, (m) => m.booking)
  cargoModifiers?: BookingCargoModifier[];

-  @OneToMany(() => BookingApprovalStep, (s) => s.booking)
-  approvalSteps?: BookingApprovalStep[];

  @OneToMany(() => BookingRateSnapshot, (s) => s.booking)
  rateSnapshots?: BookingRateSnapshot[];
--- a/apps/edr-freight-api/src/modules/contracts/contract-document-diff.util.ts
+++ b/apps/edr-freight-api/src/modules/contracts/contract-document-diff.util.ts
@@ -0,0 +1,168 @@
+import type {
+  ContractDocumentArticle,
+  ContractDocumentSnapshot,
+} from './entities/contract.entity';
+
+/**
+ * One recorded change between two document snapshots. Granularity is per
+ * article: a body edit is reported as "the body changed", not as a text diff.
+ */
+export type ContractDocumentChange =
+  | { kind: 'ARTICLE_ADDED'; articleId: string; title: string }
+  | { kind: 'ARTICLE_REMOVED'; articleId: string; title: string }
+  | {
+      kind: 'ARTICLE_RENAMED';
+      articleId: string;
+      title: string;
+      fromTitle: string;
+    }
+  | { kind: 'ARTICLE_BODY_CHANGED'; articleId: string; title: string }
+  | {
+      kind: 'ARTICLE_REORDERED';
+      articleId: string;
+      title: string;
+      fromOrder: number;
+      toOrder: number;
+    }
+  | { kind: 'DOCUMENT_TITLE_CHANGED'; title: string; fromTitle: string | null }
+  | { kind: 'WHEREAS_CHANGED'; added: number; removed: number };
+
+type SnapshotLike = Pick<
+  ContractDocumentSnapshot,
+  'documentTitle' | 'whereasClauses' | 'articles'
+> | null;
+
+/** Match on id when present, else on normalized title (editors may omit ids). */
+function articleKey(article: ContractDocumentArticle): string {
+  return article.id || `title:${article.title.trim().toLowerCase()}`;
+}
+
+function indexArticles(
+  articles: ContractDocumentArticle[] | undefined,
+): Map<string, ContractDocumentArticle> {
+  const map = new Map<string, ContractDocumentArticle>();
+  for (const article of articles ?? []) {
+    map.set(articleKey(article), article);
+  }
+  return map;
+}
+
+/**
+ * Compare two document snapshots and describe what changed, article by article.
+ * Returns an empty array when the snapshots are equivalent, so callers can skip
+ * recording a no-op revision.
+ */
+export function diffSnapshots(
+  before: SnapshotLike,
+  after: SnapshotLike,
+): ContractDocumentChange[] {
+  const changes: ContractDocumentChange[] = [];
+
+  const beforeTitle = before?.documentTitle ?? null;
+  const afterTitle = after?.documentTitle ?? null;
+  if (beforeTitle !== afterTitle && afterTitle !== null) {
+    changes.push({
+      kind: 'DOCUMENT_TITLE_CHANGED',
+      title: afterTitle,
+      fromTitle: beforeTitle,
+    });
+  }
+
+  const beforeWhereas = before?.whereasClauses ?? [];
+  const afterWhereas = after?.whereasClauses ?? [];
+  const beforeWhereasSet = new Set(beforeWhereas);
+  const afterWhereasSet = new Set(afterWhereas);
+  const whereasAdded = afterWhereas.filter((c) => !beforeWhereasSet.has(c)).length;
+  const whereasRemoved = beforeWhereas.filter((c) => !afterWhereasSet.has(c)).length;
+  if (whereasAdded > 0 || whereasRemoved > 0) {
+    changes.push({
+      kind: 'WHEREAS_CHANGED',
+      added: whereasAdded,
+      removed: whereasRemoved,
+    });
+  }
+
+  const beforeArticles = indexArticles(before?.articles);
+  const afterArticles = indexArticles(after?.articles);
+
+  for (const [key, article] of afterArticles) {
+    const previous = beforeArticles.get(key);
+    if (!previous) {
+      changes.push({
+        kind: 'ARTICLE_ADDED',
+        articleId: article.id,
+        title: article.title,
+      });
+      continue;
+    }
+
+    if (previous.title !== article.title) {
+      changes.push({
+        kind: 'ARTICLE_RENAMED',
+        articleId: article.id,
+        title: article.title,
+        fromTitle: previous.title,
+      });
+    }
+    if (previous.body !== article.body) {
+      changes.push({
+        kind: 'ARTICLE_BODY_CHANGED',
+        articleId: article.id,
+        title: article.title,
+      });
+    }
+    if (previous.order !== article.order) {
+      changes.push({
+        kind: 'ARTICLE_REORDERED',
+        articleId: article.id,
+        title: article.title,
+        fromOrder: previous.order,
+        toOrder: article.order,
+      });
+    }
+  }
+
+  for (const [key, article] of beforeArticles) {
+    if (afterArticles.has(key)) continue;
+    changes.push({
+      kind: 'ARTICLE_REMOVED',
+      articleId: article.id,
+      title: article.title,
+    });
+  }
+
+  return changes;
+}
+
+/** Short human summary of a change set, e.g. "2 articles edited, 1 article added". */
+export function summarizeChanges(changes: ContractDocumentChange[]): string {
+  if (changes.length === 0) return 'No changes';
+
+  const articleVerbs: Record<string, string> = {
+    ARTICLE_ADDED: 'added',
+    ARTICLE_REMOVED: 'removed',
+    ARTICLE_RENAMED: 'renamed',
+    ARTICLE_BODY_CHANGED: 'edited',
+    ARTICLE_REORDERED: 'reordered',
+  };
+
+  const counts = new Map<string, number>();
+  const parts: string[] = [];
+
+  for (const change of changes) {
+    const verb = articleVerbs[change.kind];
+    if (verb) {
+      counts.set(verb, (counts.get(verb) ?? 0) + 1);
+    } else if (change.kind === 'DOCUMENT_TITLE_CHANGED') {
+      parts.push('document title changed');
+    } else if (change.kind === 'WHEREAS_CHANGED') {
+      parts.push('recitals changed');
+    }
+  }
+
+  const articleParts = [...counts.entries()].map(
+    ([verb, count]) => `${count} article${count === 1 ? '' : 's'} ${verb}`,
+  );
+
+  return [...articleParts, ...parts].join(', ');
+}
--- a/apps/edr-freight-api/src/modules/contracts/contract-document-history.service.ts
+++ b/apps/edr-freight-api/src/modules/contracts/contract-document-history.service.ts
@@ -0,0 +1,61 @@
+import { Injectable, Logger } from '@nestjs/common';
+import { InjectRepository } from '@nestjs/typeorm';
+import { Repository } from 'typeorm';
+
+import { diffSnapshots, summarizeChanges } from './contract-document-diff.util';
+import { ContractDocumentRevision } from './entities/contract-document-revision.entity';
+import type { ContractDocumentSnapshot } from './entities/contract.entity';
+
+export interface RecordRevisionInput {
+  contractId: string;
+  before: ContractDocumentSnapshot | null;
+  after: ContractDocumentSnapshot | null;
+  actorId?: string | null;
+  actorRole?: string | null;
+  stepId?: string | null;
+}
+
+@Injectable()
+export class ContractDocumentHistoryService {
+  private readonly logger = new Logger(ContractDocumentHistoryService.name);
+
+  constructor(
+    @InjectRepository(ContractDocumentRevision)
+    private readonly revisionRepo: Repository<ContractDocumentRevision>,
+  ) {}
+
+  /**
+   * Append a revision describing what an edit changed. Best-effort: recording
+   * history must never break the edit that triggered it, so failures are logged
+   * and swallowed. A no-op edit records nothing.
+   */
+  async record(input: RecordRevisionInput): Promise<void> {
+    try {
+      const changes = diffSnapshots(input.before, input.after);
+      if (changes.length === 0) return;
+
+      await this.revisionRepo.save(
+        this.revisionRepo.create({
+          contractId: input.contractId,
+          actorId: input.actorId ?? null,
+          actorRole: input.actorRole ?? null,
+          stepId: input.stepId ?? null,
+          summary: summarizeChanges(changes),
+          changes,
+        }),
+      );
+    } catch (err) {
+      this.logger.error(
+        `Failed to record document revision for contract ${input.contractId}: ${String(err)}`,
+      );
+    }
+  }
+
+  /** Revision history for a contract, newest first. */
+  list(contractId: string): Promise<ContractDocumentRevision[]> {
+    return this.revisionRepo.find({
+      where: { contractId },
+      order: { createdAt: 'DESC' },
+    });
+  }
+}
--- a/apps/edr-freight-api/src/modules/contracts/contract-transition.service.ts
+++ b/apps/edr-freight-api/src/modules/contracts/contract-transition.service.ts
@@ -3,6 +3,7 @@ import {
  ConflictException,
  Injectable,
  Logger,
+  ServiceUnavailableException,
 } from '@nestjs/common';
 import { InjectDataSource } from '@nestjs/typeorm';
 import { DataSource } from 'typeorm';
@@ -17,7 +18,8 @@ import { ContractPdfService } from '../../contracts/contract-pdf.service';
 import { ContractViewModel } from '../../contracts/contract-view-model.builder';
 import { MinioService } from '../minio/minio.service';
 import { FileRecord } from '../files/entities/file.entity';
-import { assertCanApproveBookingStep } from '../../common/freight-permission.util';
+import { assertCanApproveContractStep } from '../../common/freight-permission.util';
+import { ContractDocumentHistoryService } from './contract-document-history.service';
 import { ApprovalRulesService } from '../rule-engine/services/approval-rules.service';
 import { CargoTypesService } from '../rule-engine/services/cargo-types.service';
 import { DropdownSettingsService } from '../dropdown-settings/dropdown-settings.service';
@@ -48,8 +50,12 @@ export interface ContractDocumentDraft {
  articles: ContractDocumentArticle[];
  code: string | null;
  name: string | null;
-  /** True once the document may no longer be edited/regenerated. */
+  /** True when THIS caller may not edit — the inverse of `editableByMe`. */
  locked: boolean;
+  /** Whether the requesting user is the approver whose turn it is to edit. */
+  editableByMe: boolean;
+  /** Role holding editing rights right now, for "locked because…" messaging. */
+  nextApproverRole: string | null;
  generatedAt: Date | null;
  status: string;
 }
@@ -62,6 +68,28 @@ export interface ContractDocumentDraft {
 */
 const CONTRACT_VALIDITY_PERIODS_CODE = 'contract_validity_periods';

+/**
+ * Approval chains are configured in IAM position types, so a step's role no
+ * longer maps onto the contract's fixed approver columns. These sets keep those
+ * legacy columns populated for the roles that still correspond to one — both the
+ * original role strings on historical rows and the position types that replaced
+ * them. Steps outside these sets are recorded only in `contract_approval_steps`,
+ * which is the source of truth.
+ */
+const LEGACY_STAFF_ROLES = new Set([
+  'LINE_STAFF',
+  'employee',
+  'teamLeader',
+  'officeHead',
+  'recordOfficer',
+]);
+const LEGACY_DIRECTOR_ROLES = new Set([
+  'DIRECTOR',
+  'director',
+  'operation-director',
+]);
+const LEGACY_CEO_ROLES = new Set(['CEO', 'chief', 'deputy']);
+
 /**
 * Mask a phone for display — keep the last 4 digits, star the rest
 * (`+251986680099` → `•••••••0099`). Used to tell the customer WHERE the signing
@@ -87,6 +115,7 @@ export class ContractTransitionService {
  private readonly logger = new Logger(ContractTransitionService.name);

  constructor(
+    private readonly documentHistory: ContractDocumentHistoryService,
    private readonly contractsRepository: ContractsRepository,
    private readonly contractsService: ContractsService,
    private readonly pricingService: ContractPricingService,
@@ -229,18 +258,22 @@ export class ContractTransitionService {
   */
  async getContractDocumentDraft(
    contractId: string,
+    user?: TCurrentUser | null,
  ): Promise<ContractDocumentDraft> {
    const contract = await this.contractsService.findById(contractId);
    const snapshot =
      (contract.documentSnapshot as ContractDocumentSnapshot | null) ??
      (await this.resolveDocumentSnapshot(contract));
+    const editableByMe = await this.documentIsEditableBy(contract, user);
    return {
      documentTitle: snapshot?.documentTitle ?? null,
      whereasClauses: snapshot?.whereasClauses ?? [],
      articles: snapshot?.articles ?? [],
      code: snapshot?.code ?? null,
      name: snapshot?.name ?? null,
-      locked: !this.documentIsEditable(contract),
+      locked: !editableByMe,
+      editableByMe,
+      nextApproverRole: await this.nextApproverRole(contract),
      generatedAt: contract.contractGeneratedAt ?? null,
      status: contract.status,
    };
@@ -255,10 +288,12 @@ export class ContractTransitionService {
  async updateContractDocument(
    contractId: string,
    input: ContractDocumentSnapshotInput,
+    user?: TCurrentUser | null,
+    actorId?: string,
  ): Promise<Contract> {
    const contract = await this.contractsService.findById(contractId);
    assertContractStatus(contract, ['PENDING_APPROVAL']);
-    this.assertDocumentEditable(contract);
+    await this.assertDocumentEditable(contract, user);

    const current =
      (contract.documentSnapshot as ContractDocumentSnapshot | null) ??
@@ -270,9 +305,25 @@ export class ContractTransitionService {
      whereasClauses: input.whereasClauses ?? current?.whereasClauses ?? [],
      articles: input.articles ?? current?.articles ?? [],
    };
+    const next = this.normalizeSnapshot(merged);
    await this.contractsRepository.update(contractId, {
-      documentSnapshot: this.normalizeSnapshot(merged),
+      documentSnapshot: next,
    } as never);
+
+    // Audit the edit after it lands. Recording history must never break the
+    // edit itself, so the history service swallows its own failures.
+    const step = await this.contractsRepository.findNextPendingApprovalStep(
+      contractId,
+    );
+    await this.documentHistory.record({
+      contractId,
+      before: current,
+      after: next,
+      actorId: actorId ?? null,
+      actorRole: step?.requiredRole ?? null,
+      stepId: step?.id ?? null,
+    });
+
    return this.contractsService.findById(contractId);
  }

@@ -334,23 +385,54 @@ export class ContractTransitionService {
  }

  /**
-   * The per-contract document may be edited/regenerated while the contract is at
-   * the accept stage (SUBMITTED) or in approval with NO approver having acted
-   * yet. The first approval action freezes it.
+   * The contract document stays editable for the whole approval chain, but only
+   * by the approver whose turn it is: whoever can action the next pending step.
+   * Approving therefore hands editing rights to the next approver in the chain.
+   *
+   * Edits never reset approvals already given — earlier approvers stay approved.
   */
-  private documentIsEditable(contract: Contract): boolean {
+  private async documentIsEditableBy(
+    contract: Contract,
+    user?: TCurrentUser | null,
+  ): Promise<boolean> {
    if (contract.status === 'SUBMITTED') return true;
    if (contract.status !== 'PENDING_APPROVAL') return false;
-    return !(contract.approvalSteps ?? []).some((s) => s.status !== 'PENDING');
+
+    const next = await this.contractsRepository.findNextPendingApprovalStep(
+      contract.id,
+    );
+    if (!next) return false;
+    if (!user) return false;
+
+    try {
+      assertCanApproveContractStep(user, next.requiredRole);
+      return true;
+    } catch {
+      return false;
+    }
  }

-  private assertDocumentEditable(contract: Contract): void {
-    if (!this.documentIsEditable(contract)) {
-      throw new ConflictException(
-        'The contract document is locked — an approver has already acted or the ' +
-          'contract has advanced. It can no longer be edited or regenerated.',
-      );
-    }
+  /** The role that currently holds editing rights, for UI messaging. */
+  private async nextApproverRole(contract: Contract): Promise<string | null> {
+    if (contract.status !== 'PENDING_APPROVAL') return null;
+    const next = await this.contractsRepository.findNextPendingApprovalStep(
+      contract.id,
+    );
+    return next?.requiredRole ?? null;
+  }
+
+  private async assertDocumentEditable(
+    contract: Contract,
+    user?: TCurrentUser | null,
+  ): Promise<void> {
+    if (await this.documentIsEditableBy(contract, user)) return;
+
+    const role = await this.nextApproverRole(contract);
+    throw new ConflictException(
+      role
+        ? `The contract document can only be edited by the current approver (${role}).`
+        : 'The contract document is locked — the contract has advanced beyond approval.',
+    );
  }

  /**
@@ -513,25 +595,11 @@ export class ContractTransitionService {
    contractId: string,
    stepId: string,
    actorId: string,
-    requiredRole: string,
    authUser?: TCurrentUser,
  ): Promise<Contract> {
-    if (authUser) {
-      assertCanApproveBookingStep(authUser, requiredRole);
-    }
-
    const contract = await this.contractsService.findById(contractId);
    assertContractStatus(contract, ['PENDING_APPROVAL', 'APPROVED_PENDING_SIGNATURE']);

-    // Approvers review the generated contract document, so it must exist before
-    // the first approval can be recorded. Staff generate it (from the frozen,
-    // optionally-edited snapshot) at the accept stage.
-    if (contract.status === 'PENDING_APPROVAL' && !contract.contractGeneratedAt) {
-      throw new BadRequestException(
-        'Generate the contract document before it can be approved.',
-      );
-    }
-
    const step = await this.contractsRepository.findApprovalStepById(contractId, stepId);
    if (!step || step.status !== 'PENDING') {
      throw new BadRequestException('Approval step not found or already actioned');
@@ -541,31 +609,34 @@ export class ContractTransitionService {
    if (!next || next.id !== step.id) {
      throw new BadRequestException('Approval steps must be completed in order');
    }
-    if (step.requiredRole !== requiredRole) {
-      throw new BadRequestException(
-        `Step requires role ${step.requiredRole}, not ${requiredRole}`,
-      );
-    }
-    if (step.blocksRole && step.blocksRole === requiredRole) {
-      throw new BadRequestException(`Role ${requiredRole} is blocked for this step`);
+
+    // The role is the step's own — never the caller's claim about themselves.
+    const requiredRole = step.requiredRole;
+    if (authUser) {
+      assertCanApproveContractStep(authUser, requiredRole);
    }

    await this.contractsRepository.completeApprovalStep(step.id, actorId, 'APPROVED');

    // Record who acted on this step, but DO NOT advance the contract status here —
-    // approving one step (e.g. LINE_STAFF) must not finalize the chain while later
-    // steps (e.g. DIRECTOR) are still pending. Status only moves to APPROVED once
-    // every step in the chain is complete; until then the contract stays in
-    // PENDING_APPROVAL so the next required role can act.
+    // approving one step must not finalize the chain while later steps are still
+    // pending. Status only moves to APPROVED once every step in the chain is
+    // complete; until then the contract stays in PENDING_APPROVAL so the next
+    // required approver can act.
+    //
+    // `contract_approval_steps` is the source of truth for who approved what — a
+    // chain is an arbitrary sequence of position types and cannot be represented
+    // by fixed columns. The legacy columns below are still stamped, best-effort,
+    // for the three roles that map onto them so older readers keep working.
    const updates: Record<string, unknown> = {};
    const now = new Date();
-    if (requiredRole === 'LINE_STAFF') {
+    if (LEGACY_STAFF_ROLES.has(requiredRole)) {
      updates.approvedByStaffId = actorId;
      updates.approvedByStaffAt = now;
-    } else if (requiredRole === 'DIRECTOR') {
+    } else if (LEGACY_DIRECTOR_ROLES.has(requiredRole)) {
      updates.signedByDirectorId = actorId;
      updates.signedByDirectorAt = now;
-    } else if (requiredRole === 'CEO') {
+    } else if (LEGACY_CEO_ROLES.has(requiredRole)) {
      updates.signedByCeoId = actorId;
      updates.signedByCeoAt = now;
    }
@@ -579,14 +650,19 @@ export class ContractTransitionService {
    const updated = await this.contractsService.findById(contractId);
    if (allDone) {
      this.notifier.approved(updated);
-      // Every step approved → CONTRACT_READY. The document was already generated
-      // (and reviewed) at the accept stage, so we reuse it rather than
-      // re-rendering. Best-effort: a hiccup must not roll back the approval.
+      // Final approval is what produces the contract PDF — until now there was
+      // only a live preview. The approval steps are already committed, so a
+      // render failure must not roll them back; surface it instead of swallowing
+      // it, since an APPROVED contract with no document needs operator action.
      try {
        return await this.finalizeApprovedContract(contractId);
      } catch (err) {
-        this.logger.warn(
-          `Finalizing contract after final approval failed for ${updated.reference}: ${err}`,
+        this.logger.error(
+          `Contract PDF generation failed after final approval for ${updated.reference}: ${err}`,
+        );
+        throw new ServiceUnavailableException(
+          'All approvals were recorded, but generating the contract PDF failed. ' +
+            'Retry generation from the contract page.',
        );
      }
    }
@@ -594,24 +670,13 @@ export class ContractTransitionService {
  }

  /**
-   * Staff (re)generate the contract PDF. Two stages:
-   *  - PENDING_APPROVAL: render from the frozen (optionally staff-edited)
-   *    snapshot so approvers review the real document. Status is UNCHANGED, and
-   *    it is blocked once an approver has acted (the document is then locked).
-   *  - APPROVED / APPROVED_PENDING_SIGNATURE (fallback): render and advance to
-   *    CONTRACT_READY.
-   * PDF rendering (Puppeteer/Chromium) is best-effort and never blocks the
-   * transition — the document re-renders lazily on view/download.
+   * Retry path for a contract that finished approval but whose PDF failed to
+   * render (Chromium unavailable, etc.). The normal flow generates the document
+   * automatically on the final approval — there is no manual generate step
+   * before that, only the live preview.
   */
  async generateContract(contractId: string): Promise<Contract> {
    const contract = await this.contractsService.findById(contractId);
-
-    if (contract.status === 'PENDING_APPROVAL') {
-      this.assertDocumentEditable(contract);
-      await this.renderContractDocument(contract);
-      return this.contractsService.findById(contractId);
-    }
-
    assertContractStatus(contract, ['APPROVED', 'APPROVED_PENDING_SIGNATURE']);
    await this.renderContractDocument(contract);
    await this.contractsRepository.update(contractId, {
@@ -626,11 +691,17 @@ export class ContractTransitionService {
   * changes status. Rendering is best-effort — a Chromium hiccup defers the file
   * (it re-renders on view/download) but the timestamp is still stamped.
   */
-  private async renderContractDocument(contract: Contract): Promise<void> {
+  private async renderContractDocument(
+    contract: Contract,
+    options: { strict?: boolean } = {},
+  ): Promise<void> {
    const { view } = await this.documentViewModelBuilder.build(contract.id);
    try {
      await this.upsertContractPdf(contract.id, contract.reference, view);
    } catch (err) {
+      // Strict callers (final approval) need to know the PDF is missing — it is
+      // the artifact of the completed chain, not a cache that can refill later.
+      if (options.strict) throw err;
      this.logger.warn(
        `Contract PDF deferred for ${contract.reference}: ${err}. It will render on view/download once Chromium is available.`,
      );
@@ -642,15 +713,14 @@ export class ContractTransitionService {
  }

  /**
-   * Every approval step landed → CONTRACT_READY. The document was already
-   * generated (and reviewed) at the accept stage, so reuse it; render now only
-   * if it was somehow never generated. Never re-renders over an existing file.
+   * Every approval step landed → generate the contract PDF, then CONTRACT_READY.
+   * This is the only point at which the document is produced: approvers review a
+   * live preview, and the final approval is what turns it into a PDF. Renders
+   * unconditionally so the file reflects every edit made during the chain.
   */
  private async finalizeApprovedContract(contractId: string): Promise<Contract> {
    const contract = await this.contractsService.findById(contractId);
-    if (!contract.contractGeneratedAt) {
-      await this.renderContractDocument(contract);
-    }
+    await this.renderContractDocument(contract, { strict: true });
    await this.contractsRepository.update(contractId, {
      status: 'CONTRACT_READY',
    } as never);
--- a/apps/edr-freight-api/src/modules/contracts/contracts.controller.ts
+++ b/apps/edr-freight-api/src/modules/contracts/contracts.controller.ts
@@ -32,6 +32,7 @@ import {
 } from '@nestjs/swagger';

 import { BookingStaff } from '../../common/booking-guards';
+import { ContractDocumentHistoryService } from './contract-document-history.service';
 import { FREIGHT_PERMS } from '../../seed/freight-permissions.registry';
 import {
  assertFreightPermission,
@@ -60,7 +61,6 @@ import { ContractListSummaryDto } from './dto/contract-list-summary.dto';
 import { AcceptContractDto } from './dto/accept-contract.dto';
 import { UpdateContractDocumentDto } from './dto/contract-document.dto';
 import {
-  ApproveStepDto,
  RejectContractDto,
  RejectStepDto,
  RequestChangesDto,
@@ -90,6 +90,7 @@ import {
@ApiBearerAuth()
 export class ContractsController {
  constructor(
+    private readonly documentHistory: ContractDocumentHistoryService,
    private readonly contractsService: ContractsService,
    private readonly pricingService: ContractPricingService,
    private readonly transitionService: ContractTransitionService,
@@ -352,8 +353,22 @@ export class ContractsController {
    summary:
      'Editable contract-document draft (this contract\'s snapshot, or the live template) for the accept/edit dialog',
  })
-  getContractDocumentDraft(@Param('id', ParseUUIDPipe) id: string) {
-    return this.transitionService.getContractDocumentDraft(id);
+  getContractDocumentDraft(
+    @Param('id', ParseUUIDPipe) id: string,
+    @CurrentUser() user: TCurrentUser,
+  ) {
+    // Editability depends on WHO is asking — only the approver whose turn it is
+    // may edit — so the caller is part of the draft lookup.
+    return this.transitionService.getContractDocumentDraft(id, user);
+  }
+
+  @Get(':id/document/revisions')
+  @BookingStaff(FREIGHT_PERMS.contracts.view)
+  @ApiOperation({
+    summary: 'Audit trail of edits to this contract\'s document (newest first)',
+  })
+  getContractDocumentRevisions(@Param('id', ParseUUIDPipe) id: string) {
+    return this.documentHistory.list(id);
  }

  @Put(':id/document/articles')
@@ -365,8 +380,14 @@ export class ContractsController {
  updateContractDocument(
    @Param('id', ParseUUIDPipe) id: string,
    @Body() dto: UpdateContractDocumentDto,
+    @CurrentUser() user: TCurrentUser,
  ) {
-    return this.transitionService.updateContractDocument(id, dto);
+    return this.transitionService.updateContractDocument(
+      id,
+      dto,
+      user,
+      resolveAuthUserId(user),
+    );
  }

  @Post(':id/staff/request-changes')
@@ -396,23 +417,20 @@ export class ContractsController {
  }

  @Post(':id/approval-steps/:stepId/approve')
-  @BookingStaff([
-    FREIGHT_PERMS.contracts.approveLineStaff,
-    FREIGHT_PERMS.contracts.approveDirector,
-    FREIGHT_PERMS.contracts.approveCeo,
-  ])
+  @BookingStaff(FREIGHT_PERMS.contracts.view)
  @ApiOperation({ summary: 'Approve one approval step in sequence' })
  approveStep(
    @Param('id', ParseUUIDPipe) id: string,
    @Param('stepId', ParseUUIDPipe) stepId: string,
-    @Body() dto: ApproveStepDto,
    @CurrentUser() user: TCurrentUser,
  ) {
+    // Whether this caller may approve depends on the step's own required role
+    // (an IAM position type), so the service resolves the step and authorizes
+    // against it — the client never declares its own role.
    return this.transitionService.approveStep(
      id,
      stepId,
      resolveAuthUserId(user),
-      dto.requiredRole,
      user,
    );
  }
--- a/apps/edr-freight-api/src/modules/contracts/contracts.module.ts
+++ b/apps/edr-freight-api/src/modules/contracts/contracts.module.ts
@@ -41,6 +41,8 @@ import { ContractRateSnapshot } from './entities/contract-rate-snapshot.entity';
 import { ContractSignature } from './entities/contract-signature.entity';
 import { ContractApprovalStep } from './entities/contract-approval-step.entity';
 import { ContractReviewNote } from './entities/contract-review-note.entity';
+import { ContractDocumentRevision } from './entities/contract-document-revision.entity';
+import { ContractDocumentHistoryService } from './contract-document-history.service';
 import { ContractClearanceCycle } from './entities/contract-clearance-cycle.entity';
 import { ContractDocumentReview } from './entities/contract-document-review.entity';
 import { ClearanceMilestone } from './entities/clearance-milestone.entity';
@@ -64,6 +66,7 @@ import { ContractDocumentViewModelBuilder } from '../../contracts/contract-docum
      ContractSignature,
      ContractApprovalStep,
      ContractReviewNote,
+      ContractDocumentRevision,
      ContractClearanceCycle,
      ContractDocumentReview,
      ClearanceMilestone,
@@ -107,6 +110,7 @@ import { ContractDocumentViewModelBuilder } from '../../contracts/contract-docum
    ClearanceFeeService,
    ContractNotifierService,
    ContractTransitionService,
+    ContractDocumentHistoryService,
    ContractClearanceService,
    ClearanceWorkflowService,
    BookingClearanceService,
--- a/apps/edr-freight-api/src/modules/contracts/entities/contract-approval-step.entity.ts
+++ b/apps/edr-freight-api/src/modules/contracts/entities/contract-approval-step.entity.ts
@@ -26,10 +26,10 @@ export class ContractApprovalStep extends BaseEntity {
  @Column({ name: 'step_order', type: 'smallint', default: 0 })
  stepOrder!: number;

-  @Column({ name: 'required_role', type: 'varchar', length: 40 })
+  @Column({ name: 'required_role', type: 'varchar', length: 64 })
  requiredRole!: string;

-  @Column({ name: 'blocks_role', type: 'varchar', length: 40, nullable: true })
+  @Column({ name: 'blocks_role', type: 'varchar', length: 64, nullable: true })
  blocksRole?: string | null;

  @Column({ name: 'status', type: 'varchar', length: 20, default: 'PENDING' })
--- a/apps/edr-freight-api/src/modules/contracts/entities/contract-document-revision.entity.ts
+++ b/apps/edr-freight-api/src/modules/contracts/entities/contract-document-revision.entity.ts
@@ -0,0 +1,36 @@
+import { BaseEntity } from '@edr/api-common';
+import { Column, Entity, Index, JoinColumn, ManyToOne } from 'typeorm';
+import type { ContractDocumentChange } from '../contract-document-diff.util';
+import { Contract } from './contract.entity';
+
+/**
+ * Append-only audit of contract document edits. The document stays editable
+ * through the whole approval chain, so this records who changed which article
+ * and when — the contract itself only ever holds the current snapshot.
+ */
+@Entity({ schema: 'freight', name: 'contract_document_revisions' })
+@Index(['contractId'])
+export class ContractDocumentRevision extends BaseEntity {
+  @Column({ name: 'contract_id', type: 'uuid' })
+  contractId!: string;
+
+  @ManyToOne(() => Contract, { onDelete: 'CASCADE' })
+  @JoinColumn({ name: 'contract_id' })
+  contract?: Contract;
+
+  @Column({ name: 'actor_id', type: 'uuid', nullable: true })
+  actorId?: string | null;
+
+  /** The approval step's required role at the time of the edit. */
+  @Column({ name: 'actor_role', type: 'varchar', length: 64, nullable: true })
+  actorRole?: string | null;
+
+  @Column({ name: 'step_id', type: 'uuid', nullable: true })
+  stepId?: string | null;
+
+  @Column({ name: 'summary', type: 'varchar', length: 255, nullable: true })
+  summary?: string | null;
+
+  @Column({ name: 'changes', type: 'jsonb', default: () => `'[]'::jsonb` })
+  changes!: ContractDocumentChange[];
+}
--- a/apps/edr-freight-api/src/modules/rule-engine/controllers/approval-rules.controller.ts
+++ b/apps/edr-freight-api/src/modules/rule-engine/controllers/approval-rules.controller.ts
@@ -31,6 +31,15 @@ export class ApprovalRulesController {
    return this.service.findChain(flag === 'true');
  }

+  @Get('position-types')
+  @RuleEngineView('approval-rules')
+  @ApiOperation({
+    summary: 'IAM position types to choose from when building an approval chain',
+  })
+  listPositionTypes() {
+    return this.service.listPositionTypes();
+  }
+
  @Post('reorder')
  @RuleEngineManage('approval-rules')
  @HttpCode(HttpStatus.NO_CONTENT)
--- a/apps/edr-freight-api/src/modules/rule-engine/dto/create-approval-rule.dto.ts
+++ b/apps/edr-freight-api/src/modules/rule-engine/dto/create-approval-rule.dto.ts
@@ -1,8 +1,6 @@
 import { ApiProperty, ApiPropertyOptional } from '@nestjs/swagger';
 import { IsBoolean, IsInt, IsOptional, IsString, IsUUID, MaxLength, Min } from 'class-validator';

-const ROLES = ['LINE_STAFF', 'DIRECTOR', 'CEO'] as const;
-
 export class CreateApprovalRuleDto {
  @ApiProperty({ description: 'True = Director+CEO chain; False = LineStaff+Director chain' })
  @IsBoolean()
@@ -19,9 +17,12 @@ export class CreateApprovalRuleDto {
  @IsUUID('4')
  insertAfterId?: string;

-  @ApiProperty({ enum: ROLES, description: 'Role required to action this step' })
+  @ApiProperty({
+    description:
+      'IAM position-type key required to action this step (see GET /approval-rules/position-types)',
+  })
  @IsString()
-  @MaxLength(30)
+  @MaxLength(64)
  requiredRole!: string;

  @ApiProperty({ description: 'Label shown in UI, e.g. "Review & Approve"', maxLength: 50 })
@@ -29,9 +30,11 @@ export class CreateApprovalRuleDto {
  @MaxLength(50)
  actionLabel!: string;

-  @ApiPropertyOptional({ enum: ROLES, description: 'Role explicitly blocked from actioning this step' })
+  @ApiPropertyOptional({
+    description: 'IAM position-type key explicitly blocked from actioning this step',
+  })
  @IsOptional()
  @IsString()
-  @MaxLength(30)
+  @MaxLength(64)
  blocksRole?: string;
 }
--- a/apps/edr-freight-api/src/modules/rule-engine/entities/approval-rule.entity.ts
+++ b/apps/edr-freight-api/src/modules/rule-engine/entities/approval-rule.entity.ts
@@ -12,12 +12,12 @@ export class ApprovalRule extends BaseEntity {
  @Column({ name: 'step_order', type: 'smallint' })
  stepOrder!: number;

-  @Column({ name: 'required_role', type: 'varchar', length: 30 })
+  @Column({ name: 'required_role', type: 'varchar', length: 64 })
  requiredRole!: string;

  @Column({ name: 'action_label', type: 'varchar', length: 50 })
  actionLabel!: string;

-  @Column({ name: 'blocks_role', type: 'varchar', length: 30, nullable: true })
+  @Column({ name: 'blocks_role', type: 'varchar', length: 64, nullable: true })
  blocksRole?: string | null;
 }
--- a/apps/edr-freight-api/src/modules/rule-engine/rule-engine.module.ts
+++ b/apps/edr-freight-api/src/modules/rule-engine/rule-engine.module.ts
@@ -64,7 +64,6 @@ import { RuleEngineService } from './rule-engine.service';

 import { NotificationInboxModule } from '../notification-inbox/notification-inbox.module';

-import { BookingApprovalStep } from '../bookings/entities/booking-approval-step.entity';
 import { BookingCargoModifier } from '../bookings/entities/booking-cargo-modifier.entity';
 import { BookingContainer } from '../bookings/entities/booking-container.entity';
 import { BookingRateSnapshot } from '../bookings/entities/booking-rate-snapshot.entity';
@@ -87,7 +86,6 @@ import { BookingRateSnapshot } from '../bookings/entities/booking-rate-snapshot.
      ApprovalRule,
      BookingContainer,
      BookingCargoModifier,
-      BookingApprovalStep,
      BookingRateSnapshot,
    ]),
    // Team notifications for the priority-rule approval workflow.
--- a/apps/edr-freight-api/src/modules/rule-engine/rule-engine.service.ts
+++ b/apps/edr-freight-api/src/modules/rule-engine/rule-engine.service.ts
@@ -1,6 +1,5 @@
 import { Inject, Injectable, BadRequestException } from '@nestjs/common';
 import { DataSource } from 'typeorm';
-import { BookingApprovalStep } from '../bookings/entities/booking-approval-step.entity';
 import { BookingRateSnapshot } from '../bookings/entities/booking-rate-snapshot.entity';
 import { Rate, RateTrigger } from './entities/rate.entity';
 import {
@@ -23,15 +22,10 @@ import {
  IRatesRepository,
  RATES_REPOSITORY,
 } from './interfaces/rates.repository.interface';
-import {
-  IApprovalRulesRepository,
-  APPROVAL_RULES_REPOSITORY,
-} from './interfaces/approval-rules.repository.interface';
 import {
  IShippingLinesRepository,
  SHIPPING_LINES_REPOSITORY,
 } from './interfaces/shipping-lines.repository.interface';
-import { DEFAULT_APPROVAL_RULE_ROWS } from './approval-rules.defaults';
 import { GOVERNMENT_PRIORITY_BONUS } from './government-priority.constants';

 export interface BookingContainerEvalInput {
@@ -124,8 +118,6 @@ export class RuleEngineService {
    private readonly priorityConfigsRepo: IPriorityConfigsRepository,
    @Inject(RATES_REPOSITORY)
    private readonly ratesRepo: IRatesRepository,
-    @Inject(APPROVAL_RULES_REPOSITORY)
-    private readonly approvalRulesRepo: IApprovalRulesRepository,
    @Inject(SHIPPING_LINES_REPOSITORY)
    private readonly shippingLinesRepo: IShippingLinesRepository,
    private readonly dataSource: DataSource,
@@ -390,79 +382,6 @@ export class RuleEngineService {
    return violations;
  }

-  /**
-   * Ensure ITMLS default approval chains exist (container + bulk). Idempotent.
-   */
-  async ensureDefaultApprovalRules(): Promise<void> {
-    for (const flag of [false, true] as const) {
-      const existing = await this.approvalRulesRepo.findChainForCargo(flag);
-      if (existing.length > 0) continue;
-
-      const rows = DEFAULT_APPROVAL_RULE_ROWS.filter(
-        (r) => r.requiresDirectorApproval === flag,
-      );
-      for (const row of rows) {
-        await this.approvalRulesRepo.create({
-          requiresDirectorApproval: row.requiresDirectorApproval,
-          stepOrder: row.stepOrder,
-          requiredRole: row.requiredRole,
-          actionLabel: row.actionLabel,
-          blocksRole: row.blocksRole,
-        });
-      }
-    }
-  }
-
-  /**
-   * Instantiate booking_approval_step rows from approval_rules by freight type.
-   */
-  async instantiateApprovalSteps(
-    bookingId: string,
-    options: {
-      freightType: 'CONTAINER' | 'BULK';
-      cargoTypeId?: string | null;
-    },
-  ): Promise<BookingApprovalStep[]> {
-    await this.ensureDefaultApprovalRules();
-
-    let requiresDirectorApproval = false;
-
-    if (options.cargoTypeId) {
-      const cargoType = await this.cargoTypesRepo.findById(options.cargoTypeId);
-      if (!cargoType) {
-        throw new BadRequestException(`Cargo type ${options.cargoTypeId} not found`);
-      }
-      requiresDirectorApproval = cargoType.requiresDirectorApproval;
-    }
-
-    const chain = await this.approvalRulesRepo.findChainForCargo(
-      requiresDirectorApproval,
-    );
-
-    if (chain.length === 0) {
-      throw new BadRequestException(
-        `Approval chain could not be loaded for requiresDirectorApproval=${requiresDirectorApproval}.`,
-      );
-    }
-
-    const stepRepo = this.dataSource.getRepository(BookingApprovalStep);
-    const steps: BookingApprovalStep[] = [];
-
-    for (const rule of chain) {
-      const step = stepRepo.create({
-        bookingId,
-        approvalRuleId: rule.id,
-        stepOrder: rule.stepOrder,
-        requiredRole: rule.requiredRole,
-        blocksRole: rule.blocksRole ?? null,
-        status: 'PENDING',
-      });
-      steps.push(await stepRepo.save(step));
-    }
-
-    return steps;
-  }
-
  /**
   * Snapshot only the rates used in a booking's final price.
   */
--- a/apps/edr-freight-api/src/modules/rule-engine/services/approval-rules.service.ts
+++ b/apps/edr-freight-api/src/modules/rule-engine/services/approval-rules.service.ts
@@ -1,5 +1,6 @@
 import { PaginatedResponse } from '@edr/types';
 import { BadRequestException, Inject, Injectable, NotFoundException } from '@nestjs/common';
+import { DataSource } from 'typeorm';
 import { CreateApprovalRuleDto } from '../dto/create-approval-rule.dto';
 import { ListApprovalRulesQueryDto } from '../dto/list-rule-engine-query.dto';
 import { ReorderItemsDto } from '../dto/reorder-items.dto';
@@ -17,6 +18,7 @@ export class ApprovalRulesService {
    @Inject(APPROVAL_RULES_REPOSITORY)
    private readonly repository: IApprovalRulesRepository,
    private readonly displayOrder: DisplayOrderService,
+    private readonly dataSource: DataSource,
  ) {}

  /** List approval rules — standard paginated envelope with server-side search. */
@@ -29,6 +31,21 @@ export class ApprovalRulesService {
    return this.repository.findChainForCargo(requiresDirectorApproval);
  }

+  /**
+   * IAM position types, for the approval-step role picker. A chain step names
+   * the position type that must approve it, so this is the vocabulary an admin
+   * builds chains from. Read straight from the shared `iam` schema — the same
+   * pattern the freight API already uses for `iam.users`.
+   */
+  async listPositionTypes(): Promise<Array<{ label: string; value: string }>> {
+    const rows = await this.dataSource.query<
+      Array<{ key: string; label: string }>
+    >(`SELECT key, COALESCE(name->>'en', key) AS label
+         FROM iam.position_types
+        ORDER BY 2`);
+    return rows.map((row) => ({ label: row.label, value: row.key }));
+  }
+
  /** Get an approval rule by ID. */
  async findById(id: string): Promise<ApprovalRule> {
    const entity = await this.repository.findById(id);
--- a/apps/edr-freight-web/backoffice/src/components/bookings/ApprovalStepsCard.tsx
+++ b/apps/edr-freight-web/backoffice/src/components/bookings/ApprovalStepsCard.tsx
@@ -1,217 +0,0 @@
-import { useMemo, useState } from "react";
-import { Check, ShieldCheck } from "lucide-react";
-import { Stack, Group, Text, Badge, Button, Box } from "@mantine/core";
-
-import { BookingConfirmDialog } from "./BookingConfirmDialog";
-import { useAuth } from "@/auth/useAuth";
-import { formatApprovalProgress } from "@/features/bookings/approval-progress";
-import {
-  buildApproveActionForStep,
-  canActOnApprovalStep,
-  getNextPendingApprovalStep,
-} from "@/features/bookings/booking-actions.config";
-import type { useBookingMutations } from "@/hooks/bookings/useBookings";
-import type { BookingApprovalStep, BookingDetail } from "@/types/booking";
-import { SectionCard } from "./detail/SectionCard";
-
-type Mutations = ReturnType<typeof useBookingMutations>;
-
-interface ApprovalStepsCardProps {
-  booking: BookingDetail;
-  mutations: Mutations;
-}
-
-/** Approval chain with inline approve on the current pending step. */
-export function ApprovalStepsCard({ booking, mutations }: ApprovalStepsCardProps) {
-  const { user } = useAuth();
-  const [confirmOpen, setConfirmOpen] = useState(false);
-  const [pendingStep, setPendingStep] = useState<BookingApprovalStep | null>(null);
-
-  const steps = useMemo(
-    () => [...(booking.approvalSteps ?? [])].sort((a, b) => a.stepOrder - b.stepOrder),
-    [booking.approvalSteps],
-  );
-
-  const nextPending = getNextPendingApprovalStep(steps);
-  const summary = formatApprovalProgress(booking.status, steps);
-  const pendingAction = pendingStep ? buildApproveActionForStep(pendingStep) : null;
-
-  const openApprove = (step: BookingApprovalStep) => {
-    setPendingStep(step);
-    setConfirmOpen(true);
-  };
-
-  const closeApprove = () => {
-    setConfirmOpen(false);
-    setPendingStep(null);
-  };
-
-  const runApprove = () => {
-    if (!pendingStep) return;
-    mutations.approveStep.mutate(
-      { stepId: pendingStep.id, requiredRole: pendingStep.requiredRole },
-      { onSuccess: () => closeApprove() },
-    );
-  };
-
-  const subtitle =
-    summary.detail ||
-    (nextPending
-      ? `Next: ${nextPending.requiredRole} · step ${nextPending.stepOrder}`
-      : steps.length
-        ? "All steps complete"
-        : "Accept submission to begin");
-
-  return (
-    <>
-      <SectionCard
-        icon={ShieldCheck}
-        title="Approval chain"
-        extra={
-          <Badge color="edr-green" variant="light" radius="sm">
-            {steps.filter((s) => s.status === "APPROVED").length}/{steps.length}
-          </Badge>
-        }
-      >
-        <Text size="xs" c="dimmed" mb="sm">
-          {subtitle}
-        </Text>
-
-        {steps.length === 0 ? (
-          <Text
-            size="sm"
-            c="dimmed"
-            ta="center"
-            py="lg"
-            px="md"
-            style={{
-              borderRadius: 8,
-              border: "1px dashed var(--mantine-color-gray-3)",
-              background: "var(--mantine-color-gray-0)",
-            }}
-          >
-            Use <strong>Accept for approval</strong> in staff actions to instantiate steps.
-          </Text>
-        ) : (
-          <Stack gap="xs">
-            {steps.map((step) => (
-              <StepRow
-                key={step.id}
-                step={step}
-                steps={steps}
-                user={user}
-                isNext={nextPending?.id === step.id}
-                isPending={mutations.approveStep.isPending}
-                onApprove={openApprove}
-              />
-            ))}
-          </Stack>
-        )}
-      </SectionCard>
-
-      <BookingConfirmDialog
-        open={confirmOpen}
-        onOpenChange={(open) => {
-          if (!open) closeApprove();
-          else setConfirmOpen(true);
-        }}
-        action={pendingAction}
-        reference={booking.reference}
-        inputValue=""
-        onInputChange={() => {}}
-        onConfirm={runApprove}
-        isPending={mutations.approveStep.isPending}
-      />
-    </>
-  );
-}
-
-function StepRow({
-  step,
-  steps,
-  user,
-  isNext,
-  isPending,
-  onApprove,
-}: {
-  step: BookingApprovalStep;
-  steps: BookingApprovalStep[];
-  user: ReturnType<typeof useAuth>["user"];
-  isNext: boolean;
-  isPending: boolean;
-  onApprove: (step: BookingApprovalStep) => void;
-}) {
-  const canApprove = canActOnApprovalStep(user, step, steps);
-  const statusColor =
-    step.status === "APPROVED"
-      ? "edr-green"
-      : step.status === "REJECTED"
-        ? "red"
-        : isNext
-          ? "edr-green"
-          : "gray";
-
-  return (
-    <Group
-      justify="space-between"
-      wrap="nowrap"
-      gap="sm"
-      px="sm"
-      py="xs"
-      style={{
-        borderRadius: 8,
-        border: "1px solid var(--mantine-color-gray-2)",
-        borderLeft: isNext
-          ? "3px solid var(--freight-brand)"
-          : "1px solid var(--mantine-color-gray-2)",
-        background: isNext ? "var(--mantine-color-gray-0)" : "white",
-      }}
-    >
-      <Group gap="sm" wrap="nowrap" style={{ minWidth: 0 }}>
-        <Box
-          style={{
-            display: "flex",
-            alignItems: "center",
-            justifyContent: "center",
-            width: 28,
-            height: 28,
-            borderRadius: 8,
-            flexShrink: 0,
-            fontSize: 12,
-            fontWeight: 700,
-            background: "var(--mantine-color-gray-1)",
-            color: isNext ? "var(--mantine-color-gray-7)" : "var(--mantine-color-gray-6)",
-          }}
-        >
-          {step.stepOrder}
-        </Box>
-        <Box style={{ minWidth: 0 }}>
-          <Text size="sm" fw={600}>
-            {step.requiredRole}
-          </Text>
-          {step.remarks && (
-            <Text size="xs" c="dimmed" truncate>
-              {step.remarks}
-            </Text>
-          )}
-        </Box>
-      </Group>
-      <Group gap="xs" wrap="nowrap" style={{ flexShrink: 0 }}>
-        {canApprove && (
-          <Button
-            size="compact-sm"
-            color="edr-green"
-            leftSection={<Check size={14} />}
-            disabled={isPending}
-            onClick={() => onApprove(step)}
-          >
-            Approve
-          </Button>
-        )}
-        <Badge variant="light" color={statusColor} size="sm" radius="sm" tt="uppercase">
-          {step.status}
-        </Badge>
-      </Group>
-    </Group>
-  );
-}
--- a/apps/edr-freight-web/backoffice/src/components/bookings/BookingActionsMenu.tsx
+++ b/apps/edr-freight-web/backoffice/src/components/bookings/BookingActionsMenu.tsx
@@ -6,7 +6,6 @@ import { BookingConfirmDialog } from "./BookingConfirmDialog";
 import { useBookingActionDialog } from "./useBookingActionDialog";
 import { useAuth } from "@/auth/useAuth";
 import {
-  getNextPendingApprovalStep,
  isAllocateAction,
  isClearanceNavAction,
  isContractNavAction,
@@ -37,7 +36,6 @@ export function BookingActionsMenu({
    status: row.status,
    paymentCurrency: row.paymentCurrency,
    reference: row.reference,
-    approvalSteps: row.approvalSteps,
    schedulingStatus: row.schedulingStatus,
    customsClearingEnabled: row.customsClearingEnabled,
  };
@@ -192,28 +190,6 @@ function ActionDialog({
      }}
      isPending={flow.mutations.isPending || flow.detailLoading}
      confirmDisabled={flow.confirmDisabled}
-      extra={
-        flow.detailLoading ? (
-          <Text size="sm" c="dimmed">
-            Loading approval steps…
-          </Text>
-        ) : pendingAction?.id === "approve" &&
-          !getNextPendingApprovalStep(flow.mergedContext.approvalSteps) ? (
-          <Text
-            size="sm"
-            c="orange.9"
-            p="xs"
-            style={{
-              borderRadius: 8,
-              border: "1px solid var(--mantine-color-orange-2)",
-              background: "var(--mantine-color-orange-0)",
-            }}
-          >
-            No pending approval step. Refresh the page after staff accept, or reject the
-            booking.
-          </Text>
-        ) : null
-      }
    />
  );
 }
--- a/apps/edr-freight-web/backoffice/src/components/bookings/BookingApprovalProgressCell.tsx
+++ b/apps/edr-freight-web/backoffice/src/components/bookings/BookingApprovalProgressCell.tsx
@@ -1,29 +0,0 @@
-import { formatApprovalProgress } from "@/features/bookings/approval-progress";
-import type { BookingListRow } from "@/types/booking";
-import { cn } from "@/lib/utils";
-
-interface BookingApprovalProgressCellProps {
-  row: BookingListRow;
-}
-
-export function BookingApprovalProgressCell({ row }: BookingApprovalProgressCellProps) {
-  const summary = formatApprovalProgress(row.status, row.approvalSteps);
-
-  return (
-    <div className="min-w-[8.5rem] py-1">
-      <p
-        className={cn(
-          "text-sm font-semibold",
-          summary.complete ? "text-[color:var(--freight-brand)]" : "text-foreground",
-        )}
-      >
-        {summary.label}
-      </p>
-      {summary.detail ? (
-        <p className="mt-0.5 line-clamp-2 text-[11px] leading-snug text-muted-foreground">
-          {summary.detail}
-        </p>
-      ) : null}
-    </div>
-  );
-}
--- a/apps/edr-freight-web/backoffice/src/components/bookings/detail/BookingApprovalCard.tsx
+++ b/apps/edr-freight-web/backoffice/src/components/bookings/detail/BookingApprovalCard.tsx
@@ -1,69 +0,0 @@
-import { CheckCircle, Clock, XCircle } from "lucide-react";
-import { Group, Text, Badge, Timeline } from "@mantine/core";
-
-import { SectionCard } from "./SectionCard";
-import {
-  approvalStatusColor,
-  formatDateTime,
-  type BookingApprovalStepView,
-} from "./booking-detail.styles";
-
-export interface BookingApprovalCardProps {
-  steps: BookingApprovalStepView[];
-  approvedCount: number;
-}
-
-/** Vertical timeline of the booking's approval chain. */
-export function BookingApprovalCard({ steps, approvedCount }: BookingApprovalCardProps) {
-  return (
-    <SectionCard
-      icon={CheckCircle}
-      title="Approval Workflow"
-      accent="edr-green"
-      extra={
-        <Badge color="edr-green" variant="light" radius="sm">
-          {approvedCount} / {steps.length} approved
-        </Badge>
-      }
-    >
-      <Timeline active={approvedCount - 1} bulletSize={26} lineWidth={2} color="edr-green">
-        {steps.map((step) => (
-          <Timeline.Item
-            key={step.id}
-            color={approvalStatusColor(step.status)}
-            bullet={
-              step.status === "APPROVED" ? (
-                <CheckCircle size={14} />
-              ) : step.status === "REJECTED" ? (
-                <XCircle size={14} />
-              ) : (
-                <Clock size={14} />
-              )
-            }
-            title={
-              <Group gap="sm">
-                <Text fw={600} size="sm">
-                  {step.requiredRole.replace(/_/g, " ")}
-                </Text>
-                <Badge
-                  color={approvalStatusColor(step.status)}
-                  size="xs"
-                  radius="sm"
-                  variant="light"
-                >
-                  {step.status}
-                </Badge>
-              </Group>
-            }
-          >
-            {step.actionedAt && (
-              <Text size="xs" c="dimmed">
-                {formatDateTime(step.actionedAt)}
-              </Text>
-            )}
-          </Timeline.Item>
-        ))}
-      </Timeline>
-    </SectionCard>
-  );
-}
--- a/apps/edr-freight-web/backoffice/src/components/bookings/detail/booking-detail.styles.ts
+++ b/apps/edr-freight-web/backoffice/src/components/bookings/detail/booking-detail.styles.ts
@@ -102,14 +102,6 @@ export interface BookingContainerView {
  };
 }

-export interface BookingApprovalStepView {
-  id: string;
-  stepOrder: number;
-  requiredRole: string;
-  status: string;
-  actionedAt?: string | null;
-}
-
 export interface BookingReviewNoteView {
  id: string;
  note: string;
@@ -150,7 +142,6 @@ export interface BookingDetailView {
  cargoType?: BookingNamedRefView;
  shippingLine?: BookingNamedRefView;
  bookingContainers?: BookingContainerView[];
-  approvalSteps?: BookingApprovalStepView[];
  reviewNotes?: BookingReviewNoteView[];
  files?: BookingFileView[];
 }
--- a/apps/edr-freight-web/backoffice/src/components/bookings/detail/index.ts
+++ b/apps/edr-freight-web/backoffice/src/components/bookings/detail/index.ts
@@ -10,7 +10,6 @@ export * from "./BookingLifecycleStepper";
 export * from "./BookingRouteCard";
 export * from "./BookingContainersCard";
 export * from "./BookingContainerUnitsCard";
-export * from "./BookingApprovalCard";
 export * from "./BookingReviewNotesCard";
 export * from "./BookingPaymentCard";
 export * from "./BookingPaymentCountdownCard";
--- a/apps/edr-freight-web/backoffice/src/components/bookings/useBookingActionDialog.ts
+++ b/apps/edr-freight-web/backoffice/src/components/bookings/useBookingActionDialog.ts
@@ -2,12 +2,11 @@ import { useCallback, useState } from "react";

 import {
  getBookingActions,
-  getNextPendingApprovalStep,
  type BookingActionContext,
  type BookingActionDef,
 } from "@/features/bookings/booking-actions.config";
 import { useAuth } from "@/auth/useAuth";
-import { useBookingDetail, useBookingMutations } from "@/hooks/bookings/useBookings";
+import { useBookingMutations } from "@/hooks/bookings/useBookings";

 /** A contract validity window must be a whole number of days, 1–365. */
 function isValidValidityDays(value: string): boolean {
@@ -24,22 +23,11 @@ export function useBookingActionDialog(
  const [selectedFile, setSelectedFile] = useState<File | null>(null);
  const [dialogOpen, setDialogOpen] = useState(false);

-  const needsApprovalSteps =
-    pendingAction?.id === "approve" || pendingAction?.id === "rejectApproval";
+  // Bookings no longer have an approval chain, so the dialog needs nothing
+  // beyond the list-row context it was handed.
+  const detailLoading = false;

-  const needsApprovalContext =
-    context.status === "PENDING_APPROVAL" ||
-    context.status === "APPROVED_PENDING_SIGNATURE";
-
-  const { data: detail, isLoading: detailLoading } = useBookingDetail(
-    needsApprovalSteps || needsApprovalContext ? bookingId : undefined,
-  );
-
-  const mergedContext: BookingActionContext = {
-    ...context,
-    approvalSteps: detail?.approvalSteps ?? context.approvalSteps,
-    reference: detail?.reference ?? context.reference,
-  };
+  const mergedContext: BookingActionContext = { ...context };

  const { user } = useAuth();
  const mutations = useBookingMutations(bookingId);
@@ -86,24 +74,6 @@ export function useBookingActionDialog(
          { onSuccess },
        );
        break;
-      case "approve": {
-        const step = getNextPendingApprovalStep(mergedContext.approvalSteps);
-        if (!step) return;
-        mutations.approveStep.mutate(
-          { stepId: step.id, requiredRole: step.requiredRole },
-          { onSuccess },
-        );
-        break;
-      }
-      case "rejectApproval": {
-        const step = getNextPendingApprovalStep(mergedContext.approvalSteps);
-        if (!step) return;
-        mutations.rejectStep.mutate(
-          { stepId: step.id, reason: inputValue.trim() },
-          { onSuccess },
-        );
-        break;
-      }
      case "viewContract":
        break;
      case "startTransit":
@@ -122,16 +92,12 @@ export function useBookingActionDialog(
    pendingAction,
    inputValue,
    selectedFile,
-    mergedContext.approvalSteps,
    mutations,
    closeDialog,
  ]);

  const confirmDisabled =
    mutations.isPending ||
-    (needsApprovalSteps && detailLoading) ||
-    (pendingAction?.id === "approve" &&
-      !getNextPendingApprovalStep(mergedContext.approvalSteps)) ||
    (pendingAction?.input === "file" && !selectedFile) ||
    (pendingAction?.input === "reason" && !inputValue.trim()) ||
    (pendingAction?.input === "note" && !inputValue.trim()) ||
--- a/apps/edr-freight-web/backoffice/src/components/contracts/ContractActionsToolbar.tsx
+++ b/apps/edr-freight-web/backoffice/src/components/contracts/ContractActionsToolbar.tsx
@@ -4,11 +4,10 @@ import { useQuery } from "@tanstack/react-query";
 import { Button, Modal, Stack, Text, Textarea } from "@mantine/core";
 import {
  Check,
-  FileCheck,
+  Eye,
  FilePen,
  FileSignature,
  MessageSquareWarning,
-  RefreshCw,
  ShieldCheck,
  XCircle,
  Zap,
@@ -16,8 +15,10 @@ import {
 import type { Freight } from "@edr/types";

 import { api } from "@/services/api";
+import { contractsService } from "@/services/contracts.service";
 import { SectionCard } from "@/components/bookings/detail/SectionCard";
 import { ContractDocumentEditorModal } from "@/components/contracts/ContractDocumentEditorModal";
+import { ContractPreviewModal } from "@/components/contracts/ContractPreviewModal";
 import type { useContractMutations } from "@/hooks/contracts/useContracts";

 /** Dropdown-settings code holding the admin-configured contract validity days. */
@@ -51,11 +52,21 @@ export function ContractActionsToolbar({

  const [editorOpen, setEditorOpen] = useState(false);
  const [editorMode, setEditorMode] = useState<"accept" | "edit">("accept");
+  const [previewOpen, setPreviewOpen] = useState(false);
  const [changesOpen, setChangesOpen] = useState(false);
  const [changesNote, setChangesNote] = useState("");
  const [rejectOpen, setRejectOpen] = useState(false);
  const [rejectReason, setRejectReason] = useState("");

+  // Whether the document is editable depends on WHO is viewing — only the
+  // approver whose turn it is may edit — so the server decides, not the client.
+  const { data: draft } = useQuery({
+    queryKey: ["contracts", contract.id, "document-draft"],
+    queryFn: () => contractsService.getContractDocumentDraft(contract.id),
+    enabled: contract.status === "PENDING_APPROVAL",
+    staleTime: 0,
+  });
+
  // Admin-configured validity durations (days) for the accept dialog. Staff can
  // only pick one of these — no free-typing. Read-only setting, fetched once.
  const { data: validitySetting, isLoading: validityLoading } = useQuery({
@@ -87,18 +98,11 @@ export function ContractActionsToolbar({
  }

  const canAccept = status === "SUBMITTED";
-  // While the contract is PENDING_APPROVAL and NO approver has acted yet, staff
-  // can edit this contract's articles and (re)generate its PDF. The first
-  // approval action locks the document.
-  const docLocked =
-    status !== "PENDING_APPROVAL" ||
-    (contract.approvalSteps ?? []).some((s) => s.status !== "PENDING");
-  const canEditGenerate = status === "PENDING_APPROVAL" && !docLocked;
-  const documentGenerated = Boolean(contract.contractGeneratedAt);
-  // Legacy fallback: if a contract ever lands on APPROVED without a document
-  // (older flow), still offer a manual generate that moves it to CONTRACT_READY.
-  const needsManualGenerate =
-    status === "APPROVED" && !contract.contractGeneratedAt;
+  // The document stays editable for the whole approval chain, but only by the
+  // approver whose turn it is. The server resolves that against the caller's
+  // position type; the client cannot derive it.
+  const canEditDocument = Boolean(draft?.editableByMe);
+  const inApproval = status === "PENDING_APPROVAL";
  // Signing now happens on the contract VIEW page (staff must open and read the
  // generated contract before signing) — no sign button in this toolbar.
  const canViewContract =
@@ -154,56 +158,41 @@ export function ContractActionsToolbar({
          </>
        )}

-        {canEditGenerate && (
+        {inApproval && (
          <>
            <Text size="xs" c="dimmed">
-              {documentGenerated
-                ? "Document generated. Approvers can now review it. You can still edit and regenerate until the first approval."
-                : "Review the contract document, edit its articles if needed, then generate it so approvers can review."}
+              {canEditDocument
+                ? "It is your turn to approve. You can edit the articles before approving — the PDF is generated automatically once the last approver approves."
+                : draft?.nextApproverRole
+                  ? `Awaiting ${draft.nextApproverRole}. Only the current approver can edit the document.`
+                  : "Awaiting approval."}
            </Text>
            <Button
              fullWidth
              variant="light"
              color="gray"
-              leftSection={<FilePen size={16} />}
-              onClick={() => {
-                setEditorMode("edit");
-                setEditorOpen(true);
-              }}
+              leftSection={<Eye size={16} />}
+              onClick={() => setPreviewOpen(true)}
            >
-              Edit contract articles
-            </Button>
-            <Button
-              fullWidth
-              color="edr-green"
-              leftSection={
-                documentGenerated ? (
-                  <RefreshCw size={16} />
-                ) : (
-                  <FileCheck size={16} />
-                )
-              }
-              loading={mutations.generateContract.isPending}
-              onClick={() => mutations.generateContract.mutate()}
-            >
-              {documentGenerated ? "Regenerate contract" : "Generate contract"}
+              Preview document
            </Button>
+            {canEditDocument && (
+              <Button
+                fullWidth
+                variant="light"
+                color="gray"
+                leftSection={<FilePen size={16} />}
+                onClick={() => {
+                  setEditorMode("edit");
+                  setEditorOpen(true);
+                }}
+              >
+                Edit contract articles
+              </Button>
+            )}
          </>
        )}

-        {needsManualGenerate && (
-          <Button
-            fullWidth
-            variant="light"
-            color="orange"
-            leftSection={<FileCheck size={16} />}
-            loading={mutations.generateContract.isPending}
-            onClick={() => mutations.generateContract.mutate()}
-          >
-            Generate contract
-          </Button>
-        )}
-
        {canViewContract && (
          <Button
            fullWidth
@@ -233,8 +222,7 @@ export function ContractActionsToolbar({
            the customer creates the booking in the portal. */}

        {!canAccept &&
-          !canEditGenerate &&
-          !needsManualGenerate &&
+          !inApproval &&
          !canViewContract &&
          !canReviewClearance && (
            <Text size="sm" c="dimmed">
@@ -267,6 +255,12 @@ export function ContractActionsToolbar({
        }
      />

+      <ContractPreviewModal
+        opened={previewOpen}
+        onClose={() => setPreviewOpen(false)}
+        contractId={contract.id}
+      />
+
      {/* Request changes */}
      <Modal
        opened={changesOpen}
--- a/apps/edr-freight-web/backoffice/src/components/contracts/ContractApprovalStepsCard.tsx
+++ b/apps/edr-freight-web/backoffice/src/components/contracts/ContractApprovalStepsCard.tsx
@@ -1,5 +1,5 @@
 import { useMemo, useState } from "react";
-import { AlertTriangle, Check, FileCheck, ShieldCheck, X } from "lucide-react";
+import { AlertTriangle, Check, ShieldCheck, X } from "lucide-react";
 import {
  Stack,
  Group,
@@ -31,7 +31,6 @@ export function ContractApprovalStepsCard({
  const [confirmOpen, setConfirmOpen] = useState(false);
  const [pendingStep, setPendingStep] =
    useState<Freight.IContractApprovalStep | null>(null);
-  const [needsGenerateOpen, setNeedsGenerateOpen] = useState(false);
  const [rejectOpen, setRejectOpen] = useState(false);
  const [rejectStepRow, setRejectStepRow] =
    useState<Freight.IContractApprovalStep | null>(null);
@@ -48,17 +47,9 @@ export function ContractApprovalStepsCard({
  const nextPending = steps.find((s) => s.status === "PENDING");
  const summary = formatContractApprovalProgress(contract.status, steps);

-  // Approvers must review the GENERATED contract document before approving. If
-  // it has not been generated yet, block the approval and tell staff to generate
-  // it first (via "Generate contract" in Staff actions) — mirrors the server
-  // guard so the user sees a clear reason, not a generic failure toast.
-  const documentGenerated = Boolean(contract.contractGeneratedAt);
-
+  // Approvers review a live preview of the document; there is no PDF to
+  // generate first — the final approval is what produces it.
  const openApprove = (step: Freight.IContractApprovalStep) => {
-    if (contract.status === "PENDING_APPROVAL" && !documentGenerated) {
-      setNeedsGenerateOpen(true);
-      return;
-    }
    setPendingStep(step);
    setConfirmOpen(true);
  };
@@ -71,7 +62,7 @@ export function ContractApprovalStepsCard({
  const runApprove = () => {
    if (!pendingStep) return;
    mutations.approveStep.mutate(
-      { stepId: pendingStep.id, requiredRole: pendingStep.requiredRole },
+      { stepId: pendingStep.id },
      { onSuccess: () => closeApprove() },
    );
  };
@@ -192,46 +183,6 @@ export function ContractApprovalStepsCard({
        </Stack>
      </Modal>

-      <Modal
-        opened={needsGenerateOpen}
-        onClose={() => setNeedsGenerateOpen(false)}
-        title={
-          <Group gap="xs">
-            <AlertTriangle size={18} color="var(--mantine-color-orange-6)" />
-            <Text fw={700}>Generate the contract first</Text>
-          </Group>
-        }
-        radius="md"
-        centered
-      >
-        <Stack gap="md">
-          <Text size="sm" c="dimmed">
-            The contract document for{" "}
-            <Text span fw={600} c="dark">
-              {contract.reference}
-            </Text>{" "}
-            has not been generated yet. Approvers must review the generated
-            document before it can be approved.
-          </Text>
-          <Text size="sm" c="dimmed">
-            Use{" "}
-            <Text span fw={600} c="dark">
-              Generate contract
-            </Text>{" "}
-            in the Staff actions panel — edit the articles first if needed — then
-            return here to approve.
-          </Text>
-          <Group justify="flex-end">
-            <Button
-              color="edr-green"
-              leftSection={<FileCheck size={16} />}
-              onClick={() => setNeedsGenerateOpen(false)}
-            >
-              Got it
-            </Button>
-          </Group>
-        </Stack>
-      </Modal>

      <Modal
        opened={rejectOpen}
--- a/apps/edr-freight-web/backoffice/src/components/contracts/ContractDocumentEditorModal.tsx
+++ b/apps/edr-freight-web/backoffice/src/components/contracts/ContractDocumentEditorModal.tsx
@@ -116,7 +116,9 @@ export function ContractDocumentEditorModal({
    }
  }, [mode, validityDays, validityOptions]);

-  const locked = mode === "edit" && Boolean(draft?.locked);
+  // Editing rights belong to the approver whose turn it is, so the server
+  // decides per-caller — the client cannot derive this from the contract alone.
+  const locked = mode === "edit" && !draft?.editableByMe;

  const moveArticle = (index: number, delta: number) => {
    setArticles((prev) => {
@@ -215,7 +217,9 @@ export function ContractDocumentEditorModal({
            icon={locked ? <Lock size={16} /> : <Info size={16} />}
          >
            {locked
-              ? "This document is locked — an approver has already acted, so it can no longer be edited."
+              ? draft?.nextApproverRole
+                ? `Only the current approver (${draft.nextApproverRole}) can edit this document right now.`
+                : "This document can no longer be edited — the contract has advanced beyond approval."
              : "Edits apply to THIS contract only. The six shared templates are never changed."}
          </Alert>

--- a/apps/edr-freight-web/backoffice/src/components/contracts/ContractPreviewModal.tsx
+++ b/apps/edr-freight-web/backoffice/src/components/contracts/ContractPreviewModal.tsx
@@ -0,0 +1,78 @@
+import { useQuery } from "@tanstack/react-query";
+import { Alert, Group, Loader, Modal, Text } from "@mantine/core";
+import { Info } from "lucide-react";
+
+import { contractsService } from "@/services/contracts.service";
+
+interface ContractPreviewModalProps {
+  opened: boolean;
+  onClose: () => void;
+  contractId: string;
+}
+
+/**
+ * Live preview of the contract document. Renders server-side HTML, not the
+ * stored PDF — the PDF is only produced once the final approver approves, so
+ * before that this is the document. Served in an iframe so the contract's own
+ * styles stay sandboxed away from the app.
+ */
+export function ContractPreviewModal({
+  opened,
+  onClose,
+  contractId,
+}: ContractPreviewModalProps) {
+  const { data, isLoading, isError } = useQuery({
+    queryKey: ["contracts", contractId, "contract-view"],
+    queryFn: () => contractsService.getContractView(contractId),
+    enabled: opened,
+    // The document changes as approvers edit it, so never serve a stale render.
+    staleTime: 0,
+  });
+
+  return (
+    <Modal
+      opened={opened}
+      onClose={onClose}
+      size="xl"
+      title="Contract document preview"
+    >
+      <Alert
+        icon={<Info size={16} />}
+        color="blue"
+        variant="light"
+        mb="sm"
+        p="xs"
+      >
+        <Text size="xs">
+          Draft preview. The PDF is generated automatically once the final
+          approver approves.
+        </Text>
+      </Alert>
+
+      {isLoading ? (
+        <Group gap="xs" py="xl" justify="center">
+          <Loader size="sm" />
+          <Text size="sm" c="dimmed">
+            Rendering document…
+          </Text>
+        </Group>
+      ) : isError || !data?.html ? (
+        <Text size="sm" c="red">
+          The document could not be rendered. Check that the contract has a
+          template and try again.
+        </Text>
+      ) : (
+        <iframe
+          srcDoc={data.html}
+          title="Contract document preview"
+          style={{
+            width: "100%",
+            minHeight: "70vh",
+            border: "none",
+            background: "white",
+          }}
+        />
+      )}
+    </Modal>
+  );
+}
--- a/apps/edr-freight-web/backoffice/src/components/contracts/ContractRevisionTimeline.tsx
+++ b/apps/edr-freight-web/backoffice/src/components/contracts/ContractRevisionTimeline.tsx
@@ -0,0 +1,134 @@
+import { useQuery } from "@tanstack/react-query";
+import { History } from "lucide-react";
+import { Badge, Group, Loader, Stack, Text, Timeline } from "@mantine/core";
+import type { Freight } from "@edr/types";
+
+import { contractsService } from "@/services/contracts.service";
+import { SectionCard } from "@/components/bookings/detail/SectionCard";
+
+interface ContractRevisionTimelineProps {
+  contractId: string;
+}
+
+type Change = Freight.IContractDocumentChange;
+
+/** Badge colour + verb per change kind, so a revision reads at a glance. */
+const CHANGE_STYLES: Record<Change["kind"], { color: string; label: string }> = {
+  ARTICLE_ADDED: { color: "green", label: "Added" },
+  ARTICLE_REMOVED: { color: "red", label: "Removed" },
+  ARTICLE_RENAMED: { color: "violet", label: "Renamed" },
+  ARTICLE_BODY_CHANGED: { color: "blue", label: "Edited" },
+  ARTICLE_REORDERED: { color: "gray", label: "Reordered" },
+  DOCUMENT_TITLE_CHANGED: { color: "grape", label: "Title" },
+  WHEREAS_CHANGED: { color: "teal", label: "Recitals" },
+};
+
+/** What the change applies to — an article title, or the document itself. */
+function changeSubject(change: Change): string {
+  switch (change.kind) {
+    case "DOCUMENT_TITLE_CHANGED":
+      return change.fromTitle
+        ? `“${change.fromTitle}” → “${change.title}”`
+        : change.title;
+    case "WHEREAS_CHANGED": {
+      const parts: string[] = [];
+      if (change.added) parts.push(`+${change.added}`);
+      if (change.removed) parts.push(`−${change.removed}`);
+      return parts.join(" ") || "changed";
+    }
+    case "ARTICLE_RENAMED":
+      return `“${change.fromTitle}” → “${change.title}”`;
+    case "ARTICLE_REORDERED":
+      return `${change.title} (${change.fromOrder} → ${change.toOrder})`;
+    default:
+      return change.title;
+  }
+}
+
+function formatWhen(iso: string): string {
+  const date = new Date(iso);
+  return date.toLocaleString(undefined, {
+    dateStyle: "medium",
+    timeStyle: "short",
+  });
+}
+
+/**
+ * Audit trail of edits to the contract document. The document stays editable
+ * through the approval chain, so this is the record of who changed what.
+ */
+export function ContractRevisionTimeline({
+  contractId,
+}: ContractRevisionTimelineProps) {
+  const { data: revisions, isLoading } = useQuery({
+    queryKey: ["contracts", contractId, "document-revisions"],
+    queryFn: () => contractsService.getContractDocumentRevisions(contractId),
+  });
+
+  return (
+    <SectionCard icon={History} title="Document history">
+      {isLoading ? (
+        <Group gap="xs">
+          <Loader size="xs" />
+          <Text size="sm" c="dimmed">
+            Loading history…
+          </Text>
+        </Group>
+      ) : !revisions?.length ? (
+        <Text size="sm" c="dimmed">
+          No edits recorded yet. Changes made to the contract articles during
+          approval will appear here.
+        </Text>
+      ) : (
+        <Timeline
+          active={revisions.length}
+          bulletSize={18}
+          lineWidth={2}
+          color="edr-green"
+        >
+          {revisions.map((revision) => (
+            <Timeline.Item
+              key={revision.id}
+              title={
+                <Group gap="xs" wrap="nowrap">
+                  <Text size="sm" fw={600}>
+                    {revision.actorRole ?? "Staff"}
+                  </Text>
+                  <Text size="xs" c="dimmed">
+                    {formatWhen(revision.createdAt)}
+                  </Text>
+                </Group>
+              }
+            >
+              <Stack gap={6} mt={4}>
+                {revision.summary && (
+                  <Text size="xs" c="dimmed">
+                    {revision.summary}
+                  </Text>
+                )}
+                {revision.changes.map((change, index) => {
+                  const style = CHANGE_STYLES[change.kind];
+                  return (
+                    <Group key={index} gap="xs" wrap="nowrap" align="flex-start">
+                      <Badge
+                        size="xs"
+                        variant="light"
+                        color={style?.color ?? "gray"}
+                        style={{ flexShrink: 0 }}
+                      >
+                        {style?.label ?? change.kind}
+                      </Badge>
+                      <Text size="xs" style={{ lineHeight: 1.5 }}>
+                        {changeSubject(change)}
+                      </Text>
+                    </Group>
+                  );
+                })}
+              </Stack>
+            </Timeline.Item>
+          ))}
+        </Timeline>
+      )}
+    </SectionCard>
+  );
+}
--- a/apps/edr-freight-web/backoffice/src/constants/URLS.ts
+++ b/apps/edr-freight-web/backoffice/src/constants/URLS.ts
@@ -123,10 +123,6 @@ export const URL_CONSTANTS = {
      `/bookings/${id}/staff/request-changes`,
    STAFF_REJECT: (id: string) => `/bookings/${id}/staff/reject`,
    GOVERNMENT_EXPEDITE: (id: string) => `/bookings/${id}/government-expedite`,
-    APPROVE_STEP: (id: string, stepId: string) =>
-      `/bookings/${id}/approval-steps/${stepId}/approve`,
-    REJECT_STEP: (id: string, stepId: string) =>
-      `/bookings/${id}/approval-steps/${stepId}/reject`,
    CONTRACT_GENERATE: (id: string) => `/bookings/${id}/contract/generate`,
    CONTRACT_VIEW: (id: string) => `/bookings/${id}/contract/view`,
    CONTRACT_DOCUMENT: (id: string) => `/bookings/${id}/contract/document`,
@@ -177,6 +173,8 @@ export const URL_CONSTANTS = {
    CONTRACT_DOCUMENT: (id: string) => `/contracts/${id}/contract/document`,
    CONTRACT_SIGN: (id: string) => `/contracts/${id}/contract/sign`,
    CONTRACT_DOCUMENT_DRAFT: (id: string) => `/contracts/${id}/document/draft`,
+    CONTRACT_DOCUMENT_REVISIONS: (id: string) =>
+      `/contracts/${id}/document/revisions`,
    CONTRACT_DOCUMENT_ARTICLES: (id: string) =>
      `/contracts/${id}/document/articles`,
    CLEARANCE_QUEUE: "/contracts/clearance/queue",
@@ -437,6 +435,7 @@ export const URL_CONSTANTS = {
    APPROVAL_RULES: "/approval-rules",
    APPROVAL_RULE_BY_ID: (id: string) => `/approval-rules/${id}`,
    APPROVAL_RULES_CHAIN: "/approval-rules/chain",
+    APPROVAL_RULES_POSITION_TYPES: "/approval-rules/position-types",
  },
  RATE_MATRIX: {
    BASE: "/api/rate-matrices",
--- a/apps/edr-freight-web/backoffice/src/features/bookings/approval-progress.ts
+++ b/apps/edr-freight-web/backoffice/src/features/bookings/approval-progress.ts
@@ -1,79 +0,0 @@
-import type { BookingApprovalStep, BookingStatus } from "@/types/booking";
-import { getNextPendingApprovalStep } from "@/features/bookings/booking-actions.config";
-
-export interface ApprovalProgressSummary {
-  label: string;
-  detail: string;
-  complete: boolean;
-}
-
-/** Compact approval chain summary for list rows and badges. */
-export function formatApprovalProgress(
-  status: BookingStatus | string,
-  steps?: BookingApprovalStep[] | null,
-): ApprovalProgressSummary {
-  const sorted = [...(steps ?? [])].sort((a, b) => a.stepOrder - b.stepOrder);
-
-  if (sorted.length === 0) {
-    if (status === "SUBMITTED") {
-      return {
-        label: "Awaiting accept",
-        detail: "Staff must accept intake",
-        complete: false,
-      };
-    }
-    if (
-      status === "PENDING_APPROVAL" ||
-      status === "APPROVED_PENDING_SIGNATURE"
-    ) {
-      return {
-        label: "No steps",
-        detail: "Approval chain not started",
-        complete: false,
-      };
-    }
-    if (
-      [
-        "APPROVED",
-        "CONTRACT_READY",
-        "SIGNED_CUSTOMER",
-        "FULLY_EXECUTED",
-        "PAID",
-        "COMPLETED",
-      ].includes(status)
-    ) {
-      return {
-        label: "Approved",
-        detail: "Internal approval complete",
-        complete: true,
-      };
-    }
-    return { label: "—", detail: "", complete: false };
-  }
-
-  const approved = sorted.filter((s) => s.status === "APPROVED").length;
-  const total = sorted.length;
-  const next = getNextPendingApprovalStep(sorted);
-
-  if (!next && approved === total) {
-    return {
-      label: `${approved}/${total} done`,
-      detail: sorted.map((s) => `${s.requiredRole} ✓`).join(" · "),
-      complete: true,
-    };
-  }
-
-  if (next) {
-    return {
-      label: `${approved}/${total}`,
-      detail: `Next: ${next.requiredRole} (step ${next.stepOrder})`,
-      complete: false,
-    };
-  }
-
-  return {
-    label: `${approved}/${total}`,
-    detail: sorted.map((s) => `${s.requiredRole}: ${s.status}`).join(" · "),
-    complete: approved === total,
-  };
-}
--- a/apps/edr-freight-web/backoffice/src/features/bookings/booking-actions.config.ts
+++ b/apps/edr-freight-web/backoffice/src/features/bookings/booking-actions.config.ts
@@ -14,18 +14,12 @@ import {
  hasPermission,
  isFreightApprovalAdmin,
 } from "@/lib/permissions";
-import type {
-  BookingApprovalStep,
-  BookingDetail,
-  BookingStatus,
-} from "@/types/booking";
+import type { BookingDetail, BookingStatus } from "@/types/booking";

 export type BookingActionId =
  | "accept"
  | "requestChanges"
  | "reject"
-  | "approve"
-  | "rejectApproval"
  | "viewContract"
  | "signContractStaff"
  | "reviewClearance"
@@ -62,7 +56,6 @@ export type BookingActionContext = Pick<
  BookingDetail,
  | "status"
  | "paymentCurrency"
-  | "approvalSteps"
  | "reference"
  | "schedulingStatus"
  | "customsClearingEnabled"
@@ -86,39 +79,6 @@ export function canAllocateBooking(
  );
 }

-export function getNextPendingApprovalStep(
-  steps?: BookingApprovalStep[] | null,
-): BookingApprovalStep | undefined {
-  if (!steps?.length) return undefined;
-  return [...steps]
-    .sort((a, b) => a.stepOrder - b.stepOrder)
-    .find((s) => s.status === "PENDING");
-}
-
-function approvalActions(
-  steps?: BookingApprovalStep[] | null,
-): BookingActionDef[] {
-  const next = getNextPendingApprovalStep(steps);
-  if (!next) return [];
-  return [
-    buildApproveActionForStep(next),
-    {
-      id: "rejectApproval",
-      label: "Reject approval",
-      shortLabel: "Reject",
-      description: "Reject at the current approval step",
-      confirmTitle: "Reject at approval step?",
-      confirmDescription:
-        "The booking will be marked rejected. This action cannot be undone from the UI.",
-      variant: "destructive",
-      icon: XCircle,
-      input: "reason",
-      inputLabel: "Rejection reason",
-      inputPlaceholder: "Explain why this booking is rejected…",
-    },
-  ];
-}
-
 const SUBMITTED_ACTIONS: BookingActionDef[] = [
  {
    id: "accept",
@@ -232,7 +192,6 @@ const ACTION_PERMISSION: Partial<Record<BookingActionId, string>> = {
  accept: FREIGHT_PERMS.bookings.staffAccept,
  requestChanges: FREIGHT_PERMS.bookings.requestChanges,
  reject: FREIGHT_PERMS.bookings.reject,
-  rejectApproval: FREIGHT_PERMS.bookings.rejectApproval,
  viewContract: FREIGHT_PERMS.bookings.view,
  signContractStaff: FREIGHT_PERMS.bookings.signStaff,
  reviewClearance: FREIGHT_PERMS.bookings.reviewDocuments,
@@ -244,55 +203,12 @@ const ACTION_PERMISSION: Partial<Record<BookingActionId, string>> = {
  cancel: FREIGHT_PERMS.bookings.cancel,
 };

-const approvePermissionForRole = (role: string): string | undefined => {
-  if (role === "LINE_STAFF") return FREIGHT_PERMS.bookings.approveLineStaff;
-  if (role === "DIRECTOR") return FREIGHT_PERMS.bookings.approveDirector;
-  if (role === "CEO") return FREIGHT_PERMS.bookings.approveCeo;
-  return undefined;
-};
-
-/** True when this step is the current pending step and the user may approve it. */
-export function canActOnApprovalStep(
-  user: AuthUser | null | undefined,
-  step: BookingApprovalStep,
-  steps?: BookingApprovalStep[] | null,
-): boolean {
-  if (step.status !== "PENDING") return false;
-  const next = getNextPendingApprovalStep(steps);
-  if (!next || next.id !== step.id) return false;
-  if (isFreightApprovalAdmin(user)) return true;
-  const perm = approvePermissionForRole(step.requiredRole);
-  return perm ? hasPermission(user, perm) : false;
-}
-
-export function buildApproveActionForStep(
-  step: BookingApprovalStep,
-): BookingActionDef {
-  return {
-    id: "approve",
-    label: `Approve (${step.requiredRole})`,
-    shortLabel: "Approve",
-    description: `Complete step ${step.stepOrder} as ${step.requiredRole}`,
-    confirmTitle: `Approve as ${step.requiredRole}?`,
-    confirmDescription:
-      "This records your approval and advances the booking to the next step in the chain.",
-    variant: "default",
-    icon: Check,
-    primary: true,
-  };
-}
-
 function filterActionsByUser(
  actions: BookingActionDef[],
  user: AuthUser | null | undefined,
-  approvalSteps?: BookingApprovalStep[] | null,
 ): BookingActionDef[] {
  if (!user) return [];
-  const next = getNextPendingApprovalStep(approvalSteps);
  return actions.filter((action) => {
-    if (action.id === "approve" && next) {
-      return canActOnApprovalStep(user, next, approvalSteps);
-    }
    const perm = ACTION_PERMISSION[action.id];
    return perm ? hasPermission(user, perm) : true;
  });
@@ -303,7 +219,7 @@ export function getBookingActions(
  ctx: BookingActionContext,
  user?: AuthUser | null,
 ): BookingActionDef[] {
-  const { status, approvalSteps } = ctx;
+  const { status } = ctx;

  let actions: BookingActionDef[];

@@ -313,8 +229,6 @@ export function getBookingActions(
      break;
    case "PENDING_APPROVAL":
    case "APPROVED_PENDING_SIGNATURE":
-      actions = withCancel(approvalActions(approvalSteps));
-      break;
    case "APPROVED":
      actions = [CANCEL_ACTION];
      break;
@@ -370,7 +284,7 @@ export function getBookingActions(
  }

  if (user === undefined) return actions;
-  return filterActionsByUser(actions, user, approvalSteps);
+  return filterActionsByUser(actions, user);
 }

 /** Opens contract page without confirmation dialog. */
@@ -392,7 +306,6 @@ export function listRowHasActions(
  row: {
    status: BookingStatus;
    paymentCurrency: string;
-    approvalSteps?: BookingApprovalStep[] | null;
    customsClearingEnabled?: boolean;
  },
  user?: AuthUser | null,
@@ -402,7 +315,6 @@ export function listRowHasActions(
      status: row.status,
      paymentCurrency: row.paymentCurrency,
      reference: "",
-      approvalSteps: row.approvalSteps ?? undefined,
      schedulingStatus: row.status,
      customsClearingEnabled: row.customsClearingEnabled,
    },
--- a/apps/edr-freight-web/backoffice/src/features/bookings/mapBookingListRow.ts
+++ b/apps/edr-freight-web/backoffice/src/features/bookings/mapBookingListRow.ts
@@ -20,7 +20,6 @@ export function toBookingListRow(booking: BookingDetail): BookingListRow {
    reference: booking.reference,
    contractReference: booking.contractReference ?? null,
    contractId: booking.contractId ?? null,
-    approvalSteps: booking.approvalSteps,
    customerLabel: booking.isGovernment
      ? (booking.governmentInstitution ?? "Government")
      : labelFromRef(booking.company, booking.companyId ?? undefined),
@@ -46,6 +45,8 @@ export function toBookingListRow(booking: BookingDetail): BookingListRow {
    consolidationPartnerId: booking.consolidationPartnerId ?? null,
    consolidationPartnerReference: booking.consolidationPartner?.reference ?? null,
    customsClearingEnabled: booking.customsClearingEnabled ?? false,
+    bookingKind:
+      booking.contractKind === "GENERAL" ? "GENERAL_CONTRACT" : "ONE_TIME",
    createdAt: booking.createdAt,
  };
 }
--- a/apps/edr-freight-web/backoffice/src/hooks/bookings/useBookings.ts
+++ b/apps/edr-freight-web/backoffice/src/hooks/bookings/useBookings.ts
@@ -87,40 +87,6 @@ export function useBookingMutations(bookingId: string) {
    },
  });

-  const approveStep = useMutation({
-    mutationFn: ({
-      stepId,
-      requiredRole,
-    }: {
-      stepId: string;
-      requiredRole: string;
-    }) =>
-      api.bookings.approveStep.call({
-        id: bookingId,
-        stepId,
-        requiredRole,
-      }),
-    onSuccess: (data) => onSuccess(data, "Approval step completed"),
-    onError: (error) => toast.error(parseApiError(error, "Failed to approve step")),
-  });
-
-  const rejectStep = useMutation({
-    mutationFn: ({
-      stepId,
-      reason,
-    }: {
-      stepId: string;
-      reason: string;
-    }) =>
-      api.bookings.rejectStep.call({
-        id: bookingId,
-        stepId,
-        reason,
-      }),
-    onSuccess: (data) => onSuccess(data, "Booking rejected at approval step"),
-    onError: (error) => toast.error(parseApiError(error, "Failed to reject step")),
-  });
-
  const generateContract = useMutation({
    mutationFn: () => api.bookings.generateContract.call({ id: bookingId }),
    onSuccess: (data) => onSuccess(data, "Contract generated"),
@@ -167,8 +133,6 @@ export function useBookingMutations(bookingId: string) {
    staffAccept.isPending ||
    requestChanges.isPending ||
    staffReject.isPending ||
-    approveStep.isPending ||
-    rejectStep.isPending ||
    generateContract.isPending ||
    signContract.isPending ||
    payBooking.isPending ||
@@ -182,8 +146,6 @@ export function useBookingMutations(bookingId: string) {
    requestChanges,
    staffReject,
    reviewOperation,
-    approveStep,
-    rejectStep,
    generateContract,
    signContract,
    payBooking,
--- a/apps/edr-freight-web/backoffice/src/hooks/contracts/useContracts.ts
+++ b/apps/edr-freight-web/backoffice/src/hooks/contracts/useContracts.ts
@@ -122,6 +122,15 @@ export function useContractMutations(contractId: string) {
  const onSuccess = (data: { id: string }, message: string) => {
    toast.success(message);
    void invalidateContractDetail(qc, data.id);
+    // Approving or editing can change who holds document-editing rights (it
+    // passes to the next approver), and edits add revisions — so both the draft
+    // and the history are refreshed on every contract mutation.
+    void qc.invalidateQueries({
+      queryKey: ["contracts", data.id, "document-draft"],
+    });
+    void qc.invalidateQueries({
+      queryKey: ["contracts", data.id, "document-revisions"],
+    });
  };

  const staffAccept = useMutation({
@@ -160,21 +169,16 @@ export function useContractMutations(contractId: string) {
  });

  const approveStep = useMutation({
-    mutationFn: ({
-      stepId,
-      requiredRole,
-    }: {
-      stepId: string;
-      requiredRole: string;
-    }) =>
-      contractsService.approveStep({ id: contractId, stepId, requiredRole }),
+    // The server derives the required role from the step itself, so the client
+    // does not send one.
+    mutationFn: ({ stepId }: { stepId: string }) =>
+      contractsService.approveStep({ id: contractId, stepId }),
    onSuccess: (data) => {
-      // The document is generated at the accept stage and reviewed during
-      // approval, so the final approval moves the contract straight to
-      // CONTRACT_READY on the server — no client-side generate call here.
+      // The final approval is what generates the PDF and moves the contract to
+      // CONTRACT_READY — before that approvers review a live preview.
      const message =
        data.status === "CONTRACT_READY"
-          ? "Final approval complete — contract ready to sign"
+          ? "Final approval complete — contract generated and ready to sign"
          : "Approval step completed";
      onSuccess(data, message);
    },
--- a/apps/edr-freight-web/backoffice/src/hooks/rule-engine/useRuleEngine.ts
+++ b/apps/edr-freight-web/backoffice/src/hooks/rule-engine/useRuleEngine.ts
@@ -9,7 +9,10 @@ import {
  type SubmitPriorityRuleChangePayload,
  type SubmitRateChangePayload,
 } from "@/services/ruleEngine/ruleEngine.service";
-import { RULE_ENGINE_SELECT_NONE } from "@/pages/ruleEngine/config/resources";
+import {
+  LEGACY_APPROVAL_ROLES,
+  RULE_ENGINE_SELECT_NONE,
+} from "@/pages/ruleEngine/config/resources";
 import type {
  RuleEngineRecord,
  RuleEngineResourceSlug,
@@ -155,6 +158,33 @@ export const useContainerTypeOptions = (
    select: (rows) => buildContainerTypeSelectOptions(rows, includeNone),
  });

+/**
+ * Approval-step role options, sourced from the live IAM position types. The
+ * three pre-IAM role strings are appended (marked "(legacy)") so an approval
+ * rule still stored against one of them renders its label instead of an empty
+ * select; a position type that reuses one of those values wins the dedupe.
+ */
+export const useApprovalRoleOptions = (enabled = true) =>
+  useQuery({
+    queryKey: QUERY_KEYS.RULE_ENGINE.selectOptions("approval-rules", {
+      positionTypes: true,
+    }),
+    queryFn: () => ruleEngineService.getApprovalPositionTypes(),
+    enabled,
+    select: (rows): { label: string; value: string }[] => {
+      const byValue = new Map<string, { label: string; value: string }>();
+      for (const row of rows) {
+        const value = String(row?.value ?? "").trim();
+        if (!value) continue;
+        byValue.set(value, { label: String(row.label ?? "").trim() || value, value });
+      }
+      for (const legacy of LEGACY_APPROVAL_ROLES) {
+        if (!byValue.has(legacy.value)) byValue.set(legacy.value, legacy);
+      }
+      return [...byValue.values()];
+    },
+  });
+
 /** A yard option that remembers its country, so callers can filter by leg. */
 export interface YardOption {
  label: string;
--- a/apps/edr-freight-web/backoffice/src/pages/bookings/BookingDetailPage.tsx
+++ b/apps/edr-freight-web/backoffice/src/pages/bookings/BookingDetailPage.tsx
@@ -4,7 +4,6 @@ import { useMutation, useQueryClient } from "@tanstack/react-query";
 import toast from "react-hot-toast";

 import {
-  BookingApprovalCard,
  BookingContainersCard,
  BookingDetailToolbar,
  BookingDocumentsCard,
@@ -75,29 +74,6 @@ const BookingDetailPage = () => {
        containerType: { label: "20FT Standard", sizeFt: 20 },
      },
    ],
-    approvalSteps: [
-      {
-        id: "1",
-        stepOrder: 1,
-        requiredRole: "LINE_STAFF",
-        status: "APPROVED",
-        actionedAt: "2026-06-05T11:00:00Z",
-      },
-      // {
-      //   id: "2",
-      //   stepOrder: 2,
-      //   requiredRole: "DIRECTOR",
-      //   status: "APPROVED",
-      //   actionedAt: "2026-06-05T13:30:00Z",
-      // },
-      {
-        id: "3",
-        stepOrder: 3,
-        requiredRole: "CEO",
-        status: "APPROVED",
-        actionedAt: "2026-06-05T15:45:00Z",
-      },
-    ],
    reviewNotes: [
      {
        id: "1",
@@ -119,11 +95,6 @@ const BookingDetailPage = () => {
    ],
  };

-  const approvalSteps = booking.approvalSteps ?? [];
-  const approvedCount = approvalSteps.filter(
-    (s) => s.status === "APPROVED",
-  ).length;
-
  return (
    <div style={detailStyles.page}>
      <Container size="xxl" py="lg">
@@ -136,13 +107,6 @@ const BookingDetailPage = () => {
            { label: booking.reference },
          ]}
        />
-        {/* 
-        <BookingDetailHeader
-          booking={booking}
-          approvedCount={approvedCount}
-          totalSteps={totalSteps}
-        /> */}
-
        <BookingLifecycleStepper status={booking.status} />

        <Grid>
@@ -164,10 +128,6 @@ const BookingDetailPage = () => {
                  await allocateMutation.mutateAsync({ allocations });
                }}
              />
-              <BookingApprovalCard
-                steps={approvalSteps}
-                approvedCount={approvedCount}
-              />
              <BookingReviewNotesCard notes={booking.reviewNotes ?? []} />
            </Stack>
          </Grid.Col>
--- a/apps/edr-freight-web/backoffice/src/pages/bookings/BookingRequestDetailPage.tsx
+++ b/apps/edr-freight-web/backoffice/src/pages/bookings/BookingRequestDetailPage.tsx
@@ -23,7 +23,6 @@ import {

 import { PageContainer } from "@/components/page";
 import Breadcrumbs from "@/components/ui/Breadcrumbs";
-import { ApprovalStepsCard } from "@/components/bookings/ApprovalStepsCard";
 import { BookingActionsToolbar } from "@/components/bookings/BookingActionsToolbar";
 import { BookingPricingSummary } from "@/components/bookings/BookingPricingSummary";
 import { BookingWorkflowStepper } from "@/components/bookings/BookingWorkflowStepper";
@@ -130,10 +129,6 @@ export default function BookingRequestDetailPage() {

  const row = toBookingListRow(booking);
  const statusMeta = getStatusMeta(booking.status);
-  const showApprovalCard =
-    booking.status === "PENDING_APPROVAL" ||
-    booking.status === "APPROVED_PENDING_SIGNATURE";
-
  // Non-customs clearance is reviewed here by Marketing in its own tab; customs
  // bookings are handled in the Global Logistics clearance queue instead.
  const showClearanceTab =
@@ -283,9 +278,6 @@ export default function BookingRequestDetailPage() {
                    View document clearance
                  </Button>
                )}
-                {showApprovalCard && (
-                  <ApprovalStepsCard booking={booking} mutations={mutations} />
-                )}
              </Stack>
            </Box>
          </Grid.Col>
--- a/apps/edr-freight-web/backoffice/src/pages/bookings/BookingRequestsPage.tsx
+++ b/apps/edr-freight-web/backoffice/src/pages/bookings/BookingRequestsPage.tsx
@@ -7,7 +7,6 @@ import {
  MultiSelect,
  Select,
  Stack,
-  Tabs,
  Text,
  TextInput,
 } from "@mantine/core";
@@ -33,7 +32,6 @@ import { useNavigate } from "react-router-dom";
 import { useQuery } from "@tanstack/react-query";

 import { BookingActionsMenu } from "@/components/bookings/BookingActionsMenu";
-import { BookingApprovalProgressCell } from "@/components/bookings/BookingApprovalProgressCell";
 import { BookingPriorityBadge } from "@/components/bookings/BookingPriorityBadge";
 import { BookingStatusBadge } from "@/components/bookings/BookingStatusBadge";
 // BookingStatusTabs / Operations* queues removed — replaced by booking-kind tabs.
@@ -60,10 +58,10 @@ import {
  type ColumnDef,
 } from "@edr/ui-common";

-/** The two booking-kind tabs: one-time vs general-contract bookings. */
-type BookingKindTab = "ONE_TIME" | "GENERAL_CONTRACT";
+/** Booking kind: one-time vs general-contract bookings. Now a filter, not a tab. */
+type BookingKind = "ONE_TIME" | "GENERAL_CONTRACT";

-const BOOKING_KIND_TABS: { value: BookingKindTab; label: string }[] = [
+const BOOKING_KIND_OPTIONS: { value: BookingKind; label: string }[] = [
  { value: "ONE_TIME", label: "One-time booking" },
  { value: "GENERAL_CONTRACT", label: "General booking" },
 ];
@@ -128,9 +126,9 @@ export default function BookingRequestsPage() {
  const { pagination, setPagination } = usePagination({ pageSize: 10 });
  const [query, setQuery] = useState("");
  const [debouncedQuery] = useDebouncedValue(query, 300);
-  // Booking-kind tabs (one-time vs general contract) replace the old status tabs.
-  const [kindTab, setKindTab] = useState<BookingKindTab>("ONE_TIME");
-  // Per-tab filter controls (empty/null = "all").
+  // Booking kind is a filter now — one list holds both kinds (null = "all").
+  const [kindFilter, setKindFilter] = useState<BookingKind | null>(null);
+  // Filter controls (empty/null = "all").
  const [statusFilter, setStatusFilter] = useState<string[]>([]);
  const [directionFilter, setDirectionFilter] = useState<string | null>(null);
  const [freightTypeFilter, setFreightTypeFilter] = useState<string | null>(null);
@@ -158,9 +156,9 @@ export default function BookingRequestsPage() {
      pageSize: pagination.pageSize,
      sortBy: "createdAt",
      sortOrder: "DESC",
-      // React Query cache key per kind tab.
-      tab: kindTab,
-      bookingType: kindTab,
+      // React Query cache key per kind selection ("ALL" when unfiltered).
+      tab: kindFilter ?? "ALL",
+      ...(kindFilter ? { bookingType: kindFilter } : {}),
      // Server-side free-text search (booking ref, customer, contract ref).
      ...(debouncedQuery.trim() ? { search: debouncedQuery.trim() } : {}),
      ...(statusFilter.length ? { statuses: statusFilter.join(",") } : {}),
@@ -182,7 +180,7 @@ export default function BookingRequestsPage() {
  }, [
    pagination.pageIndex,
    pagination.pageSize,
-    kindTab,
+    kindFilter,
    debouncedQuery,
    statusFilter,
    directionFilter,
@@ -226,6 +224,7 @@ export default function BookingRequestsPage() {
  }, [setPagination, pagination.pageSize]);

  const activeFilterCount =
+    (kindFilter ? 1 : 0) +
    (statusFilter.length ? 1 : 0) +
    (directionFilter ? 1 : 0) +
    (freightTypeFilter ? 1 : 0) +
@@ -237,6 +236,7 @@ export default function BookingRequestsPage() {
    (scheduledFrom || scheduledTo ? 1 : 0);

  const clearFilters = useCallback(() => {
+    setKindFilter(null);
    setStatusFilter([]);
    setDirectionFilter(null);
    setFreightTypeFilter(null);
@@ -327,6 +327,23 @@ export default function BookingRequestsPage() {
        );
      },
    },
+    {
+      id: "bookingKind",
+      header: () => <span className={bookingTable.headerCell}>Type</span>,
+      cell: ({ row }) => {
+        const isGeneral = row.original.bookingKind === "GENERAL_CONTRACT";
+        return (
+          <div className="py-1">
+            <Badge
+              variant={isGeneral ? "secondary" : "outline"}
+              className="h-5 px-1.5 text-[10px] font-medium"
+            >
+              {isGeneral ? "General" : "One-time"}
+            </Badge>
+          </div>
+        );
+      },
+    },
    {
      id: "route",
      header: () => <span className={bookingTable.headerCell}>Route</span>,
@@ -376,13 +393,6 @@ export default function BookingRequestsPage() {
        cellClassName: "min-w-[11rem]",
      },
    },
-    {
-      id: "approval",
-      header: () => (
-        <span className={bookingTable.headerCell}>Approval</span>
-      ),
-      cell: ({ row }) => <BookingApprovalProgressCell row={row.original} />,
-    },
    {
      id: "scheduled",
      header: () => <span className={bookingTable.headerCell}>Scheduled</span>,
@@ -482,22 +492,6 @@ export default function BookingRequestsPage() {
          />
          */}

-          <Tabs
-            value={kindTab}
-            onChange={(value) => {
-              setKindTab((value as BookingKindTab) ?? "ONE_TIME");
-              setPagination({ pageIndex: 0, pageSize: pagination.pageSize });
-            }}
-          >
-            <Tabs.List>
-              {BOOKING_KIND_TABS.map((t) => (
-                <Tabs.Tab key={t.value} value={t.value}>
-                  {t.label}
-                </Tabs.Tab>
-              ))}
-            </Tabs.List>
-          </Tabs>
-
          <Card p={0}>
            <Stack gap={0}>
              <Box px="md" pt="md" pb="sm" w="100%">
@@ -535,6 +529,18 @@ export default function BookingRequestsPage() {
                    </Text>
                  </Group>
                  <Group gap="sm" wrap="wrap">
+                    <Select
+                      placeholder="All booking types"
+                      data={BOOKING_KIND_OPTIONS}
+                      value={kindFilter}
+                      onChange={(v) => {
+                        setKindFilter((v as BookingKind | null) ?? null);
+                        resetPage();
+                      }}
+                      clearable
+                      radius="lg"
+                      style={{ minWidth: 190 }}
+                    />
                    <MultiSelect
                      placeholder={statusFilter.length ? undefined : "All statuses"}
                      data={STATUS_OPTIONS}
--- a/apps/edr-freight-web/backoffice/src/pages/contracts/ContractRequestDetailPage.tsx
+++ b/apps/edr-freight-web/backoffice/src/pages/contracts/ContractRequestDetailPage.tsx
@@ -50,6 +50,7 @@ import { ContractActionsToolbar } from "@/components/contracts/ContractActionsTo
 import { ContractApprovalStepsCard } from "@/components/contracts/ContractApprovalStepsCard";
 import { ContractClearanceReviewSection } from "@/components/contracts/ContractClearanceReviewSection";
 import { ClearanceWorkflowFilesPanel } from "@/components/contracts/ClearanceWorkflowFilesPanel";
+import { ContractRevisionTimeline } from "@/components/contracts/ContractRevisionTimeline";
 import {
  ContractCustomerCard,
  ContractDocumentsCard,
@@ -493,6 +494,7 @@ export default function ContractRequestDetailPage() {
                  onView={handleViewFile}
                  onDownload={handleDownloadFile}
                />
+                <ContractRevisionTimeline contractId={contract.id} />
                <ContractDocumentsCard
                  files={profileDocuments}
                  title="Customer profile documents"
--- a/apps/edr-freight-web/backoffice/src/pages/ruleEngine/RuleEngineResourcePage.tsx
+++ b/apps/edr-freight-web/backoffice/src/pages/ruleEngine/RuleEngineResourcePage.tsx
@@ -36,6 +36,7 @@ import { ruleEngineTable } from "@/components/ruleEngine/ruleEngineStyles";
 import { useRuleEngineViewMode } from "@/components/ruleEngine/useRuleEngineViewMode";
 import {
    useApprovalChain,
+    useApprovalRoleOptions,
    useCargoLeafOptions,
    useCargoTypeParentOptions,
    useContainerTypeOptions,
@@ -247,6 +248,13 @@ const RuleEngineResourcePage = () => {
  );
  const { data: yardOptions, isLoading: yardOptionsLoading } =
    useYardOptions(usesYardField);
+  const usesApprovalRoleField = Boolean(
+    config?.formFields.some(
+      (f) => f.name === "requiredRole" || f.name === "blocksRole",
+    ),
+  );
+  const { data: approvalRoleOptions, isLoading: approvalRoleOptionsLoading } =
+    useApprovalRoleOptions(usesApprovalRoleField);

  // Full rule list backing the auto-filled "min wagon count": the next range
  // always continues the chain for the selected type (per currency), so the
@@ -321,6 +329,20 @@ const RuleEngineResourcePage = () => {
          options: wagonTypeOptions ?? [],
        };
      }
+      // Approval steps are configured against live IAM position types; until
+      // they load, the static legacy list on the field config stands in so an
+      // existing row's role still shows a label.
+      if (field.name === "requiredRole" || field.name === "blocksRole") {
+        if (!approvalRoleOptions) return field;
+        const includeNone = field.name === "blocksRole";
+        return {
+          ...field,
+          type: "select" as const,
+          options: includeNone
+            ? [{ label: "None", value: RULE_ENGINE_SELECT_NONE }, ...approvalRoleOptions]
+            : approvalRoleOptions,
+        };
+      }
      // Each end of the leg only offers yards in the country that end of the
      // trade actually sits in, so an import can't be configured as if it
      // started inland. Resolved per keystroke because the legal set changes
@@ -336,7 +358,7 @@ const RuleEngineResourcePage = () => {
      }
      return field;
    });
-  }, [config, cargoParentOptions, cargoLeafOptions, containerTypeOptions, liveRateOptions, wagonTypeOptions, yardOptions, isPriorityRules, allPriorityRules, editing, editingId]);
+  }, [config, cargoParentOptions, cargoLeafOptions, containerTypeOptions, liveRateOptions, wagonTypeOptions, yardOptions, approvalRoleOptions, isPriorityRules, allPriorityRules, editing, editingId]);

  const rows = data?.items ?? [];
  const meta = data?.meta;
@@ -765,7 +787,8 @@ const RuleEngineResourcePage = () => {
          (usesCargoTypeField && cargoLeafOptionsLoading) ||
          (usesLiveRateField && liveRateOptionsLoading) ||
          (usesWagonTypeField && wagonTypeOptionsLoading) ||
-          (usesYardField && yardOptionsLoading)
+          (usesYardField && yardOptionsLoading) ||
+          (usesApprovalRoleField && approvalRoleOptionsLoading)
        }
        positionOptions={!editing ? createPositionOptions : undefined}
        positionLoading={createPositionLoading}
--- a/apps/edr-freight-web/backoffice/src/pages/ruleEngine/config/resources.ts
+++ b/apps/edr-freight-web/backoffice/src/pages/ruleEngine/config/resources.ts
@@ -118,10 +118,16 @@ const YARD_COUNTRIES = [
  { label: "Djibouti", value: "Djibouti" },
 ];

-const APPROVAL_ROLES = [
-  { label: "Line staff", value: "LINE_STAFF" },
-  { label: "Director", value: "DIRECTOR" },
-  { label: "CEO", value: "CEO" },
+/**
+ * The three role strings the approval chain was hardcoded to before it was
+ * driven by IAM position types. Kept only so rows still stored against them
+ * render a readable label instead of a blank select — the live options come
+ * from GET /approval-rules/position-types (see `useApprovalRoleOptions`).
+ */
+export const LEGACY_APPROVAL_ROLES = [
+  { label: "Line staff (legacy)", value: "LINE_STAFF" },
+  { label: "Director (legacy)", value: "DIRECTOR" },
+  { label: "CEO (legacy)", value: "CEO" },
 ];

 /**
@@ -718,7 +724,8 @@ export const RULE_ENGINE_RESOURCES: RuleEngineResourceConfig[] = [
        label: "Required role",
        type: "select",
        required: true,
-        options: APPROVAL_ROLES,
+        // Replaced at render time with live IAM position types (+ legacy values).
+        options: LEGACY_APPROVAL_ROLES,
      },
      { name: "actionLabel", label: "Action label", type: "text", required: true },
      {
@@ -726,7 +733,8 @@ export const RULE_ENGINE_RESOURCES: RuleEngineResourceConfig[] = [
        label: "Blocks role",
        type: "select",
        optional: true,
-        options: [{ label: "None", value: RULE_ENGINE_SELECT_NONE }, ...APPROVAL_ROLES],
+        // Replaced at render time with live IAM position types (+ legacy values).
+        options: [{ label: "None", value: RULE_ENGINE_SELECT_NONE }, ...LEGACY_APPROVAL_ROLES],
      },
    ],
  },
--- a/apps/edr-freight-web/backoffice/src/services/api.ts
+++ b/apps/edr-freight-web/backoffice/src/services/api.ts
@@ -132,9 +132,7 @@ import { endpoint } from "@/utils/endpoint";
 import {
  BookingListFilter,
  bookingsService,
-  type ApproveStepPayload,
  type PaginatedBookings,
-  type RejectStepPayload,
 } from "./bookings.service";
 import { cargoTypesService } from "./cargo-types.service";
 import {
@@ -2481,18 +2479,6 @@ export const api = {
      bookingsService.reviewOperation(id, decision, { note }),
    ),

-    approveStep: endpoint<ApproveStepPayload, BookingDetail>(
-      "bookings",
-      "approveStep",
-      (payload) => bookingsService.approveStep(payload),
-    ),
-
-    rejectStep: endpoint<RejectStepPayload, BookingDetail>(
-      "bookings",
-      "rejectStep",
-      (payload) => bookingsService.rejectStep(payload),
-    ),
-
    generateContract: endpoint<{ id: string }, BookingDetail>(
      "bookings",
      "generateContract",
--- a/apps/edr-freight-web/backoffice/src/services/bookings.service.ts
+++ b/apps/edr-freight-web/backoffice/src/services/bookings.service.ts
@@ -72,18 +72,6 @@ export interface BookingListSummary {
  tabs: BookingListSummaryTabs;
 }

-export interface ApproveStepPayload {
-  id: string;
-  stepId: string;
-  requiredRole: string;
-}
-
-export interface RejectStepPayload {
-  id: string;
-  stepId: string;
-  reason: string;
-}
-
 export interface ContractView {
  bookingId: string;
  reference: string;
@@ -255,12 +243,6 @@ export const bookingsService = {
      ...options,
    }),

-  approveStep: ({ id, stepId, requiredRole }: ApproveStepPayload) =>
-    postBooking<BookingDetail>(B.APPROVE_STEP(id, stepId), { requiredRole }),
-
-  rejectStep: ({ id, stepId, reason }: RejectStepPayload) =>
-    postBooking<BookingDetail>(B.REJECT_STEP(id, stepId), { reason }),
-
  generateContract: (id: string) =>
    postBooking<BookingDetail>(B.CONTRACT_GENERATE(id)),

--- a/apps/edr-freight-web/backoffice/src/services/contracts.service.ts
+++ b/apps/edr-freight-web/backoffice/src/services/contracts.service.ts
@@ -196,6 +196,14 @@ export const contractsService = {
    return unwrap(response.data) as Freight.IContractDocumentDraft;
  },

+  /** Audit trail of edits to this contract's document, newest first. */
+  getContractDocumentRevisions: async (
+    id: string,
+  ): Promise<Freight.IContractDocumentRevision[]> => {
+    const response = await client.get(C.CONTRACT_DOCUMENT_REVISIONS(id));
+    return unwrap(response.data) as Freight.IContractDocumentRevision[];
+  },
+
  /** Save this contract's edited document articles (never touches the templates). */
  updateContractDocument: async (
    id: string,
@@ -214,18 +222,12 @@ export const contractsService = {
  reject: (id: string, reason: string) =>
    postContract<Freight.IContract>(C.STAFF_REJECT(id), { reason }),

-  approveStep: ({
-    id,
-    stepId,
-    requiredRole,
-  }: {
-    id: string;
-    stepId: string;
-    requiredRole: string;
-  }) =>
-    postContract<Freight.IContract>(C.APPROVE_STEP(id, stepId), {
-      requiredRole,
-    }),
+  /**
+   * Approve the next pending step. The server resolves the step's required role
+   * and authorizes against it — the client never declares its own role.
+   */
+  approveStep: ({ id, stepId }: { id: string; stepId: string }) =>
+    postContract<Freight.IContract>(C.APPROVE_STEP(id, stepId)),

  rejectStep: ({
    id,
--- a/apps/edr-freight-web/backoffice/src/services/ruleEngine/ruleEngine.service.ts
+++ b/apps/edr-freight-web/backoffice/src/services/ruleEngine/ruleEngine.service.ts
@@ -72,6 +72,12 @@ export interface SubmitRateChangePayload {
  update: Record<string, unknown>;
 }

+/** One selectable IAM position type, as returned by /approval-rules/position-types. */
+export interface ApprovalPositionType {
+  label: string;
+  value: string;
+}
+
 const RESOURCE_BASE: Record<RuleEngineResourceSlug, string> = {
  "cargo-types": URL_CONSTANTS.RULE_ENGINE.CARGO_TYPES,
  "container-types": URL_CONSTANTS.RULE_ENGINE.CONTAINER_TYPES,
@@ -368,6 +374,28 @@ export const ruleEngineService = {
    return unwrap(response.data) as RateChangeRequest;
  },

+  /**
+   * IAM position types that an approval step can require/block. Replaces the
+   * old hardcoded LINE_STAFF/DIRECTOR/CEO triple — the chain is configured from
+   * whatever positions IAM actually defines.
+   */
+  getApprovalPositionTypes: async (): Promise<ApprovalPositionType[]> => {
+    const response = await client.get(
+      URL_CONSTANTS.RULE_ENGINE.APPROVAL_RULES_POSITION_TYPES,
+    );
+    const body = unwrap(response.data) as unknown;
+    if (Array.isArray(body)) return body as ApprovalPositionType[];
+    if (
+      body &&
+      typeof body === "object" &&
+      "data" in body &&
+      Array.isArray((body as { data: unknown }).data)
+    ) {
+      return (body as { data: ApprovalPositionType[] }).data;
+    }
+    return [];
+  },
+
  getApprovalChain: async (
    requiresDirectorApproval = true,
  ): Promise<RuleEngineRecord[]> => {
--- a/apps/edr-freight-web/backoffice/src/types/booking.ts
+++ b/apps/edr-freight-web/backoffice/src/types/booking.ts
@@ -101,16 +101,6 @@ export interface BookingContainerLine {
  units?: BookingContainerUnit[];
 }

-export interface BookingApprovalStep {
-  id: string;
-  stepOrder: number;
-  requiredRole: string;
-  blocksRole?: string | null;
-  status: "PENDING" | "APPROVED" | "REJECTED" | "SKIPPED";
-  actionedAt?: string | null;
-  remarks?: string | null;
-}
-
 export interface BookingNextStep {
  action: string;
  description: string;
@@ -219,7 +209,6 @@ export interface BookingDetail {
  cargoType?: BookingNamedRef;
  shippingLine?: BookingNamedRef;
  bookingContainers?: BookingContainerLine[];
-  approvalSteps?: BookingApprovalStep[];
  reviewNotes?: BookingReviewNote[];
  files?: BookingFile[];
  cargoModifiers?: Array<{
@@ -236,7 +225,6 @@ export interface BookingListRow {
  /** Needed to link the reference to the contract's detail page. */
  contractId?: string | null;
  customerLabel: string;
-  approvalSteps?: BookingApprovalStep[];
  status: BookingStatus;
  scheduledDate: string;
  totalAmount: number;
@@ -255,5 +243,11 @@ export interface BookingListRow {
  consolidationPartnerId?: string | null;
  consolidationPartnerReference?: string | null;
  customsClearingEnabled?: boolean;
+  /**
+   * Derived booking kind for the list "Type" column. Mirrors the server's
+   * bookingType filter: bookings under a GENERAL contract are general,
+   * everything else is one-time.
+   */
+  bookingKind?: "ONE_TIME" | "GENERAL_CONTRACT";
  createdAt: string;
 }
--- a/packages/types/src/freight/contracts.ts
+++ b/packages/types/src/freight/contracts.ts
@@ -219,12 +219,54 @@ export interface IContractDocumentDraft {
  articles: IContractDocumentArticle[];
  code: string | null;
  name: string | null;
-  /** True once the document may no longer be edited/regenerated. */
+  /** True when THIS caller may not edit — the inverse of `editableByMe`. */
  locked: boolean;
+  /**
+   * Whether the requesting user is the approver whose turn it is. The document
+   * stays editable through the whole approval chain, but only by the approver
+   * currently holding it, so editability is caller-dependent.
+   */
+  editableByMe: boolean;
+  /** Role holding editing rights right now, for "locked because…" messaging. */
+  nextApproverRole: string | null;
  generatedAt: string | null;
  status: ContractStatus;
 }

+/** One recorded change within a contract-document revision. */
+export type IContractDocumentChange =
+  | { kind: 'ARTICLE_ADDED'; articleId: string; title: string }
+  | { kind: 'ARTICLE_REMOVED'; articleId: string; title: string }
+  | {
+      kind: 'ARTICLE_RENAMED';
+      articleId: string;
+      title: string;
+      fromTitle: string;
+    }
+  | { kind: 'ARTICLE_BODY_CHANGED'; articleId: string; title: string }
+  | {
+      kind: 'ARTICLE_REORDERED';
+      articleId: string;
+      title: string;
+      fromOrder: number;
+      toOrder: number;
+    }
+  | { kind: 'DOCUMENT_TITLE_CHANGED'; title: string; fromTitle: string | null }
+  | { kind: 'WHEREAS_CHANGED'; added: number; removed: number };
+
+/** An audit entry for one edit to a contract's document. */
+export interface IContractDocumentRevision {
+  id: string;
+  contractId: string;
+  actorId: string | null;
+  /** The approval step's required role at the time of the edit. */
+  actorRole: string | null;
+  stepId: string | null;
+  summary: string | null;
+  changes: IContractDocumentChange[];
+  createdAt: string;
+}
+
 export type ContractApprovalStepStatus =
  | "PENDING"
  | "APPROVED"