diff --git a/.github/workflows/deploy.yml b/.github/workflows/deploy.yml
index 057cb0c1b..f0beccd20 100644
--- a/.github/workflows/deploy.yml
+++ b/.github/workflows/deploy.yml
@@ -2,7 +2,6 @@ name: Deploy Stacks
 on:
   push:
     branches:
-      - main
       - dev
       - staging
   workflow_dispatch:
diff --git a/apps/edr-freight-api/Dockerfile b/apps/edr-freight-api/Dockerfile
index d88029a80..984e622db 100644
--- a/apps/edr-freight-api/Dockerfile
+++ b/apps/edr-freight-api/Dockerfile
@@ -43,3 +43,4 @@ EXPOSE 3001
 # GT06 GPS tracker TCP listener (raw TCP, not HTTP). Change via GT06_TCP_PORT.
 EXPOSE 5023
 CMD ["node", "dist/main.js"]
+
diff --git a/apps/edr-freight-api/package.json b/apps/edr-freight-api/package.json
index 6bea9424c..bca74475e 100644
--- a/apps/edr-freight-api/package.json
+++ b/apps/edr-freight-api/package.json
@@ -27,6 +27,7 @@
     "seed:gate-pass-train-scenarios": "ts-node -r tsconfig-paths/register src/scripts/seed-gate-pass-train-scenarios.ts",
     "auto-unload:arrived-import-trains": "ts-node -r tsconfig-paths/register src/scripts/auto-unload-arrived-import-trains.ts",
     "seed:file-upload-settings": "ts-node -r tsconfig-paths/register src/scripts/seed-file-upload-settings.ts",
+    "seed:dropdown-settings": "ts-node -r tsconfig-paths/register src/scripts/seed-dropdown-settings.ts",
     "seed:gov-companies": "ts-node -r tsconfig-paths/register src/scripts/seed-gov-companies.ts",
     "seed:fleet-wagons": "bash ../../../docs/new/seeds/seed-fleet-wagons.sh",
     "iam:typeorm:cli": "cross-env MIGRATIONS_DIR=node_modules/@tria-plc/iamapi-common/dist/db/migrations/*.{ts,js} ts-node -r tsconfig-paths/register   ./node_modules/typeorm/cli.js -d ./node_modules/@tria-plc/api-common/dist/modules/typeorm/typeorm.config.js",
diff --git a/apps/edr-freight-api/src/common/dto/pagination-query.dto.ts b/apps/edr-freight-api/src/common/dto/pagination-query.dto.ts
new file mode 100644
index 000000000..997ced76d
--- /dev/null
+++ b/apps/edr-freight-api/src/common/dto/pagination-query.dto.ts
@@ -0,0 +1,44 @@
+import { ApiPropertyOptional } from '@nestjs/swagger';
+import { Transform } from 'class-transformer';
+import { IsIn, IsInt, IsOptional, Max, Min } from 'class-validator';
+
+/**
+ * Base query DTO for every paginated list endpoint. Extend it and add the
+ * module's own filter fields; sort-field whitelists stay in the subclass
+ * because the allowed columns differ per resource.
+ *
+ * All list endpoints built on this return the shared `PaginatedResponse<T>`
+ * envelope from `@edr/types` (`items` + `meta`), produced by
+ * `common/utils/pagination.util.ts`.
+ */
+export class PaginationQueryDto {
+  @ApiPropertyOptional({ default: 1, minimum: 1 })
+  @IsOptional()
+  @Transform(({ value }) => parseInt(String(value), 10) || 1)
+  @IsInt()
+  @Min(1)
+  page?: number;
+
+  @ApiPropertyOptional({ default: 20, minimum: 1, maximum: 100 })
+  @IsOptional()
+  @Transform(({ value }) => parseInt(String(value), 10) || 20)
+  @IsInt()
+  @Min(1)
+  @Max(100)
+  pageSize?: number;
+
+  @ApiPropertyOptional({
+    description: 'Free-text search, applied server-side (resource-specific columns).',
+  })
+  @IsOptional()
+  @Transform(({ value }) =>
+    typeof value === 'string' && value.trim() ? value.trim() : undefined,
+  )
+  search?: string;
+
+  @ApiPropertyOptional({ enum: ['ASC', 'DESC'], default: 'DESC' })
+  @IsOptional()
+  @Transform(({ value }) => String(value).toUpperCase())
+  @IsIn(['ASC', 'DESC'])
+  sortOrder?: 'ASC' | 'DESC';
+}
diff --git a/apps/edr-freight-api/src/common/utils/pagination.util.ts b/apps/edr-freight-api/src/common/utils/pagination.util.ts
new file mode 100644
index 000000000..310b2da6d
--- /dev/null
+++ b/apps/edr-freight-api/src/common/utils/pagination.util.ts
@@ -0,0 +1,85 @@
+import { PaginatedResponse, PaginationMeta } from '@edr/types';
+import { ObjectLiteral, SelectQueryBuilder } from 'typeorm';
+
+/** Raw page/pageSize as they arrive from a query DTO (both optional). */
+export interface PageRequest {
+  page?: number;
+  pageSize?: number;
+}
+
+export interface PaginationOptions {
+  defaultPageSize?: number;
+  maxPageSize?: number;
+}
+
+export interface NormalizedPage {
+  page: number;
+  pageSize: number;
+  skip: number;
+  take: number;
+}
+
+const DEFAULT_PAGE_SIZE = 20;
+const MAX_PAGE_SIZE = 100;
+
+/** Clamp raw query values into a safe page window (page ≥ 1, pageSize capped). */
+export function normalizePagination(
+  request: PageRequest,
+  options: PaginationOptions = {},
+): NormalizedPage {
+  const defaultPageSize = options.defaultPageSize ?? DEFAULT_PAGE_SIZE;
+  const maxPageSize = options.maxPageSize ?? MAX_PAGE_SIZE;
+
+  const page = Math.max(1, Math.floor(request.page ?? 1) || 1);
+  const requested = Math.floor(request.pageSize ?? defaultPageSize) || defaultPageSize;
+  const pageSize = Math.min(Math.max(1, requested), maxPageSize);
+
+  return { page, pageSize, skip: (page - 1) * pageSize, take: pageSize };
+}
+
+export function buildPaginationMeta(
+  total: number,
+  page: number,
+  pageSize: number,
+): PaginationMeta {
+  const totalPages = pageSize > 0 ? Math.ceil(total / pageSize) : 0;
+  return {
+    page,
+    pageSize,
+    total,
+    totalPages,
+    hasNextPage: page < totalPages,
+    hasPreviousPage: page > 1,
+  };
+}
+
+/**
+ * Apply skip/take to a query builder, run it, and wrap the result in the
+ * shared `PaginatedResponse` envelope. Ordering and filtering must already be
+ * applied by the caller.
+ */
+export async function paginateQuery<T extends ObjectLiteral>(
+  qb: SelectQueryBuilder<T>,
+  request: PageRequest,
+  options?: PaginationOptions,
+): Promise<PaginatedResponse<T>> {
+  const { page, pageSize, skip, take } = normalizePagination(request, options);
+  const [items, total] = await qb.skip(skip).take(take).getManyAndCount();
+  return { items, meta: buildPaginationMeta(total, page, pageSize) };
+}
+
+/**
+ * Paginate an already-materialized array. Prefer `paginateQuery` (DB-level
+ * LIMIT/OFFSET); use this only for lists that are inherently in-memory.
+ */
+export function paginateArray<T>(
+  rows: readonly T[],
+  request: PageRequest,
+  options?: PaginationOptions,
+): PaginatedResponse<T> {
+  const { page, pageSize, skip } = normalizePagination(request, options);
+  return {
+    items: rows.slice(skip, skip + pageSize),
+    meta: buildPaginationMeta(rows.length, page, pageSize),
+  };
+}
diff --git a/apps/edr-freight-api/src/migrations/2110000000000-AddBookingIsSplit.ts b/apps/edr-freight-api/src/migrations/2110000000000-AddBookingIsSplit.ts
new file mode 100644
index 000000000..8e5ded189
--- /dev/null
+++ b/apps/edr-freight-api/src/migrations/2110000000000-AddBookingIsSplit.ts
@@ -0,0 +1,32 @@
+import { MigrationInterface, QueryRunner } from 'typeorm';
+
+/**
+ * Partial-batch splits no longer promote a ONE_TIME contract to GENERAL.
+ * Instead the reduced booking is flagged is_split, and the booking gate lets
+ * the customer book exactly the remainder under the still-ONE_TIME contract.
+ */
+export class AddBookingIsSplit2110000000000 implements MigrationInterface {
+  name = 'AddBookingIsSplit2110000000000';
+
+  public async up(queryRunner: QueryRunner): Promise<void> {
+    await queryRunner.query(`
+      ALTER TABLE freight.bookings
+        ADD COLUMN IF NOT EXISTS is_split BOOLEAN NOT NULL DEFAULT FALSE
+    `);
+    // Quantities the booking carried before the split — the remainder ledger
+    // for ONE_TIME contracts, which have no quantity cap to derive it from.
+    await queryRunner.query(`
+      ALTER TABLE freight.bookings
+        ADD COLUMN IF NOT EXISTS pre_split_quantities JSONB NULL
+    `);
+  }
+
+  public async down(queryRunner: QueryRunner): Promise<void> {
+    await queryRunner.query(`
+      ALTER TABLE freight.bookings DROP COLUMN IF EXISTS pre_split_quantities
+    `);
+    await queryRunner.query(`
+      ALTER TABLE freight.bookings DROP COLUMN IF EXISTS is_split
+    `);
+  }
+}
diff --git a/apps/edr-freight-api/src/migrations/2120000000000-AddLastMileProofOfDelivery.ts b/apps/edr-freight-api/src/migrations/2120000000000-AddLastMileProofOfDelivery.ts
new file mode 100644
index 000000000..ed5054e87
--- /dev/null
+++ b/apps/edr-freight-api/src/migrations/2120000000000-AddLastMileProofOfDelivery.ts
@@ -0,0 +1,34 @@
+import { MigrationInterface, QueryRunner } from "typeorm";
+
+/**
+ * Proof of delivery for EDR last-mile: recipient name, a captured signature
+ * (stored as a file), delivery photos (file ids), notes, and the capture time.
+ * Recorded when the driver completes the delivery.
+ */
+export class AddLastMileProofOfDelivery2120000000000
+  implements MigrationInterface
+{
+  name = "AddLastMileProofOfDelivery2120000000000";
+
+  public async up(queryRunner: QueryRunner): Promise<void> {
+    await queryRunner.query(`
+      ALTER TABLE freight.last_mile
+        ADD COLUMN IF NOT EXISTS pod_recipient_name varchar(160),
+        ADD COLUMN IF NOT EXISTS pod_signature_file_id uuid,
+        ADD COLUMN IF NOT EXISTS pod_photo_file_ids text[] NOT NULL DEFAULT '{}',
+        ADD COLUMN IF NOT EXISTS pod_notes text,
+        ADD COLUMN IF NOT EXISTS pod_captured_at timestamptz
+    `);
+  }
+
+  public async down(queryRunner: QueryRunner): Promise<void> {
+    await queryRunner.query(`
+      ALTER TABLE freight.last_mile
+        DROP COLUMN IF EXISTS pod_recipient_name,
+        DROP COLUMN IF EXISTS pod_signature_file_id,
+        DROP COLUMN IF EXISTS pod_photo_file_ids,
+        DROP COLUMN IF EXISTS pod_notes,
+        DROP COLUMN IF EXISTS pod_captured_at
+    `);
+  }
+}
diff --git a/apps/edr-freight-api/src/migrations/2120000000000-AddScheduleWagonAllocationSnapshot.ts b/apps/edr-freight-api/src/migrations/2120000000000-AddScheduleWagonAllocationSnapshot.ts
new file mode 100644
index 000000000..651c4ba13
--- /dev/null
+++ b/apps/edr-freight-api/src/migrations/2120000000000-AddScheduleWagonAllocationSnapshot.ts
@@ -0,0 +1,34 @@
+import { MigrationInterface, QueryRunner } from "typeorm";
+
+/**
+ * Add a frozen wagon-allocation snapshot to each train schedule.
+ *
+ * Once a schedule leaves the editable DRAFT/SCHEDULED phase (dispatch / arrive /
+ * cancel), the same physical wagons get released and re-pinned onto later trains.
+ * The live wagon↔slot joins then no longer describe THIS train's plan, so an
+ * admin viewing a past schedule saw a mangled or "unavailable" allocation.
+ *
+ * This jsonb column stores a one-shot frozen copy of the wagon plan (per-slot
+ * physical wagon + booking allocations) captured at the transition. Non-editable
+ * schedules render from the snapshot; DRAFT/SCHEDULED still read live. NULL on
+ * legacy rows and while editable — the read path falls back to the live joins.
+ */
+export class AddScheduleWagonAllocationSnapshot2120000000000
+  implements MigrationInterface
+{
+  name = "AddScheduleWagonAllocationSnapshot2120000000000";
+
+  public async up(queryRunner: QueryRunner): Promise<void> {
+    await queryRunner.query(`
+      ALTER TABLE freight.train_schedules
+        ADD COLUMN IF NOT EXISTS wagon_allocation_snapshot jsonb;
+    `);
+  }
+
+  public async down(queryRunner: QueryRunner): Promise<void> {
+    await queryRunner.query(`
+      ALTER TABLE freight.train_schedules
+        DROP COLUMN IF EXISTS wagon_allocation_snapshot;
+    `);
+  }
+}
diff --git a/apps/edr-freight-api/src/modules/bookings/bookings.repository.ts b/apps/edr-freight-api/src/modules/bookings/bookings.repository.ts
index a3009ec3c..6a04014a7 100644
--- a/apps/edr-freight-api/src/modules/bookings/bookings.repository.ts
+++ b/apps/edr-freight-api/src/modules/bookings/bookings.repository.ts
@@ -605,6 +605,7 @@ export class BookingsRepository extends BaseRepository<Booking> {
   async findAllPaginated(options: BookingListFilterOptions & {
     page: number;
     pageSize: number;
+    search?: string;
     sortBy?: string;
     sortOrder?: 'ASC' | 'DESC';
   }): Promise<{
@@ -640,6 +641,16 @@ export class BookingsRepository extends BaseRepository<Booking> {
 
     this.applyListFilters(qb, options);
 
+    // Free-text search spans joined columns (company, contract) that only this
+    // list query joins — so it lives here, not in applyListFilters (shared
+    // with getListSummaryMetrics, whose query builder has no joins).
+    if (options.search) {
+      qb.andWhere(
+        '(booking.reference ILIKE :search OR company.name ILIKE :search OR contract.reference ILIKE :search)',
+        { search: `%${options.search}%` },
+      );
+    }
+
     if (options.sortBy === 'isGovernment') {
       qb.orderBy('booking.isGovernment', 'DESC')
         .addOrderBy('booking.priorityScore', 'DESC')
@@ -1258,7 +1269,12 @@ export class BookingsRepository extends BaseRepository<Booking> {
     fields: Partial<
       Pick<
         Booking,
-        'schedulingStatus' | 'wagonsRequired' | 'scheduledAt' | 'holdStartedAt' | 'holdExpiresAt'
+        | 'schedulingStatus'
+        | 'wagonsRequired'
+        | 'scheduledAt'
+        | 'holdStartedAt'
+        | 'holdExpiresAt'
+        | 'trainScheduleId'
       >
     >,
     manager?: EntityManager,
diff --git a/apps/edr-freight-api/src/modules/bookings/bookings.service.ts b/apps/edr-freight-api/src/modules/bookings/bookings.service.ts
index 9f72c7409..dd5011df3 100644
--- a/apps/edr-freight-api/src/modules/bookings/bookings.service.ts
+++ b/apps/edr-freight-api/src/modules/bookings/bookings.service.ts
@@ -31,6 +31,7 @@ import { deriveTradeDirection } from '../../common/derive-trade-direction.util';
 import { Yard } from '../rule-engine/entities/yard.entity';
 import { ServiceType } from '../rule-engine/entities/service-type.entity';
 import { TrainSchedule } from '../train-schedules/entities/train-schedule.entity';
+import { Contract } from '../contracts/entities/contract.entity';
 import { BookingsRepository } from './bookings.repository';
 import { ConsolidationService } from './consolidation.service';
 import { VehiclesService } from '../vehicles/vehicles.service';
@@ -1211,6 +1212,13 @@ export class BookingsService {
       destinationYardId: filter.destinationYardId,
       isGovernment: filter.isGovernment,
       consolidationPaired: filter.consolidationPaired,
+      // DTO carries 'true'/'false' strings (query params); the repo option is a
+      // real boolean — convert, preserving "not filtered" when absent.
+      customsClearingEnabled:
+        filter.customsClearingEnabled === undefined
+          ? undefined
+          : filter.customsClearingEnabled === 'true',
+      search: filter.search,
       sortBy: filter.sortBy,
       sortOrder: filter.sortOrder,
     });
@@ -1262,6 +1270,7 @@ export class BookingsService {
       // Global Logistics only clears customs bookings; non-customs clearance is
       // reviewed by Marketing from the booking detail, not this queue.
       customsClearingEnabled: true,
+      search: filter.search,
       sortBy: filter.sortBy,
       sortOrder: filter.sortOrder,
     });
@@ -1286,6 +1295,7 @@ export class BookingsService {
       // Company-wide: payables span all of the customer's services.
       companyId: company.id,
       companyProfileId: filter.companyProfileId,
+      search: filter.search,
       sortBy: filter.sortBy,
       sortOrder: filter.sortOrder,
     });
@@ -1473,6 +1483,18 @@ export class BookingsService {
       );
     }
 
+    // Surface the parent contract's reference for drawdown bookings — the
+    // portal detail header shows it (the entity has no contract relation, so
+    // the list attaches it via a raw join and the detail attaches it here).
+    if (booking.contractId) {
+      const contract = await this.dataSource.getRepository(Contract).findOne({
+        where: { id: booking.contractId },
+        select: { reference: true },
+      });
+      (booking as Booking & { contractReference?: string | null }).contractReference =
+        contract?.reference ?? null;
+    }
+
     // Surface the assigned train's operational status so the portal stepper
     // can show the Arrival stage: the booking status stays IN_TRANSIT from
     // dispatch until delivery, so arrival is only knowable from the schedule.
diff --git a/apps/edr-freight-api/src/modules/bookings/customer-truck.service.ts b/apps/edr-freight-api/src/modules/bookings/customer-truck.service.ts
index 4e364a03a..b61d0078d 100644
--- a/apps/edr-freight-api/src/modules/bookings/customer-truck.service.ts
+++ b/apps/edr-freight-api/src/modules/bookings/customer-truck.service.ts
@@ -2,18 +2,24 @@ import {
   BadRequestException,
   ConflictException,
   Injectable,
+  Logger,
   NotFoundException,
 } from '@nestjs/common';
 import { DataSource, EntityManager, IsNull } from 'typeorm';
+import { NotificationAudience, NotificationType } from '@edr/types';
 
 import { AddCustomerTruckDto } from './dto/add-customer-truck.dto';
 import { DepartCustomerTruckDto } from './dto/depart-customer-truck.dto';
 import { CustomerTruckAssignment } from './entities/customer-truck-assignment.entity';
 import { CustomerTruckContainer } from './entities/customer-truck-container.entity';
 import { CustomerTruckAssignmentsRepository } from './customer-truck-assignments.repository';
+import { NotificationInboxService } from '../notification-inbox/notification-inbox.service';
+import { NotificationsService } from '../notifications/notifications.service';
+import { sendCompanyChannels } from '../notifications/notify-company.util';
 
 interface BookingGuardRow {
   tradeDirection: string | null;
+  freightType: string | null;
   firstMile: string | null;
   lastMile: string | null;
   paymentStatus: string | null;
@@ -29,9 +35,13 @@ interface BookingGuardRow {
  */
 @Injectable()
 export class CustomerTruckService {
+  private readonly logger = new Logger(CustomerTruckService.name);
+
   constructor(
     private readonly dataSource: DataSource,
     private readonly assignments: CustomerTruckAssignmentsRepository,
+    private readonly inbox: NotificationInboxService,
+    private readonly notifications: NotificationsService,
   ) {}
 
   listTrucks(bookingId: string): Promise<CustomerTruckAssignment[]> {
@@ -41,14 +51,20 @@ export class CustomerTruckService {
   async addTruck(bookingId: string, dto: AddCustomerTruckDto): Promise<CustomerTruckAssignment[]> {
     const booking = await this.loadBookingGuard(bookingId);
     this.assertSelfHaulPaid(booking);
+    this.assertAssignmentWindow(booking);
 
-    const requested = (dto.containerNumbers ?? []).map((n) => n.trim().toUpperCase());
+    // Bulk bookings have no containers — the truck hauls loose tonnage and is
+    // weighed out on departure (gross_weight_kg). Container bookings assign the
+    // 1–2 specific containers each truck carries.
+    const isBulk = booking.freightType === 'BULK';
+    const requested = isBulk
+      ? []
+      : (dto.containerNumbers ?? []).map((n) => n.trim().toUpperCase());
 
-    // Both import and export specify the containers each truck carries. Capacity
-    // is size-based: a 40ft container fills the truck (max 1); two 20ft containers
-    // fit (max 2), no size mixing. #trucks <= #containers follows naturally since
-    // each container is assigned to exactly one truck.
-    if (requested.length < 1) {
+    // Container capacity is size-based: a 40ft container fills the truck (max 1);
+    // two 20ft containers fit (max 2), no size mixing. #trucks <= #containers
+    // follows naturally since each container is assigned to exactly one truck.
+    if (!isBulk && requested.length < 1) {
       throw new BadRequestException('Select at least one container for this truck');
     }
     if (requested.length > 2) {
@@ -395,20 +411,74 @@ export class CustomerTruckService {
     });
     if (!container) return;
 
+    const assignment = await m
+      .getRepository(CustomerTruckAssignment)
+      .findOne({ where: { id: container.assignmentId } });
+    const justArrived = Boolean(assignment) && !assignment?.arrivedAt;
+
     await m
       .getRepository(CustomerTruckAssignment)
       .update({ id: container.assignmentId, arrivedAt: IsNull() }, { arrivedAt: new Date() });
 
     await this.syncBookingArrival(bookingId, m);
+
+    if (justArrived && assignment) {
+      await this.notifyTruckArrival(bookingId, assignment.plateNumber, m);
+    }
   }
 
   /** Mark every truck on the booking arrived (fallback when no container is known). */
   async markAllArrived(bookingId: string, manager?: EntityManager): Promise<void> {
     const m = manager ?? this.dataSource.manager;
+    const justArrived = await m
+      .getRepository(CustomerTruckAssignment)
+      .find({ where: { bookingId, arrivedAt: IsNull() } });
     await m
       .getRepository(CustomerTruckAssignment)
       .update({ bookingId, arrivedAt: IsNull() }, { arrivedAt: new Date() });
     await this.syncBookingArrival(bookingId, m);
+    for (const truck of justArrived) {
+      await this.notifyTruckArrival(bookingId, truck.plateNumber, m);
+    }
+  }
+
+  /**
+   * Best-effort truck-arrival notification to the booking's company across every
+   * channel: in-app (portal inbox) + SMS + email. Never throws — a missing
+   * provider or contact must not break the arrival flow.
+   */
+  private async notifyTruckArrival(
+    bookingId: string,
+    plateNumber: string | null,
+    m: EntityManager,
+  ): Promise<void> {
+    try {
+      const [booking]: Array<{ companyId: string | null; reference: string | null }> =
+        await m.query(
+          `SELECT company_id AS "companyId", reference
+             FROM freight.bookings
+            WHERE id = $1 AND deleted_at IS NULL`,
+          [bookingId],
+        );
+      if (!booking?.companyId) return;
+      const ref = booking.reference ?? bookingId;
+      const truck = plateNumber ? `Truck ${plateNumber}` : 'A customer truck';
+      const body = `${truck} has arrived at the terminal for booking ${ref}.`;
+      await this.inbox.notify({
+        recipients: { companyId: booking.companyId },
+        audience: NotificationAudience.PORTAL,
+        type: NotificationType.BOOKING_STATUS,
+        title: 'Truck arrived',
+        body,
+        link: `/bookings/${bookingId}`,
+        data: { bookingId, plateNumber, action: 'TRUCK_ARRIVED' },
+      });
+      await sendCompanyChannels(this.dataSource, this.notifications, booking.companyId, body);
+    } catch (err) {
+      this.logger.warn(
+        `Truck-arrival notify failed for ${bookingId}: ${(err as Error).message}`,
+      );
+    }
   }
 
   /**
@@ -430,6 +500,7 @@ export class CustomerTruckService {
   private async loadBookingGuard(bookingId: string): Promise<BookingGuardRow> {
     const [row]: BookingGuardRow[] = await this.dataSource.query(
       `SELECT trade_direction AS "tradeDirection",
+              freight_type AS "freightType",
               first_mile_pickup_address AS "firstMile",
               last_mile_delivery_address AS "lastMile",
               payment_status AS "paymentStatus",
@@ -463,6 +534,30 @@ export class CustomerTruckService {
     }
   }
 
+  /**
+   * Assignment window by direction:
+   *  - IMPORT: pickup trucks are assigned only AFTER the train has arrived.
+   *  - EXPORT / DOMESTIC: delivery trucks are assigned only BEFORE the cargo is
+   *    loaded onto the train (booking still PAID / TRUCK_ASSIGNED). Once loaded
+   *    (IN_TRANSIT and beyond) assignment is closed.
+   */
+  private assertAssignmentWindow(booking: BookingGuardRow): void {
+    const status = booking.status ?? '';
+    if (booking.tradeDirection === 'IMPORT') {
+      if (status !== 'ARRIVED') {
+        throw new BadRequestException(
+          'Import pickup trucks can only be assigned after the train has arrived',
+        );
+      }
+      return;
+    }
+    if (!['PAID', 'TRUCK_ASSIGNED'].includes(status)) {
+      throw new BadRequestException(
+        'Export delivery trucks can only be assigned before the cargo is loaded onto the train',
+      );
+    }
+  }
+
   private async bookingContainerNumbers(bookingId: string): Promise<string[]> {
     const rows: Array<{ containerNumber: string }> = await this.dataSource.query(
       `SELECT bcu.container_number AS "containerNumber"
diff --git a/apps/edr-freight-api/src/modules/bookings/dto/filter-booking.dto.ts b/apps/edr-freight-api/src/modules/bookings/dto/filter-booking.dto.ts
index ae973b97d..2d3297af8 100644
--- a/apps/edr-freight-api/src/modules/bookings/dto/filter-booking.dto.ts
+++ b/apps/edr-freight-api/src/modules/bookings/dto/filter-booking.dto.ts
@@ -106,6 +106,14 @@ export class FilterBookingDto {
   @IsIn(['true', 'false'])
   isGovernment?: 'true' | 'false';
 
+  @ApiPropertyOptional({
+    enum: ['true', 'false'],
+    description: 'Filter customs vs self-clearance (non-customs) bookings',
+  })
+  @IsOptional()
+  @IsIn(['true', 'false'])
+  customsClearingEnabled?: 'true' | 'false';
+
   @ApiPropertyOptional({ enum: TRADE_DIRECTIONS })
   @IsOptional()
   @IsIn([...TRADE_DIRECTIONS])
@@ -125,6 +133,16 @@ export class FilterBookingDto {
   @IsOptional()
   consolidationPaired?: string;
 
+  @ApiPropertyOptional({
+    description:
+      'Free-text search across booking reference, company name, and contract reference.',
+  })
+  @IsOptional()
+  @Transform(({ value }) =>
+    typeof value === 'string' && value.trim() ? value.trim() : undefined,
+  )
+  search?: string;
+
   @ApiPropertyOptional({ default: 1 })
   @IsOptional()
   @Transform(({ value }) => (value ? parseInt(value, 10) : 1))
diff --git a/apps/edr-freight-api/src/modules/bookings/entities/booking.entity.ts b/apps/edr-freight-api/src/modules/bookings/entities/booking.entity.ts
index 398c64809..4cc15854e 100644
--- a/apps/edr-freight-api/src/modules/bookings/entities/booking.entity.ts
+++ b/apps/edr-freight-api/src/modules/bookings/entities/booking.entity.ts
@@ -166,6 +166,24 @@ export class Booking extends BaseEntity {
   @Column({ name: 'contract_kind', type: 'varchar', length: 20, nullable: true })
   contractKind?: string | null;
 
+  /**
+   * The customer paid a partial batch offer and this booking was reduced to the
+   * offered part (see BookingSplitService.applySplit). On a ONE_TIME contract a
+   * split booking releases the single-active-booking slot for the remainder —
+   * the contract kind itself is never changed.
+   */
+  @Column({ name: 'is_split', type: 'boolean', default: false })
+  isSplit!: boolean;
+
+  /**
+   * Quantities this booking carried BEFORE it was reduced by a split — the
+   * split chain's source of truth for the outstanding remainder (ONE_TIME
+   * contracts have no quantity cap to derive it from). Bulk: total tons;
+   * container: units per size. Null until the booking is split.
+   */
+  @Column({ name: 'pre_split_quantities', type: 'jsonb', nullable: true })
+  preSplitQuantities?: { bulkTons?: number; bySize?: Record<string, number> } | null;
+
   /** Who created this booking: CUSTOMER (Path A), GL_ET (Path B), or STAFF. */
   @Column({ name: 'created_by_role', type: 'varchar', length: 20, default: 'CUSTOMER', nullable: true })
   createdByRole?: string | null;
diff --git a/apps/edr-freight-api/src/modules/contracts/booking-request.service.ts b/apps/edr-freight-api/src/modules/contracts/booking-request.service.ts
index 1005409e0..a17406d64 100644
--- a/apps/edr-freight-api/src/modules/contracts/booking-request.service.ts
+++ b/apps/edr-freight-api/src/modules/contracts/booking-request.service.ts
@@ -199,6 +199,8 @@ export class BookingRequestService {
       reviewedByStaffId: staffId ?? null,
       reviewedAt: new Date(),
     } as never);
+    const contract = await this.contractsService.findById(request.contractId);
+    this.notifier.shipmentRequestRejected(contract, request.reference, note);
     return (await this.repo.findById(requestId)) ?? request;
   }
 
diff --git a/apps/edr-freight-api/src/modules/contracts/contract-booking.completion.spec.ts b/apps/edr-freight-api/src/modules/contracts/contract-booking.completion.spec.ts
index 4e21078ff..7dc676398 100644
--- a/apps/edr-freight-api/src/modules/contracts/contract-booking.completion.spec.ts
+++ b/apps/edr-freight-api/src/modules/contracts/contract-booking.completion.spec.ts
@@ -28,6 +28,7 @@ describe('ContractBookingService — quantity-cap completion', () => {
       {} as never, // invoiceService
       {} as never, // dataSource
       {} as never, // trainSchedulingService
+      {} as never, // bookingBatchService
       {} as never, // bookingTransitionService
     );
     return { service, contractsRepository };
diff --git a/apps/edr-freight-api/src/modules/contracts/contract-booking.consolidation.spec.ts b/apps/edr-freight-api/src/modules/contracts/contract-booking.consolidation.spec.ts
index 7225d6e3f..c2e3a107b 100644
--- a/apps/edr-freight-api/src/modules/contracts/contract-booking.consolidation.spec.ts
+++ b/apps/edr-freight-api/src/modules/contracts/contract-booking.consolidation.spec.ts
@@ -59,6 +59,7 @@ describe('ContractBookingService — drawdown consolidation gate', () => {
       invoiceService as never,
       {} as never, // dataSource
       {} as never, // trainSchedulingService
+      {} as never, // bookingBatchService
       {} as never, // bookingTransitionService
     );
     return {
diff --git a/apps/edr-freight-api/src/modules/contracts/contract-booking.service.ts b/apps/edr-freight-api/src/modules/contracts/contract-booking.service.ts
index c09f2ccb0..f055a0c15 100644
--- a/apps/edr-freight-api/src/modules/contracts/contract-booking.service.ts
+++ b/apps/edr-freight-api/src/modules/contracts/contract-booking.service.ts
@@ -24,9 +24,11 @@ import { BookingInvoiceService } from '../bookings/booking-invoice.service';
 import { validate20ftWeightPairing } from '../bookings/container-pairing.util';
 import { TrainSchedulingGlobalRules } from '../train-scheduling/entities/train-scheduling-global-rules.entity';
 import { TrainSchedulingService } from '../train-scheduling/train-scheduling.service';
+import { BookingBatchService } from '../train-scheduling/booking-batch.service';
 import { ContainerTypesService } from '../rule-engine/services/container-types.service';
 import { RuleEngineService } from '../rule-engine/rule-engine.service';
 import { ContainerType } from '../rule-engine/entities/container-type.entity';
+import { CargoType } from '../rule-engine/entities/cargo-type.entity';
 import { FREIGHT_PERMS } from '../../seed/freight-permissions.registry';
 import { hasFreightPermission } from '../../common/freight-permission.util';
 
@@ -40,6 +42,11 @@ import { CreateBookingUnderContractDto } from './dto/create-booking-under-contra
 /** Statuses that still occupy the single active-booking slot of a ONE_TIME contract. */
 const TERMINAL_BOOKING_STATUSES = ['EXPIRED', 'CANCELLED', 'COMPLETED', 'REJECTED'];
 
+/** Bookings that never shipped release their quantity hold on the contract. */
+const RELEASING_BOOKING_STATUSES = ['CANCELLED', 'REJECTED', 'EXPIRED'];
+
+const round3 = (n: number): number => Math.round(n * 1000) / 1000;
+
 export interface CreateBookingUnderContractResult {
   booking: Booking;
   warnings: string[];
@@ -74,6 +81,8 @@ export class ContractBookingService {
     private readonly dataSource: DataSource,
     @Inject(forwardRef(() => TrainSchedulingService))
     private readonly trainSchedulingService: TrainSchedulingService,
+    @Inject(forwardRef(() => BookingBatchService))
+    private readonly bookingBatchService: BookingBatchService,
     @Inject(forwardRef(() => BookingTransitionService))
     private readonly bookingTransitionService: BookingTransitionService,
   ) {}
@@ -90,10 +99,22 @@ export class ContractBookingService {
     // A contract whose quantity cap was fully booked is completed — no further
     // bookings, even while contract validity and a booking window are still
     // open. Capacity released after closure (a cancelled/expired booking)
-    // reopens the contract on the next booking attempt.
+    // reopens the contract on the next booking attempt. A ONE_TIME contract
+    // only closes via a finished split chain, so its room is the outstanding
+    // split remainder rather than a cap line.
     if (contract.status === 'CONTRACT_CLOSED') {
-      const capacity = await this.computeCapacity(contract);
-      const hasRoom = capacity.some((c) => c.remaining == null || c.remaining > 0);
+      let hasRoom: boolean;
+      if (contract.contractKind !== 'GENERAL') {
+        const outstanding = await this.splitOutstanding(contract);
+        hasRoom = outstanding
+          ? contract.freightType === 'CONTAINER'
+            ? [...outstanding.bySize.values()].some((s) => s.outstanding > 0)
+            : (outstanding.bulk?.outstanding ?? 0) > 0.001
+          : false;
+      } else {
+        const capacity = await this.computeCapacity(contract);
+        hasRoom = capacity.some((c) => c.remaining == null || c.remaining > 0);
+      }
       if (!hasRoom) {
         throw new BadRequestException(
           'This contract is completed — the full contracted quantity has been booked.',
@@ -121,12 +142,21 @@ export class ContractBookingService {
     // ONE_TIME: a single shipment at a time. The slot frees only if the prior
     // booking reached a terminal state (e.g. payment expired without shipping),
     // letting the customer re-book within contract validity (doc §10.4).
+    // EXCEPTION — split chain: a paid partial split (booking.isSplit) releases
+    // the slot for the leftover, but the next booking must take the WHOLE
+    // remainder; the customer cannot start any other booking on the contract.
+    // If the remainder splits again the same rule repeats until the cap is
+    // exhausted and the contract completes.
     if (contract.contractKind === 'ONE_TIME') {
-      const active = await this.countActiveBookings(contractId);
-      if (active > 0) {
-        throw new BadRequestException(
-          'This one-time contract already has an active booking.',
-        );
+      if (await this.hasSplitBooking(contractId)) {
+        await this.assertExactRemainder(contract, dto);
+      } else {
+        const active = await this.countActiveBookings(contractId);
+        if (active > 0) {
+          throw new BadRequestException(
+            'This one-time contract already has an active booking.',
+          );
+        }
       }
     } else {
       // GENERAL: draw down against the cargo quantity cap until it is full.
@@ -181,6 +211,10 @@ export class ContractBookingService {
         scheduledDate: dto.scheduledDate ?? null,
         direction: contract.tradeDirection ?? null,
       });
+      // EXPORT rides whole or not at all (no split concept): reject the booking
+      // up front when no single open train on the day can carry it, telling the
+      // customer how much space is still bookable.
+      await this.assertExportTrainSpace(contract, route, dto);
     }
 
     // Hard capacity gate: a container line whose total weight exceeds the
@@ -573,6 +607,31 @@ export class ContractBookingService {
       Number(booking.cargoTotalWeightVgm) > 0;
     const warnings: string[] = [];
 
+    // EXPORT rides whole or not at all (no split concept): the chosen day must
+    // have a single open train that carries the whole booking. First completion
+    // sizes from the dto's cargo; a changes-requested resubmit (cargo already
+    // persisted, only the day re-picked) sizes from the booking itself.
+    if (contract.tradeDirection === 'EXPORT') {
+      if (hasCargo) {
+        const probe = Object.assign(
+          Object.create(Object.getPrototypeOf(booking)),
+          booking,
+          { scheduledDate: new Date(dto.scheduledDate) },
+        ) as Booking;
+        const report = await this.bookingBatchService.exportSpaceReport(probe);
+        if (!report.scheduleId) {
+          throw new BadRequestException(
+            report.fullMessage ?? 'Not enough train space for this day.',
+          );
+        }
+      } else {
+        await this.assertExportTrainSpace(contract, null, dto, {
+          originYardId: booking.originYardId ?? null,
+          destinationYardId: booking.destinationYardId ?? null,
+        });
+      }
+    }
+
     // First completion persists cargo and draws contract capacity; a resubmit
     // after OPERATION_CHANGES_REQUESTED already has its cargo and only re-picks
     // the shipment day.
@@ -869,6 +928,196 @@ export class ContractBookingService {
       .getCount();
   }
 
+  /**
+   * Whether the contract is in split-remainder mode: some booking on it was
+   * reduced by a paid partial batch offer and still holds capacity. A split
+   * booking that never shipped (CANCELLED / REJECTED / EXPIRED) releases its
+   * hold and the contract falls back to the plain single-slot rule — the
+   * customer can rebook the whole quantity again.
+   */
+  private async hasSplitBooking(contractId: string): Promise<boolean> {
+    const count = await this.dataSource
+      .getRepository(Booking)
+      .createQueryBuilder('b')
+      .where('b.contract_id = :contractId', { contractId })
+      .andWhere('b.is_split = true')
+      .andWhere('b.status NOT IN (:...releasing)', { releasing: RELEASING_BOOKING_STATUSES })
+      .getCount();
+    return count > 0;
+  }
+
+  /**
+   * Outstanding split remainder of a ONE_TIME contract: what the FIRST split
+   * booking carried before its reduction (its pre_split_quantities snapshot —
+   * one-time contracts have no quantity cap to derive this from) minus
+   * everything currently booked on the contract. Bookings that never shipped
+   * (CANCELLED / REJECTED / EXPIRED) release their share. Null when the
+   * contract has no live split booking.
+   */
+  private async splitOutstanding(
+    contract: Contract,
+  ): Promise<{ bySize: Map<string, { total: number; outstanding: number }>; bulk: { total: number; outstanding: number } | null } | null> {
+    const first = await this.dataSource
+      .getRepository(Booking)
+      .createQueryBuilder('b')
+      .where('b.contract_id = :contractId', { contractId: contract.id })
+      .andWhere('b.is_split = true')
+      .andWhere('b.status NOT IN (:...releasing)', { releasing: RELEASING_BOOKING_STATUSES })
+      .orderBy('b.created_at', 'ASC')
+      .getOne();
+    if (!first?.preSplitQuantities) return null;
+
+    const booked = await this.bookedQuantities(contract);
+    if (contract.freightType === 'CONTAINER') {
+      const bySize = new Map<string, { total: number; outstanding: number }>();
+      for (const [size, total] of Object.entries(first.preSplitQuantities.bySize ?? {})) {
+        bySize.set(size, {
+          total: Number(total),
+          outstanding: Math.max(0, Number(total) - (booked.bySize.get(size) ?? 0)),
+        });
+      }
+      return { bySize, bulk: null };
+    }
+    const total = Number(first.preSplitQuantities.bulkTons ?? 0);
+    return {
+      bySize: new Map(),
+      bulk: { total, outstanding: Math.max(0, round3(total - booked.bulk)) },
+    };
+  }
+
+  /**
+   * EXPORT whole-booking single-train gate. Export bookings never split — the
+   * entire booking must ride ONE open train on the chosen day. When no train
+   * fits it whole (trying every fillable train on the corridor, earliest
+   * first), reject BEFORE anything is written, with the largest still-bookable
+   * space (tons for bulk via the cargo type's wagon type; wagons/containers
+   * for container freight) so the customer knows what he CAN book.
+   */
+  private async assertExportTrainSpace(
+    contract: Contract,
+    route: ContractRoute | null,
+    dto: CreateBookingUnderContractDto,
+    yards?: { originYardId: string | null; destinationYardId: string | null },
+  ): Promise<void> {
+    if (contract.tradeDirection !== 'EXPORT' || !dto.scheduledDate) return;
+    const probe = await this.buildExportProbe(contract, route, dto, yards);
+    const report = await this.bookingBatchService.exportSpaceReport(probe);
+    if (report.scheduleId) return;
+    throw new BadRequestException(
+      report.fullMessage ?? 'Not enough train space for this day.',
+    );
+  }
+
+  /**
+   * Unsaved booking twin carrying exactly what the batch engine's capacity
+   * math reads: yards + day for the leg, container lines WITH their container
+   * type (wagon-type FK) for TEU/wagon sizing, or bulk tons + cargo type
+   * (wagon-type FK) for tons→wagons conversion.
+   */
+  private async buildExportProbe(
+    contract: Contract,
+    route: ContractRoute | null,
+    dto: CreateBookingUnderContractDto,
+    yards?: { originYardId: string | null; destinationYardId: string | null },
+  ): Promise<Booking> {
+    const probe = new Booking();
+    probe.freightType = contract.freightType;
+    probe.tradeDirection = contract.tradeDirection;
+    probe.scheduledDate = dto.scheduledDate ? new Date(dto.scheduledDate) : null;
+    // Entity types are non-nullable; a missing yard just makes legOf() match no
+    // train, which surfaces as "no export train for this day" — the right failure.
+    probe.originYardId = (yards?.originYardId ?? route?.originYardId) as string;
+    probe.destinationYardId = (yards?.destinationYardId ??
+      route?.destinationYardId) as string;
+
+    if (contract.freightType === 'CONTAINER') {
+      const lines = await Promise.all(
+        (dto.containers ?? []).map(async (line) => {
+          const ct = await this.resolveContainerTypeForSize(
+            line.containerSize,
+            contract.isReefer || (line.reeferQuantity ?? 0) > 0,
+          );
+          const bc = new BookingContainer();
+          bc.containerSize = line.containerSize;
+          bc.quantity = line.quantity;
+          bc.containerTypeId = ct.id;
+          bc.containerType = ct;
+          bc.wagonsRequired = Math.ceil(line.quantity * Number(ct.wagonsPerUnit ?? 1));
+          bc.totalVgmTons = (line.units ?? []).reduce(
+            (sum, u) => sum + Number(u.vgmTons ?? 0),
+            0,
+          );
+          return bc;
+        }),
+      );
+      probe.bookingContainers = lines;
+      probe.cargoTotalWeightVgm = lines.reduce(
+        (sum, l) => sum + Number(l.totalVgmTons ?? 0),
+        0,
+      );
+      return probe;
+    }
+
+    probe.cargoTotalWeightVgm = this.resolveBulkTons(dto);
+    const cargoTypeId = this.resolveCargoTypeId(contract, dto);
+    probe.cargoTypeId = cargoTypeId;
+    if (cargoTypeId) {
+      probe.cargoType =
+        (await this.dataSource
+          .getRepository(CargoType)
+          .findOne({ where: { id: cargoTypeId } })) ?? undefined;
+    }
+    return probe;
+  }
+
+  /**
+   * ONE_TIME split chain: the next booking must take the WHOLE outstanding
+   * remainder — a one-time contract is a single shipment, so the only way it
+   * fragments is the system splitting it on train capacity, never the customer
+   * choosing a partial amount.
+   */
+  private async assertExactRemainder(
+    contract: Contract,
+    dto: CreateBookingUnderContractDto,
+  ): Promise<void> {
+    const outstanding = await this.splitOutstanding(contract);
+    if (!outstanding) return; // no live split booking — nothing to pin the remainder to
+
+    if (contract.freightType === 'CONTAINER') {
+      const sizes = new Set<string>([
+        ...outstanding.bySize.keys(),
+        ...(dto.containers ?? []).map((l) => l.containerSize ?? ''),
+      ]);
+      for (const size of sizes) {
+        const remaining = outstanding.bySize.get(size)?.outstanding ?? 0;
+        const requested = (dto.containers ?? [])
+          .filter((l) => (l.containerSize ?? '') === size)
+          .reduce((sum, l) => sum + Number(l.quantity ?? 0), 0);
+        if (requested !== remaining) {
+          throw new BadRequestException(
+            `This one-time contract was split — the next booking must take the whole remainder: ` +
+              `${remaining} × ${size || 'container'} container(s), got ${requested}.`,
+          );
+        }
+      }
+      return;
+    }
+
+    const requested =
+      (dto.bulkLines ?? []).reduce(
+        (sum, b) => sum + (b.cargoWeightTons ?? b.itemCount ?? 0),
+        0,
+      ) || this.resolveBulkTons(dto) || 0;
+    const remaining = outstanding.bulk?.outstanding ?? 0;
+    // 0.001 t tolerance absorbs the 3-decimal rounding applied to split weights.
+    if (Math.abs(requested - remaining) > 0.001) {
+      throw new BadRequestException(
+        `This one-time contract was split — the next booking must take the whole ` +
+          `remaining ${remaining} tons, got ${requested}.`,
+      );
+    }
+  }
+
   // ── GENERAL contract quantity cap (draw-down) ──────────────────────────────
 
   /**
@@ -980,34 +1229,96 @@ export class ContractBookingService {
     });
   }
 
+  /**
+   * Capacity as shown to bookers (the /:id/capacity endpoint): GENERAL cap
+   * lines as-is, or — for a ONE_TIME contract in split-remainder mode —
+   * synthesized lines whose cap is the first split booking's pre-split
+   * snapshot and whose remaining is the outstanding remainder, i.e. the exact
+   * quantity the next booking must take.
+   */
+  async capacityView(
+    contract: Contract,
+  ): Promise<
+    Array<{
+      containerSize?: string | null;
+      cargoTypeId?: string | null;
+      cap: number | null;
+      booked: number;
+      remaining: number | null;
+    }>
+  > {
+    const capacity = await this.computeCapacity(contract);
+    if (capacity.length > 0 || contract.contractKind === 'GENERAL') {
+      return capacity;
+    }
+    const outstanding = await this.splitOutstanding(contract);
+    if (!outstanding) return capacity;
+    if (contract.freightType === 'CONTAINER') {
+      return [...outstanding.bySize.entries()].map(([size, s]) => ({
+        containerSize: size,
+        cargoTypeId: null,
+        cap: s.total,
+        booked: s.total - s.outstanding,
+        remaining: s.outstanding,
+      }));
+    }
+    const bulk = outstanding.bulk;
+    if (!bulk) return [];
+    return [
+      {
+        containerSize: null,
+        cargoTypeId: null,
+        cap: bulk.total,
+        booked: round3(bulk.total - bulk.outstanding),
+        remaining: bulk.outstanding,
+      },
+    ];
+  }
+
   /**
    * Complete the contract once its quantity cap is fully consumed. Runs after
-   * every booking created under a GENERAL contract (including a split remainder
-   * being rebooked): when no capped scope line has capacity left, the contract
-   * moves to CONTRACT_CLOSED even though its validity window is still open —
-   * blocking further bookings and shipment requests, including inside an open
-   * booking window. Never throws: a status hiccup must not undo the booking
-   * that was just created.
+   * every booking created under a GENERAL contract, and under a ONE_TIME
+   * contract in split-remainder mode (a split remainder being rebooked): when
+   * no capped scope line has capacity left, the contract moves to
+   * CONTRACT_CLOSED even though its validity window is still open — blocking
+   * further bookings and shipment requests, including inside an open booking
+   * window. Never throws: a status hiccup must not undo the booking that was
+   * just created.
    */
   private async maybeCompleteContract(contract: Contract): Promise<void> {
     try {
-      // ONE_TIME contracts are governed by the single-active-booking slot (and
-      // are promoted to GENERAL on split), so only GENERAL completes by cap.
-      if (contract.contractKind !== 'GENERAL') return;
       if (!['CONTRACT_ACTIVE', 'FULLY_EXECUTED'].includes(contract.status)) return;
-      const capacity = await this.computeCapacity(contract);
-      if (capacity.length === 0) return; // uncapped — completes only by expiry
-      // 0.001 tolerance absorbs bulk-ton float rounding (split weights round to
-      // 3 decimals); container caps are integers and unaffected.
-      const exhausted = capacity.every(
-        (c) => c.remaining != null && c.remaining <= 0.001,
-      );
-      if (!exhausted) return;
+
+      // ONE_TIME contracts are governed by the single-active-booking slot, so
+      // they normally complete by expiry — EXCEPT once a booking was split: the
+      // remainder chain draws down the split booking's pre-split snapshot, and
+      // the contract completes when the outstanding remainder hits zero.
+      // (An unsplit ONE_TIME never completes here, so re-booking after an
+      // expired unpaid booking keeps working.)
+      if (contract.contractKind !== 'GENERAL') {
+        const outstanding = await this.splitOutstanding(contract);
+        if (!outstanding) return;
+        // 0.001 tolerance absorbs bulk-ton float rounding (split weights round
+        // to 3 decimals); container quantities are integers and unaffected.
+        const exhausted =
+          contract.freightType === 'CONTAINER'
+            ? [...outstanding.bySize.values()].every((s) => s.outstanding <= 0)
+            : (outstanding.bulk?.outstanding ?? 0) <= 0.001;
+        if (!exhausted) return;
+      } else {
+        const capacity = await this.computeCapacity(contract);
+        if (capacity.length === 0) return; // uncapped — completes only by expiry
+        const exhausted = capacity.every(
+          (c) => c.remaining != null && c.remaining <= 0.001,
+        );
+        if (!exhausted) return;
+      }
+
       await this.contractsRepository.update(contract.id, {
         status: 'CONTRACT_CLOSED',
       } as never);
       this.logger.log(
-        `Contract ${contract.reference} quantity cap fully booked — completed; no further bookings within validity.`,
+        `Contract ${contract.reference} quantity fully booked — completed; no further bookings within validity.`,
       );
     } catch (err) {
       this.logger.error(
@@ -1025,7 +1336,7 @@ export class ContractBookingService {
   private async bookedQuantities(
     contract: Contract,
   ): Promise<{ bySize: Map<string, number>; bulk: number }> {
-    const releasing = ['CANCELLED', 'REJECTED', 'EXPIRED'];
+    const releasing = RELEASING_BOOKING_STATUSES;
     if (contract.freightType === 'CONTAINER') {
       const rows = await this.dataSource
         .getRepository(BookingContainer)
@@ -1213,6 +1524,8 @@ export class ContractBookingService {
     currency: string | null;
     pairingErrors: string[];
     capacityErrors: string[];
+    containerClashErrors: string[];
+    spaceErrors: string[];
     lineItems: PriceLineItemDto[];
     totalAmount: number;
   }> {
@@ -1227,6 +1540,8 @@ export class ContractBookingService {
         currency: null,
         pairingErrors: [],
         capacityErrors: [],
+        containerClashErrors: [],
+        spaceErrors: [],
         lineItems: [],
         totalAmount: 0,
       };
@@ -1312,12 +1627,50 @@ export class ContractBookingService {
       contract.tradeDirection,
     );
 
+    // A physical container rides one train only — surface a clash with another
+    // active booking on the same day + route in the preview, so the form can
+    // hard-block before the create call rejects with the same rule.
+    let containerClashErrors: string[] = [];
+    if (dto.scheduledDate) {
+      const numbers = lines.flatMap((line) =>
+        (line.units ?? [])
+          .map((u) => (u.containerNumber ?? '').trim().toUpperCase())
+          .filter((n) => n.length > 0),
+      );
+      const clashes = await this.findContainerClashesOnTrain(
+        [...new Set(numbers)],
+        dto.scheduledDate,
+        {
+          originYardId: route?.originYardId,
+          destinationYardId: route?.destinationYardId,
+        },
+      );
+      containerClashErrors = clashes.map(
+        (c) =>
+          `${c.containerNumber} is already booked on ${c.reference} for this shipment day.`,
+      );
+    }
+
+    // EXPORT rides whole or not at all — surface the single-train space check
+    // in the preview so the form hard-blocks BEFORE the create call rejects
+    // with the same message (including how much space is still bookable).
+    let spaceErrors: string[] = [];
+    if (contract.tradeDirection === 'EXPORT' && dto.scheduledDate) {
+      const probe = await this.buildExportProbe(contract, route, dto);
+      const report = await this.bookingBatchService.exportSpaceReport(probe);
+      if (!report.scheduleId) {
+        spaceErrors = [report.fullMessage ?? 'Not enough train space for this day.'];
+      }
+    }
+
     return {
       overweightLines: computed.overweightLines,
       overweightSurchargeAmount,
       currency: computed.currency,
       pairingErrors,
       capacityErrors,
+      containerClashErrors,
+      spaceErrors,
       lineItems: computed.lineItems,
       totalAmount: computed.totalAmount,
     };
@@ -1445,6 +1798,37 @@ export class ContractBookingService {
     route: { originYardId?: string | null; destinationYardId?: string | null },
     excludeBookingId?: string,
   ): Promise<void> {
+    const clashes = await this.findContainerClashesOnTrain(
+      numbers,
+      scheduledDate,
+      route,
+      excludeBookingId,
+    );
+
+    if (clashes.length) {
+      const detail = clashes
+        .map((c) => `${c.containerNumber} (booking ${c.reference})`)
+        .join(', ');
+      throw new ConflictException(
+        `Container(s) already booked on this route for ${scheduledDate}: ${detail}. ` +
+          'A container can only be on one booking per train — remove it or pick another shipment day.',
+      );
+    }
+  }
+
+  /**
+   * Container numbers among `numbers` that already sit on another active
+   * booking of the same train — same day and same route. One row per clashing
+   * number. Bookings without route yards (legacy rows) match on the day alone
+   * rather than let through.
+   */
+  private async findContainerClashesOnTrain(
+    numbers: string[],
+    scheduledDate: string,
+    route: { originYardId?: string | null; destinationYardId?: string | null },
+    excludeBookingId?: string,
+  ): Promise<Array<{ containerNumber: string; reference: string }>> {
+    if (!numbers.length) return [];
     const qb = this.dataSource
       .getRepository(BookingContainerUnit)
       .createQueryBuilder('unit')
@@ -1474,18 +1858,7 @@ export class ContractBookingService {
     }
     const clashes: Array<{ containerNumber: string; reference: string }> =
       await qb.getRawMany();
-
-    if (clashes.length) {
-      const detail = [
-        ...new Map(clashes.map((c) => [c.containerNumber, c])).values(),
-      ]
-        .map((c) => `${c.containerNumber} (booking ${c.reference})`)
-        .join(', ');
-      throw new ConflictException(
-        `Container(s) already booked on this route for ${scheduledDate}: ${detail}. ` +
-          'A container can only be on one booking per train — remove it or pick another shipment day.',
-      );
-    }
+    return [...new Map(clashes.map((c) => [c.containerNumber, c])).values()];
   }
 
   private async assert20ftPairableAtCreate(
@@ -1528,8 +1901,8 @@ export class ContractBookingService {
     preferReefer: boolean,
   ): Promise<ContainerType> {
     const sizeFt = parseInt(size, 10);
-    const { data } = await this.containerTypesService.findAll({ pageSize: 200 });
-    const types = data.filter((t) => Number(t.sizeFt) === sizeFt && t.isActive !== false);
+    const { items } = await this.containerTypesService.findAll({ pageSize: 100 });
+    const types = items.filter((t) => Number(t.sizeFt) === sizeFt && t.isActive !== false);
     if (!types.length) {
       throw new BadRequestException(`No container type configured for size ${size}.`);
     }
diff --git a/apps/edr-freight-api/src/modules/contracts/contract-clearance.service.ts b/apps/edr-freight-api/src/modules/contracts/contract-clearance.service.ts
index 3d41e68a5..60eebf3da 100644
--- a/apps/edr-freight-api/src/modules/contracts/contract-clearance.service.ts
+++ b/apps/edr-freight-api/src/modules/contracts/contract-clearance.service.ts
@@ -848,8 +848,10 @@ export class ContractClearanceService {
   }
 
   /**
-   * GL ET clearance hub: every customs (Path B) contract in phased clearance,
-   * including after booking is created.
+   * GL ET clearance hub, Contracts tab: ONE_TIME customs (Path B) contracts in
+   * phased clearance that already carry at least one uploaded clearance
+   * document — a contract still waiting for its first document has nothing to
+   * review, and GENERAL contracts clear per booking, not at contract level.
    */
   async queue(filter: FilterContractDto): Promise<PaginatedContracts> {
     return this.contractsRepository.findAllPaginated({
@@ -857,6 +859,8 @@ export class ContractClearanceService {
       pageSize: filter.pageSize ?? 100,
       statuses: [...PHASED_CUSTOMS_CONTRACT_QUEUE_STATUSES],
       customsClearingEnabled: true,
+      contractKind: 'ONE_TIME',
+      hasClearanceDocuments: true,
       sortBy: filter.sortBy,
       sortOrder: filter.sortOrder,
     });
@@ -866,12 +870,38 @@ export class ContractClearanceService {
    * Operations queue: self-clearance (Path A) contracts awaiting Operations
    * review of the customer's own clearance documents.
    */
+  /**
+   * Statuses a non-customs contract passes through around Operations
+   * clearance review — the set a caller may narrow {@link opsQueue} to.
+   */
+  private static readonly OPS_CLEARANCE_STATUSES = [
+    'AWAITING_CLEARANCE_DOCUMENTS',
+    'CLEARANCE_UNDER_REVIEW',
+    'CLEARANCE_READY_FOR_BOOKING',
+    'FULLY_EXECUTED',
+    'CONTRACT_ACTIVE',
+    'ACTIVE_SHIPMENT_IN_PROGRESS',
+    'CONTRACT_CLOSED',
+    'CANCELLED',
+  ];
+
   async opsQueue(filter: FilterContractDto): Promise<PaginatedContracts> {
+    // Callers may narrow to any subset of the ops-clearance lifecycle (the
+    // hub's status filter sends an explicit list); anything outside the
+    // whitelist is dropped so this endpoint can't become a general contract
+    // browser. No statuses given → the original under-review queue.
+    const requested = (filter.statuses ?? filter.status ?? '')
+      .split(',')
+      .map((s) => s.trim())
+      .filter((s) =>
+        ContractClearanceService.OPS_CLEARANCE_STATUSES.includes(s),
+      );
     return this.contractsRepository.findAllPaginated({
       page: filter.page ?? 1,
       pageSize: filter.pageSize ?? 100,
-      statuses: ['CLEARANCE_UNDER_REVIEW'],
+      statuses: requested.length ? requested : ['CLEARANCE_UNDER_REVIEW'],
       customsClearingEnabled: false,
+      search: filter.search,
       sortBy: filter.sortBy,
       sortOrder: filter.sortOrder,
     });
@@ -896,6 +926,7 @@ export class ContractClearanceService {
       pageSize: filter.pageSize ?? 50,
       statuses: ['CLEARANCE_READY_FOR_BOOKING', 'ACTIVE', 'CLOSED', 'CANCELLED'],
       customsClearingEnabled: false,
+      search: filter.search,
       sortBy: filter.sortBy ?? 'createdAt',
       sortOrder: filter.sortOrder ?? 'DESC',
     });
diff --git a/apps/edr-freight-api/src/modules/contracts/contract-notifier.service.ts b/apps/edr-freight-api/src/modules/contracts/contract-notifier.service.ts
index d4f31e570..3834b55f0 100644
--- a/apps/edr-freight-api/src/modules/contracts/contract-notifier.service.ts
+++ b/apps/edr-freight-api/src/modules/contracts/contract-notifier.service.ts
@@ -145,6 +145,19 @@ export class ContractNotifierService {
     this.inApp(c, 'Contract changes requested', msg);
   }
 
+  /** GL rejected a shipment request filed under the contract. */
+  shipmentRequestRejected(c: Contract, requestRef: string, note?: string): void {
+    const msg =
+      `Your shipment request ${requestRef} under contract ${c.reference} was rejected.` +
+      (note ? ` Reason: ${note}.` : '') +
+      ` Please contact us for details.`;
+    void this.notifyContact(c, msg, 'SHIPMENT REQUEST REJECTED');
+    this.inApp(c, 'Shipment request rejected', msg, {
+      type: NotificationType.BOOKING_STATUS,
+      data: { contractId: c.id, reference: requestRef },
+    });
+  }
+
   // ── Clearance milestones needing customer action ──────────────────────────
 
   /** GL advised duty & tax on the contract cycle — customer pays + uploads slip. */
diff --git a/apps/edr-freight-api/src/modules/contracts/contract-pricing.service.ts b/apps/edr-freight-api/src/modules/contracts/contract-pricing.service.ts
index 8ce7ad2ea..286cd9a01 100644
--- a/apps/edr-freight-api/src/modules/contracts/contract-pricing.service.ts
+++ b/apps/edr-freight-api/src/modules/contracts/contract-pricing.service.ts
@@ -80,9 +80,9 @@ export class ContractPricingService {
       const sizes = (contract.cargoScope ?? [])
         .map((c) => c.containerSize)
         .filter((s): s is string => !!s);
-      const { data: containerTypes } = await this.containerTypesService.findAll({
+      const { items: containerTypes } = await this.containerTypesService.findAll({
         isActive: true,
-        pageSize: 500,
+        pageSize: 100,
       });
       for (const size of sizes) {
         const sizeFt = size === '40ft' ? 40 : 20;
diff --git a/apps/edr-freight-api/src/modules/contracts/contracts.controller.ts b/apps/edr-freight-api/src/modules/contracts/contracts.controller.ts
index 95b734c60..2b79d3274 100644
--- a/apps/edr-freight-api/src/modules/contracts/contracts.controller.ts
+++ b/apps/edr-freight-api/src/modules/contracts/contracts.controller.ts
@@ -852,11 +852,12 @@ export class ContractsController {
 
   @Get(':id/capacity')
   @ApiOperation({
-    summary: 'Remaining bookable quantity per cargo line (GENERAL draw-down cap)',
+    summary:
+      'Remaining bookable quantity per cargo line (GENERAL draw-down cap, or the outstanding remainder of a split ONE_TIME contract)',
   })
   async capacity(@Param('id', ParseUUIDPipe) id: string) {
     const contract = await this.contractsService.findById(id);
-    return this.contractBookingService.computeCapacity(contract);
+    return this.contractBookingService.capacityView(contract);
   }
 
   // ── Clearance milestones (doc §11.3, §12.2) ────────────────────────────────
diff --git a/apps/edr-freight-api/src/modules/contracts/contracts.repository.ts b/apps/edr-freight-api/src/modules/contracts/contracts.repository.ts
index e53ba0e13..3c9c7db14 100644
--- a/apps/edr-freight-api/src/modules/contracts/contracts.repository.ts
+++ b/apps/edr-freight-api/src/modules/contracts/contracts.repository.ts
@@ -26,6 +26,8 @@ export interface ContractListFilterOptions {
   tradeDirection?: string;
   paymentCurrency?: string;
   customsClearingEnabled?: boolean;
+  /** true → only contracts with at least one uploaded clearance document. */
+  hasClearanceDocuments?: boolean;
   createdFrom?: string;
   createdTo?: string;
 }
@@ -98,6 +100,7 @@ export class ContractsRepository extends BaseRepository<Contract> {
     options: ContractListFilterOptions & {
       page: number;
       pageSize: number;
+      search?: string;
       sortBy?: string;
       sortOrder?: 'ASC' | 'DESC';
     },
@@ -128,6 +131,16 @@ export class ContractsRepository extends BaseRepository<Contract> {
 
     this.applyListFilters(qb, options);
 
+    // Free-text search across contract reference and customer (company) name.
+    // Applied here (not in applyListFilters) because only this query joins the
+    // `company` alias — the summary-metrics query builder does not.
+    if (options.search) {
+      qb.andWhere(
+        '(contract.reference ILIKE :search OR company.name ILIKE :search)',
+        { search: `%${options.search}%` },
+      );
+    }
+
     const sortField =
       options.sortBy === 'contractValidUntil'
         ? 'contract.contractValidUntil'
@@ -273,6 +286,12 @@ export class ContractsRepository extends BaseRepository<Contract> {
         customsClearingEnabled: options.customsClearingEnabled,
       });
     }
+    if (options.hasClearanceDocuments) {
+      qb.andWhere(
+        'EXISTS (SELECT 1 FROM freight.contract_document_review cdr ' +
+          'WHERE cdr.contract_id = contract.id AND cdr.deleted_at IS NULL)',
+      );
+    }
     if (options.serviceTypeId) {
       qb.andWhere('contract.service_type_id = :serviceTypeId', {
         serviceTypeId: options.serviceTypeId,
diff --git a/apps/edr-freight-api/src/modules/contracts/contracts.service.ts b/apps/edr-freight-api/src/modules/contracts/contracts.service.ts
index 517d818bf..224745cc4 100644
--- a/apps/edr-freight-api/src/modules/contracts/contracts.service.ts
+++ b/apps/edr-freight-api/src/modules/contracts/contracts.service.ts
@@ -579,6 +579,7 @@ export class ContractsService {
       paymentCurrency: filter.paymentCurrency,
       createdFrom: filter.createdFrom,
       createdTo: filter.createdTo,
+      search: filter.search,
       sortBy: filter.sortBy,
       sortOrder: filter.sortOrder,
     });
diff --git a/apps/edr-freight-api/src/modules/contracts/dto/filter-contract.dto.ts b/apps/edr-freight-api/src/modules/contracts/dto/filter-contract.dto.ts
index 9c1c60921..8950e7eb3 100644
--- a/apps/edr-freight-api/src/modules/contracts/dto/filter-contract.dto.ts
+++ b/apps/edr-freight-api/src/modules/contracts/dto/filter-contract.dto.ts
@@ -71,6 +71,15 @@ export class FilterContractDto {
   @IsDateString()
   createdTo?: string;
 
+  @ApiPropertyOptional({
+    description: 'Free-text search across contract reference and company name.',
+  })
+  @IsOptional()
+  @Transform(({ value }) =>
+    typeof value === 'string' && value.trim() ? value.trim() : undefined,
+  )
+  search?: string;
+
   @ApiPropertyOptional({ default: 1 })
   @IsOptional()
   @Transform(({ value }) => (value ? parseInt(value, 10) : 1))
diff --git a/apps/edr-freight-api/src/modules/dropdown-settings/dropdown-settings.controller.ts b/apps/edr-freight-api/src/modules/dropdown-settings/dropdown-settings.controller.ts
index 7a63964d8..aad904557 100644
--- a/apps/edr-freight-api/src/modules/dropdown-settings/dropdown-settings.controller.ts
+++ b/apps/edr-freight-api/src/modules/dropdown-settings/dropdown-settings.controller.ts
@@ -10,12 +10,14 @@ import {
   Patch,
   Post,
   Put,
+  Query,
 } from "@nestjs/common";
 import { ApiOperation, ApiTags } from "@nestjs/swagger";
 
 import { FreightAdmin } from "../../common/booking-guards";
 import { CreateDropdownOptionDto } from "./dto/create-dropdown-option.dto";
 import { CreateDropdownSettingDto } from "./dto/create-dropdown-setting.dto";
+import { ListDropdownSettingsQueryDto } from "./dto/list-dropdown-settings-query.dto";
 import { UpdateDropdownOptionDto } from "./dto/update-dropdown-option.dto";
 import { UpdateDropdownSettingDto } from "./dto/update-dropdown-setting.dto";
 import { DropdownSettingsService } from "./dropdown-settings.service";
@@ -34,6 +36,15 @@ export class DropdownSettingsController {
     return this.service.list();
   }
 
+  // Must be declared before @Get(":id") so "paged" isn't captured as an id.
+  @Get("paged")
+  @ApiOperation({
+    summary: "Paged admin listing of dropdown settings (server-side search)",
+  })
+  listPaged(@Query() query: ListDropdownSettingsQueryDto) {
+    return this.service.listPaged(query);
+  }
+
   @Get(":id")
   @ApiOperation({ summary: "Get a dropdown setting by ID" })
   getById(@Param("id", ParseUUIDPipe) id: string) {
diff --git a/apps/edr-freight-api/src/modules/dropdown-settings/dropdown-settings.repository.ts b/apps/edr-freight-api/src/modules/dropdown-settings/dropdown-settings.repository.ts
index a4f851e53..1cf12b219 100644
--- a/apps/edr-freight-api/src/modules/dropdown-settings/dropdown-settings.repository.ts
+++ b/apps/edr-freight-api/src/modules/dropdown-settings/dropdown-settings.repository.ts
@@ -1,8 +1,11 @@
 import { BaseRepository } from "@edr/api-common";
+import { PaginatedResponse } from "@edr/types";
 import { Injectable } from "@nestjs/common";
 import { InjectRepository } from "@nestjs/typeorm";
 import { Repository } from "typeorm";
 
+import { paginateQuery } from "../../common/utils/pagination.util";
+import { ListDropdownSettingsQueryDto } from "./dto/list-dropdown-settings-query.dto";
 import { DropdownOption } from "./entities/dropdown-option.entity";
 import { DropdownSetting } from "./entities/dropdown-setting.entity";
 import type { IDropdownSettingsRepository } from "./interfaces/dropdown-settings.repository.interface";
@@ -44,6 +47,27 @@ export class DropdownSettingsRepository
     });
   }
 
+  findPaged(
+    query: ListDropdownSettingsQueryDto,
+  ): Promise<PaginatedResponse<DropdownSetting>> {
+    // Soft-deleted rows are excluded automatically by the query builder
+    // (BaseEntity's deletedAt column). Ordering mirrors findAll (label ASC).
+    const qb = this.repository
+      .createQueryBuilder("setting")
+      .leftJoinAndSelect("setting.children", "option")
+      .orderBy("setting.label", query.sortOrder ?? "ASC")
+      .addOrderBy("option.order", "ASC");
+
+    if (query.search) {
+      qb.andWhere(
+        "(setting.code ILIKE :search OR setting.label ILIKE :search OR setting.description ILIKE :search)",
+        { search: `%${query.search}%` },
+      );
+    }
+
+    return paginateQuery(qb, query);
+  }
+
   async replaceOptions(
     settingId: string,
     options: Array<Partial<DropdownOption>>,
diff --git a/apps/edr-freight-api/src/modules/dropdown-settings/dropdown-settings.service.ts b/apps/edr-freight-api/src/modules/dropdown-settings/dropdown-settings.service.ts
index 530cfded4..dda6e1294 100644
--- a/apps/edr-freight-api/src/modules/dropdown-settings/dropdown-settings.service.ts
+++ b/apps/edr-freight-api/src/modules/dropdown-settings/dropdown-settings.service.ts
@@ -5,8 +5,11 @@ import {
   NotFoundException,
 } from "@nestjs/common";
 
+import { PaginatedResponse } from "@edr/types";
+
 import { CreateDropdownOptionDto } from "./dto/create-dropdown-option.dto";
 import { CreateDropdownSettingDto } from "./dto/create-dropdown-setting.dto";
+import { ListDropdownSettingsQueryDto } from "./dto/list-dropdown-settings-query.dto";
 import { UpdateDropdownOptionDto } from "./dto/update-dropdown-option.dto";
 import { UpdateDropdownSettingDto } from "./dto/update-dropdown-setting.dto";
 import { DropdownOption } from "./entities/dropdown-option.entity";
@@ -16,71 +19,6 @@ import {
   IDropdownSettingsRepository,
 } from "./interfaces/dropdown-settings.repository.interface";
 
-const STATIONS_TER_CODE = "stations_ter";
-
-const DEFAULT_STATION_OPTIONS: CreateDropdownOptionDto[] = [
-  {
-    value: "inside_addis_ababa",
-    label: "Addis Ababa",
-    note: "Inside country",
-    order: 1,
-  },
-  {
-    value: "inside_adama",
-    label: "Adama",
-    note: "Inside country",
-    order: 2,
-  },
-  {
-    value: "inside_mojo",
-    label: "Mojo",
-    note: "Inside country",
-    order: 3,
-  },
-  {
-    value: "inside_awash",
-    label: "Awash",
-    note: "Inside country",
-    order: 4,
-  },
-  {
-    value: "inside_mieso",
-    label: "Mieso",
-    note: "Inside country",
-    order: 5,
-  },
-  {
-    value: "inside_dire_dawa",
-    label: "Dire Dawa",
-    note: "Inside country",
-    order: 6,
-  },
-  {
-    value: "outside_ali_sabieh",
-    label: "Ali Sabieh",
-    note: "Outside country",
-    order: 7,
-  },
-  {
-    value: "outside_holhol",
-    label: "Holhol",
-    note: "Outside country",
-    order: 8,
-  },
-  {
-    value: "outside_djibouti_city",
-    label: "Djibouti City",
-    note: "Outside country",
-    order: 9,
-  },
-  {
-    value: "outside_doraleh_terminal",
-    label: "Doraleh Terminal",
-    note: "Outside country",
-    order: 10,
-  },
-];
-
 @Injectable()
 export class DropdownSettingsService {
   constructor(
@@ -92,6 +30,12 @@ export class DropdownSettingsService {
     return this.repository.findAll();
   }
 
+  listPaged(
+    query: ListDropdownSettingsQueryDto,
+  ): Promise<PaginatedResponse<DropdownSetting>> {
+    return this.repository.findPaged(query);
+  }
+
   async getById(id: string): Promise<DropdownSetting> {
     const setting = await this.repository.findById(id);
     if (!setting) throw new NotFoundException(`Setting ${id} not found`);
@@ -127,34 +71,6 @@ export class DropdownSettingsService {
     return this.getById(setting.id);
   }
 
-  async seedDefaultStations(): Promise<void> {
-    const existing = await this.repository.findByCode(STATIONS_TER_CODE);
-
-    if (!existing) {
-      await this.create({
-        code: STATIONS_TER_CODE,
-        label: "Stations TER",
-        description:
-          "Temporary freight station list used by booking origin and destination yards.",
-        multiple: false,
-        meta: {
-          searchable: true,
-          clearable: true,
-          version: "temporary",
-        },
-        children: DEFAULT_STATION_OPTIONS,
-      });
-      return;
-    }
-
-    if ((existing.children?.length ?? 0) === 0) {
-      await this.repository.replaceOptions(
-        existing.id,
-        DEFAULT_STATION_OPTIONS,
-      );
-    }
-  }
-
   async update(
     id: string,
     dto: UpdateDropdownSettingDto,
diff --git a/apps/edr-freight-api/src/modules/dropdown-settings/dto/list-dropdown-settings-query.dto.ts b/apps/edr-freight-api/src/modules/dropdown-settings/dto/list-dropdown-settings-query.dto.ts
new file mode 100644
index 000000000..d98b3bf36
--- /dev/null
+++ b/apps/edr-freight-api/src/modules/dropdown-settings/dto/list-dropdown-settings-query.dto.ts
@@ -0,0 +1,8 @@
+import { PaginationQueryDto } from "../../../common/dto/pagination-query.dto";
+
+/**
+ * Query params for the paged admin listing (`GET /dropdown-settings/paged`).
+ * `search` matches code, label and description server-side. The entity has no
+ * status/isActive flag, so the base pagination fields are all that's needed.
+ */
+export class ListDropdownSettingsQueryDto extends PaginationQueryDto {}
diff --git a/apps/edr-freight-api/src/modules/dropdown-settings/interfaces/dropdown-settings.repository.interface.ts b/apps/edr-freight-api/src/modules/dropdown-settings/interfaces/dropdown-settings.repository.interface.ts
index 7b004a066..e0def4663 100644
--- a/apps/edr-freight-api/src/modules/dropdown-settings/interfaces/dropdown-settings.repository.interface.ts
+++ b/apps/edr-freight-api/src/modules/dropdown-settings/interfaces/dropdown-settings.repository.interface.ts
@@ -1,3 +1,6 @@
+import { PaginatedResponse } from "@edr/types";
+
+import { ListDropdownSettingsQueryDto } from "../dto/list-dropdown-settings-query.dto";
 import { DropdownOption } from "../entities/dropdown-option.entity";
 import { DropdownSetting } from "../entities/dropdown-setting.entity";
 
@@ -11,6 +14,9 @@ export const DROPDOWN_SETTINGS_REPOSITORY = Symbol(
 
 export interface IDropdownSettingsRepository {
   findAll(): Promise<DropdownSetting[]>;
+  findPaged(
+    query: ListDropdownSettingsQueryDto,
+  ): Promise<PaginatedResponse<DropdownSetting>>;
   findById(id: string): Promise<DropdownSetting | null>;
   findByCode(code: string): Promise<DropdownSetting | null>;
 
diff --git a/apps/edr-freight-api/src/modules/last-mile/dto/record-proof-of-delivery.dto.ts b/apps/edr-freight-api/src/modules/last-mile/dto/record-proof-of-delivery.dto.ts
new file mode 100644
index 000000000..44bf2f9c9
--- /dev/null
+++ b/apps/edr-freight-api/src/modules/last-mile/dto/record-proof-of-delivery.dto.ts
@@ -0,0 +1,22 @@
+import { ApiProperty, ApiPropertyOptional } from '@nestjs/swagger';
+import { IsNotEmpty, IsOptional, IsString, MaxLength } from 'class-validator';
+
+/**
+ * Proof of delivery captured by the EDR driver when a last-mile leg is
+ * completed. Sent as multipart/form-data — the recipient's signature (field
+ * `signature`) and proof photos (field `photos`) are uploaded alongside these
+ * text fields.
+ */
+export class RecordProofOfDeliveryDto {
+  @ApiProperty({ description: 'Name of the person who received the cargo.' })
+  @IsString()
+  @IsNotEmpty()
+  @MaxLength(160)
+  recipientName!: string;
+
+  @ApiPropertyOptional({ description: 'Optional delivery notes.' })
+  @IsOptional()
+  @IsString()
+  @MaxLength(1000)
+  notes?: string;
+}
diff --git a/apps/edr-freight-api/src/modules/last-mile/entities/last-mile.entity.ts b/apps/edr-freight-api/src/modules/last-mile/entities/last-mile.entity.ts
index 5dca86cc4..833911365 100644
--- a/apps/edr-freight-api/src/modules/last-mile/entities/last-mile.entity.ts
+++ b/apps/edr-freight-api/src/modules/last-mile/entities/last-mile.entity.ts
@@ -70,4 +70,22 @@ export class LastMile extends BaseEntity {
 
   @OneToMany(() => LastMileVehicleAssignment, (va) => va.lastMile)
   vehicleAssignments?: LastMileVehicleAssignment[];
+
+  // ── Proof of delivery (captured by the EDR driver on completion) ──────────
+  @Column({ name: 'pod_recipient_name', type: 'varchar', length: 160, nullable: true })
+  podRecipientName?: string | null;
+
+  /** File id of the recipient's captured signature (PNG). */
+  @Column({ name: 'pod_signature_file_id', type: 'uuid', nullable: true })
+  podSignatureFileId?: string | null;
+
+  /** File ids of the delivery proof photos. */
+  @Column({ name: 'pod_photo_file_ids', type: 'text', array: true, default: '{}' })
+  podPhotoFileIds!: string[];
+
+  @Column({ name: 'pod_notes', type: 'text', nullable: true })
+  podNotes?: string | null;
+
+  @Column({ name: 'pod_captured_at', type: 'timestamptz', nullable: true })
+  podCapturedAt?: Date | null;
 }
diff --git a/apps/edr-freight-api/src/modules/last-mile/last-mile.controller.ts b/apps/edr-freight-api/src/modules/last-mile/last-mile.controller.ts
index 207b71a25..abee4d53d 100644
--- a/apps/edr-freight-api/src/modules/last-mile/last-mile.controller.ts
+++ b/apps/edr-freight-api/src/modules/last-mile/last-mile.controller.ts
@@ -11,8 +11,11 @@ import {
   Patch,
   Post,
   Query,
+  UploadedFiles,
+  UseInterceptors,
 } from '@nestjs/common';
-import { ApiBearerAuth, ApiOperation, ApiTags } from '@nestjs/swagger';
+import { AnyFilesInterceptor } from '@nestjs/platform-express';
+import { ApiBearerAuth, ApiConsumes, ApiOperation, ApiTags } from '@nestjs/swagger';
 
 import { BookingStaff } from '../../common/booking-guards';
 import { FREIGHT_PERMS } from '../../seed/freight-permissions.registry';
@@ -21,6 +24,7 @@ import { CreateLastMileDto } from './dto/create-last-mile.dto';
 import { UpdateLastMileDto } from './dto/update-last-mile.dto';
 import { SetVehiclesDto } from './dto/set-vehicles.dto';
 import { SetDistancesDto } from './dto/set-distances.dto';
+import { RecordProofOfDeliveryDto } from './dto/record-proof-of-delivery.dto';
 import { LastMileStatus } from './entities/last-mile.entity';
 import { LastMileService } from './last-mile.service';
 import { LastMileInvoiceService } from './last-mile-invoice.service';
@@ -115,6 +119,19 @@ export class LastMileController {
     return this.lastMileService.setDistances(id, dto.distances, dto.remainingPayment);
   }
 
+  @Post(':id/proof-of-delivery')
+  @BookingStaff(FREIGHT_PERMS.lastMile.update)
+  @UseInterceptors(AnyFilesInterceptor())
+  @ApiConsumes('multipart/form-data')
+  @ApiOperation({ summary: 'Record proof of delivery (signature + photos) and complete the leg' })
+  async recordProofOfDelivery(
+    @Param('id', ParseUUIDPipe) id: string,
+    @Body() dto: RecordProofOfDeliveryDto,
+    @UploadedFiles() files: Express.Multer.File[],
+  ) {
+    return this.lastMileService.recordProofOfDelivery(id, dto, files ?? []);
+  }
+
   @Post(':id/invoice')
   @BookingStaff(FREIGHT_PERMS.lastMile.generateInvoice)
   @ApiOperation({ summary: 'Generate the delivery-fee invoice for a last-mile leg' })
diff --git a/apps/edr-freight-api/src/modules/last-mile/last-mile.module.ts b/apps/edr-freight-api/src/modules/last-mile/last-mile.module.ts
index e639e4dfd..289c2156f 100644
--- a/apps/edr-freight-api/src/modules/last-mile/last-mile.module.ts
+++ b/apps/edr-freight-api/src/modules/last-mile/last-mile.module.ts
@@ -3,6 +3,7 @@ import { TypeOrmModule } from '@nestjs/typeorm';
 
 import { BillingModule } from '../billing/billing.module';
 import { BookingsModule } from '../bookings/bookings.module';
+import { FilesModule } from '../files/files.module';
 import { DriversModule } from '../drivers/drivers.module';
 import { NotificationsModule } from '../notifications/notifications.module';
 import { VehiclesModule } from '../vehicles/vehicles.module';
@@ -22,6 +23,7 @@ import { LastMileService } from './last-mile.service';
     VehiclesModule,
     DriversModule,
     NotificationsModule,
+    FilesModule,
   ],
   controllers: [LastMileController],
   providers: [LastMileRepository, LastMileService, LastMileInvoiceService],
diff --git a/apps/edr-freight-api/src/modules/last-mile/last-mile.service.ts b/apps/edr-freight-api/src/modules/last-mile/last-mile.service.ts
index 15b8df3e7..999137e6e 100644
--- a/apps/edr-freight-api/src/modules/last-mile/last-mile.service.ts
+++ b/apps/edr-freight-api/src/modules/last-mile/last-mile.service.ts
@@ -8,10 +8,12 @@ import { VehiclesService } from '../vehicles/vehicles.service';
 import { VehicleAvailability } from '../vehicles/entities/vehicle.entity';
 import { CreateLastMileDto } from './dto/create-last-mile.dto';
 import { UpdateLastMileDto } from './dto/update-last-mile.dto';
+import { RecordProofOfDeliveryDto } from './dto/record-proof-of-delivery.dto';
 import { LastMile, LastMileStatus } from './entities/last-mile.entity';
 import { LastMileContainerAllocation } from './entities/last-mile-container-allocation.entity';
 import { LastMileVehicleAssignment } from './entities/last-mile-vehicle-assignment.entity';
 import { LastMileRepository } from './last-mile.repository';
+import { FilesService } from '../files/files.service';
 import { BillingService, InvoiceEventPayload } from '../billing/billing.service';
 import { OnEvent } from '@nestjs/event-emitter';
 import { FleetHistoryService } from '../fleet-history/fleet-history.service';
@@ -47,6 +49,7 @@ export class LastMileService {
     private readonly dataSource: DataSource,
     private readonly history: FleetHistoryService,
     private readonly billing: BillingService,
+    private readonly filesService: FilesService,
   ) {}
 
   /** Attach real invoice info (number/status) to records so the UI can show an
@@ -210,6 +213,49 @@ export class LastMileService {
     return record;
   }
 
+  /**
+   * Record proof of delivery (recipient signature + photos + notes) and complete
+   * the leg. Marking DELIVERED reuses {@link update}'s side effects (deliveredAt,
+   * vehicle release, history).
+   */
+  async recordProofOfDelivery(
+    id: string,
+    dto: RecordProofOfDeliveryDto,
+    files: Express.Multer.File[],
+  ): Promise<LastMile> {
+    const existing = await this.findById(id);
+
+    const signature = files.find((f) => f.fieldname === 'signature');
+    const photos = files.filter((f) => f.fieldname === 'photos');
+
+    const signatureFileId = signature
+      ? (
+          await this.filesService.upload({
+            resourceId: id,
+            resource: 'last-mile',
+            code: 'pod-signature',
+            file: signature,
+          })
+        ).id
+      : null;
+    const photoFileIds = photos.length
+      ? (await this.filesService.uploadMany(id, 'last-mile', photos)).map((r) => r.id)
+      : [];
+
+    await this.lastMileRepository.update(id, {
+      podRecipientName: dto.recipientName.trim(),
+      podSignatureFileId: signatureFileId,
+      podPhotoFileIds: photoFileIds,
+      podNotes: dto.notes?.trim() || null,
+      podCapturedAt: new Date(),
+    } as never);
+
+    if (existing.status !== 'DELIVERED') {
+      return this.update(id, { status: 'DELIVERED' } as UpdateLastMileDto);
+    }
+    return this.findById(id);
+  }
+
   async create(dto: CreateLastMileDto): Promise<LastMile> {
     const record = await this.lastMileRepository.create({
       bookingId: dto.bookingId,
diff --git 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
index 8e13d3ec7..8d9ed00c9 100644
--- 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
@@ -5,6 +5,7 @@ import {
 import { RuleEngineManage, RuleEngineView } from '../../../common/rule-engine-guards';
 import { ApiBearerAuth, ApiOperation, ApiTags } from '@nestjs/swagger';
 import { CreateApprovalRuleDto } from '../dto/create-approval-rule.dto';
+import { ListApprovalRulesQueryDto } from '../dto/list-rule-engine-query.dto';
 import { MoveOrderDto } from '../dto/move-order.dto';
 import { ReorderItemsDto } from '../dto/reorder-items.dto';
 import { UpdateApprovalRuleDto } from '../dto/update-approval-rule.dto';
@@ -19,15 +20,8 @@ export class ApprovalRulesController {
   @Get()
   @RuleEngineView('approval-rules')
   @ApiOperation({ summary: 'List approval rules' })
-  findAll(@Query() query: Record<string, string>) {
-    return this.service.findAll({
-      requiresDirectorApproval:
-        query['requiresDirectorApproval'] !== undefined
-          ? query['requiresDirectorApproval'] === 'true'
-          : undefined,
-      page: query['page'] ? parseInt(query['page'], 10) : undefined,
-      pageSize: query['pageSize'] ? parseInt(query['pageSize'], 10) : undefined,
-    });
+  findAll(@Query() query: ListApprovalRulesQueryDto) {
+    return this.service.findAll(query);
   }
 
   @Get('chain')
diff --git a/apps/edr-freight-api/src/modules/rule-engine/controllers/cargo-types.controller.ts b/apps/edr-freight-api/src/modules/rule-engine/controllers/cargo-types.controller.ts
index e2b8425bf..421e49165 100644
--- a/apps/edr-freight-api/src/modules/rule-engine/controllers/cargo-types.controller.ts
+++ b/apps/edr-freight-api/src/modules/rule-engine/controllers/cargo-types.controller.ts
@@ -5,6 +5,7 @@ import {
 import { ApiBearerAuth, ApiOperation, ApiTags } from '@nestjs/swagger';
 import { RuleEngineManage, RuleEngineView } from '../../../common/rule-engine-guards';
 import { CreateCargoTypeDto } from '../dto/create-cargo-type.dto';
+import { ListCargoTypesQueryDto } from '../dto/list-rule-engine-query.dto';
 import { MoveOrderDto } from '../dto/move-order.dto';
 import { ReorderItemsDto } from '../dto/reorder-items.dto';
 import { UpdateCargoTypeDto } from '../dto/update-cargo-type.dto';
@@ -19,19 +20,8 @@ export class CargoTypesController {
   @Get()
   @RuleEngineView('cargo-types')
   @ApiOperation({ summary: 'List cargo types' })
-  findAll(@Query() query: Record<string, string>) {
-    return this.service.findAll({
-      isActive: query['isActive'] !== undefined ? query['isActive'] === 'true' : undefined,
-      requiresDirectorApproval: query['requiresDirectorApproval'] !== undefined
-        ? query['requiresDirectorApproval'] === 'true'
-        : undefined,
-      parentGroupId: query['parentGroupId'],
-      search: query['search'],
-      page: query['page'] ? parseInt(query['page'], 10) : undefined,
-      pageSize: query['pageSize'] ? parseInt(query['pageSize'], 10) : undefined,
-      sortBy: query['sortBy'],
-      sortOrder: (query['sortOrder'] as 'ASC' | 'DESC') ?? 'ASC',
-    });
+  findAll(@Query() query: ListCargoTypesQueryDto) {
+    return this.service.findAll(query);
   }
 
   @Post('reorder')
diff --git a/apps/edr-freight-api/src/modules/rule-engine/controllers/container-types.controller.ts b/apps/edr-freight-api/src/modules/rule-engine/controllers/container-types.controller.ts
index 624cf4b03..3c1c27c7c 100644
--- a/apps/edr-freight-api/src/modules/rule-engine/controllers/container-types.controller.ts
+++ b/apps/edr-freight-api/src/modules/rule-engine/controllers/container-types.controller.ts
@@ -5,6 +5,7 @@ import {
 import { ApiBearerAuth, ApiOperation, ApiTags } from '@nestjs/swagger';
 import { RuleEngineManage, RuleEngineView } from '../../../common/rule-engine-guards';
 import { CreateContainerTypeDto } from '../dto/create-container-type.dto';
+import { ListContainerTypesQueryDto } from '../dto/list-rule-engine-query.dto';
 import { MoveOrderDto } from '../dto/move-order.dto';
 import { ReorderItemsDto } from '../dto/reorder-items.dto';
 import { UpdateContainerTypeDto } from '../dto/update-container-type.dto';
@@ -19,12 +20,8 @@ export class ContainerTypesController {
   @Get()
   @RuleEngineView('container-types')
   @ApiOperation({ summary: 'List container types' })
-  findAll(@Query() query: Record<string, string>) {
-    return this.service.findAll({
-      isActive: query['isActive'] !== undefined ? query['isActive'] === 'true' : undefined,
-      page: query['page'] ? parseInt(query['page'], 10) : undefined,
-      pageSize: query['pageSize'] ? parseInt(query['pageSize'], 10) : undefined,
-    });
+  findAll(@Query() query: ListContainerTypesQueryDto) {
+    return this.service.findAll(query);
   }
 
   @Post('reorder')
diff --git a/apps/edr-freight-api/src/modules/rule-engine/controllers/priority-configs.controller.ts b/apps/edr-freight-api/src/modules/rule-engine/controllers/priority-configs.controller.ts
index 8dcc58e77..99eaabf3f 100644
--- a/apps/edr-freight-api/src/modules/rule-engine/controllers/priority-configs.controller.ts
+++ b/apps/edr-freight-api/src/modules/rule-engine/controllers/priority-configs.controller.ts
@@ -5,6 +5,7 @@ import {
 import { RuleEngineManage, RuleEngineView } from '../../../common/rule-engine-guards';
 import { ApiBearerAuth, ApiOperation, ApiTags } from '@nestjs/swagger';
 import { CreatePriorityConfigDto } from '../dto/create-priority-config.dto';
+import { ListPriorityConfigsQueryDto } from '../dto/list-rule-engine-query.dto';
 import { UpdatePriorityConfigDto } from '../dto/update-priority-config.dto';
 import { MoveOrderDto } from '../dto/move-order.dto';
 import { ReorderItemsDto } from '../dto/reorder-items.dto';
@@ -19,13 +20,8 @@ export class PriorityConfigsController {
   @Get()
   @RuleEngineView('priority-configs')
   @ApiOperation({ summary: 'List priority configs' })
-  findAll(@Query() query: Record<string, string>) {
-    return this.service.findAll({
-      type: (query['type'] as 'WAGON' | 'CURRENCY' | 'CUSTOMS') || undefined,
-      isActive: query['isActive'] !== undefined ? query['isActive'] === 'true' : undefined,
-      page: query['page'] ? parseInt(query['page'], 10) : undefined,
-      pageSize: query['pageSize'] ? parseInt(query['pageSize'], 10) : undefined,
-    });
+  findAll(@Query() query: ListPriorityConfigsQueryDto) {
+    return this.service.findAll(query);
   }
 
   @Get(':id')
diff --git a/apps/edr-freight-api/src/modules/rule-engine/controllers/rates.controller.ts b/apps/edr-freight-api/src/modules/rule-engine/controllers/rates.controller.ts
index 3c7776a27..c818c9f12 100644
--- a/apps/edr-freight-api/src/modules/rule-engine/controllers/rates.controller.ts
+++ b/apps/edr-freight-api/src/modules/rule-engine/controllers/rates.controller.ts
@@ -6,6 +6,7 @@ import { ApiBearerAuth, ApiOperation, ApiTags } from '@nestjs/swagger';
 import { CurrentUser } from '@edr/api-common';
 import { RuleEngineManage, RuleEngineView } from '../../../common/rule-engine-guards';
 import { CreateRateDto } from '../dto/create-rate.dto';
+import { ListRatesQueryDto } from '../dto/list-rule-engine-query.dto';
 import {
   type AuthUserPayload,
   resolveAuthUserId,
@@ -22,13 +23,8 @@ export class RatesController {
   @Get()
   @RuleEngineView('rates')
   @ApiOperation({ summary: 'List rates' })
-  findAll(@Query() query: Record<string, string>) {
-    return this.service.findAll({
-      status: query['status'],
-      rateType: query['rateType'],
-      page: query['page'] ? parseInt(query['page'], 10) : undefined,
-      pageSize: query['pageSize'] ? parseInt(query['pageSize'], 10) : undefined,
-    });
+  findAll(@Query() query: ListRatesQueryDto) {
+    return this.service.findAll(query);
   }
 
   @Get('live')
diff --git a/apps/edr-freight-api/src/modules/rule-engine/controllers/service-types.controller.ts b/apps/edr-freight-api/src/modules/rule-engine/controllers/service-types.controller.ts
index 18c597b38..c36d4fd79 100644
--- a/apps/edr-freight-api/src/modules/rule-engine/controllers/service-types.controller.ts
+++ b/apps/edr-freight-api/src/modules/rule-engine/controllers/service-types.controller.ts
@@ -5,6 +5,7 @@ import {
 import { RuleEngineManage, RuleEngineView } from '../../../common/rule-engine-guards';
 import { ApiBearerAuth, ApiOperation, ApiTags } from '@nestjs/swagger';
 import { CreateServiceTypeDto } from '../dto/create-service-type.dto';
+import { ListServiceTypesQueryDto } from '../dto/list-rule-engine-query.dto';
 import { MoveOrderDto } from '../dto/move-order.dto';
 import { ReorderItemsDto } from '../dto/reorder-items.dto';
 import { UpdateServiceTypeDto } from '../dto/update-service-type.dto';
@@ -19,16 +20,8 @@ export class ServiceTypesController {
   @Get()
   @RuleEngineView('service-types')
   @ApiOperation({ summary: 'List service types' })
-  findAll(@Query() query: Record<string, string>) {
-    return this.service.findAll({
-      isActive: query['isActive'] !== undefined ? query['isActive'] === 'true' : undefined,
-      canBeBookedAlone: query['canBeBookedAlone'] !== undefined ? query['canBeBookedAlone'] === 'true' : undefined,
-      search: query['search'],
-      page: query['page'] ? parseInt(query['page'], 10) : undefined,
-      pageSize: query['pageSize'] ? parseInt(query['pageSize'], 10) : undefined,
-      sortBy: query['sortBy'],
-      sortOrder: (query['sortOrder'] as 'ASC' | 'DESC') ?? 'ASC',
-    });
+  findAll(@Query() query: ListServiceTypesQueryDto) {
+    return this.service.findAll(query);
   }
 
   @Post('reorder')
diff --git a/apps/edr-freight-api/src/modules/rule-engine/controllers/shipping-lines.controller.ts b/apps/edr-freight-api/src/modules/rule-engine/controllers/shipping-lines.controller.ts
index 40a67c7f5..baec6b785 100644
--- a/apps/edr-freight-api/src/modules/rule-engine/controllers/shipping-lines.controller.ts
+++ b/apps/edr-freight-api/src/modules/rule-engine/controllers/shipping-lines.controller.ts
@@ -5,6 +5,7 @@ import {
 import { RuleEngineManage, RuleEngineView } from '../../../common/rule-engine-guards';
 import { ApiBearerAuth, ApiOperation, ApiTags } from '@nestjs/swagger';
 import { CreateShippingLineDto } from '../dto/create-shipping-line.dto';
+import { ListRuleEngineQueryDto } from '../dto/list-rule-engine-query.dto';
 import { UpdateShippingLineDto } from '../dto/update-shipping-line.dto';
 import { ShippingLinesService } from '../services/shipping-lines.service';
 
@@ -17,12 +18,8 @@ export class ShippingLinesController {
   @Get()
   @RuleEngineView('shipping-lines')
   @ApiOperation({ summary: 'List shipping lines' })
-  findAll(@Query() query: Record<string, string>) {
-    return this.service.findAll({
-      isActive: query['isActive'] !== undefined ? query['isActive'] === 'true' : undefined,
-      page: query['page'] ? parseInt(query['page'], 10) : undefined,
-      pageSize: query['pageSize'] ? parseInt(query['pageSize'], 10) : undefined,
-    });
+  findAll(@Query() query: ListRuleEngineQueryDto) {
+    return this.service.findAll(query);
   }
 
   @Get(':id')
diff --git a/apps/edr-freight-api/src/modules/rule-engine/controllers/weight-limit-rules.controller.ts b/apps/edr-freight-api/src/modules/rule-engine/controllers/weight-limit-rules.controller.ts
index c3f0c1472..98c45798e 100644
--- a/apps/edr-freight-api/src/modules/rule-engine/controllers/weight-limit-rules.controller.ts
+++ b/apps/edr-freight-api/src/modules/rule-engine/controllers/weight-limit-rules.controller.ts
@@ -5,6 +5,7 @@ import {
 import { RuleEngineManage, RuleEngineView } from '../../../common/rule-engine-guards';
 import { ApiBearerAuth, ApiOperation, ApiTags } from '@nestjs/swagger';
 import { CreateWeightLimitRuleDto } from '../dto/create-weight-limit-rule.dto';
+import { ListWeightLimitRulesQueryDto } from '../dto/list-rule-engine-query.dto';
 import { UpdateWeightLimitRuleDto } from '../dto/update-weight-limit-rule.dto';
 import { WeightLimitRulesService } from '../services/weight-limit-rules.service';
 
@@ -17,13 +18,8 @@ export class WeightLimitRulesController {
   @Get()
   @RuleEngineView('weight-limit-rules')
   @ApiOperation({ summary: 'List weight limit rules' })
-  findAll(@Query() query: Record<string, string>) {
-    return this.service.findAll({
-      tradeDirection: query['tradeDirection'],
-      containerTypeId: query['containerTypeId'],
-      page: query['page'] ? parseInt(query['page'], 10) : undefined,
-      pageSize: query['pageSize'] ? parseInt(query['pageSize'], 10) : undefined,
-    });
+  findAll(@Query() query: ListWeightLimitRulesQueryDto) {
+    return this.service.findAll(query);
   }
 
   @Get(':id')
diff --git a/apps/edr-freight-api/src/modules/rule-engine/controllers/yards.controller.ts b/apps/edr-freight-api/src/modules/rule-engine/controllers/yards.controller.ts
index d18d0b748..40b2764bf 100644
--- a/apps/edr-freight-api/src/modules/rule-engine/controllers/yards.controller.ts
+++ b/apps/edr-freight-api/src/modules/rule-engine/controllers/yards.controller.ts
@@ -5,6 +5,7 @@ import {
 import { RuleEngineManage, RuleEngineView } from '../../../common/rule-engine-guards';
 import { ApiBearerAuth, ApiOperation, ApiTags } from '@nestjs/swagger';
 import { CreateYardDto } from '../dto/create-yard.dto';
+import { ListYardsQueryDto } from '../dto/list-rule-engine-query.dto';
 import { MoveOrderDto } from '../dto/move-order.dto';
 import { ReorderItemsDto } from '../dto/reorder-items.dto';
 import { UpdateYardDto } from '../dto/update-yard.dto';
@@ -19,13 +20,8 @@ export class YardsController {
   @Get()
   @RuleEngineView('yards')
   @ApiOperation({ summary: 'List yards' })
-  findAll(@Query() query: Record<string, string>) {
-    return this.service.findAll({
-      isActive: query['isActive'] !== undefined ? query['isActive'] === 'true' : undefined,
-      country: query['country'],
-      page: query['page'] ? parseInt(query['page'], 10) : undefined,
-      pageSize: query['pageSize'] ? parseInt(query['pageSize'], 10) : undefined,
-    });
+  findAll(@Query() query: ListYardsQueryDto) {
+    return this.service.findAll(query);
   }
 
   @Post('reorder')
diff --git a/apps/edr-freight-api/src/modules/rule-engine/dto/list-rule-engine-query.dto.ts b/apps/edr-freight-api/src/modules/rule-engine/dto/list-rule-engine-query.dto.ts
new file mode 100644
index 000000000..5718b0531
--- /dev/null
+++ b/apps/edr-freight-api/src/modules/rule-engine/dto/list-rule-engine-query.dto.ts
@@ -0,0 +1,129 @@
+import { ApiPropertyOptional } from '@nestjs/swagger';
+import { Transform, TransformFnParams } from 'class-transformer';
+import { IsBoolean, IsIn, IsOptional, IsString, IsUUID, MaxLength } from 'class-validator';
+import { PaginationQueryDto } from '../../../common/dto/pagination-query.dto';
+
+/**
+ * Query-string booleans arrive as strings; implicit conversion is disabled
+ * app-wide, so coerce explicitly. Mirrors the previous controller behaviour
+ * (`query['flag'] === 'true'`): only the literal "true" is truthy.
+ */
+const toOptionalBoolean = ({ value }: TransformFnParams): boolean | undefined =>
+  value === undefined || value === null || value === '' ? undefined : value === true || value === 'true';
+
+/**
+ * Shared list query for rule-engine resources. Every rule-engine list endpoint
+ * returns the standard `PaginatedResponse` envelope (`items` + `meta`) built by
+ * `common/utils/pagination.util.ts`; `search` is applied server-side against
+ * each resource's human-readable columns (see the repository `findPaged`).
+ */
+export class ListRuleEngineQueryDto extends PaginationQueryDto {
+  @ApiPropertyOptional({ description: 'Filter by active flag.' })
+  @IsOptional()
+  @Transform(toOptionalBoolean)
+  @IsBoolean()
+  isActive?: boolean;
+}
+
+export class ListCargoTypesQueryDto extends ListRuleEngineQueryDto {
+  @ApiPropertyOptional({ description: 'Filter by director-approval requirement.' })
+  @IsOptional()
+  @Transform(toOptionalBoolean)
+  @IsBoolean()
+  requiresDirectorApproval?: boolean;
+
+  @ApiPropertyOptional({ description: 'Filter by parent cargo-type group.' })
+  @IsOptional()
+  @IsUUID()
+  parentGroupId?: string;
+
+  @ApiPropertyOptional({ enum: ['displayOrder', 'cargoTypeName', 'code', 'createdAt'], default: 'displayOrder' })
+  @IsOptional()
+  @IsIn(['displayOrder', 'cargoTypeName', 'code', 'createdAt'])
+  sortBy?: string;
+}
+
+export class ListContainerTypesQueryDto extends ListRuleEngineQueryDto {
+  @ApiPropertyOptional({ enum: ['displayOrder'], default: 'displayOrder' })
+  @IsOptional()
+  @IsIn(['displayOrder'])
+  sortBy?: string;
+}
+
+export class ListPriorityConfigsQueryDto extends ListRuleEngineQueryDto {
+  @ApiPropertyOptional({ enum: ['WAGON', 'CURRENCY', 'CUSTOMS'] })
+  @IsOptional()
+  @IsIn(['WAGON', 'CURRENCY', 'CUSTOMS'])
+  type?: 'WAGON' | 'CURRENCY' | 'CUSTOMS';
+
+  @ApiPropertyOptional({ enum: ['displayOrder'], default: 'displayOrder' })
+  @IsOptional()
+  @IsIn(['displayOrder'])
+  sortBy?: string;
+}
+
+export class ListServiceTypesQueryDto extends ListRuleEngineQueryDto {
+  @ApiPropertyOptional({ description: 'Filter by standalone-bookable flag.' })
+  @IsOptional()
+  @Transform(toOptionalBoolean)
+  @IsBoolean()
+  canBeBookedAlone?: boolean;
+
+  @ApiPropertyOptional({ enum: ['displayOrder', 'serviceName', 'code', 'createdAt'], default: 'displayOrder' })
+  @IsOptional()
+  @IsIn(['displayOrder', 'serviceName', 'code', 'createdAt'])
+  sortBy?: string;
+}
+
+export class ListYardsQueryDto extends ListRuleEngineQueryDto {
+  @ApiPropertyOptional({ description: 'Filter by yard country.' })
+  @IsOptional()
+  @IsString()
+  @MaxLength(50)
+  country?: string;
+
+  @ApiPropertyOptional({ enum: ['displayOrder'], default: 'displayOrder' })
+  @IsOptional()
+  @IsIn(['displayOrder'])
+  sortBy?: string;
+}
+
+export class ListApprovalRulesQueryDto extends PaginationQueryDto {
+  @ApiPropertyOptional({ description: 'Filter by approval chain (director vs standard).' })
+  @IsOptional()
+  @Transform(toOptionalBoolean)
+  @IsBoolean()
+  requiresDirectorApproval?: boolean;
+
+  @ApiPropertyOptional({ enum: ['stepOrder'], default: 'stepOrder' })
+  @IsOptional()
+  @IsIn(['stepOrder'])
+  sortBy?: string;
+}
+
+export class ListRatesQueryDto extends PaginationQueryDto {
+  @ApiPropertyOptional({ description: 'Filter by rate status (DRAFT, PENDING_APPROVAL, LIVE...).' })
+  @IsOptional()
+  @IsString()
+  @MaxLength(20)
+  status?: string;
+
+  @ApiPropertyOptional({ description: 'Filter by derived rate type.' })
+  @IsOptional()
+  @IsString()
+  @MaxLength(50)
+  rateType?: string;
+}
+
+export class ListWeightLimitRulesQueryDto extends PaginationQueryDto {
+  @ApiPropertyOptional({ description: 'Filter by container type.' })
+  @IsOptional()
+  @IsUUID()
+  containerTypeId?: string;
+
+  @ApiPropertyOptional({ description: 'Filter by trade direction (IMPORT/EXPORT/BOTH).' })
+  @IsOptional()
+  @IsString()
+  @MaxLength(10)
+  tradeDirection?: string;
+}
diff --git a/apps/edr-freight-api/src/modules/rule-engine/interfaces/approval-rules.repository.interface.ts b/apps/edr-freight-api/src/modules/rule-engine/interfaces/approval-rules.repository.interface.ts
index 95c8d2568..b87cbae4a 100644
--- a/apps/edr-freight-api/src/modules/rule-engine/interfaces/approval-rules.repository.interface.ts
+++ b/apps/edr-freight-api/src/modules/rule-engine/interfaces/approval-rules.repository.interface.ts
@@ -1,4 +1,6 @@
+import { PaginatedResponse } from '@edr/types';
 import { FindManyOptions } from 'typeorm';
+import { ListApprovalRulesQueryDto } from '../dto/list-rule-engine-query.dto';
 import { ApprovalRule } from '../entities/approval-rule.entity';
 
 export interface IApprovalRulesRepository {
@@ -6,6 +8,7 @@ export interface IApprovalRulesRepository {
   findChainForCargo(requiresDirectorApproval: boolean): Promise<ApprovalRule[]>;
   findAll(options?: FindManyOptions<ApprovalRule>): Promise<ApprovalRule[]>;
   findAndCount(options?: FindManyOptions<ApprovalRule>): Promise<[ApprovalRule[], number]>;
+  findPaged(query: ListApprovalRulesQueryDto): Promise<PaginatedResponse<ApprovalRule>>;
   create(data: Partial<ApprovalRule>): Promise<ApprovalRule>;
   update(id: string, data: Partial<ApprovalRule>): Promise<ApprovalRule | null>;
   softDelete(id: string): Promise<void>;
diff --git a/apps/edr-freight-api/src/modules/rule-engine/interfaces/cargo-types.repository.interface.ts b/apps/edr-freight-api/src/modules/rule-engine/interfaces/cargo-types.repository.interface.ts
index d757b6569..c7d31171f 100644
--- a/apps/edr-freight-api/src/modules/rule-engine/interfaces/cargo-types.repository.interface.ts
+++ b/apps/edr-freight-api/src/modules/rule-engine/interfaces/cargo-types.repository.interface.ts
@@ -1,4 +1,6 @@
+import { PaginatedResponse } from '@edr/types';
 import { FindManyOptions } from 'typeorm';
+import { ListCargoTypesQueryDto } from '../dto/list-rule-engine-query.dto';
 import { CargoType } from '../entities/cargo-type.entity';
 
 export interface ICargoTypesRepository {
@@ -6,6 +8,7 @@ export interface ICargoTypesRepository {
   findByCode(code: string): Promise<CargoType | null>;
   findAll(options?: FindManyOptions<CargoType>): Promise<CargoType[]>;
   findAndCount(options?: FindManyOptions<CargoType>): Promise<[CargoType[], number]>;
+  findPaged(query: ListCargoTypesQueryDto): Promise<PaginatedResponse<CargoType>>;
   create(data: Partial<CargoType>): Promise<CargoType>;
   update(id: string, data: Partial<CargoType>): Promise<CargoType | null>;
   softDelete(id: string): Promise<void>;
diff --git a/apps/edr-freight-api/src/modules/rule-engine/interfaces/container-types.repository.interface.ts b/apps/edr-freight-api/src/modules/rule-engine/interfaces/container-types.repository.interface.ts
index f8e097309..35c97ac64 100644
--- a/apps/edr-freight-api/src/modules/rule-engine/interfaces/container-types.repository.interface.ts
+++ b/apps/edr-freight-api/src/modules/rule-engine/interfaces/container-types.repository.interface.ts
@@ -1,4 +1,6 @@
+import { PaginatedResponse } from '@edr/types';
 import { FindManyOptions } from 'typeorm';
+import { ListContainerTypesQueryDto } from '../dto/list-rule-engine-query.dto';
 import { ContainerType } from '../entities/container-type.entity';
 
 export interface IContainerTypesRepository {
@@ -6,6 +8,7 @@ export interface IContainerTypesRepository {
   findByCode(code: string): Promise<ContainerType | null>;
   findAll(options?: FindManyOptions<ContainerType>): Promise<ContainerType[]>;
   findAndCount(options?: FindManyOptions<ContainerType>): Promise<[ContainerType[], number]>;
+  findPaged(query: ListContainerTypesQueryDto): Promise<PaginatedResponse<ContainerType>>;
   create(data: Partial<ContainerType>): Promise<ContainerType>;
   update(id: string, data: Partial<ContainerType>): Promise<ContainerType | null>;
   softDelete(id: string): Promise<void>;
diff --git a/apps/edr-freight-api/src/modules/rule-engine/interfaces/priority-configs.repository.interface.ts b/apps/edr-freight-api/src/modules/rule-engine/interfaces/priority-configs.repository.interface.ts
index e4ca08234..d1337c8a6 100644
--- a/apps/edr-freight-api/src/modules/rule-engine/interfaces/priority-configs.repository.interface.ts
+++ b/apps/edr-freight-api/src/modules/rule-engine/interfaces/priority-configs.repository.interface.ts
@@ -1,4 +1,6 @@
+import { PaginatedResponse } from '@edr/types';
 import { FindManyOptions } from 'typeorm';
+import { ListPriorityConfigsQueryDto } from '../dto/list-rule-engine-query.dto';
 import { PriorityConfig } from '../entities/priority-config.entity';
 
 export const PRIORITY_CONFIGS_REPOSITORY = Symbol('PRIORITY_CONFIGS_REPOSITORY');
@@ -7,6 +9,7 @@ export interface IPriorityConfigsRepository {
   findById(id: string): Promise<PriorityConfig | null>;
   findAll(options?: FindManyOptions<PriorityConfig>): Promise<PriorityConfig[]>;
   findAndCount(options?: FindManyOptions<PriorityConfig>): Promise<[PriorityConfig[], number]>;
+  findPaged(query: ListPriorityConfigsQueryDto): Promise<PaginatedResponse<PriorityConfig>>;
   findAllActive(): Promise<PriorityConfig[]>;
   create(data: Partial<PriorityConfig>): Promise<PriorityConfig>;
   update(id: string, data: Partial<PriorityConfig>): Promise<PriorityConfig | null>;
diff --git a/apps/edr-freight-api/src/modules/rule-engine/interfaces/rates.repository.interface.ts b/apps/edr-freight-api/src/modules/rule-engine/interfaces/rates.repository.interface.ts
index 96db214c4..be0962942 100644
--- a/apps/edr-freight-api/src/modules/rule-engine/interfaces/rates.repository.interface.ts
+++ b/apps/edr-freight-api/src/modules/rule-engine/interfaces/rates.repository.interface.ts
@@ -1,4 +1,6 @@
+import { PaginatedResponse } from '@edr/types';
 import { FindManyOptions } from 'typeorm';
+import { ListRatesQueryDto } from '../dto/list-rule-engine-query.dto';
 import { Rate } from '../entities/rate.entity';
 
 export interface IRatesRepository {
@@ -13,6 +15,7 @@ export interface IRatesRepository {
   }): Promise<Rate | null>;
   findAll(options?: FindManyOptions<Rate>): Promise<Rate[]>;
   findAndCount(options?: FindManyOptions<Rate>): Promise<[Rate[], number]>;
+  findPaged(query: ListRatesQueryDto): Promise<PaginatedResponse<Rate>>;
   create(data: Partial<Rate>): Promise<Rate>;
   update(id: string, data: Partial<Rate>): Promise<Rate | null>;
   softDelete(id: string): Promise<void>;
diff --git a/apps/edr-freight-api/src/modules/rule-engine/interfaces/service-types.repository.interface.ts b/apps/edr-freight-api/src/modules/rule-engine/interfaces/service-types.repository.interface.ts
index 49c7f08e3..aeb5cef43 100644
--- a/apps/edr-freight-api/src/modules/rule-engine/interfaces/service-types.repository.interface.ts
+++ b/apps/edr-freight-api/src/modules/rule-engine/interfaces/service-types.repository.interface.ts
@@ -1,4 +1,6 @@
+import { PaginatedResponse } from '@edr/types';
 import { FindManyOptions } from 'typeorm';
+import { ListServiceTypesQueryDto } from '../dto/list-rule-engine-query.dto';
 import { ServiceType } from '../entities/service-type.entity';
 
 export interface IServiceTypesRepository {
@@ -6,6 +8,7 @@ export interface IServiceTypesRepository {
   findByCode(code: string): Promise<ServiceType | null>;
   findAll(options?: FindManyOptions<ServiceType>): Promise<ServiceType[]>;
   findAndCount(options?: FindManyOptions<ServiceType>): Promise<[ServiceType[], number]>;
+  findPaged(query: ListServiceTypesQueryDto): Promise<PaginatedResponse<ServiceType>>;
   create(data: Partial<ServiceType>): Promise<ServiceType>;
   update(id: string, data: Partial<ServiceType>): Promise<ServiceType | null>;
   softDelete(id: string): Promise<void>;
diff --git a/apps/edr-freight-api/src/modules/rule-engine/interfaces/shipping-lines.repository.interface.ts b/apps/edr-freight-api/src/modules/rule-engine/interfaces/shipping-lines.repository.interface.ts
index 88f36933d..6f39da549 100644
--- a/apps/edr-freight-api/src/modules/rule-engine/interfaces/shipping-lines.repository.interface.ts
+++ b/apps/edr-freight-api/src/modules/rule-engine/interfaces/shipping-lines.repository.interface.ts
@@ -1,4 +1,6 @@
+import { PaginatedResponse } from '@edr/types';
 import { FindManyOptions } from 'typeorm';
+import { ListRuleEngineQueryDto } from '../dto/list-rule-engine-query.dto';
 import { ShippingLine } from '../entities/shipping-line.entity';
 
 export interface IShippingLinesRepository {
@@ -6,6 +8,7 @@ export interface IShippingLinesRepository {
   findByCode(code: string): Promise<ShippingLine | null>;
   findAll(options?: FindManyOptions<ShippingLine>): Promise<ShippingLine[]>;
   findAndCount(options?: FindManyOptions<ShippingLine>): Promise<[ShippingLine[], number]>;
+  findPaged(query: ListRuleEngineQueryDto): Promise<PaginatedResponse<ShippingLine>>;
   create(data: Partial<ShippingLine>): Promise<ShippingLine>;
   update(id: string, data: Partial<ShippingLine>): Promise<ShippingLine | null>;
   softDelete(id: string): Promise<void>;
diff --git a/apps/edr-freight-api/src/modules/rule-engine/interfaces/weight-limit-rules.repository.interface.ts b/apps/edr-freight-api/src/modules/rule-engine/interfaces/weight-limit-rules.repository.interface.ts
index 3c175df4e..d08ebfc97 100644
--- a/apps/edr-freight-api/src/modules/rule-engine/interfaces/weight-limit-rules.repository.interface.ts
+++ b/apps/edr-freight-api/src/modules/rule-engine/interfaces/weight-limit-rules.repository.interface.ts
@@ -1,4 +1,6 @@
+import { PaginatedResponse } from '@edr/types';
 import { FindManyOptions } from 'typeorm';
+import { ListWeightLimitRulesQueryDto } from '../dto/list-rule-engine-query.dto';
 import { WeightLimitRule } from '../entities/weight-limit-rule.entity';
 
 export interface IWeightLimitRulesRepository {
@@ -14,6 +16,7 @@ export interface IWeightLimitRulesRepository {
   ): Promise<WeightLimitRule | null>;
   findAll(options?: FindManyOptions<WeightLimitRule>): Promise<WeightLimitRule[]>;
   findAndCount(options?: FindManyOptions<WeightLimitRule>): Promise<[WeightLimitRule[], number]>;
+  findPaged(query: ListWeightLimitRulesQueryDto): Promise<PaginatedResponse<WeightLimitRule>>;
   create(data: Partial<WeightLimitRule>): Promise<WeightLimitRule>;
   update(id: string, data: Partial<WeightLimitRule>): Promise<WeightLimitRule | null>;
   softDelete(id: string): Promise<void>;
diff --git a/apps/edr-freight-api/src/modules/rule-engine/interfaces/yards.repository.interface.ts b/apps/edr-freight-api/src/modules/rule-engine/interfaces/yards.repository.interface.ts
index 9cfcfd940..75baca5de 100644
--- a/apps/edr-freight-api/src/modules/rule-engine/interfaces/yards.repository.interface.ts
+++ b/apps/edr-freight-api/src/modules/rule-engine/interfaces/yards.repository.interface.ts
@@ -1,4 +1,6 @@
+import { PaginatedResponse } from '@edr/types';
 import { FindManyOptions } from 'typeorm';
+import { ListYardsQueryDto } from '../dto/list-rule-engine-query.dto';
 import { Yard } from '../entities/yard.entity';
 
 export interface IYardsRepository {
@@ -6,6 +8,7 @@ export interface IYardsRepository {
   findByCode(code: string): Promise<Yard | null>;
   findAll(options?: FindManyOptions<Yard>): Promise<Yard[]>;
   findAndCount(options?: FindManyOptions<Yard>): Promise<[Yard[], number]>;
+  findPaged(query: ListYardsQueryDto): Promise<PaginatedResponse<Yard>>;
   create(data: Partial<Yard>): Promise<Yard>;
   update(id: string, data: Partial<Yard>): Promise<Yard | null>;
   softDelete(id: string): Promise<void>;
diff --git a/apps/edr-freight-api/src/modules/rule-engine/repositories/approval-rules.repository.ts b/apps/edr-freight-api/src/modules/rule-engine/repositories/approval-rules.repository.ts
index c77695395..c62ce6724 100644
--- a/apps/edr-freight-api/src/modules/rule-engine/repositories/approval-rules.repository.ts
+++ b/apps/edr-freight-api/src/modules/rule-engine/repositories/approval-rules.repository.ts
@@ -1,5 +1,8 @@
+import { PaginatedResponse } from '@edr/types';
 import { Injectable } from '@nestjs/common';
 import { DataSource, FindManyOptions, Repository } from 'typeorm';
+import { paginateQuery } from '../../../common/utils/pagination.util';
+import { ListApprovalRulesQueryDto } from '../dto/list-rule-engine-query.dto';
 import { ApprovalRule } from '../entities/approval-rule.entity';
 import { IApprovalRulesRepository } from '../interfaces/approval-rules.repository.interface';
 
@@ -30,6 +33,31 @@ export class ApprovalRulesRepository implements IApprovalRulesRepository {
     return this.repo.findAndCount(options);
   }
 
+  /**
+   * Paged list in the standard envelope. Chain grouping is preserved: rows are
+   * grouped by chain (requiresDirectorApproval) first, then step order.
+   */
+  findPaged(query: ListApprovalRulesQueryDto): Promise<PaginatedResponse<ApprovalRule>> {
+    const qb = this.repo
+      .createQueryBuilder('rule')
+      .orderBy('rule.requiresDirectorApproval', 'ASC')
+      .addOrderBy('rule.stepOrder', query.sortOrder ?? 'ASC');
+
+    if (query.requiresDirectorApproval !== undefined) {
+      qb.andWhere('rule.requiresDirectorApproval = :requiresDirectorApproval', {
+        requiresDirectorApproval: query.requiresDirectorApproval,
+      });
+    }
+    if (query.search) {
+      qb.andWhere(
+        '(rule.actionLabel ILIKE :search OR rule.requiredRole ILIKE :search OR rule.blocksRole ILIKE :search)',
+        { search: `%${query.search}%` },
+      );
+    }
+
+    return paginateQuery(qb, query);
+  }
+
   async create(data: Partial<ApprovalRule>): Promise<ApprovalRule> {
     const entity = this.repo.create(data);
     return this.repo.save(entity);
diff --git a/apps/edr-freight-api/src/modules/rule-engine/repositories/cargo-types.repository.ts b/apps/edr-freight-api/src/modules/rule-engine/repositories/cargo-types.repository.ts
index 5fba70fe1..8e4be5a3b 100644
--- a/apps/edr-freight-api/src/modules/rule-engine/repositories/cargo-types.repository.ts
+++ b/apps/edr-freight-api/src/modules/rule-engine/repositories/cargo-types.repository.ts
@@ -1,5 +1,8 @@
+import { PaginatedResponse } from '@edr/types';
 import { Injectable } from '@nestjs/common';
 import { DataSource, FindManyOptions, Repository } from 'typeorm';
+import { paginateQuery } from '../../../common/utils/pagination.util';
+import { ListCargoTypesQueryDto } from '../dto/list-rule-engine-query.dto';
 import { CargoType } from '../entities/cargo-type.entity';
 import { ICargoTypesRepository } from '../interfaces/cargo-types.repository.interface';
 
@@ -27,6 +30,33 @@ export class CargoTypesRepository implements ICargoTypesRepository {
     return this.repo.findAndCount(options);
   }
 
+  /** Paged list with server-side search (name/code) in the standard envelope. */
+  findPaged(query: ListCargoTypesQueryDto): Promise<PaginatedResponse<CargoType>> {
+    const qb = this.repo
+      .createQueryBuilder('cargoType')
+      .leftJoinAndSelect('cargoType.parent', 'parent')
+      .orderBy(`cargoType.${query.sortBy ?? 'displayOrder'}`, query.sortOrder ?? 'ASC');
+
+    if (query.isActive !== undefined) {
+      qb.andWhere('cargoType.isActive = :isActive', { isActive: query.isActive });
+    }
+    if (query.requiresDirectorApproval !== undefined) {
+      qb.andWhere('cargoType.requiresDirectorApproval = :requiresDirectorApproval', {
+        requiresDirectorApproval: query.requiresDirectorApproval,
+      });
+    }
+    if (query.parentGroupId !== undefined) {
+      qb.andWhere('cargoType.parentGroupId = :parentGroupId', { parentGroupId: query.parentGroupId });
+    }
+    if (query.search) {
+      qb.andWhere('(cargoType.cargoTypeName ILIKE :search OR cargoType.code ILIKE :search)', {
+        search: `%${query.search}%`,
+      });
+    }
+
+    return paginateQuery(qb, query);
+  }
+
   async create(data: Partial<CargoType>): Promise<CargoType> {
     const entity = this.repo.create(data);
     return this.repo.save(entity);
diff --git a/apps/edr-freight-api/src/modules/rule-engine/repositories/container-types.repository.ts b/apps/edr-freight-api/src/modules/rule-engine/repositories/container-types.repository.ts
index 0e4fb2716..ff5a3f994 100644
--- a/apps/edr-freight-api/src/modules/rule-engine/repositories/container-types.repository.ts
+++ b/apps/edr-freight-api/src/modules/rule-engine/repositories/container-types.repository.ts
@@ -1,5 +1,8 @@
+import { PaginatedResponse } from '@edr/types';
 import { Injectable } from '@nestjs/common';
 import { DataSource, FindManyOptions, Repository } from 'typeorm';
+import { paginateQuery } from '../../../common/utils/pagination.util';
+import { ListContainerTypesQueryDto } from '../dto/list-rule-engine-query.dto';
 import { ContainerType } from '../entities/container-type.entity';
 import { IContainerTypesRepository } from '../interfaces/container-types.repository.interface';
 
@@ -27,6 +30,24 @@ export class ContainerTypesRepository implements IContainerTypesRepository {
     return this.repo.findAndCount(options);
   }
 
+  /** Paged list with server-side search (label/code) in the standard envelope. */
+  findPaged(query: ListContainerTypesQueryDto): Promise<PaginatedResponse<ContainerType>> {
+    const qb = this.repo
+      .createQueryBuilder('containerType')
+      .orderBy(`containerType.${query.sortBy ?? 'displayOrder'}`, query.sortOrder ?? 'ASC');
+
+    if (query.isActive !== undefined) {
+      qb.andWhere('containerType.isActive = :isActive', { isActive: query.isActive });
+    }
+    if (query.search) {
+      qb.andWhere('(containerType.label ILIKE :search OR containerType.code ILIKE :search)', {
+        search: `%${query.search}%`,
+      });
+    }
+
+    return paginateQuery(qb, query);
+  }
+
   async create(data: Partial<ContainerType>): Promise<ContainerType> {
     const entity = this.repo.create(data);
     return this.repo.save(entity);
diff --git a/apps/edr-freight-api/src/modules/rule-engine/repositories/priority-configs.repository.ts b/apps/edr-freight-api/src/modules/rule-engine/repositories/priority-configs.repository.ts
index d8326b794..909b1d8af 100644
--- a/apps/edr-freight-api/src/modules/rule-engine/repositories/priority-configs.repository.ts
+++ b/apps/edr-freight-api/src/modules/rule-engine/repositories/priority-configs.repository.ts
@@ -1,5 +1,8 @@
+import { PaginatedResponse } from '@edr/types';
 import { Injectable } from '@nestjs/common';
 import { DataSource, FindManyOptions, Repository } from 'typeorm';
+import { paginateQuery } from '../../../common/utils/pagination.util';
+import { ListPriorityConfigsQueryDto } from '../dto/list-rule-engine-query.dto';
 import { PriorityConfig } from '../entities/priority-config.entity';
 import { IPriorityConfigsRepository } from '../interfaces/priority-configs.repository.interface';
 
@@ -23,6 +26,28 @@ export class PriorityConfigsRepository implements IPriorityConfigsRepository {
     return this.repo.findAndCount(options);
   }
 
+  /** Paged list with server-side search (label/type/currency) in the standard envelope. */
+  findPaged(query: ListPriorityConfigsQueryDto): Promise<PaginatedResponse<PriorityConfig>> {
+    const qb = this.repo
+      .createQueryBuilder('config')
+      .orderBy(`config.${query.sortBy ?? 'displayOrder'}`, query.sortOrder ?? 'ASC');
+
+    if (query.type !== undefined) {
+      qb.andWhere('config.type = :type', { type: query.type });
+    }
+    if (query.isActive !== undefined) {
+      qb.andWhere('config.isActive = :isActive', { isActive: query.isActive });
+    }
+    if (query.search) {
+      qb.andWhere(
+        '(config.label ILIKE :search OR config.type ILIKE :search OR config.currency ILIKE :search)',
+        { search: `%${query.search}%` },
+      );
+    }
+
+    return paginateQuery(qb, query);
+  }
+
   async findAllActive(): Promise<PriorityConfig[]> {
     return this.repo.find({
       where: { isActive: true },
diff --git a/apps/edr-freight-api/src/modules/rule-engine/repositories/rates.repository.ts b/apps/edr-freight-api/src/modules/rule-engine/repositories/rates.repository.ts
index a7b8e69ab..85bfc783f 100644
--- a/apps/edr-freight-api/src/modules/rule-engine/repositories/rates.repository.ts
+++ b/apps/edr-freight-api/src/modules/rule-engine/repositories/rates.repository.ts
@@ -1,5 +1,8 @@
+import { PaginatedResponse } from '@edr/types';
 import { Injectable } from '@nestjs/common';
 import { DataSource, FindManyOptions, Repository } from 'typeorm';
+import { paginateQuery } from '../../../common/utils/pagination.util';
+import { ListRatesQueryDto } from '../dto/list-rule-engine-query.dto';
 import { Rate } from '../entities/rate.entity';
 import { IRatesRepository } from '../interfaces/rates.repository.interface';
 
@@ -68,6 +71,28 @@ export class RatesRepository implements IRatesRepository {
     return this.repo.findAndCount(options);
   }
 
+  /** Paged list with server-side search (type/status/unit/currency), newest first. */
+  findPaged(query: ListRatesQueryDto): Promise<PaginatedResponse<Rate>> {
+    const qb = this.repo
+      .createQueryBuilder('rate')
+      .orderBy('rate.createdAt', query.sortOrder ?? 'DESC');
+
+    if (query.status) {
+      qb.andWhere('rate.status = :status', { status: query.status });
+    }
+    if (query.rateType) {
+      qb.andWhere('rate.rateType = :rateType', { rateType: query.rateType });
+    }
+    if (query.search) {
+      qb.andWhere(
+        '(rate.rateType ILIKE :search OR rate.status ILIKE :search OR rate.rateUnit ILIKE :search OR rate.currency ILIKE :search)',
+        { search: `%${query.search}%` },
+      );
+    }
+
+    return paginateQuery(qb, query);
+  }
+
   async create(data: Partial<Rate>): Promise<Rate> {
     const entity = this.repo.create(data);
     return this.repo.save(entity);
diff --git a/apps/edr-freight-api/src/modules/rule-engine/repositories/service-types.repository.ts b/apps/edr-freight-api/src/modules/rule-engine/repositories/service-types.repository.ts
index 5e5f88b0a..bda47e31e 100644
--- a/apps/edr-freight-api/src/modules/rule-engine/repositories/service-types.repository.ts
+++ b/apps/edr-freight-api/src/modules/rule-engine/repositories/service-types.repository.ts
@@ -1,5 +1,8 @@
+import { PaginatedResponse } from '@edr/types';
 import { Injectable } from '@nestjs/common';
 import { DataSource, FindManyOptions, Repository } from 'typeorm';
+import { paginateQuery } from '../../../common/utils/pagination.util';
+import { ListServiceTypesQueryDto } from '../dto/list-rule-engine-query.dto';
 import { ServiceType } from '../entities/service-type.entity';
 import { IServiceTypesRepository } from '../interfaces/service-types.repository.interface';
 
@@ -27,6 +30,30 @@ export class ServiceTypesRepository implements IServiceTypesRepository {
     return this.repo.findAndCount(options);
   }
 
+  /** Paged list with server-side search (name/code/description) in the standard envelope. */
+  findPaged(query: ListServiceTypesQueryDto): Promise<PaginatedResponse<ServiceType>> {
+    const qb = this.repo
+      .createQueryBuilder('serviceType')
+      .orderBy(`serviceType.${query.sortBy ?? 'displayOrder'}`, query.sortOrder ?? 'ASC');
+
+    if (query.isActive !== undefined) {
+      qb.andWhere('serviceType.isActive = :isActive', { isActive: query.isActive });
+    }
+    if (query.canBeBookedAlone !== undefined) {
+      qb.andWhere('serviceType.canBeBookedAlone = :canBeBookedAlone', {
+        canBeBookedAlone: query.canBeBookedAlone,
+      });
+    }
+    if (query.search) {
+      qb.andWhere(
+        '(serviceType.serviceName ILIKE :search OR serviceType.code ILIKE :search OR serviceType.description ILIKE :search)',
+        { search: `%${query.search}%` },
+      );
+    }
+
+    return paginateQuery(qb, query);
+  }
+
   async create(data: Partial<ServiceType>): Promise<ServiceType> {
     const entity = this.repo.create(data);
     return this.repo.save(entity);
diff --git a/apps/edr-freight-api/src/modules/rule-engine/repositories/shipping-lines.repository.ts b/apps/edr-freight-api/src/modules/rule-engine/repositories/shipping-lines.repository.ts
index 521a72b95..2ae163d66 100644
--- a/apps/edr-freight-api/src/modules/rule-engine/repositories/shipping-lines.repository.ts
+++ b/apps/edr-freight-api/src/modules/rule-engine/repositories/shipping-lines.repository.ts
@@ -1,5 +1,8 @@
+import { PaginatedResponse } from '@edr/types';
 import { Injectable } from '@nestjs/common';
 import { DataSource, FindManyOptions, Repository } from 'typeorm';
+import { paginateQuery } from '../../../common/utils/pagination.util';
+import { ListRuleEngineQueryDto } from '../dto/list-rule-engine-query.dto';
 import { ShippingLine } from '../entities/shipping-line.entity';
 import { IShippingLinesRepository } from '../interfaces/shipping-lines.repository.interface';
 
@@ -27,6 +30,25 @@ export class ShippingLinesRepository implements IShippingLinesRepository {
     return this.repo.findAndCount(options);
   }
 
+  /** Paged list with server-side search (label/code/mappedToCode), ordered by code. */
+  findPaged(query: ListRuleEngineQueryDto): Promise<PaginatedResponse<ShippingLine>> {
+    const qb = this.repo
+      .createQueryBuilder('line')
+      .orderBy('line.code', query.sortOrder ?? 'ASC');
+
+    if (query.isActive !== undefined) {
+      qb.andWhere('line.isActive = :isActive', { isActive: query.isActive });
+    }
+    if (query.search) {
+      qb.andWhere(
+        '(line.label ILIKE :search OR line.code ILIKE :search OR line.mappedToCode ILIKE :search)',
+        { search: `%${query.search}%` },
+      );
+    }
+
+    return paginateQuery(qb, query);
+  }
+
   async create(data: Partial<ShippingLine>): Promise<ShippingLine> {
     const entity = this.repo.create(data);
     return this.repo.save(entity);
diff --git a/apps/edr-freight-api/src/modules/rule-engine/repositories/weight-limit-rules.repository.ts b/apps/edr-freight-api/src/modules/rule-engine/repositories/weight-limit-rules.repository.ts
index 7432dfc34..598bdf8bb 100644
--- a/apps/edr-freight-api/src/modules/rule-engine/repositories/weight-limit-rules.repository.ts
+++ b/apps/edr-freight-api/src/modules/rule-engine/repositories/weight-limit-rules.repository.ts
@@ -1,5 +1,8 @@
+import { PaginatedResponse } from '@edr/types';
 import { Injectable } from '@nestjs/common';
 import { DataSource, FindManyOptions, Repository } from 'typeorm';
+import { paginateQuery } from '../../../common/utils/pagination.util';
+import { ListWeightLimitRulesQueryDto } from '../dto/list-rule-engine-query.dto';
 import { WeightLimitRule } from '../entities/weight-limit-rule.entity';
 import { IWeightLimitRulesRepository } from '../interfaces/weight-limit-rules.repository.interface';
 
@@ -59,6 +62,34 @@ export class WeightLimitRulesRepository implements IWeightLimitRulesRepository {
     return this.repo.findAndCount(options);
   }
 
+  /**
+   * Paged list with the container relation loaded, newest first. `search`
+   * matches the trade direction and the joined container type's label/code.
+   */
+  findPaged(query: ListWeightLimitRulesQueryDto): Promise<PaginatedResponse<WeightLimitRule>> {
+    const qb = this.repo
+      .createQueryBuilder('rule')
+      .leftJoinAndSelect('rule.containerType', 'containerType')
+      .orderBy('rule.createdAt', query.sortOrder ?? 'DESC');
+
+    if (query.containerTypeId) {
+      qb.andWhere('rule.containerTypeId = :containerTypeId', {
+        containerTypeId: query.containerTypeId,
+      });
+    }
+    if (query.tradeDirection) {
+      qb.andWhere('rule.tradeDirection = :tradeDirection', { tradeDirection: query.tradeDirection });
+    }
+    if (query.search) {
+      qb.andWhere(
+        '(rule.tradeDirection ILIKE :search OR containerType.label ILIKE :search OR containerType.code ILIKE :search)',
+        { search: `%${query.search}%` },
+      );
+    }
+
+    return paginateQuery(qb, query);
+  }
+
   async create(data: Partial<WeightLimitRule>): Promise<WeightLimitRule> {
     const entity = this.repo.create(data);
     return this.repo.save(entity);
diff --git a/apps/edr-freight-api/src/modules/rule-engine/repositories/yards.repository.ts b/apps/edr-freight-api/src/modules/rule-engine/repositories/yards.repository.ts
index c2f1c62f1..1cb74d9ce 100644
--- a/apps/edr-freight-api/src/modules/rule-engine/repositories/yards.repository.ts
+++ b/apps/edr-freight-api/src/modules/rule-engine/repositories/yards.repository.ts
@@ -1,5 +1,8 @@
+import { PaginatedResponse } from '@edr/types';
 import { Injectable } from '@nestjs/common';
 import { DataSource, FindManyOptions, Repository } from 'typeorm';
+import { paginateQuery } from '../../../common/utils/pagination.util';
+import { ListYardsQueryDto } from '../dto/list-rule-engine-query.dto';
 import { Yard } from '../entities/yard.entity';
 import { IYardsRepository } from '../interfaces/yards.repository.interface';
 
@@ -27,6 +30,29 @@ export class YardsRepository implements IYardsRepository {
     return this.repo.findAndCount(options);
   }
 
+  /** Paged list with server-side search (label/code/country) in the standard envelope. */
+  findPaged(query: ListYardsQueryDto): Promise<PaginatedResponse<Yard>> {
+    const qb = this.repo
+      .createQueryBuilder('yard')
+      .orderBy(`yard.${query.sortBy ?? 'displayOrder'}`, query.sortOrder ?? 'ASC')
+      .addOrderBy('yard.label', 'ASC');
+
+    if (query.isActive !== undefined) {
+      qb.andWhere('yard.isActive = :isActive', { isActive: query.isActive });
+    }
+    if (query.country) {
+      qb.andWhere('yard.country = :country', { country: query.country });
+    }
+    if (query.search) {
+      qb.andWhere(
+        '(yard.label ILIKE :search OR yard.code ILIKE :search OR yard.country ILIKE :search)',
+        { search: `%${query.search}%` },
+      );
+    }
+
+    return paginateQuery(qb, query);
+  }
+
   async create(data: Partial<Yard>): Promise<Yard> {
     const entity = this.repo.create(data);
     return this.repo.save(entity);
diff --git 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
index 063cc6439..c22677608 100644
--- 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,7 @@
+import { PaginatedResponse } from '@edr/types';
 import { BadRequestException, Inject, Injectable, NotFoundException } from '@nestjs/common';
 import { CreateApprovalRuleDto } from '../dto/create-approval-rule.dto';
+import { ListApprovalRulesQueryDto } from '../dto/list-rule-engine-query.dto';
 import { ReorderItemsDto } from '../dto/reorder-items.dto';
 import { UpdateApprovalRuleDto } from '../dto/update-approval-rule.dto';
 import { ApprovalRule } from '../entities/approval-rule.entity';
@@ -17,26 +19,9 @@ export class ApprovalRulesService {
     private readonly displayOrder: DisplayOrderService,
   ) {}
 
-  /** List approval rules. */
-  async findAll(filter: {
-    requiresDirectorApproval?: boolean;
-    page?: number;
-    pageSize?: number;
-  }): Promise<{ data: ApprovalRule[]; meta: { total: number; page: number; pageSize: number; totalPages: number } }> {
-    const page = filter.page ?? 1;
-    const pageSize = filter.pageSize ?? 10;
-    const where: Record<string, unknown> = {};
-    if (filter.requiresDirectorApproval !== undefined) {
-      where.requiresDirectorApproval = filter.requiresDirectorApproval;
-    }
-
-    const [data, total] = await this.repository.findAndCount({
-      where,
-      order: { requiresDirectorApproval: 'ASC', stepOrder: 'ASC' },
-      skip: (page - 1) * pageSize,
-      take: pageSize,
-    });
-    return { data, meta: { total, page, pageSize, totalPages: Math.ceil(total / pageSize) } };
+  /** List approval rules — standard paginated envelope with server-side search. */
+  async findAll(query: ListApprovalRulesQueryDto): Promise<PaginatedResponse<ApprovalRule>> {
+    return this.repository.findPaged(query);
   }
 
   /** Get approval chain for a cargo type flag. */
diff --git a/apps/edr-freight-api/src/modules/rule-engine/services/cargo-types.service.ts b/apps/edr-freight-api/src/modules/rule-engine/services/cargo-types.service.ts
index 5470094a5..941d35f2f 100644
--- a/apps/edr-freight-api/src/modules/rule-engine/services/cargo-types.service.ts
+++ b/apps/edr-freight-api/src/modules/rule-engine/services/cargo-types.service.ts
@@ -1,7 +1,8 @@
+import { PaginatedResponse } from '@edr/types';
 import { ConflictException, Inject, Injectable, NotFoundException } from '@nestjs/common';
-import { ILike } from 'typeorm';
 import { generateCode } from '../../../common/utils/generate-code.util';
 import { CreateCargoTypeDto } from '../dto/create-cargo-type.dto';
+import { ListCargoTypesQueryDto } from '../dto/list-rule-engine-query.dto';
 import { ReorderItemsDto } from '../dto/reorder-items.dto';
 import { UpdateCargoTypeDto } from '../dto/update-cargo-type.dto';
 import { CargoType } from '../entities/cargo-type.entity';
@@ -19,33 +20,9 @@ export class CargoTypesService {
     private readonly displayOrder: DisplayOrderService,
   ) {}
 
-  /** List cargo types with pagination and optional filtering. */
-  async findAll(filter: {
-    isActive?: boolean;
-    requiresDirectorApproval?: boolean;
-    parentGroupId?: string;
-    search?: string;
-    page?: number;
-    pageSize?: number;
-    sortBy?: string;
-    sortOrder?: 'ASC' | 'DESC';
-  }): Promise<{ data: CargoType[]; meta: { total: number; page: number; pageSize: number; totalPages: number } }> {
-    const page = filter.page ?? 1;
-    const pageSize = filter.pageSize ?? 10;
-    const where: Record<string, unknown> = {};
-    if (filter.isActive !== undefined) where.isActive = filter.isActive;
-    if (filter.requiresDirectorApproval !== undefined) where.requiresDirectorApproval = filter.requiresDirectorApproval;
-    if (filter.parentGroupId !== undefined) where.parentGroupId = filter.parentGroupId;
-    if (filter.search) where.cargoTypeName = ILike(`%${filter.search}%`);
-
-    const [data, total] = await this.repository.findAndCount({
-      where,
-      order: { [filter.sortBy ?? 'displayOrder']: filter.sortOrder ?? 'ASC' },
-      skip: (page - 1) * pageSize,
-      take: pageSize,
-      relations: { parent: true },
-    });
-    return { data, meta: { total, page, pageSize, totalPages: Math.ceil(total / pageSize) } };
+  /** List cargo types — standard paginated envelope with server-side search. */
+  async findAll(query: ListCargoTypesQueryDto): Promise<PaginatedResponse<CargoType>> {
+    return this.repository.findPaged(query);
   }
 
   /** Get a single cargo type by ID. */
diff --git a/apps/edr-freight-api/src/modules/rule-engine/services/container-types.service.ts b/apps/edr-freight-api/src/modules/rule-engine/services/container-types.service.ts
index 629bf3023..da641afe0 100644
--- a/apps/edr-freight-api/src/modules/rule-engine/services/container-types.service.ts
+++ b/apps/edr-freight-api/src/modules/rule-engine/services/container-types.service.ts
@@ -1,6 +1,8 @@
+import { PaginatedResponse } from '@edr/types';
 import { ConflictException, Inject, Injectable, NotFoundException } from '@nestjs/common';
 import { generateCode } from '../../../common/utils/generate-code.util';
 import { CreateContainerTypeDto } from '../dto/create-container-type.dto';
+import { ListContainerTypesQueryDto } from '../dto/list-rule-engine-query.dto';
 import { ReorderItemsDto } from '../dto/reorder-items.dto';
 import { UpdateContainerTypeDto } from '../dto/update-container-type.dto';
 import { ContainerType } from '../entities/container-type.entity';
@@ -18,24 +20,9 @@ export class ContainerTypesService {
     private readonly displayOrder: DisplayOrderService,
   ) {}
 
-  /** List container types with pagination. */
-  async findAll(filter: {
-    isActive?: boolean;
-    page?: number;
-    pageSize?: number;
-  }): Promise<{ data: ContainerType[]; meta: { total: number; page: number; pageSize: number; totalPages: number } }> {
-    const page = filter.page ?? 1;
-    const pageSize = filter.pageSize ?? 10;
-    const where: Record<string, unknown> = {};
-    if (filter.isActive !== undefined) where.isActive = filter.isActive;
-
-    const [data, total] = await this.repository.findAndCount({
-      where,
-      order: { displayOrder: 'ASC' },
-      skip: (page - 1) * pageSize,
-      take: pageSize,
-    });
-    return { data, meta: { total, page, pageSize, totalPages: Math.ceil(total / pageSize) } };
+  /** List container types — standard paginated envelope with server-side search. */
+  async findAll(query: ListContainerTypesQueryDto): Promise<PaginatedResponse<ContainerType>> {
+    return this.repository.findPaged(query);
   }
 
   /** Get a single container type by ID. */
diff --git a/apps/edr-freight-api/src/modules/rule-engine/services/priority-configs.service.ts b/apps/edr-freight-api/src/modules/rule-engine/services/priority-configs.service.ts
index 6d7034ad4..560a550b2 100644
--- a/apps/edr-freight-api/src/modules/rule-engine/services/priority-configs.service.ts
+++ b/apps/edr-freight-api/src/modules/rule-engine/services/priority-configs.service.ts
@@ -1,5 +1,7 @@
+import { PaginatedResponse } from '@edr/types';
 import { BadRequestException, Inject, Injectable, NotFoundException } from '@nestjs/common';
 import { CreatePriorityConfigDto } from '../dto/create-priority-config.dto';
+import { ListPriorityConfigsQueryDto } from '../dto/list-rule-engine-query.dto';
 import { UpdatePriorityConfigDto } from '../dto/update-priority-config.dto';
 import { PriorityConfig } from '../entities/priority-config.entity';
 import {
@@ -16,25 +18,9 @@ export class PriorityConfigsService {
     private readonly displayOrder: DisplayOrderService,
   ) {}
 
-  async findAll(filter: {
-    type?: 'WAGON' | 'CURRENCY' | 'CUSTOMS';
-    isActive?: boolean;
-    page?: number;
-    pageSize?: number;
-  }): Promise<{ data: PriorityConfig[]; meta: { total: number; page: number; pageSize: number; totalPages: number } }> {
-    const page = filter.page ?? 1;
-    const pageSize = filter.pageSize ?? 20;
-    const where: Record<string, unknown> = {};
-    if (filter.type !== undefined) where.type = filter.type;
-    if (filter.isActive !== undefined) where.isActive = filter.isActive;
-
-    const [data, total] = await this.repository.findAndCount({
-      where,
-      order: { displayOrder: 'ASC' },
-      skip: (page - 1) * pageSize,
-      take: pageSize,
-    });
-    return { data, meta: { total, page, pageSize, totalPages: Math.ceil(total / pageSize) } };
+  /** List priority configs — standard paginated envelope with server-side search. */
+  async findAll(query: ListPriorityConfigsQueryDto): Promise<PaginatedResponse<PriorityConfig>> {
+    return this.repository.findPaged(query);
   }
 
   async findById(id: string): Promise<PriorityConfig> {
diff --git a/apps/edr-freight-api/src/modules/rule-engine/services/rates.service.ts b/apps/edr-freight-api/src/modules/rule-engine/services/rates.service.ts
index 0027e18c1..2be1cf670 100644
--- a/apps/edr-freight-api/src/modules/rule-engine/services/rates.service.ts
+++ b/apps/edr-freight-api/src/modules/rule-engine/services/rates.service.ts
@@ -5,7 +5,9 @@ import {
   Injectable,
   NotFoundException,
 } from '@nestjs/common';
+import { PaginatedResponse } from '@edr/types';
 import { CreateRateDto } from '../dto/create-rate.dto';
+import { ListRatesQueryDto } from '../dto/list-rule-engine-query.dto';
 import { UpdateRateDto } from '../dto/update-rate.dto';
 import { Rate } from '../entities/rate.entity';
 import { deriveRateType } from '../entities/rate-type.util';
@@ -19,26 +21,9 @@ export class RatesService {
     private readonly repository: IRatesRepository,
   ) {}
 
-  /** List rates with pagination. */
-  async findAll(filter: {
-    status?: string;
-    rateType?: string;
-    page?: number;
-    pageSize?: number;
-  }): Promise<{ data: Rate[]; meta: { total: number; page: number; pageSize: number; totalPages: number } }> {
-    const page = filter.page ?? 1;
-    const pageSize = filter.pageSize ?? 20;
-    const where: Record<string, unknown> = {};
-    if (filter.status) where.status = filter.status;
-    if (filter.rateType) where.rateType = filter.rateType;
-
-    const [data, total] = await this.repository.findAndCount({
-      where,
-      order: { createdAt: 'DESC' },
-      skip: (page - 1) * pageSize,
-      take: pageSize,
-    });
-    return { data, meta: { total, page, pageSize, totalPages: Math.max(1, Math.ceil(total / pageSize)) } };
+  /** List rates — standard paginated envelope with server-side search. */
+  async findAll(query: ListRatesQueryDto): Promise<PaginatedResponse<Rate>> {
+    return this.repository.findPaged(query);
   }
 
   /** Return all currently LIVE rates. */
diff --git a/apps/edr-freight-api/src/modules/rule-engine/services/service-types.service.ts b/apps/edr-freight-api/src/modules/rule-engine/services/service-types.service.ts
index 6608749d1..7592a6f76 100644
--- a/apps/edr-freight-api/src/modules/rule-engine/services/service-types.service.ts
+++ b/apps/edr-freight-api/src/modules/rule-engine/services/service-types.service.ts
@@ -1,7 +1,8 @@
+import { PaginatedResponse } from '@edr/types';
 import { ConflictException, Inject, Injectable, NotFoundException } from '@nestjs/common';
-import { ILike } from 'typeorm';
 import { generateCode } from '../../../common/utils/generate-code.util';
 import { CreateServiceTypeDto } from '../dto/create-service-type.dto';
+import { ListServiceTypesQueryDto } from '../dto/list-rule-engine-query.dto';
 import { ReorderItemsDto } from '../dto/reorder-items.dto';
 import { UpdateServiceTypeDto } from '../dto/update-service-type.dto';
 import { ServiceType } from '../entities/service-type.entity';
@@ -19,30 +20,9 @@ export class ServiceTypesService {
     private readonly displayOrder: DisplayOrderService,
   ) {}
 
-  /** List service types with pagination and optional filtering. */
-  async findAll(filter: {
-    isActive?: boolean;
-    canBeBookedAlone?: boolean;
-    search?: string;
-    page?: number;
-    pageSize?: number;
-    sortBy?: string;
-    sortOrder?: 'ASC' | 'DESC';
-  }): Promise<{ data: ServiceType[]; meta: { total: number; page: number; pageSize: number; totalPages: number } }> {
-    const page = filter.page ?? 1;
-    const pageSize = filter.pageSize ?? 10;
-    const where: Record<string, unknown> = {};
-    if (filter.isActive !== undefined) where.isActive = filter.isActive;
-    if (filter.canBeBookedAlone !== undefined) where.canBeBookedAlone = filter.canBeBookedAlone;
-    if (filter.search) where.serviceName = ILike(`%${filter.search}%`);
-
-    const [data, total] = await this.repository.findAndCount({
-      where,
-      order: { [filter.sortBy ?? 'displayOrder']: filter.sortOrder ?? 'ASC' },
-      skip: (page - 1) * pageSize,
-      take: pageSize,
-    });
-    return { data, meta: { total, page, pageSize, totalPages: Math.ceil(total / pageSize) } };
+  /** List service types — standard paginated envelope with server-side search. */
+  async findAll(query: ListServiceTypesQueryDto): Promise<PaginatedResponse<ServiceType>> {
+    return this.repository.findPaged(query);
   }
 
   /** Get a single service type by ID. */
diff --git a/apps/edr-freight-api/src/modules/rule-engine/services/shipping-lines.service.ts b/apps/edr-freight-api/src/modules/rule-engine/services/shipping-lines.service.ts
index 4eaa47a26..381b25728 100644
--- a/apps/edr-freight-api/src/modules/rule-engine/services/shipping-lines.service.ts
+++ b/apps/edr-freight-api/src/modules/rule-engine/services/shipping-lines.service.ts
@@ -1,5 +1,7 @@
+import { PaginatedResponse } from '@edr/types';
 import { ConflictException, Inject, Injectable, NotFoundException } from '@nestjs/common';
 import { CreateShippingLineDto } from '../dto/create-shipping-line.dto';
+import { ListRuleEngineQueryDto } from '../dto/list-rule-engine-query.dto';
 import { UpdateShippingLineDto } from '../dto/update-shipping-line.dto';
 import { ShippingLine } from '../entities/shipping-line.entity';
 import {
@@ -14,24 +16,9 @@ export class ShippingLinesService {
     private readonly repository: IShippingLinesRepository,
   ) {}
 
-  /** List shipping lines with pagination. */
-  async findAll(filter: {
-    isActive?: boolean;
-    page?: number;
-    pageSize?: number;
-  }): Promise<{ data: ShippingLine[]; meta: { total: number; page: number; pageSize: number; totalPages: number } }> {
-    const page = filter.page ?? 1;
-    const pageSize = filter.pageSize ?? 20;
-    const where: Record<string, unknown> = {};
-    if (filter.isActive !== undefined) where.isActive = filter.isActive;
-
-    const [data, total] = await this.repository.findAndCount({
-      where,
-      order: { code: 'ASC' },
-      skip: (page - 1) * pageSize,
-      take: pageSize,
-    });
-    return { data, meta: { total, page, pageSize, totalPages: Math.ceil(total / pageSize) } };
+  /** List shipping lines — standard paginated envelope with server-side search. */
+  async findAll(query: ListRuleEngineQueryDto): Promise<PaginatedResponse<ShippingLine>> {
+    return this.repository.findPaged(query);
   }
 
   /** Get a shipping line by ID. */
diff --git a/apps/edr-freight-api/src/modules/rule-engine/services/weight-limit-rules.service.ts b/apps/edr-freight-api/src/modules/rule-engine/services/weight-limit-rules.service.ts
index 44f5332f2..076ebc1ea 100644
--- a/apps/edr-freight-api/src/modules/rule-engine/services/weight-limit-rules.service.ts
+++ b/apps/edr-freight-api/src/modules/rule-engine/services/weight-limit-rules.service.ts
@@ -5,7 +5,9 @@ import {
   Injectable,
   NotFoundException,
 } from '@nestjs/common';
+import { PaginatedResponse } from '@edr/types';
 import { CreateWeightLimitRuleDto } from '../dto/create-weight-limit-rule.dto';
+import { ListWeightLimitRulesQueryDto } from '../dto/list-rule-engine-query.dto';
 import { UpdateWeightLimitRuleDto } from '../dto/update-weight-limit-rule.dto';
 import { WeightLimitRule } from '../entities/weight-limit-rule.entity';
 import {
@@ -20,27 +22,9 @@ export class WeightLimitRulesService {
     private readonly repository: IWeightLimitRulesRepository,
   ) {}
 
-  /** List weight limit rules with pagination. */
-  async findAll(filter: {
-    containerTypeId?: string;
-    tradeDirection?: string;
-    page?: number;
-    pageSize?: number;
-  }): Promise<{ data: WeightLimitRule[]; meta: { total: number; page: number; pageSize: number; totalPages: number } }> {
-    const page = filter.page ?? 1;
-    const pageSize = filter.pageSize ?? 20;
-    const where: Record<string, unknown> = {};
-    if (filter.containerTypeId) where.containerTypeId = filter.containerTypeId;
-    if (filter.tradeDirection) where.tradeDirection = filter.tradeDirection;
-
-    const [data, total] = await this.repository.findAndCount({
-      where,
-      relations: { containerType: true },
-      order: { createdAt: 'DESC' },
-      skip: (page - 1) * pageSize,
-      take: pageSize,
-    });
-    return { data, meta: { total, page, pageSize, totalPages: Math.ceil(total / pageSize) } };
+  /** List weight limit rules — standard paginated envelope with server-side search. */
+  async findAll(query: ListWeightLimitRulesQueryDto): Promise<PaginatedResponse<WeightLimitRule>> {
+    return this.repository.findPaged(query);
   }
 
   /** Get a single weight limit rule by ID. */
diff --git a/apps/edr-freight-api/src/modules/rule-engine/services/yards.service.ts b/apps/edr-freight-api/src/modules/rule-engine/services/yards.service.ts
index 0c95582af..47b1f05bc 100644
--- a/apps/edr-freight-api/src/modules/rule-engine/services/yards.service.ts
+++ b/apps/edr-freight-api/src/modules/rule-engine/services/yards.service.ts
@@ -1,6 +1,8 @@
+import { PaginatedResponse } from '@edr/types';
 import { ConflictException, Inject, Injectable, NotFoundException } from '@nestjs/common';
 import { generateCode } from '../../../common/utils/generate-code.util';
 import { CreateYardDto } from '../dto/create-yard.dto';
+import { ListYardsQueryDto } from '../dto/list-rule-engine-query.dto';
 import { ReorderItemsDto } from '../dto/reorder-items.dto';
 import { UpdateYardDto } from '../dto/update-yard.dto';
 import { Yard } from '../entities/yard.entity';
@@ -15,26 +17,9 @@ export class YardsService {
     private readonly displayOrder: DisplayOrderService,
   ) {}
 
-  /** List yards with pagination. */
-  async findAll(filter: {
-    isActive?: boolean;
-    country?: string;
-    page?: number;
-    pageSize?: number;
-  }): Promise<{ data: Yard[]; meta: { total: number; page: number; pageSize: number; totalPages: number } }> {
-    const page = filter.page ?? 1;
-    const pageSize = filter.pageSize ?? 10;
-    const where: Record<string, unknown> = {};
-    if (filter.isActive !== undefined) where.isActive = filter.isActive;
-    if (filter.country) where.country = filter.country;
-
-    const [data, total] = await this.repository.findAndCount({
-      where,
-      order: { displayOrder: 'ASC', label: 'ASC' },
-      skip: (page - 1) * pageSize,
-      take: pageSize,
-    });
-    return { data, meta: { total, page, pageSize, totalPages: Math.ceil(total / pageSize) } };
+  /** List yards — standard paginated envelope with server-side search. */
+  async findAll(query: ListYardsQueryDto): Promise<PaginatedResponse<Yard>> {
+    return this.repository.findPaged(query);
   }
 
   /** Get a yard by ID. */
diff --git a/apps/edr-freight-api/src/modules/train-schedules/entities/train-schedule.entity.ts b/apps/edr-freight-api/src/modules/train-schedules/entities/train-schedule.entity.ts
index 899b302fc..cf87622ab 100644
--- a/apps/edr-freight-api/src/modules/train-schedules/entities/train-schedule.entity.ts
+++ b/apps/edr-freight-api/src/modules/train-schedules/entities/train-schedule.entity.ts
@@ -1,5 +1,8 @@
 import { BaseEntity } from '@edr/api-common';
-import { TrainScheduleStatus as TrainScheduleStatusEnum } from '@edr/types';
+import {
+  TrainScheduleStatus as TrainScheduleStatusEnum,
+  WagonAllocationSnapshot,
+} from '@edr/types';
 import { Column, Entity, Index, JoinColumn, ManyToOne, OneToMany, OneToOne } from 'typeorm';
 
 import { Yard } from '../../rule-engine/entities/yard.entity';
@@ -146,6 +149,14 @@ export class TrainSchedule extends BaseEntity {
   @Column({ name: 'rule_export_booking_lead_hours', type: 'int', nullable: true })
   ruleExportBookingLeadHours?: number | null;
 
+  // Frozen wagon plan captured once when the schedule leaves the editable
+  // DRAFT/SCHEDULED phase (dispatch / arrive / cancel). Admin views of a
+  // non-editable schedule read THIS instead of the live wagon↔slot joins, so the
+  // historical allocation survives the same physical wagons being re-pinned onto
+  // later trains. NULL while DRAFT/SCHEDULED (read live) and on legacy rows.
+  @Column({ name: 'wagon_allocation_snapshot', type: 'jsonb', nullable: true })
+  wagonAllocationSnapshot?: WagonAllocationSnapshot | null;
+
   @OneToMany(() => TrainScheduleBooking, (scheduleBooking) => scheduleBooking.trainSchedule)
   scheduleBookings?: TrainScheduleBooking[];
 }
diff --git a/apps/edr-freight-api/src/modules/train-schedules/train-schedules.repository.ts b/apps/edr-freight-api/src/modules/train-schedules/train-schedules.repository.ts
index 6a8aced53..f32f2094e 100644
--- a/apps/edr-freight-api/src/modules/train-schedules/train-schedules.repository.ts
+++ b/apps/edr-freight-api/src/modules/train-schedules/train-schedules.repository.ts
@@ -53,6 +53,18 @@ export class TrainSchedulesRepository extends BaseRepository<TrainSchedule> {
     });
   }
 
+  /**
+   * Light fetch for human-facing labels (notifications): reference, train
+   * number, departure and the two station names — none of the composition
+   * graph {@link findByIdWithFullGraph} drags in.
+   */
+  findByIdWithStations(id: string): Promise<TrainSchedule | null> {
+    return this.repository.findOne({
+      where: { id },
+      relations: { originStation: true, destinationStation: true },
+    });
+  }
+
   async updateStatus(
     id: string,
     status: TrainScheduleStatus,
diff --git a/apps/edr-freight-api/src/modules/train-scheduling/booking-batch.export-space.spec.ts b/apps/edr-freight-api/src/modules/train-scheduling/booking-batch.export-space.spec.ts
new file mode 100644
index 000000000..cb2e63223
--- /dev/null
+++ b/apps/edr-freight-api/src/modules/train-scheduling/booking-batch.export-space.spec.ts
@@ -0,0 +1,140 @@
+import { ConflictException } from '@nestjs/common';
+
+import { BookingBatchService } from './booking-batch.service';
+import { Booking } from '../bookings/entities/booking.entity';
+
+/**
+ * Export whole-booking single-train gate: an export booking never splits — it
+ * rides one train whole or is rejected. The report must try every fillable
+ * train on the day (first full → use the second), and when none fits, say how
+ * much space is still bookable so the customer knows what he CAN book.
+ */
+describe('BookingBatchService — exportSpaceReport (whole-booking, single train)', () => {
+  const DAY = new Date('2026-07-20T10:00:00Z');
+
+  const schedule = (id: string) => ({
+    id,
+    status: 'SCHEDULED',
+    direction: 'EXPORT',
+    scheduledDepartureDate: DAY,
+    bookingWindowStatus: 'OPEN',
+    windowPhase: null, // legacy gate: OPEN alone makes it fillable
+  });
+
+  const fullGraph = (id: string) => ({
+    id,
+    originStationId: 'yard-a',
+    destinationStationId: 'yard-b',
+    routeId: null, // legacy two-stop pseudo-route — no milestone query
+    scheduleBookings: [],
+    trainSet: {
+      locomotive: {
+        maxPullWeightTons: 500,
+        maxTrainLengthMeters: 140,
+        overageToleranceTons: 0,
+        overageToleranceMeters: 0,
+      },
+    },
+  });
+
+  const exportBooking = (cargoTons: number) =>
+    ({
+      id: 'bk-exp',
+      freightType: 'BULK',
+      tradeDirection: 'EXPORT',
+      scheduledDate: DAY,
+      originYardId: 'yard-a',
+      destinationYardId: 'yard-b',
+      cargoTotalWeightVgm: cargoTons,
+      bookingContainers: [],
+    }) as unknown as Booking;
+
+  // A reserved bulk booking heavy enough to exhaust the 500t pull budget.
+  const heavyReserved = {
+    id: 'bk-heavy',
+    freightType: 'BULK',
+    originYardId: 'yard-a',
+    destinationYardId: 'yard-b',
+    cargoTotalWeightVgm: 476,
+    bookingContainers: [],
+  } as unknown as Booking;
+
+  let service: BookingBatchService;
+  let trainSchedulesRepository: {
+    findAll: jest.Mock;
+    findByIdWithFullGraph: jest.Mock;
+    findById: jest.Mock;
+  };
+  let bookingsRepository: { findReservedForSchedule: jest.Mock };
+
+  beforeEach(() => {
+    trainSchedulesRepository = {
+      findAll: jest.fn().mockResolvedValue([]),
+      findByIdWithFullGraph: jest
+        .fn()
+        .mockImplementation(async (id: string) => fullGraph(id)),
+      findById: jest.fn(),
+    };
+    bookingsRepository = { findReservedForSchedule: jest.fn().mockResolvedValue([]) };
+
+    // WagonType.find() → [] so representative default dims apply (bulk 60t
+    // payload / 23.4t tare / 14m); RouteMilestone is never queried (routeId null).
+    const genericRepo = { find: jest.fn().mockResolvedValue([]) };
+    const dataSource = { getRepository: jest.fn().mockReturnValue(genericRepo) };
+
+    service = new BookingBatchService(
+      dataSource as never,
+      bookingsRepository as never,
+      trainSchedulesRepository as never,
+      {} as never, // trainScheduleBookingsRepository
+      {} as never, // notifier
+      {} as never, // scheduler
+      {} as never, // trainSchedulingService
+      {} as never, // billing
+      {} as never, // bookingWindowGateway
+      {} as never, // pricingService
+    );
+  });
+
+  it('uses the other train when the first one is full', async () => {
+    trainSchedulesRepository.findAll.mockResolvedValue([
+      schedule('train-1'),
+      schedule('train-2'),
+    ]);
+    bookingsRepository.findReservedForSchedule.mockImplementation(
+      async (id: string) => (id === 'train-1' ? [heavyReserved] : []),
+    );
+
+    const report = await service.exportSpaceReport(exportBooking(60));
+
+    expect(report.scheduleId).toBe('train-2');
+  });
+
+  it('rejects a booking no single train fits and reports the bookable space', async () => {
+    trainSchedulesRepository.findAll.mockResolvedValue([schedule('train-1')]);
+
+    const report = await service.exportSpaceReport(exportBooking(900));
+
+    expect(report.scheduleId).toBeNull();
+    expect(report.bestAvailable).not.toBeNull();
+    expect(report.bestAvailable!.cargoTons).toBeGreaterThan(0);
+    expect(report.bestAvailable!.cargoTons).toBeLessThan(900);
+    expect(report.fullMessage).toMatch(/largest remaining space is about .* tons/);
+    expect(report.fullMessage).toMatch(/single train whole/);
+
+    await expect(service.pickExportSchedule(exportBooking(900))).rejects.toThrow(
+      ConflictException,
+    );
+  });
+
+  it('says no train is accepting bookings when the day has none', async () => {
+    trainSchedulesRepository.findAll.mockResolvedValue([]);
+
+    const report = await service.exportSpaceReport(exportBooking(60));
+
+    expect(report.scheduleId).toBeNull();
+    expect(report.fullMessage).toBe(
+      'No export train is accepting bookings for this day',
+    );
+  });
+});
diff --git a/apps/edr-freight-api/src/modules/train-scheduling/booking-batch.service.ts b/apps/edr-freight-api/src/modules/train-scheduling/booking-batch.service.ts
index cda6de85f..1c829b4ce 100644
--- a/apps/edr-freight-api/src/modules/train-scheduling/booking-batch.service.ts
+++ b/apps/edr-freight-api/src/modules/train-scheduling/booking-batch.service.ts
@@ -38,8 +38,16 @@ import {
   BATCH_BOARD_STATUSES,
   BatchBoardQueryDto,
 } from './dto/batch-board-query.dto';
-import { Freight, TrainScheduleStatus as TrainScheduleStatusEnum } from "@edr/types";
+import {
+  Freight,
+  PaginatedResponse,
+  TrainScheduleStatus as TrainScheduleStatusEnum,
+} from "@edr/types";
 import { BillingService } from "../billing/billing.service";
+import {
+  buildPaginationMeta,
+  normalizePagination,
+} from '../../common/utils/pagination.util';
 
 
 import {
@@ -83,6 +91,21 @@ export type { Capacity } from './corridor-capacity.util';
  */
 type TrainLimits = { base: Capacity; tolerance: OverageTolerance };
 
+/**
+ * Result of the export whole-booking single-train space check. `scheduleId`
+ * is the earliest fillable train that carries the whole booking, or null when
+ * none can — then `bestAvailable` reports the largest single-train leftover
+ * in the booking's own units and `fullMessage` is the customer-facing copy.
+ */
+export interface ExportSpaceReport {
+  scheduleId: string | null;
+  trainsForDay: boolean;
+  corridorMatched: boolean;
+  need: Capacity;
+  bestAvailable: { wagons: number; cargoTons: number } | null;
+  fullMessage: string | null;
+}
+
 /** A day-level pool key: all trains on this route departing on this EAT day. */
 interface RouteDayGroup {
   originYardId: string;
@@ -241,15 +264,10 @@ export interface BatchBoardSchedule {
   bookings: BatchBoardBooking[];
 }
 
-/** Paginated batch-board list. `items` (not `data`) — the API response wrapper
- * already uses `data`, and the frontend's unwrap() strips one `data` level. */
-export interface BatchBoardListResponse {
-  items: BatchBoardSchedule[];
-  total: number;
-  page: number;
-  pageSize: number;
-  totalPages: number;
-}
+/** Paginated batch-board list in the shared `{items, meta}` envelope — the API
+ * response wrapper already uses `data`, and the frontend's unwrap() strips one
+ * `data` level. */
+export type BatchBoardListResponse = PaginatedResponse<BatchBoardSchedule>;
 
 /**
  * Demand-batching engine: every 3h (EAT) it ranks each OPEN schedule's ready pool
@@ -514,6 +532,7 @@ export class BookingBatchService implements OnModuleInit {
         `Wagon allocation issue for ${booking.reference ?? bookingId}: ${issue?.issue ?? issue?.status}`,
       );
     }
+    this.notifyBoardChanged(booking.trainScheduleId, "booking_paid_allocated");
   }
 
   /** Customer paid — delegate to ensurePaidBookingAllocated. */
@@ -542,12 +561,18 @@ export class BookingBatchService implements OnModuleInit {
   // ---- export FCFS -----------------------------------------------------------
 
   /**
-   * Export is first-come-first-serve: no window cycle, no priority, no batch.
-   * Pick the earliest open export train on the booking's corridor/day that still
-   * fits the booking. Throws ConflictException when every train is full — the
-   * staff accept fails and no more export bookings are taken.
+   * Whole-booking single-train space report for an EXPORT booking. Export
+   * bookings never split — the entire booking must ride ONE train, so the
+   * report scans every fillable export train on the booking's corridor/day
+   * (earliest first) for one whose remaining budget fits the whole need. When
+   * none fits, `bestAvailable` carries the largest single-train leftover
+   * converted into the booking's own units (base caps, no overage tolerance)
+   * so the customer can be told exactly how much he COULD book on that day.
    */
-  async pickExportSchedule(booking: Booking, need?: Capacity): Promise<string> {
+  async exportSpaceReport(
+    booking: Booking,
+    need?: Capacity,
+  ): Promise<ExportSpaceReport> {
     if (!booking.scheduledDate) {
       throw new BadRequestException('Booking has no scheduled date');
     }
@@ -573,15 +598,19 @@ export class BookingBatchService implements OnModuleInit {
         (a, b) =>
           a.scheduledDepartureDate.getTime() - b.scheduledDepartureDate.getTime(),
       );
-    if (!candidates.length) {
-      throw new ConflictException(
-        'No export train is accepting bookings for this day',
-      );
-    }
 
     const wagonDims = await this.loadWagonDims();
     const required = need ?? this.needFor(booking, wagonDims);
-    let corridorMatched = false;
+    const dims = this.dimsFor(booking, wagonDims);
+    const report: ExportSpaceReport = {
+      scheduleId: null,
+      trainsForDay: candidates.length > 0,
+      corridorMatched: false,
+      need: required,
+      bestAvailable: null,
+      fullMessage: null,
+    };
+
     for (const candidate of candidates) {
       const schedule = await this.trainSchedulesRepository.findByIdWithFullGraph(
         candidate.id,
@@ -592,15 +621,101 @@ export class BookingBatchService implements OnModuleInit {
       const budget = await this.remainingBudget(schedule, limits, wagonDims);
       const leg = budget.legOf(booking.originYardId, booking.destinationYardId);
       if (!leg) continue; // this train's route doesn't carry the booking's leg
-      corridorMatched = true;
-      if (budget.fits(required, leg)) return schedule.id;
+      report.corridorMatched = true;
+      if (budget.fits(required, leg)) {
+        // Earliest fitting train wins — no need to keep sizing leftovers.
+        report.scheduleId = schedule.id;
+        return report;
+      }
+      const available = this.bookableWithin(budget.remainingFor(leg), dims);
+      if (
+        !report.bestAvailable ||
+        available.cargoTons > report.bestAvailable.cargoTons ||
+        (available.cargoTons === report.bestAvailable.cargoTons &&
+          available.wagons > report.bestAvailable.wagons)
+      ) {
+        report.bestAvailable = available;
+      }
     }
-    if (!corridorMatched) {
-      throw new ConflictException(
-        'No export train is accepting bookings for this day',
+
+    report.fullMessage = this.exportFullMessage(booking, report);
+    return report;
+  }
+
+  /**
+   * Largest booking (in the requester's own wagon-type units) that a single
+   * train's leftover base capacity could still admit: bounded by free wagon
+   * slots, free train length, and the locomotive's remaining pull weight
+   * (gross — each wagon's tare eats into it before any cargo does).
+   */
+  private bookableWithin(
+    remaining: Capacity,
+    dims: PerWagonDims,
+  ): { wagons: number; cargoTons: number } {
+    const byLength =
+      dims.lengthMeters > 0
+        ? Math.floor(Math.max(0, remaining.lengthMeters) / dims.lengthMeters)
+        : Math.floor(Math.max(0, remaining.wagons));
+    const maxWagons = Math.max(
+      0,
+      Math.min(Math.floor(Math.max(0, remaining.wagons)), byLength),
+    );
+    let bestTons = 0;
+    let usableWagons = 0;
+    for (let w = 1; w <= maxWagons; w++) {
+      if (w * dims.tareWeightTons > remaining.weightTons) break;
+      usableWagons = w;
+      const tons = Math.min(
+        w * dims.capacityTons,
+        remaining.weightTons - w * dims.tareWeightTons,
+      );
+      if (tons > bestTons) bestTons = tons;
+    }
+    return {
+      wagons: usableWagons,
+      cargoTons: Math.max(0, Math.floor(bestTons * 1000) / 1000),
+    };
+  }
+
+  /** Customer-facing "train is full" copy carrying the bookable leftover. */
+  private exportFullMessage(booking: Booking, report: ExportSpaceReport): string {
+    if (!report.trainsForDay || !report.corridorMatched) {
+      return 'No export train is accepting bookings for this day';
+    }
+    const best = report.bestAvailable;
+    const base =
+      'Not enough train space — an export booking must ride a single train whole, ' +
+      'and no open train on this day can carry it. ';
+    if (!best || best.wagons <= 0) {
+      return base + 'No capacity is left on this day — pick another shipment day.';
+    }
+    if (booking.freightType === 'BULK') {
+      return (
+        base +
+        `The largest remaining space is about ${best.cargoTons} tons ` +
+        `(${best.wagons} wagon${best.wagons === 1 ? '' : 's'}) — book up to that amount or pick another day.`
       );
     }
-    throw new ConflictException('Train is full — no export capacity left for this day');
+    return (
+      base +
+      `The largest remaining space is ${best.wagons} wagon${best.wagons === 1 ? '' : 's'} ` +
+      `(up to ${best.wagons * 2} × 20ft or ${best.wagons} × 40ft, weight permitting) — ` +
+      'reduce the booking or pick another day.'
+    );
+  }
+
+  /**
+   * Export is first-come-first-serve: no window cycle, no priority, no batch.
+   * Pick the earliest open export train on the booking's corridor/day that still
+   * fits the booking. Throws ConflictException when every train is full — the
+   * staff accept fails and no more export bookings are taken.
+   */
+  async pickExportSchedule(booking: Booking, need?: Capacity): Promise<string> {
+    const report = await this.exportSpaceReport(booking, need);
+    if (report.scheduleId) return report.scheduleId;
+    throw new ConflictException(
+      report.fullMessage ?? 'Train is full — no export capacity left for this day',
+    );
   }
 
   /**
@@ -652,6 +767,7 @@ export class BookingBatchService implements OnModuleInit {
     if (schedule && (await this.isTrainFull(schedule))) {
       await this.setWindow(scheduleId, 'FULL');
     }
+    this.notifyBoardChanged(scheduleId, 'export_booking_accepted');
   }
 
   /** Link PAID bookings that have no train_schedule_bookings row (cron backstop). */
@@ -664,6 +780,9 @@ export class BookingBatchService implements OnModuleInit {
         `Reconciled PAID booking ${booking.reference ?? booking.id} → schedule ${scheduleId}`,
       );
     }
+    if (unlinked.length > 0) {
+      this.notifyBoardChanged(scheduleId, "paid_reconciled");
+    }
   }
 
   // ---- legacy fill entry point ----------------------------------------------
@@ -700,8 +819,11 @@ export class BookingBatchService implements OnModuleInit {
   async getBatchBoard(
     query: BatchBoardQueryDto = {},
   ): Promise<BatchBoardListResponse> {
-    const page = query.page ?? 1;
-    const pageSize = query.pageSize ?? 12;
+    // Board cards are heavy (per-schedule booking summaries), so the default
+    // page is smaller than the toolkit-wide 20.
+    const { page, pageSize, skip, take } = normalizePagination(query, {
+      defaultPageSize: 12,
+    });
 
     // Status filter: any subset of the lifecycle. Omitted = all statuses, so
     // arrived / cancelled / dispatched schedules stay visible as history.
@@ -763,8 +885,8 @@ export class BookingBatchService implements OnModuleInit {
         route: { originYard: true, destinationYard: true, milestones: { yard: true } },
       },
       order: { [sortBy]: sortOrder } as never,
-      skip: (page - 1) * pageSize,
-      take: pageSize,
+      skip,
+      take,
     });
 
     const wagonDims = await this.loadWagonDims();
@@ -800,13 +922,7 @@ export class BookingBatchService implements OnModuleInit {
       board.push(this.buildScheduleSummary(s, items));
     }
 
-    return {
-      items: board,
-      total,
-      page,
-      pageSize,
-      totalPages: Math.max(1, Math.ceil(total / pageSize)),
-    };
+    return { items: board, meta: buildPaginationMeta(total, page, pageSize) };
   }
 
   /** Schedule-level batch board with EAT 3h windows grouped by fullyExecutedAt. */
@@ -1048,7 +1164,12 @@ export class BookingBatchService implements OnModuleInit {
 
   /** Run wagon-level allocation for all eligible linked bookings on a schedule. */
   async runWagonAllocation(scheduleId: string) {
-    return this.trainSchedulingService.tryAutoWagonAllocation(scheduleId);
+    const result =
+      await this.trainSchedulingService.tryAutoWagonAllocation(scheduleId);
+    if (result.assignedBookingIds.length > 0) {
+      this.notifyBoardChanged(scheduleId, "wagon_allocation_run");
+    }
+    return result;
   }
 
   /**
@@ -1070,9 +1191,11 @@ export class BookingBatchService implements OnModuleInit {
     maxWagons: number | null,
   ): BatchBoardSchedule["capacity"] {
     const allocated = items.filter((i) => i.state === "ALLOCATED");
-    const committed = items.filter(
-      (i) => i.state === "ALLOCATED" || i.state === "SELECTED_FOR_BATCH",
-    );
+    // Every booking still targeting this train holds gross weight — including
+    // PAID ones waiting for wagon allocation (WAITING) and post-dispatch
+    // catch-all states. Counting only ALLOCATED + SELECTED_FOR_BATCH zeroed the
+    // board's weight the moment customers paid. Only EXPIRED released its hold.
+    const committed = items.filter((i) => i.state !== "EXPIRED");
     const caps = loco
       ? trainHardCaps({
           maxPullWeightTons: Number(loco.maxPullWeightTons),
@@ -1218,6 +1341,7 @@ export class BookingBatchService implements OnModuleInit {
     this.resortPoolByPriority(pool);
     const units = this.groupConsolidatedPool(pool);
     let armed = false;
+    let preempted = false;
     let reservedThisPass = 0;
     let commercialReserved = 0;
 
@@ -1256,6 +1380,7 @@ export class BookingBatchService implements OnModuleInit {
             budget,
             wagonDims,
           );
+          preempted = true;
           if (!freed) continue; // still doesn't fit even after preempt
         } else {
           // Doesn't fit whole. A split-eligible import booking is offered the part
@@ -1304,6 +1429,10 @@ export class BookingBatchService implements OnModuleInit {
     );
     if (budget.isExhausted(minPerWagon)) await this.setWindow(scheduleId, "FULL");
     if (armed) this.armSettle(scheduleId);
+    // One push per fill pass (never per booking) — only when rows changed.
+    if (reservedThisPass > 0 || armed || preempted) {
+      this.notifyBoardChanged(scheduleId, "batch_fill");
+    }
     void this.triggerWagonAllocation(scheduleId);
     return commercialReserved;
   }
@@ -1404,8 +1533,13 @@ export class BookingBatchService implements OnModuleInit {
 
     const wagonDims = await this.loadWagonDims();
 
-    // Live per-schedule corridor budget + arm flag, in departure order.
-    const trains: Array<{ id: string; budget: CorridorBudget; armed: boolean }> = [];
+    // Live per-schedule corridor budget + arm/changed flags, in departure order.
+    const trains: Array<{
+      id: string;
+      budget: CorridorBudget;
+      armed: boolean;
+      changed: boolean;
+    }> = [];
     for (const id of scheduleIds) {
       const schedule =
         await this.trainSchedulesRepository.findByIdWithFullGraph(id);
@@ -1419,7 +1553,7 @@ export class BookingBatchService implements OnModuleInit {
       const limits = await this.capacityLimits(locomotive);
       await this.syncScheduleMaxWagons(schedule, locomotive);
       const budget = await this.remainingBudget(schedule, limits, wagonDims);
-      trains.push({ id, budget, armed: false });
+      trains.push({ id, budget, armed: false, changed: false });
     }
     if (trains.length === 0) return { scheduleIds, commercialReserved: 0 };
 
@@ -1492,6 +1626,9 @@ export class BookingBatchService implements OnModuleInit {
             t.budget,
             wagonDims,
           );
+          // Preempt may have displaced (expired) victims even when the need
+          // still doesn't fit — the board must refresh either way.
+          t.changed = true;
           if (freed) {
             target = t;
             break;
@@ -1536,6 +1673,7 @@ export class BookingBatchService implements OnModuleInit {
           commercialReserved += 1;
         }
         target.budget.subtract(need, legOn(target)!);
+        target.changed = true;
         reservedThisPass += 1;
       } catch (err) {
         this.logger.error(
@@ -1553,6 +1691,10 @@ export class BookingBatchService implements OnModuleInit {
     for (const t of trains) {
       if (t.budget.isExhausted(minPerWagon)) await this.setWindow(t.id, "FULL");
       if (t.armed) this.armSettle(t.id);
+      // One push per touched train per pass (never per booking). `armed` covers
+      // commercial reserves + partial offers; `changed` covers gov allocations
+      // and preemption.
+      if (t.armed || t.changed) this.notifyBoardChanged(t.id, "batch_fill");
       void this.triggerWagonAllocation(t.id);
     }
 
@@ -1799,6 +1941,10 @@ export class BookingBatchService implements OnModuleInit {
           `— payment phase extended for them`,
       );
     }
+    // Emitted here (not in settleDueReservations/settleBatch, which both wrap
+    // this) so one settle produces one push, after every allocation/expiry/
+    // top-up extension for this schedule has been persisted.
+    this.notifyBoardChanged(scheduleId, "reservations_settled");
     return true;
   }
 
@@ -1851,6 +1997,21 @@ export class BookingBatchService implements OnModuleInit {
       );
   }
 
+  /**
+   * Announce that a schedule's batch-board data changed so open boards refetch.
+   * Called AFTER the state change is persisted; a push failure only logs — it
+   * must never break the business transaction that triggered it.
+   */
+  private notifyBoardChanged(scheduleId: string, reason: string): void {
+    try {
+      this.bookingWindowGateway.emitBatchChanged(scheduleId, reason);
+    } catch (err) {
+      this.logger.warn(
+        `Batch-board push (${reason}) failed for ${scheduleId}: ${(err as Error).message}`,
+      );
+    }
+  }
+
   // ---- staff override actions ----------------------------------------------
 
   /** Staff "mark paid" override → set PAID and allocate immediately (don't wait for settle). */
@@ -1876,6 +2037,7 @@ export class BookingBatchService implements OnModuleInit {
       await this.setWindow(booking.trainScheduleId, "FULL");
     }
     void this.triggerWagonAllocation(booking.trainScheduleId!);
+    this.notifyBoardChanged(booking.trainScheduleId, "booking_marked_paid");
   }
 
   /**
@@ -1910,6 +2072,7 @@ export class BookingBatchService implements OnModuleInit {
       );
     }
 
+    const sourceScheduleId = booking.trainScheduleId ?? null;
     await this.dataSource.transaction(async (manager) => {
       if (booking.trainScheduleId) {
         await this.trainScheduleBookingsRepository.deleteByScheduleAndBooking(
@@ -1932,6 +2095,11 @@ export class BookingBatchService implements OnModuleInit {
         selectedForBatchAt: null,
       } as never);
     });
+    // Both boards changed: the booking left the source train and joined the target.
+    if (sourceScheduleId && sourceScheduleId !== newScheduleId) {
+      this.notifyBoardChanged(sourceScheduleId, "booking_moved");
+    }
+    this.notifyBoardChanged(newScheduleId, "booking_moved");
   }
 
   /** Staff "expire" override → free a reservation now (booking becomes EXPIRED). */
@@ -1949,6 +2117,8 @@ export class BookingBatchService implements OnModuleInit {
       if (topUpReserved > 0) {
         await this.extendPaymentPhaseForTopUp(freedScheduleId);
       }
+      // After the top-up + phase extension so one push carries the final state.
+      this.notifyBoardChanged(freedScheduleId, "reservation_expired");
     }
   }
 
@@ -1988,10 +2158,12 @@ export class BookingBatchService implements OnModuleInit {
         .update(booking.id, { trainScheduleId: scheduleId });
       booking.trainScheduleId = scheduleId;
       await this.allocate(scheduleId, booking, 'gov');
+      this.notifyBoardChanged(scheduleId, 'intercity_accepted');
       return;
     }
     await this.reserve(booking, scheduleId);
     this.armSettle(scheduleId);
+    this.notifyBoardChanged(scheduleId, 'intercity_accepted');
   }
 
   // ---- mutations ------------------------------------------------------------
@@ -2088,7 +2260,7 @@ export class BookingBatchService implements OnModuleInit {
     this.logger.log(
       `[BATCH] ALLOCATED ${booking.reference} (${reason}) to train on schedule ${scheduleId}`,
     );
-    this.notifier.secured(booking, reason);
+    this.notifier.secured(booking, reason, scheduleId);
     void this.triggerWagonAllocation(scheduleId);
     void this.markWagonAllocatedMilestone(booking.id);
     // Customer tracking: freight payment settled (commercial pay-window path).
@@ -2254,7 +2426,12 @@ export class BookingBatchService implements OnModuleInit {
           day,
         );
     const leftovers = pool.filter((b) => !b.isGovernment);
+    // Capture pinned schedules BEFORE expire() clears trainScheduleId, so each
+    // touched board gets exactly one push at the end of the sweep.
+    const touchedScheduleIds = new Set<string>();
+    if (leftovers.length) touchedScheduleIds.add(scheduleId);
     for (const booking of leftovers) {
+      if (booking.trainScheduleId) touchedScheduleIds.add(booking.trainScheduleId);
       await this.expire(booking, "no-capacity");
     }
     if (leftovers.length) {
@@ -2263,6 +2440,9 @@ export class BookingBatchService implements OnModuleInit {
           `expired ${leftovers.length} waiting booking(s)`,
       );
     }
+    for (const id of touchedScheduleIds) {
+      this.notifyBoardChanged(id, "day_pool_expired");
+    }
     return leftovers.length;
   }
 
@@ -2325,7 +2505,12 @@ export class BookingBatchService implements OnModuleInit {
           `on ${group.originYardId}->${group.destinationYardId} ${group.day}`,
       );
     }
+    // Only bookings pinned to a train show on a board — collect their schedules
+    // and push once per schedule after the sweep (most unaccepted rows are
+    // unpinned under day-level pooling, so this usually emits nothing).
+    const touchedScheduleIds = new Set<string>();
     for (const booking of unaccepted) {
+      if (booking.trainScheduleId) touchedScheduleIds.add(booking.trainScheduleId);
       await this.bookingsRepository.update(booking.id, {
         status: "EXPIRED",
         schedulingStatus: "ELIGIBLE",
@@ -2342,6 +2527,9 @@ export class BookingBatchService implements OnModuleInit {
         `[BATCH] EXPIRED (unaccepted) ${booking.reference}:${booking.id} at doc-review end`,
       );
     }
+    for (const id of touchedScheduleIds) {
+      this.notifyBoardChanged(id, "unaccepted_expired");
+    }
   }
 
   /**
diff --git a/apps/edr-freight-api/src/modules/train-scheduling/booking-notifier.service.ts b/apps/edr-freight-api/src/modules/train-scheduling/booking-notifier.service.ts
index edd807152..f3d7697f6 100644
--- a/apps/edr-freight-api/src/modules/train-scheduling/booking-notifier.service.ts
+++ b/apps/edr-freight-api/src/modules/train-scheduling/booking-notifier.service.ts
@@ -9,6 +9,7 @@ import {
 import { Booking } from '../bookings/entities/booking.entity';
 import { NotificationsService } from '../notifications/notifications.service';
 import { NotificationInboxService } from '../notification-inbox/notification-inbox.service';
+import { TrainSchedulesRepository } from '../train-schedules/train-schedules.repository';
 import { BATCH_TIMEZONE } from './booking-batch.constants';
 
 @Injectable()
@@ -18,8 +19,37 @@ export class BookingNotifierService {
   constructor(
     private readonly notifications: NotificationsService,
     private readonly inbox: NotificationInboxService,
+    private readonly trainSchedules: TrainSchedulesRepository,
   ) {}
 
+  /**
+   * Human-readable description of a train schedule for customer messages:
+   * reference (or train number) + route + departure date. Never leaks a UUID —
+   * falls back to a generic phrase when the schedule can't be loaded.
+   */
+  private async scheduleLabel(scheduleId?: string | null): Promise<string> {
+    const fallback = 'your selected train';
+    if (!scheduleId) return fallback;
+    try {
+      const s = await this.trainSchedules.findByIdWithStations(scheduleId);
+      if (!s) return fallback;
+      const ref = s.reference ?? s.trainNumber ?? null;
+      const route =
+        s.originStation?.label && s.destinationStation?.label
+          ? ` (${s.originStation.label} → ${s.destinationStation.label})`
+          : '';
+      const departure = s.scheduledDepartureDate
+        ? `, departing ${new Date(s.scheduledDepartureDate).toLocaleDateString('en-GB', { timeZone: BATCH_TIMEZONE })}`
+        : '';
+      return ref ? `train ${ref}${route}${departure}` : `${fallback}${route}${departure}`;
+    } catch (err) {
+      this.logger.warn(
+        `scheduleLabel(${scheduleId}) failed: ${(err as Error).message}`,
+      );
+      return fallback;
+    }
+  }
+
   private ref(b: Booking): string {
     return `${b.reference}${b.isGovernment ? ' (gov)' : ''}`;
   }
@@ -127,12 +157,15 @@ export class BookingNotifierService {
     });
   }
 
-  secured(b: Booking, reason: 'paid' | 'gov'): void {
-    const msg = `Booking ${b.reference ?? b.id} allocated on train schedule ${b.trainScheduleId ?? ''}${
-      reason === 'gov' ? ' (government)' : ''
-    }.`;
-    void this.notifyContact(b, msg, 'ALLOCATED');
-    this.inApp(b, 'Wagon allocated', msg);
+  secured(b: Booking, reason: 'paid' | 'gov', scheduleId?: string | null): void {
+    void (async () => {
+      const label = await this.scheduleLabel(scheduleId ?? b.trainScheduleId);
+      const msg = `Booking ${b.reference ?? b.id} allocated on ${label}${
+        reason === 'gov' ? ' (government)' : ''
+      }.`;
+      void this.notifyContact(b, msg, 'ALLOCATED');
+      this.inApp(b, 'Wagon allocated', msg);
+    })();
   }
 
   expired(b: Booking): void {
diff --git a/apps/edr-freight-api/src/modules/train-scheduling/booking-split.service.spec.ts b/apps/edr-freight-api/src/modules/train-scheduling/booking-split.service.spec.ts
index 6d706c423..fc47d8a70 100644
--- a/apps/edr-freight-api/src/modules/train-scheduling/booking-split.service.spec.ts
+++ b/apps/edr-freight-api/src/modules/train-scheduling/booking-split.service.spec.ts
@@ -6,11 +6,12 @@ import { Contract } from '../contracts/entities/contract.entity';
 import { BookingBatchOffer } from './entities/booking-batch-offer.entity';
 
 /**
- * applySplit promotion behaviour: a ONE_TIME contract must be flipped to GENERAL
- * (both the parent contract row and the booking's denormalized copy) so the split
- * remainder can be rebooked. A GENERAL booking is left untouched.
+ * applySplit split-marking behaviour: the reduced booking is flagged is_split
+ * and keeps a pre_split_quantities snapshot (the remainder ledger for ONE_TIME
+ * contracts). The contract kind is NEVER changed — a ONE_TIME contract stays
+ * ONE_TIME through the split chain.
  */
-describe('BookingSplitService — applySplit ONE_TIME promotion', () => {
+describe('BookingSplitService — applySplit split marking', () => {
   const bookingId = 'bk-1';
   const contractId = 'ct-1';
   const offerId = 'of-1';
@@ -34,6 +35,7 @@ describe('BookingSplitService — applySplit ONE_TIME promotion', () => {
         id: bookingId,
         contractId,
         contractKind: bookingContractKind,
+        cargoTotalWeightVgm: 50,
       }),
       find: jest.fn().mockResolvedValue([]),
       softDelete: jest.fn().mockResolvedValue(undefined),
@@ -76,22 +78,35 @@ describe('BookingSplitService — applySplit ONE_TIME promotion', () => {
     return { service, bookingRepo, contractRepo };
   };
 
-  it('promotes a ONE_TIME booking + parent contract to GENERAL', async () => {
-    const { service, bookingRepo, contractRepo } = buildService('ONE_TIME');
+  it('flags the reduced booking is_split with a pre-split bulk snapshot', async () => {
+    const { service, bookingRepo } = buildService('ONE_TIME');
 
     await service.applySplit(bookingId);
 
     expect(bookingRepo.update).toHaveBeenCalledWith(
       bookingId,
-      expect.objectContaining({ contractKind: 'GENERAL' }),
-    );
-    expect(contractRepo.update).toHaveBeenCalledWith(
-      contractId,
-      expect.objectContaining({ contractKind: 'GENERAL' }),
+      expect.objectContaining({
+        isSplit: true,
+        preSplitQuantities: { bulkTons: 50 },
+        cargoTotalWeightVgm: 30,
+        wagonsRequired: 3,
+      }),
     );
   });
 
-  it('leaves a GENERAL booking untouched (no contract promotion)', async () => {
+  it('never changes the contract kind — ONE_TIME stays ONE_TIME', async () => {
+    const { service, bookingRepo, contractRepo } = buildService('ONE_TIME');
+
+    await service.applySplit(bookingId);
+
+    expect(contractRepo.update).not.toHaveBeenCalled();
+    expect(bookingRepo.update).not.toHaveBeenCalledWith(
+      bookingId,
+      expect.objectContaining({ contractKind: expect.anything() }),
+    );
+  });
+
+  it('leaves a GENERAL contract untouched too', async () => {
     const { service, contractRepo } = buildService('GENERAL');
 
     await service.applySplit(bookingId);
diff --git a/apps/edr-freight-api/src/modules/train-scheduling/booking-split.service.ts b/apps/edr-freight-api/src/modules/train-scheduling/booking-split.service.ts
index ad0967cf0..9121e4841 100644
--- a/apps/edr-freight-api/src/modules/train-scheduling/booking-split.service.ts
+++ b/apps/edr-freight-api/src/modules/train-scheduling/booking-split.service.ts
@@ -9,7 +9,6 @@ import { BillingService } from '../billing/billing.service';
 import { Booking } from '../bookings/entities/booking.entity';
 import { BookingContainer } from '../bookings/entities/booking-container.entity';
 import { BookingContainerUnit } from '../bookings/entities/booking-container-unit.entity';
-import { Contract } from '../contracts/entities/contract.entity';
 import {
   BookingBatchOffer,
   OfferedLine,
@@ -34,11 +33,14 @@ export interface SizedOffer {
  * GENERAL and ONE_TIME commercial bookings are offered partials: the remainder
  * returns to the contract's quantity cap (derived live from booking_container
  * rows, so reducing the lines releases it automatically) and can be rebooked in
- * any later window within contract validity. A ONE_TIME contract is promoted to
- * GENERAL on split (see applySplit) so its remainder is actually rebookable.
- * Once the remainder is rebooked and the cap hits zero, ContractBookingService
- * completes the contract (CONTRACT_CLOSED): no further bookings or shipment
- * requests, even while validity and a booking window are still open.
+ * any later window within contract validity. The reduced booking is flagged
+ * is_split (see applySplit); the contract kind never changes. On a ONE_TIME
+ * contract a split booking releases the single-active-booking slot, but the
+ * next booking must take the WHOLE remainder — the split chain is the only way
+ * a ONE_TIME contract produces multiple bookings. Once the remainder is
+ * rebooked and the cap hits zero, ContractBookingService completes the
+ * contract (CONTRACT_CLOSED): no further bookings or shipment requests, even
+ * while validity and a booking window are still open.
  */
 @Injectable()
 export class BookingSplitService {
@@ -215,11 +217,26 @@ export class BookingSplitService {
     if (!offer) return;
 
     await this.dataSource.transaction(async (manager) => {
+      // Snapshot what the booking carried BEFORE the reduction: on a ONE_TIME
+      // contract this is the ledger the outstanding remainder is derived from
+      // (there is no contract quantity cap to fall back on).
+      const preSplit = await manager.getRepository(Booking).findOne({
+        where: { id: bookingId },
+        select: { id: true, cargoTotalWeightVgm: true },
+      });
+      const preSplitQuantities: { bulkTons?: number; bySize?: Record<string, number> } = {};
+
       if (offer.offeredLines?.length) {
         const keptByLine = new Map(offer.offeredLines.map((l) => [l.bookingContainerId, l]));
         const lines = await manager.getRepository(BookingContainer).find({
           where: { bookingId },
         });
+        const bySize: Record<string, number> = {};
+        for (const line of lines) {
+          const size = line.containerSize ?? '';
+          bySize[size] = (bySize[size] ?? 0) + Number(line.quantity ?? 0);
+        }
+        preSplitQuantities.bySize = bySize;
         for (const line of lines) {
           const kept = keptByLine.get(line.id);
           if (!kept) {
@@ -251,34 +268,24 @@ export class BookingSplitService {
             }
           }
         }
+      } else {
+        preSplitQuantities.bulkTons = Number(preSplit?.cargoTotalWeightVgm ?? 0);
       }
 
+      // is_split releases the ONE_TIME single-active-booking slot for the
+      // remainder (whole-remainder-only, enforced at booking creation) and
+      // switches the contract into remainder-based completion. The contract
+      // kind is NOT changed: a ONE_TIME contract stays ONE_TIME through the
+      // split chain.
       await manager.getRepository(Booking).update(bookingId, {
         wagonsRequired: offer.offeredWagons,
         cargoTotalWeightVgm: offer.offeredWeightTons,
         totalAmount: offer.offeredAmount,
         pricingBreakdown: offer.offeredPricingBreakdown,
+        isSplit: true,
+        preSplitQuantities,
       } as never);
 
-      // A ONE_TIME contract permits a single active booking, which would block the
-      // split remainder from ever being rebooked. Promote the parent contract (and
-      // the booking's denormalized copy) to GENERAL so the leftover quantity draws
-      // down against the cap like any general contract, within the same validity.
-      const booking = await manager.getRepository(Booking).findOne({
-        where: { id: bookingId },
-        select: { id: true, contractId: true, contractKind: true },
-      });
-      if (booking?.contractKind === 'ONE_TIME') {
-        await manager
-          .getRepository(Booking)
-          .update(bookingId, { contractKind: 'GENERAL' } as never);
-        if (booking.contractId) {
-          await manager
-            .getRepository(Contract)
-            .update(booking.contractId, { contractKind: 'GENERAL' } as never);
-        }
-      }
-
       await manager
         .getRepository(BookingBatchOffer)
         .update(offer.id, { status: 'APPLIED' });
diff --git a/apps/edr-freight-api/src/modules/train-scheduling/booking-window.gateway.ts b/apps/edr-freight-api/src/modules/train-scheduling/booking-window.gateway.ts
index 699471d90..69e60dd3a 100644
--- a/apps/edr-freight-api/src/modules/train-scheduling/booking-window.gateway.ts
+++ b/apps/edr-freight-api/src/modules/train-scheduling/booking-window.gateway.ts
@@ -1,6 +1,7 @@
 import {
   BOOKING_WINDOW_WS_EVENTS,
   BOOKING_WINDOW_WS_NAMESPACE,
+  type BatchBoardChangedEvent,
   type BookingWindowPhaseEvent,
 } from '@edr/types';
 import { Logger } from '@nestjs/common';
@@ -65,6 +66,20 @@ export class BookingWindowGateway implements OnGatewayConnection {
     this.server.emit(BOOKING_WINDOW_WS_EVENTS.PHASE, payload);
   }
 
+  /**
+   * Announce that a schedule's batch-board data changed (payment, allocation,
+   * fill, expiry, …). Broadcast namespace-wide like PHASE — the payload carries
+   * no board data, only the scheduleId; clients holding that board refetch.
+   */
+  emitBatchChanged(scheduleId: string, reason: string): void {
+    const payload: BatchBoardChangedEvent = {
+      scheduleId,
+      reason,
+      at: new Date().toISOString(),
+    };
+    this.server.emit(BOOKING_WINDOW_WS_EVENTS.BATCH_CHANGED, payload);
+  }
+
   private extractToken(socket: Socket): string | undefined {
     const authToken = socket.handshake.auth?.token as string | undefined;
     if (authToken) return authToken;
diff --git a/apps/edr-freight-api/src/modules/train-scheduling/booking-window.service.ts b/apps/edr-freight-api/src/modules/train-scheduling/booking-window.service.ts
index 25a7b1aed..d3405c951 100644
--- a/apps/edr-freight-api/src/modules/train-scheduling/booking-window.service.ts
+++ b/apps/edr-freight-api/src/modules/train-scheduling/booking-window.service.ts
@@ -153,6 +153,16 @@ export class BookingWindowService implements OnModuleInit {
         .update(s.id, { docReviewCompletedAt: now });
       s.docReviewCompletedAt = now;
       await this.advanceSchedule(s, effectiveWindowConfig(s, liveCfg), now);
+      // The batch fill emits only for trains it actually reserved onto — this
+      // covers the empty-pool case so every open board still refetches. Push
+      // failures only log; the doc-review completion itself already persisted.
+      try {
+        this.gateway.emitBatchChanged(s.id, 'doc_review_completed');
+      } catch (err) {
+        this.logger.warn(
+          `Batch-board push failed for ${s.id}: ${(err as Error).message}`,
+        );
+      }
     }
     const fresh = await this.trainSchedulesRepository.findById(scheduleId);
     return fresh ?? schedule;
diff --git a/apps/edr-freight-api/src/modules/train-scheduling/dto/batch-board-query.dto.ts b/apps/edr-freight-api/src/modules/train-scheduling/dto/batch-board-query.dto.ts
index 11bc8ceb5..d2a25d7b9 100644
--- a/apps/edr-freight-api/src/modules/train-scheduling/dto/batch-board-query.dto.ts
+++ b/apps/edr-freight-api/src/modules/train-scheduling/dto/batch-board-query.dto.ts
@@ -1,15 +1,7 @@
 import { ApiPropertyOptional } from '@nestjs/swagger';
-import { Type } from 'class-transformer';
-import {
-  IsIn,
-  IsInt,
-  IsISO8601,
-  IsOptional,
-  IsString,
-  Max,
-  MaxLength,
-  Min,
-} from 'class-validator';
+import { IsIn, IsISO8601, IsOptional, IsString } from 'class-validator';
+
+import { PaginationQueryDto } from '../../../common/dto/pagination-query.dto';
 
 export const BATCH_BOARD_STATUSES = [
   'DRAFT',
@@ -27,23 +19,13 @@ export const BATCH_BOARD_SORT_FIELDS = [
 ] as const;
 export type BatchBoardSortField = (typeof BATCH_BOARD_SORT_FIELDS)[number];
 
-/** Filters for the batch monitoring board list (import schedules, all statuses). */
-export class BatchBoardQueryDto {
-  @ApiPropertyOptional({ default: 1, minimum: 1 })
-  @IsOptional()
-  @Type(() => Number)
-  @IsInt()
-  @Min(1)
-  page?: number;
-
-  @ApiPropertyOptional({ default: 12, minimum: 1, maximum: 100 })
-  @IsOptional()
-  @Type(() => Number)
-  @IsInt()
-  @Min(1)
-  @Max(100)
-  pageSize?: number;
-
+/**
+ * Filters for the batch monitoring board list (import schedules, all statuses).
+ * `page`/`pageSize`/`search`/`sortOrder` come from the shared
+ * {@link PaginationQueryDto}; search matches train number, route yards,
+ * stations, or locomotive code (case-insensitive).
+ */
+export class BatchBoardQueryDto extends PaginationQueryDto {
   @ApiPropertyOptional({
     description:
       'Comma-separated schedule statuses (DRAFT,SCHEDULED,DISPATCHED,ARRIVED,CANCELLED). Omit for all.',
@@ -58,15 +40,6 @@ export class BatchBoardQueryDto {
   @IsIn(['OPEN', 'FULL', 'CLOSED'])
   bookingWindowStatus?: 'OPEN' | 'FULL' | 'CLOSED';
 
-  @ApiPropertyOptional({
-    description:
-      'Case-insensitive match on train number, route yards, stations, or locomotive code.',
-  })
-  @IsOptional()
-  @IsString()
-  @MaxLength(120)
-  search?: string;
-
   @ApiPropertyOptional({ description: 'Departure date lower bound (ISO 8601).' })
   @IsOptional()
   @IsISO8601()
@@ -91,9 +64,4 @@ export class BatchBoardQueryDto {
   @IsOptional()
   @IsIn(BATCH_BOARD_SORT_FIELDS as unknown as string[])
   sortBy?: BatchBoardSortField;
-
-  @ApiPropertyOptional({ enum: ['ASC', 'DESC'], default: 'DESC' })
-  @IsOptional()
-  @IsIn(['ASC', 'DESC'])
-  sortOrder?: 'ASC' | 'DESC';
 }
diff --git a/apps/edr-freight-api/src/modules/train-scheduling/dto/list-train-schedules-query.dto.ts b/apps/edr-freight-api/src/modules/train-scheduling/dto/list-train-schedules-query.dto.ts
new file mode 100644
index 000000000..7cc6b7115
--- /dev/null
+++ b/apps/edr-freight-api/src/modules/train-scheduling/dto/list-train-schedules-query.dto.ts
@@ -0,0 +1,64 @@
+import { ApiPropertyOptional } from '@nestjs/swagger';
+import { IsIn, IsOptional, IsUUID } from 'class-validator';
+
+import { PaginationQueryDto } from '../../../common/dto/pagination-query.dto';
+import {
+  TRAIN_SCHEDULE_STATUSES,
+  TrainScheduleStatus,
+} from '../../train-schedules/entities/train-schedule.entity';
+
+export const TRAIN_SCHEDULE_SORT_FIELDS = [
+  'createdAt',
+  'scheduledDepartureDate',
+  'reference',
+  'trainNumber',
+  'status',
+] as const;
+export type TrainScheduleSortField = (typeof TRAIN_SCHEDULE_SORT_FIELDS)[number];
+
+/**
+ * Schedules have no freight-type column — the type is DERIVED from the
+ * bookings aboard (see `resolveScheduleFreightType`): a single kind yields
+ * CONTAINER or BULK, both kinds yield MIXED, no bookings yield null (never
+ * matched by this filter).
+ */
+export const TRAIN_SCHEDULE_FREIGHT_TYPES = ['CONTAINER', 'BULK', 'MIXED'] as const;
+export type TrainScheduleFreightType = (typeof TRAIN_SCHEDULE_FREIGHT_TYPES)[number];
+
+/**
+ * Query for the train-schedule list (container/bulk boards). Pagination and
+ * free-text `search` come from the shared {@link PaginationQueryDto}; search
+ * matches schedule reference, train number, route yards, stations, or
+ * locomotive code (case-insensitive). The remaining fields are exact-match
+ * filters that the search never widens.
+ */
+export class ListTrainSchedulesQueryDto extends PaginationQueryDto {
+  @ApiPropertyOptional({ enum: TRAIN_SCHEDULE_SORT_FIELDS, default: 'createdAt' })
+  @IsOptional()
+  @IsIn(TRAIN_SCHEDULE_SORT_FIELDS as unknown as string[])
+  sortBy?: TrainScheduleSortField;
+
+  /** Lifecycle status (exact match). */
+  @ApiPropertyOptional({ enum: TRAIN_SCHEDULE_STATUSES })
+  @IsOptional()
+  @IsIn(TRAIN_SCHEDULE_STATUSES as unknown as string[])
+  status?: TrainScheduleStatus;
+
+  /** Derived freight type of the bookings aboard (exact match). */
+  @ApiPropertyOptional({ enum: TRAIN_SCHEDULE_FREIGHT_TYPES })
+  @IsOptional()
+  @IsIn(TRAIN_SCHEDULE_FREIGHT_TYPES as unknown as string[])
+  freightType?: TrainScheduleFreightType;
+
+  /** Origin station/yard id (exact match). */
+  @ApiPropertyOptional({ format: 'uuid' })
+  @IsOptional()
+  @IsUUID()
+  originStationId?: string;
+
+  /** Destination station/yard id (exact match). */
+  @ApiPropertyOptional({ format: 'uuid' })
+  @IsOptional()
+  @IsUUID()
+  destinationStationId?: string;
+}
diff --git a/apps/edr-freight-api/src/modules/train-scheduling/train-scheduling.controller.ts b/apps/edr-freight-api/src/modules/train-scheduling/train-scheduling.controller.ts
index fd41d4a29..4196e0972 100644
--- a/apps/edr-freight-api/src/modules/train-scheduling/train-scheduling.controller.ts
+++ b/apps/edr-freight-api/src/modules/train-scheduling/train-scheduling.controller.ts
@@ -41,6 +41,7 @@ import {
 import { AvailableLocomotivesQueryDto } from "./dto/available-locomotives-query.dto";
 import { BatchBoardQueryDto } from "./dto/batch-board-query.dto";
 import { BookableSchedulesQueryDto } from "./dto/bookable-schedules-query.dto";
+import { ListTrainSchedulesQueryDto } from "./dto/list-train-schedules-query.dto";
 import { AvailableDaysQueryDto } from "./dto/available-days-query.dto";
 import { AvailableDaysForCargoQueryDto } from "./dto/available-days-for-cargo-query.dto";
 import { UpdateTrainSchedulingGlobalRulesDto } from "./dto/update-train-scheduling-global-rules.dto";
@@ -743,16 +744,16 @@ export class TrainSchedulingController {
 
   @Get("container/schedules")
   @TrainSchedulingView()
-  @ApiOperation({ summary: "List container train schedules" })
-  getContainerTrainSchedules() {
-    return this.trainSchedulingService.getContainerTrainSchedules();
+  @ApiOperation({ summary: "List container train schedules (paginated)" })
+  getContainerTrainSchedules(@Query() query: ListTrainSchedulesQueryDto) {
+    return this.trainSchedulingService.getContainerTrainSchedules(query);
   }
 
   @Get("bulk/schedules")
   @TrainSchedulingView()
-  @ApiOperation({ summary: "List bulk train schedules" })
-  getBulkTrainSchedules() {
-    return this.trainSchedulingService.getContainerTrainSchedules();
+  @ApiOperation({ summary: "List bulk train schedules (paginated)" })
+  getBulkTrainSchedules(@Query() query: ListTrainSchedulesQueryDto) {
+    return this.trainSchedulingService.getContainerTrainSchedules(query);
   }
 
   @Get("container/schedules/:id")
diff --git a/apps/edr-freight-api/src/modules/train-scheduling/train-scheduling.service.ts b/apps/edr-freight-api/src/modules/train-scheduling/train-scheduling.service.ts
index eee880a6b..9e82bca33 100644
--- a/apps/edr-freight-api/src/modules/train-scheduling/train-scheduling.service.ts
+++ b/apps/edr-freight-api/src/modules/train-scheduling/train-scheduling.service.ts
@@ -4,6 +4,7 @@
   SchedulingStatus,
   TrainCheckpointKind,
   TrainScheduleStatus as TrainScheduleStatusEnum,
+  WagonAllocationSnapshot,
   WagonMovementKind,
   WagonStatus,
 } from '@edr/types';
@@ -17,8 +18,21 @@ import {
 } from '@nestjs/common';
 import { ConfigService } from '@nestjs/config';
 import { InjectDataSource } from '@nestjs/typeorm';
-import { DataSource, EntityManager, In, Not, QueryFailedError } from 'typeorm';
+import {
+  DataSource,
+  EntityManager,
+  FindOptionsWhere,
+  ILike,
+  In,
+  Not,
+  QueryFailedError,
+  Raw,
+} from 'typeorm';
 
+import {
+  buildPaginationMeta,
+  normalizePagination,
+} from '../../common/utils/pagination.util';
 import { BookingsRepository } from '../bookings/bookings.repository';
 import { Booking } from '../bookings/entities/booking.entity';
 import { BookingContainer } from '../bookings/entities/booking-container.entity';
@@ -50,6 +64,10 @@ import { CreateContainerTrainScheduleDto } from './dto/create-container-train-sc
 import { GetEligibleBookingsDto } from './dto/get-eligible-bookings.dto';
 import { GetEligibleBulkBookingsDto } from './dto/get-eligible-bulk-bookings.dto';
 import { GetEligibleContainerBookingsDto } from './dto/get-eligible-container-bookings.dto';
+import {
+  ListTrainSchedulesQueryDto,
+  TrainScheduleFreightType,
+} from './dto/list-train-schedules-query.dto';
 import { PinWagonsDto } from './dto/pin-wagons.dto';
 import { UpdateContainerItemDto } from './dto/update-container-item.dto';
 import { UpdateImportLoadingStatusDto } from './dto/update-import-loading-status.dto';
@@ -115,6 +133,8 @@ import {
   computeImportWindowTimes,
   earliestSchedulableDeparture,
   eatDay,
+  eatDayToUtc,
+  shiftEatDay,
 } from './batch-window.util';
 import { TrainCheckpointEvent } from './entities/train-checkpoint-event.entity';
 import { BookingJourneyService } from './booking-journey.service';
@@ -378,6 +398,142 @@ export class TrainSchedulingService {
     }
   }
 
+  /**
+   * A schedule GROUP is every schedule sharing an origin, destination, and EAT
+   * departure day — regardless of intermediate stops (ADD→DJ and ADD→DIRE→DJ
+   * group together, since the route entity keys only origin + destination). All
+   * schedules in a group must run ONE shared booking-window timeline so a
+   * customer booking on a later-created train is never expired by a sibling
+   * train's payment window closing on a different clock.
+   *
+   * Grouping keys off the columns the schedule already carries — no new schema.
+   * Callers pass a live `manager` so both the create (inside its transaction) and
+   * the update paths see uncommitted siblings.
+   */
+  private async findGroupSiblings(
+    manager: EntityManager,
+    originStationId: string,
+    destinationStationId: string,
+    departure: Date,
+    excludeScheduleId?: string,
+  ): Promise<TrainSchedule[]> {
+    const day = eatDay(departure);
+    const dayStart = eatDayToUtc(day, 0);
+    const nextDayStart = eatDayToUtc(shiftEatDay(day, 1), 0);
+    const qb = manager
+      .getRepository(TrainSchedule)
+      .createQueryBuilder('s')
+      .where('s.originStationId = :originStationId', { originStationId })
+      .andWhere('s.destinationStationId = :destinationStationId', { destinationStationId })
+      .andWhere('s.scheduledDepartureDate >= :dayStart', { dayStart })
+      .andWhere('s.scheduledDepartureDate < :nextDayStart', { nextDayStart });
+    if (excludeScheduleId) {
+      qb.andWhere('s.id != :excludeScheduleId', { excludeScheduleId });
+    }
+    return qb.getMany();
+  }
+
+  /**
+   * The window timeline a brand-new schedule must adopt to join its route+day
+   * group. Returns the canonical open/close times + rule snapshot copied from an
+   * existing sibling, or null when this is the first schedule in the group (the
+   * caller then computes its own times as before — nothing changes for the
+   * single-schedule case).
+   *
+   * The anchor is the sibling that best represents where the GROUP currently is
+   * on its shared clock, so a train created mid-cycle joins the group AT its
+   * current phase (with the group's exact doc-review / payment deadlines) instead
+   * of restarting the whole cycle on its own `now`. When the group has advanced
+   * past PRE_WINDOW we pick the MOST-ADVANCED live (non-DONE) sibling — that is
+   * the phase the joiner must adopt to see the same "N minutes left" the group
+   * already shows. When every sibling is still PRE_WINDOW we pick the
+   * earliest-opening one (the group's frozen open clock).
+   */
+  private async findGroupWindowAnchor(
+    manager: EntityManager,
+    originStationId: string,
+    destinationStationId: string,
+    departure: Date,
+  ): Promise<TrainSchedule | null> {
+    const siblings = await this.findGroupSiblings(
+      manager,
+      originStationId,
+      destinationStationId,
+      departure,
+    );
+    if (siblings.length === 0) return null;
+    const withWindow = siblings.filter((s) => s.windowOpensAt != null);
+    if (withWindow.length === 0) return null;
+
+    // A group whose window is live (some sibling has moved past PRE_WINDOW but is
+    // not yet DONE) — the joiner must land in that same phase on the same clock.
+    const PHASE_ORDER = ['PRE_WINDOW', 'OPEN', 'DOC_REVIEW', 'PAYMENT'];
+    const live = withWindow.filter(
+      (s) => s.windowPhase != null && PHASE_ORDER.includes(s.windowPhase) &&
+        s.windowPhase !== 'PRE_WINDOW',
+    );
+    if (live.length > 0) {
+      // Most-advanced phase leads; ties broken by earliest open for determinism.
+      return live.reduce((best, s) => {
+        const a = PHASE_ORDER.indexOf(s.windowPhase!);
+        const b = PHASE_ORDER.indexOf(best.windowPhase!);
+        if (a !== b) return a > b ? s : best;
+        return s.windowOpensAt!.getTime() < best.windowOpensAt!.getTime() ? s : best;
+      });
+    }
+
+    // Otherwise the whole group is still PRE_WINDOW — earliest-opening sibling
+    // defines the group clock (the one a customer would have seen first).
+    const pending = withWindow.filter((s) => s.windowPhase === 'PRE_WINDOW');
+    const pool = pending.length > 0 ? pending : withWindow;
+    return pool.reduce((earliest, s) =>
+      s.windowOpensAt!.getTime() < earliest.windowOpensAt!.getTime() ? s : earliest,
+    );
+  }
+
+  /**
+   * The full window state an anchor sibling hands down to a schedule JOINING its
+   * group. Copies not just the open/close times + frozen rule snapshot but the
+   * anchor's LIVE PHASE and every phase-end timestamp (docReviewEndsAt,
+   * paymentPhaseEndsAt, bookingCycleNo, bookingWindowStatus). This is what makes a
+   * train created mid-cycle show the EXACT SAME "N minutes left" as the rest of
+   * the group: it enters directly at the group's current phase with the group's
+   * shared payment deadline, instead of restarting PRE_WINDOW→…→PAYMENT on its own
+   * `now` and stamping its own later `paymentPhaseEndsAt`.
+   *
+   * `targetDeparture` is the JOINING schedule's own departure: every time is
+   * clamped to it so a group whose trains depart at different times of the same
+   * day never hands an earlier-departing train a deadline that outlives its
+   * departure (computeImport/ExportWindowTimes clamp to departure at source; this
+   * preserves that invariant when the anchor departed later).
+   */
+  private groupWindowFieldsFrom(anchor: TrainSchedule, targetDeparture: Date) {
+    const cap = targetDeparture.getTime();
+    const clamp = (d: Date | null | undefined): Date | null =>
+      d == null ? null : d.getTime() > cap ? targetDeparture : d;
+    return {
+      // Live phase + its deadlines — a mid-cycle joiner lands here directly.
+      windowPhase: anchor.windowPhase,
+      bookingWindowStatus:
+        anchor.bookingWindowStatus === 'FULL'
+          ? 'OPEN'
+          : anchor.bookingWindowStatus,
+      bookingCycleNo: anchor.bookingCycleNo,
+      windowOpensAt: clamp(anchor.windowOpensAt),
+      windowClosesAt: clamp(anchor.windowClosesAt),
+      docReviewEndsAt: clamp(anchor.docReviewEndsAt),
+      docReviewCompletedAt: clamp(anchor.docReviewCompletedAt),
+      paymentPhaseEndsAt: clamp(anchor.paymentPhaseEndsAt),
+      // Frozen rule snapshot.
+      ruleWindowOpenHour: anchor.ruleWindowOpenHour,
+      ruleWindowCloseHour: anchor.ruleWindowCloseHour,
+      ruleWindowDurationHours: anchor.ruleWindowDurationHours,
+      ruleReopenDelayMinutes: anchor.ruleReopenDelayMinutes,
+      ruleImportWindowLeadDays: anchor.ruleImportWindowLeadDays,
+      ruleExportBookingLeadHours: anchor.ruleExportBookingLeadHours,
+    };
+  }
+
   async getEligibleBookings(query: GetEligibleBookingsDto) {
     // Day-level pooling: when the wizard targets a schedule, surface the whole
     // (route, EAT day) pool — not just bookings pre-pinned to that train — by
@@ -544,15 +700,53 @@ export class TrainSchedulingService {
       );
     }
 
-    await this.dataSource.getRepository(TrainSchedule).update(id, {
-      windowOpensAt: times.windowOpensAt,
-      windowClosesAt: times.windowClosesAt,
-      ...windowRuleSnapshot(merged),
-    });
+    // Route+day grouping (IMPORT/DOMESTIC only): the override applies to the
+    // WHOLE group — every schedule sharing this origin + destination + EAT
+    // departure day. They all adopt the SAME rule snapshot and share the SAME
+    // window open/close timeline (the whole point of grouping). The shared times
+    // are clamped to each train's OWN departure so a group whose trains depart at
+    // different times of the same day never hands an earlier-departing sibling a
+    // window that outlives its departure. Only still-PRE_WINDOW siblings are
+    // touched — a sibling that has already opened, finalized, or dispatched stays
+    // frozen on the times its customers were shown and simply drops out of the
+    // group; the remaining pending trains stay in sync. EXPORT is excluded
+    // (departure-anchored FCFS window, no cross-expiry), so an export override
+    // only touches its own schedule.
+    const ruleFields = windowRuleSnapshot(merged);
+    const repo = this.dataSource.getRepository(TrainSchedule);
+    const cap = (d: Date, departure: Date): Date =>
+      d.getTime() > departure.getTime() ? departure : d;
+
+    const targets: Array<{ id: string; departure: Date }> = [
+      { id, departure: schedule.scheduledDepartureDate },
+    ];
+    if (schedule.direction !== 'EXPORT') {
+      const siblings = await this.findGroupSiblings(
+        this.dataSource.manager,
+        schedule.originStationId,
+        schedule.destinationStationId,
+        schedule.scheduledDepartureDate,
+        id,
+      );
+      for (const sib of siblings) {
+        if (sib.windowPhase === 'PRE_WINDOW' && sib.scheduledDepartureDate) {
+          targets.push({ id: sib.id, departure: sib.scheduledDepartureDate });
+        }
+      }
+    }
+
+    for (const t of targets) {
+      await repo.update(t.id, {
+        windowOpensAt: cap(times.windowOpensAt, t.departure),
+        windowClosesAt: cap(times.windowClosesAt, t.departure),
+        ...ruleFields,
+      });
+    }
     this.logger.log(
-      `Booking-window rule overridden for schedule ${id} — reopens ${times.windowOpensAt.toISOString()}`,
+      `Booking-window rule overridden for schedule ${id} and ${targets.length - 1} ` +
+        `route+day sibling(s) — reopens ${times.windowOpensAt.toISOString()}`,
     );
-    void this.emitWindowState(id);
+    for (const t of targets) void this.emitWindowState(t.id);
 
     const fresh = await this.trainSchedulesRepository.findById(id);
     return fresh ?? schedule;
@@ -617,14 +811,34 @@ export class TrainSchedulingService {
         ? computeExportWindowTimes(departure, merged)
         : computeImportWindowTimes(departure, merged, now);
 
+    // Moving the departure moves this train between route+day GROUPS. If the
+    // destination day already has a group (a sibling on the same origin +
+    // destination + new EAT day), adopt that group's shared timeline instead of
+    // the times just derived, so the rescheduled train lines up with the group
+    // it lands in rather than drifting onto its own clock. Otherwise it keeps its
+    // own re-derived times and becomes the anchor for that day. EXPORT is
+    // excluded — its window is anchored to its own departure, not shared.
+    const anchor =
+      schedule.direction === 'EXPORT'
+        ? null
+        : await this.findGroupWindowAnchor(
+            this.dataSource.manager,
+            schedule.originStationId,
+            schedule.destinationStationId,
+            departure,
+          );
+    const windowFields = anchor
+      ? this.groupWindowFieldsFrom(anchor, departure)
+      : { windowOpensAt: times.windowOpensAt, windowClosesAt: times.windowClosesAt };
+
     await this.dataSource.getRepository(TrainSchedule).update(id, {
       scheduledDepartureDate: departure,
-      windowOpensAt: times.windowOpensAt,
-      windowClosesAt: times.windowClosesAt,
+      ...windowFields,
     });
     this.logger.log(
       `Departure date changed for schedule ${id} → ${departure.toISOString()} ` +
-        `(window reopens ${times.windowOpensAt.toISOString()})`,
+        `(window reopens ${windowFields.windowOpensAt?.toISOString() ?? 'n/a'}` +
+        `${anchor ? `, joined route+day group anchor ${anchor.id}` : ''})`,
     );
     void this.emitWindowState(id);
 
@@ -837,21 +1051,44 @@ export class TrainSchedulingService {
       // already-open schedule keeps this snapshot, and the batch board draws its
       // windows from it rather than the live config.
       const ruleSnapshot = windowRuleSnapshot(windowCfg);
-      const windowFields =
+      // Route+day grouping (IMPORT/DOMESTIC only): if a schedule already exists
+      // on this origin + destination + EAT departure day, this new train JOINS
+      // its group and adopts the group's shared window timeline (open/close +
+      // frozen rule) verbatim — it does NOT compute its own `now`-based times.
+      // That keeps every train on the day advancing through the same open/
+      // doc-review/payment/close instants, so a booking on one train is never
+      // expired by a sibling train's payment window closing on a different clock.
+      // First train in the group falls through to the normal computation.
+      //
+      // EXPORT is excluded: an export window is a single FCFS window anchored to
+      // each train's OWN departure (windowClosesAt = departure) with no
+      // doc-review/payment phase — so there is no cross-expiry to fix, and two
+      // export trains departing the same day at different times must keep their
+      // own departure-anchored windows.
+      const groupAnchor =
         direction === 'EXPORT'
-          ? {
-              bookingWindowStatus: 'CLOSED',
-              windowPhase: 'PRE_WINDOW',
-              ...ruleSnapshot,
-              ...computeExportWindowTimes(departure, windowCfg),
-            }
+          ? null
+          : await this.findGroupWindowAnchor(
+              manager,
+              route.originYardId,
+              route.destinationYardId,
+              departure,
+            );
+      const computedTimes =
+        direction === 'EXPORT'
+          ? { ...ruleSnapshot, ...computeExportWindowTimes(departure, windowCfg) }
           : {
               // IMPORT and DOMESTIC share the import booking-day window cycle.
-              bookingWindowStatus: 'CLOSED',
-              windowPhase: 'PRE_WINDOW',
               ...ruleSnapshot,
               ...computeImportWindowTimes(departure, windowCfg, new Date()),
             };
+      const windowFields = {
+        bookingWindowStatus: 'CLOSED',
+        windowPhase: 'PRE_WINDOW',
+        ...(groupAnchor
+          ? this.groupWindowFieldsFrom(groupAnchor, departure)
+          : computedTimes),
+      };
       const maxWagons = (await this.resolveTrainLimitConfig(dto, limitLoco))
         .maxWagonsPerTrain;
       // Retry past a concurrent insert that grabbed the same S-<year> sequence
@@ -899,14 +1136,35 @@ export class TrainSchedulingService {
       throw new BadRequestException('Schedule has no train set');
     }
 
-    // Batch parity: a schedule may only allocate bookings that targeted it. This mirrors
-    // the automatic fill, which only pulls bookings whose train_schedule_id is this schedule.
+    // Batch parity: a schedule may only allocate bookings from its route-day POOL.
+    // Under day-level pooling (see fillRouteDayInternal) an unreserved booking has
+    // a NULL train_schedule_id and is only pinned by reserve(); a reserved one is
+    // pinned to whichever train in the day's group first held it. Every train
+    // sharing this origin + destination + EAT departure day draws from ONE shared
+    // pool (one shared booking window), so a booking is allocatable here when it is
+    // either unpinned (NULL) or pinned to THIS train or a GROUP SIBLING. A booking
+    // pinned to a train on a DIFFERENT route/day is a real stray. Genuine route/
+    // day/capacity fit is enforced downstream by validateBookingsForScheduling.
+    // EXPORT never groups, so its pool is this schedule alone (plus NULL pool).
     if (dto.bookingIds.length) {
+      const groupScheduleIds = new Set<string>([scheduleId]);
+      if (schedule.direction !== 'EXPORT') {
+        const siblings = await this.findGroupSiblings(
+          this.dataSource.manager,
+          schedule.originStationId,
+          schedule.destinationStationId,
+          schedule.scheduledDepartureDate,
+          scheduleId,
+        );
+        for (const sib of siblings) groupScheduleIds.add(sib.id);
+      }
       const targeted = await this.bookingsRepository.findByIdsForScheduling(dto.bookingIds);
-      const stray = targeted.filter((b) => b.trainScheduleId !== scheduleId);
+      const stray = targeted.filter(
+        (b) => b.trainScheduleId != null && !groupScheduleIds.has(b.trainScheduleId),
+      );
       if (stray.length) {
         throw new BadRequestException(
-          `These bookings are not assigned to this schedule: ${stray
+          `These bookings are pinned to a train on a different route or day: ${stray
             .map((b) => b.reference ?? b.id)
             .join(', ')}`,
         );
@@ -1150,9 +1408,13 @@ export class TrainSchedulingService {
 
       const booking = await this.bookingsRepository.findById(bookingId);
       const schedulingStatus = this.resolvePostUnassignStatus(booking);
+      // Clear the schedule pointer too: unassign fully detaches the booking from
+      // this train. Leaving trainScheduleId set glued the booking to a schedule
+      // that may then be dispatched/cancelled/deleted, orphaning it — the
+      // assign-bookings parity guard would reject it from every OTHER schedule.
       await this.bookingsRepository.updateSchedulingFields(
         bookingId,
-        { schedulingStatus, wagonsRequired: null },
+        { schedulingStatus, wagonsRequired: null, trainScheduleId: null },
         manager,
       );
 
@@ -1505,12 +1767,34 @@ export class TrainSchedulingService {
       await this.trainSchedulesRepository.updateStatus(
         scheduleId,
         TrainScheduleStatusEnum.Dispatched,
-        { actualDepartureAt: now, trainNumber },
+        {
+          actualDepartureAt: now,
+          trainNumber,
+          // Freeze the wagon plan the moment the train leaves the editable phase.
+          wagonAllocationSnapshot: this.buildWagonAllocationSnapshot(
+            schedule,
+            TrainScheduleStatusEnum.Dispatched,
+            now,
+          ),
+        },
         manager,
       );
       if (schedule.trainSetId) {
         await manager.getRepository(TrainSet).update(schedule.trainSetId, { status: 'DISPATCHED' });
       }
+      // The train is out — every pinned wagon is ASSIGNED to this schedule and
+      // stays pinned so no other schedule can pick it while it's rolling.
+      const dispatchedPhysicalIds = (schedule.trainSet?.wagons ?? [])
+        .map((slot) => slot.physicalWagonId)
+        .filter((id): id is string => Boolean(id));
+      if (dispatchedPhysicalIds.length) {
+        await manager
+          .getRepository(Wagon)
+          .update(
+            { id: In(dispatchedPhysicalIds) },
+            { status: WagonStatus.Assigned, currentTrainScheduleId: scheduleId },
+          );
+      }
       for (const sb of schedule.scheduleBookings ?? []) {
         await this.bookingsRepository.updateSchedulingFields(
           sb.bookingId,
@@ -1587,7 +1871,24 @@ export class TrainSchedulingService {
       );
     }
     void this.notifyScheduleBookings(schedule, 'dispatched');
-    return this.getTrainScheduleById(scheduleId);
+
+    const detail = await this.getTrainScheduleById(scheduleId);
+    // Surface a compact dispatch confirmation so the caller can toast the "train
+    // is out" info (train number, departure, wagons committed) without re-deriving it.
+    const dispatchedWagonCount = (schedule.trainSet?.wagons ?? []).filter(
+      (slot) => slot.physicalWagonId,
+    ).length;
+    return Object.assign(detail, {
+      dispatchInfo: {
+        // The real train number was assigned inside the txn — read it back off
+        // the persisted detail (schedule.trainNumber is the pre-dispatch value).
+        trainNumber: detail.trainNumber ?? schedule.trainNumber ?? null,
+        departedAt: now.toISOString(),
+        wagonsDispatched: dispatchedWagonCount,
+        originStationId: schedule.originStationId,
+        destinationStationId: schedule.destinationStationId,
+      },
+    });
   }
 
   async getImportDjiboutiOperation(scheduleId: string) {
@@ -2544,7 +2845,15 @@ export class TrainSchedulingService {
       await this.trainSchedulesRepository.updateStatus(
         scheduleId,
         TrainScheduleStatusEnum.Arrived,
-        { actualArrivalAt: now },
+        {
+          actualArrivalAt: now,
+          // Freeze the plan before the wagons below are released to their yards.
+          wagonAllocationSnapshot: this.buildWagonAllocationSnapshot(
+            schedule,
+            TrainScheduleStatusEnum.Arrived,
+            now,
+          ),
+        },
         manager,
       );
 
@@ -2641,8 +2950,42 @@ export class TrainSchedulingService {
     return Object.assign(detail, { warehouseAutomation });
   }
 
-  async getContainerTrainSchedules() {
-    const schedules = await this.trainSchedulesRepository.findAll({
+  async getContainerTrainSchedules(query: ListTrainSchedulesQueryDto = {}) {
+    const { page, pageSize, skip, take } = normalizePagination(query);
+
+    // Exact-match filters (enum/id semantics). Freight type is derived from
+    // the bookings aboard — no column to match — so it rides on `id` as an
+    // EXISTS fragment instead.
+    const base: FindOptionsWhere<TrainSchedule> = {};
+    if (query.status) base.status = query.status;
+    if (query.originStationId) base.originStationId = query.originStationId;
+    if (query.destinationStationId) base.destinationStationId = query.destinationStationId;
+    if (query.freightType) base.id = this.scheduleFreightTypeFilter(query.freightType) as never;
+
+    // Search fans out across every human-recognizable label; each OR variant
+    // repeats the base filters so the search never widens them.
+    const term = query.search?.trim();
+    let where: FindOptionsWhere<TrainSchedule> | FindOptionsWhere<TrainSchedule>[] =
+      base;
+    if (term) {
+      const like = ILike(`%${term}%`);
+      where = [
+        { ...base, reference: like as never },
+        { ...base, trainNumber: like as never },
+        { ...base, originStation: { label: like } },
+        { ...base, destinationStation: { label: like } },
+        { ...base, route: { originYard: { label: like } } },
+        { ...base, route: { destinationYard: { label: like } } },
+        { ...base, trainSet: { locomotive: { code: like } } },
+      ] as FindOptionsWhere<TrainSchedule>[];
+    }
+
+    // Newest-created first (the client can re-sort; this is the default order).
+    const sortBy = query.sortBy ?? 'createdAt';
+    const sortOrder = query.sortOrder ?? 'DESC';
+
+    const [schedules, total] = await this.trainSchedulesRepository.findAndCount({
+      where,
       relations: {
         trainSet: { locomotive: true, locomotives: { locomotive: true } },
         // Yards carry the route's display name used by mapScheduleListItem;
@@ -2652,10 +2995,14 @@ export class TrainSchedulingService {
         destinationStation: true,
         scheduleBookings: { booking: true },
       },
-      // Newest-created first (the client can re-sort; this is the default order).
-      order: { createdAt: 'DESC', scheduledDepartureDate: 'DESC' },
+      order: { [sortBy]: sortOrder } as never,
+      skip,
+      take,
     });
-    return schedules.map((s) => this.mapScheduleListItem(s));
+    return {
+      items: schedules.map((s) => this.mapScheduleListItem(s)),
+      meta: buildPaginationMeta(total, page, pageSize),
+    };
   }
 
   async getContainerTrainScheduleById(id: string) {
@@ -2668,13 +3015,24 @@ export class TrainSchedulingService {
       throw new NotFoundException(`Train schedule ${id} not found`);
     }
 
+    const now = new Date();
+
     await this.dataSource.transaction(async (manager) => {
       await this.trainSchedulesRepository.updateStatus(
         id,
         TrainScheduleStatusEnum.Cancelled,
-        // Retire the booking window so a canceled schedule never lingers as an
-        // "open window" in booking-window lists or the legacy batch fill.
-        { bookingWindowStatus: 'CLOSED', windowPhase: 'DONE' },
+        {
+          // Retire the booking window so a canceled schedule never lingers as an
+          // "open window" in booking-window lists or the legacy batch fill.
+          bookingWindowStatus: 'CLOSED',
+          windowPhase: 'DONE',
+          // Freeze the plan before the wagons below are released back to the yard.
+          wagonAllocationSnapshot: this.buildWagonAllocationSnapshot(
+            schedule,
+            TrainScheduleStatusEnum.Cancelled,
+            now,
+          ),
+        },
         manager,
       );
       if (schedule.trainSetId) {
@@ -2702,14 +3060,23 @@ export class TrainSchedulingService {
             currentTrainScheduleId: null,
             trainSetWagonId: null,
             status: WagonStatus.Available,
+            // A cancelled train never left — its wagons stay/return at the origin
+            // yard, free to be re-pinned onto another schedule from there.
+            currentYardId: schedule.originStationId,
           });
         }
       }
       for (const sb of schedule.scheduleBookings ?? []) {
         const booking = await this.bookingsRepository.findById(sb.bookingId);
+        // Detach from the cancelled schedule — clear the pointer so the freed
+        // booking can be assigned to another train. Leaving it set orphans the
+        // booking against a schedule that is about to be gone.
         await this.bookingsRepository.updateSchedulingFields(
           sb.bookingId,
-          { schedulingStatus: this.resolvePostUnassignStatus(booking) },
+          {
+            schedulingStatus: this.resolvePostUnassignStatus(booking),
+            trainScheduleId: null,
+          },
           manager,
         );
       }
@@ -3241,6 +3608,47 @@ export class TrainSchedulingService {
     }));
   }
 
+  /**
+   * Freeze the schedule's live wagon plan into a snapshot. Built from the fully
+   * hydrated graph (findByIdWithFullGraph) BEFORE the transition releases the
+   * physical wagons, so the historical allocation survives those wagons being
+   * re-pinned onto later trains. `capturedStatus` is the status being applied.
+   */
+  private buildWagonAllocationSnapshot(
+    schedule: TrainSchedule,
+    capturedStatus: TrainScheduleStatusEnum,
+    capturedAt: Date,
+  ): WagonAllocationSnapshot {
+    const slots = [...(schedule.trainSet?.wagons ?? [])]
+      .sort((a, b) => a.sequenceNo - b.sequenceNo)
+      .map((wagon) => ({
+        sequenceNo: wagon.sequenceNo,
+        trainSetWagonId: wagon.id,
+        physicalWagonId: wagon.physicalWagonId ?? null,
+        physicalWagonNumber: wagon.physicalWagon?.wagonNumber ?? null,
+        wagonTypeId: wagon.wagonTypeId ?? null,
+        wagonTypeCode: wagon.wagonType?.code ?? null,
+        slotStatus: wagon.status ?? null,
+        boardYardId: wagon.boardYardId ?? null,
+        alightYardId: wagon.alightYardId ?? null,
+        allocations: (wagon.allocations ?? []).map((allocation) => ({
+          bookingId: allocation.bookingId,
+          bookingReference: allocation.booking?.reference ?? null,
+          allocatedWeightTons: Number(allocation.allocatedWeightTons) || 0,
+          loadType: allocation.loadType ?? null,
+          containerNumbers: (allocation.containerItems ?? [])
+            .map((item) => item.containerNumber)
+            .filter((n): n is string => Boolean(n)),
+        })),
+      }));
+
+    return {
+      capturedStatus,
+      capturedAt: capturedAt.toISOString(),
+      slots,
+    };
+  }
+
   private async releasePinnedWagonsForTrainSet(manager: EntityManager, trainSetId: string) {
     const slots = await manager.getRepository(TrainSetWagon).find({ where: { trainSetId } });
     for (const slot of slots) {
@@ -3869,6 +4277,33 @@ export class TrainSchedulingService {
     };
   }
 
+  /**
+   * WHERE fragment matching the DERIVED schedule freight type — the SQL mirror
+   * of {@link resolveScheduleFreightType} (keep the two in sync). CONTAINER /
+   * BULK = has bookings and every one is that kind; MIXED = both kinds aboard.
+   * Schedules with no bookings (type null) match nothing. Applied to `id` so
+   * the list query stays on findAndCount instead of a query-builder rewrite.
+   */
+  private scheduleFreightTypeFilter(freightType: TrainScheduleFreightType) {
+    const hasBookingOfType = (alias: string, cmp: '=' | '<>', param: string) =>
+      'EXISTS (SELECT 1 FROM freight.train_schedule_bookings tsb ' +
+      'JOIN freight.bookings b ON b.id = tsb.booking_id AND b.deleted_at IS NULL ' +
+      `WHERE tsb.train_schedule_id = ${alias} AND tsb.deleted_at IS NULL ` +
+      `AND b.freight_type ${cmp} :${param})`;
+    if (freightType === 'MIXED') {
+      return Raw(
+        (alias) =>
+          `${hasBookingOfType(alias, '=', 'ftContainer')} AND ${hasBookingOfType(alias, '=', 'ftBulk')}`,
+        { ftContainer: 'CONTAINER', ftBulk: 'BULK' },
+      );
+    }
+    return Raw(
+      (alias) =>
+        `${hasBookingOfType(alias, '=', 'ftIs')} AND NOT ${hasBookingOfType(alias, '<>', 'ftNot')}`,
+      { ftIs: freightType, ftNot: freightType },
+    );
+  }
+
   private resolveScheduleFreightType(
     schedule: import('../train-schedules/entities/train-schedule.entity').TrainSchedule,
   ): 'CONTAINER' | 'BULK' | 'MIXED' | null {
@@ -4441,6 +4876,20 @@ export class TrainSchedulingService {
       bulkLoads.map((load) => [load.wagonBookingAllocationId, load]),
     );
 
+    // Once a schedule leaves DRAFT/SCHEDULED, its physical wagons are released
+    // and re-pinned onto later trains — the live wagon↔slot joins no longer
+    // describe THIS train. If a frozen snapshot was captured at the transition,
+    // the per-slot wagon number + booking allocations are read from it instead.
+    const snapshot = schedule.wagonAllocationSnapshot ?? null;
+    const isWagonAllocationFrozen = Boolean(
+      snapshot &&
+        schedule.status !== TrainScheduleStatusEnum.Draft &&
+        schedule.status !== TrainScheduleStatusEnum.Scheduled,
+    );
+    const snapshotSlotByTrainSetWagonId = new Map(
+      (snapshot?.slots ?? []).map((slot) => [slot.trainSetWagonId, slot]),
+    );
+
     return {
       id: schedule.id,
       reference: schedule.reference ?? null,
@@ -4523,52 +4972,84 @@ export class TrainSchedulingService {
             })),
             wagons: [...(schedule.trainSet.wagons ?? [])]
               .sort((a, b) => a.sequenceNo - b.sequenceNo)
-              .map((wagon) => ({
-                id: wagon.id,
-                sequenceNo: wagon.sequenceNo,
-                capacityTons: roundTons(Number(wagon.capacityTons)),
-                lengthMeters: roundTons(Number(wagon.lengthMeters)),
-                assignedWeightTons: roundTons(Number(wagon.assignedWeightTons)),
-                // Empty-wagon weight — the pull limit hauls tare + cargo, so the
-                // frontend needs it to show the gross train weight.
-                tareWeightTons: wagon.wagonType
-                  ? roundTons(Number(wagon.wagonType.tareWeightTons))
-                  : null,
-                status: wagon.status,
-                physicalWagonId: wagon.physicalWagonId ?? null,
-                physicalWagonNumber: wagon.physicalWagon?.wagonNumber ?? null,
-                wagonType: wagon.wagonType
-                  ? { id: wagon.wagonType.id, code: wagon.wagonType.code, name: wagon.wagonType.name }
-                  : null,
-                allocations:
-                  wagon.allocations?.map((allocation) => ({
-                    id: allocation.id,
-                    bookingId: allocation.bookingId,
-                    bookingReference: allocation.booking?.reference ?? null,
-                    allocatedWeightTons: roundTons(Number(allocation.allocatedWeightTons)),
-                    loadType: allocation.loadType ?? null,
-                    status: allocation.status,
-                    containerItems: (containerItemsByAllocation.get(allocation.id) ?? []).map(
-                      (item) => ({
-                        id: item.id,
-                        containerNumber: item.containerNumber ?? null,
-                        containerTypeId: item.containerTypeId,
-                        grossWeightTons: item.grossWeightTons ?? null,
-                        containerId: item.containerId ?? null,
-                        positionOnWagon: item.positionOnWagon ?? null,
-                        bookingContainerId: item.bookingContainerId ?? null,
-                      }),
-                    ),
-                    bulkLoad: bulkLoadsByAllocation.get(allocation.id)
-                      ? {
-                          id: bulkLoadsByAllocation.get(allocation.id)!.id,
-                          weightTons: bulkLoadsByAllocation.get(allocation.id)!.weightTons,
-                          cargoDescription:
-                            bulkLoadsByAllocation.get(allocation.id)!.cargoDescription ?? null,
-                        }
-                      : null,
-                  })) ?? [],
-              })),
+              .map((wagon) => {
+                // Frozen schedules read the wagon number + allocations from the
+                // snapshot slot; the immutable slot geometry (capacity/type) still
+                // comes live. Falls back to live if a slot is missing from the snap.
+                const frozenSlot = isWagonAllocationFrozen
+                  ? snapshotSlotByTrainSetWagonId.get(wagon.id)
+                  : undefined;
+                return {
+                  id: wagon.id,
+                  sequenceNo: wagon.sequenceNo,
+                  capacityTons: roundTons(Number(wagon.capacityTons)),
+                  lengthMeters: roundTons(Number(wagon.lengthMeters)),
+                  assignedWeightTons: roundTons(Number(wagon.assignedWeightTons)),
+                  // Empty-wagon weight — the pull limit hauls tare + cargo, so the
+                  // frontend needs it to show the gross train weight.
+                  tareWeightTons: wagon.wagonType
+                    ? roundTons(Number(wagon.wagonType.tareWeightTons))
+                    : null,
+                  status: wagon.status,
+                  physicalWagonId: frozenSlot
+                    ? frozenSlot.physicalWagonId
+                    : wagon.physicalWagonId ?? null,
+                  physicalWagonNumber: frozenSlot
+                    ? frozenSlot.physicalWagonNumber
+                    : wagon.physicalWagon?.wagonNumber ?? null,
+                  wagonType: wagon.wagonType
+                    ? { id: wagon.wagonType.id, code: wagon.wagonType.code, name: wagon.wagonType.name }
+                    : null,
+                  allocations: frozenSlot
+                    ? frozenSlot.allocations.map((allocation) => ({
+                        id: null,
+                        bookingId: allocation.bookingId,
+                        bookingReference: allocation.bookingReference,
+                        allocatedWeightTons: roundTons(allocation.allocatedWeightTons),
+                        loadType: allocation.loadType,
+                        status: null,
+                        // Frozen: container detail collapses to the captured numbers;
+                        // per-container geometry isn't re-derivable post-release.
+                        containerItems: allocation.containerNumbers.map((containerNumber) => ({
+                          id: null,
+                          containerNumber,
+                          containerTypeId: null,
+                          grossWeightTons: null,
+                          containerId: null,
+                          positionOnWagon: null,
+                          bookingContainerId: null,
+                        })),
+                        bulkLoad: null,
+                      }))
+                    : wagon.allocations?.map((allocation) => ({
+                        id: allocation.id,
+                        bookingId: allocation.bookingId,
+                        bookingReference: allocation.booking?.reference ?? null,
+                        allocatedWeightTons: roundTons(Number(allocation.allocatedWeightTons)),
+                        loadType: allocation.loadType ?? null,
+                        status: allocation.status,
+                        containerItems: (containerItemsByAllocation.get(allocation.id) ?? []).map(
+                          (item) => ({
+                            id: item.id,
+                            containerNumber: item.containerNumber ?? null,
+                            containerTypeId: item.containerTypeId,
+                            grossWeightTons: item.grossWeightTons ?? null,
+                            containerId: item.containerId ?? null,
+                            positionOnWagon: item.positionOnWagon ?? null,
+                            bookingContainerId: item.bookingContainerId ?? null,
+                          }),
+                        ),
+                        bulkLoad: bulkLoadsByAllocation.get(allocation.id)
+                          ? {
+                              id: bulkLoadsByAllocation.get(allocation.id)!.id,
+                              weightTons: bulkLoadsByAllocation.get(allocation.id)!.weightTons,
+                              cargoDescription:
+                                bulkLoadsByAllocation.get(allocation.id)!.cargoDescription ?? null,
+                            }
+                          : null,
+                      })) ?? [],
+                };
+              }),
           }
         : null,
       bookings:
@@ -4586,6 +5067,11 @@ export class TrainSchedulingService {
           loadingStatus: sb.loadingStatus ?? LoadingStatus.Unloaded,
           wagonAssigned: allocatedBookingIds.has(sb.booking?.id ?? sb.bookingId),
         })) ?? [],
+      // True when the wagon plan above is served from the frozen snapshot (schedule
+      // is dispatched/arrived/cancelled) rather than the live joins — the UI can badge
+      // it "historical" and skip re-pin affordances.
+      isWagonAllocationFrozen,
+      wagonAllocationSnapshot: snapshot,
     };
   }
 
diff --git a/apps/edr-freight-api/src/modules/warehouses/warehouse-inventory.controller.ts b/apps/edr-freight-api/src/modules/warehouses/warehouse-inventory.controller.ts
index 070a267a4..21f2663b6 100644
--- a/apps/edr-freight-api/src/modules/warehouses/warehouse-inventory.controller.ts
+++ b/apps/edr-freight-api/src/modules/warehouses/warehouse-inventory.controller.ts
@@ -52,6 +52,12 @@ export class WarehouseInventoryController {
     return this.inventoryService.arrivalQueue();
   }
 
+  @Get('zone-occupancy')
+  @ApiOperation({ summary: 'Live occupancy per zone (rated capacity vs held) — heatmap data' })
+  zoneOccupancy(@Query('yardId') yardId?: string) {
+    return this.inventoryService.zoneOccupancy(yardId);
+  }
+
   @Post('auto-unload-arrived')
   @ApiOperation({ summary: 'Bulk auto-unload all arrived bookings into the warehouse' })
   autoUnloadArrived() {
diff --git a/apps/edr-freight-api/src/modules/warehouses/warehouse-inventory.service.ts b/apps/edr-freight-api/src/modules/warehouses/warehouse-inventory.service.ts
index fd4f2057f..7c8edcce0 100644
--- a/apps/edr-freight-api/src/modules/warehouses/warehouse-inventory.service.ts
+++ b/apps/edr-freight-api/src/modules/warehouses/warehouse-inventory.service.ts
@@ -1,4 +1,5 @@
 import { BadRequestException, Injectable, Logger, NotFoundException } from '@nestjs/common';
+import { Cron, CronExpression } from '@nestjs/schedule';
 import { Between, DataSource, EntityManager, FindManyOptions, ILike, LessThanOrEqual, MoreThanOrEqual } from 'typeorm';
 
 import { deriveTradeDirection } from '../../common/derive-trade-direction.util';
@@ -396,6 +397,135 @@ export class WarehouseInventoryService {
    * but has no customer truck assigned yet, nudge the customer to assign one — with
    * a deep-link to the booking's truck-assignment card. Fire-and-forget.
    */
+  /**
+   * Live occupancy per zone: rated capacity vs the weight/items currently held
+   * (excludes items that have left — DELIVERED/DISPATCHED). Powers the yard
+   * occupancy heatmap. Optionally scoped to one yard.
+   */
+  async zoneOccupancy(yardId?: string): Promise<
+    Array<{
+      id: string;
+      name: string;
+      code: string;
+      type: string;
+      yardId: string;
+      capacityWeight: number | null;
+      capacityContainers: number | null;
+      usedWeight: number;
+      usedItems: number;
+      occupancyPct: number | null;
+    }>
+  > {
+    const rows: Array<{
+      id: string;
+      name: string;
+      code: string;
+      type: string;
+      yardId: string;
+      capacityWeight: string | null;
+      capacityContainers: number | null;
+      usedWeight: number;
+      usedItems: number;
+    }> = await this.dataSource.query(
+      `SELECT z.id,
+              z.name,
+              z.code,
+              z.type,
+              z.yard_id AS "yardId",
+              z.capacity_weight AS "capacityWeight",
+              z.capacity_containers AS "capacityContainers",
+              COALESCE(SUM(inv.weight) FILTER (
+                WHERE inv.deleted_at IS NULL
+                  AND inv.status NOT IN ('DELIVERED', 'DISPATCHED')
+              ), 0)::float8 AS "usedWeight",
+              COALESCE(COUNT(inv.id) FILTER (
+                WHERE inv.deleted_at IS NULL
+                  AND inv.status NOT IN ('DELIVERED', 'DISPATCHED')
+              ), 0)::int AS "usedItems"
+         FROM freight.warehouse_zones z
+         LEFT JOIN freight.warehouse_inventory inv ON inv.zone_id = z.id
+        WHERE z.is_active = true
+          AND z.deleted_at IS NULL
+          AND ($1::uuid IS NULL OR z.yard_id = $1)
+        GROUP BY z.id
+        ORDER BY z.name`,
+      [yardId ?? null],
+    );
+
+    return rows.map((r) => {
+      const capWeight = r.capacityWeight != null ? Number(r.capacityWeight) : null;
+      const byWeight =
+        capWeight && capWeight > 0 ? (r.usedWeight / capWeight) * 100 : null;
+      const byItems =
+        r.capacityContainers && r.capacityContainers > 0
+          ? (r.usedItems / r.capacityContainers) * 100
+          : null;
+      // Prefer container-count occupancy (unit-consistent). Weight capacity is
+      // tonnes while inventory weight is kg, so weight% is only a rough fallback.
+      const pct = byItems ?? byWeight;
+      return {
+        id: r.id,
+        name: r.name,
+        code: r.code,
+        type: r.type,
+        yardId: r.yardId,
+        capacityWeight: capWeight,
+        capacityContainers: r.capacityContainers,
+        usedWeight: r.usedWeight,
+        usedItems: r.usedItems,
+        occupancyPct: pct == null ? null : Math.round(pct * 10) / 10,
+      };
+    });
+  }
+
+  /**
+   * Recurring nudge: keep reminding self-haul IMPORT customers to assign a
+   * collection truck while their goods are still in the warehouse
+   * (READY_FOR_PICKUP) and no truck has been assigned yet. Stops once a truck is
+   * assigned (customer_truck_assigned_at set) or the goods leave (DELIVERED).
+   */
+  @Cron(CronExpression.EVERY_30_MINUTES, { name: 'import-truck-assignment-reminder' })
+  async remindImportTruckAssignment(): Promise<void> {
+    try {
+      const rows: Array<{
+        bookingId: string;
+        companyId: string | null;
+        reference: string | null;
+      }> = await this.dataSource.query(
+        `SELECT DISTINCT b.id AS "bookingId",
+                b.company_id AS "companyId",
+                b.reference
+           FROM freight.warehouse_inventory inv
+           JOIN freight.bookings b ON b.id = inv.booking_id AND b.deleted_at IS NULL
+          WHERE inv.deleted_at IS NULL
+            AND inv.status = 'READY_FOR_PICKUP'
+            AND b.trade_direction = 'IMPORT'
+            AND b.customer_truck_assigned_at IS NULL
+            AND COALESCE(NULLIF(TRIM(b.last_mile_delivery_address), ''), '') = ''`,
+      );
+      if (!rows.length) return;
+      this.logger.log(
+        `Import truck-assignment reminder: ${rows.length} booking(s) awaiting a collection truck`,
+      );
+      for (const row of rows) {
+        await this.notifyTruckAssignmentNeeded(
+          {
+            companyId: row.companyId,
+            reference: row.reference,
+            hasFirstMile: false,
+            hasLastMile: false,
+            customerTruckAssignedAt: null,
+          },
+          row.bookingId,
+        );
+      }
+    } catch (err) {
+      this.logger.warn(
+        `Import truck-assignment reminder tick failed: ${(err as Error).message}`,
+      );
+    }
+  }
+
   private async notifyTruckAssignmentNeeded(booking: {
     companyId?: string | null;
     reference?: string | null;
diff --git a/apps/edr-freight-api/src/scripts/seed-dropdown-settings.ts b/apps/edr-freight-api/src/scripts/seed-dropdown-settings.ts
new file mode 100644
index 000000000..a8df3cc71
--- /dev/null
+++ b/apps/edr-freight-api/src/scripts/seed-dropdown-settings.ts
@@ -0,0 +1,23 @@
+import { AppDataSource } from "../data-source";
+import { DropdownSettingsSeeder } from "../seed/dropdown-settings.seeder";
+
+/**
+ * Seed the dropdown settings catalog (codes/labels only, no options) into an
+ * EMPTY dropdown_settings table; skips entirely if any rows exist. Run on
+ * demand:
+ *   pnpm --filter @edr/freight-api seed:dropdown-settings
+ */
+async function run() {
+  await AppDataSource.initialize();
+  try {
+    const seeder = new DropdownSettingsSeeder(AppDataSource);
+    await seeder.run();
+  } finally {
+    await AppDataSource.destroy();
+  }
+}
+
+run().catch((error) => {
+  console.error("Failed to seed dropdown settings:", error);
+  process.exit(1);
+});
diff --git a/apps/edr-freight-api/src/seed/dropdown-settings.seeder.ts b/apps/edr-freight-api/src/seed/dropdown-settings.seeder.ts
new file mode 100644
index 000000000..4df5d9028
--- /dev/null
+++ b/apps/edr-freight-api/src/seed/dropdown-settings.seeder.ts
@@ -0,0 +1,89 @@
+import { Injectable, Logger } from "@nestjs/common";
+import { DataSource } from "typeorm";
+
+import {
+  DropdownSetting,
+  DropdownSettingMeta,
+} from "../modules/dropdown-settings/entities/dropdown-setting.entity";
+
+interface DefaultDropdownSetting {
+  code: string;
+  label: string;
+  description: string;
+  multiple: boolean;
+  meta?: DropdownSettingMeta | null;
+}
+
+/**
+ * Known dropdown settings, seeded as empty catalogs (no options). The options
+ * are managed by the admin from the backoffice Dropdown Settings editor.
+ */
+const DEFAULT_DROPDOWN_SETTINGS: DefaultDropdownSetting[] = [
+  {
+    code: "stations_ter",
+    label: "Stations TER",
+    description:
+      "Temporary freight station list used by booking origin and destination yards.",
+    multiple: false,
+    meta: { searchable: true, clearable: true, version: "temporary" },
+  },
+  {
+    code: "general_contract_period",
+    label: "General Contract Period (months)",
+    description:
+      "How many months a general contract stays open for ordering after activation.",
+    multiple: false,
+  },
+  {
+    code: "contract_validity_periods",
+    label: "Contract Validity Periods (days)",
+    description:
+      "Validity durations (in days) a staff can choose when accepting a submitted contract.",
+    multiple: false,
+  },
+  {
+    code: "ro_vessel_min_days",
+    label: "RO vessel minimum lead time (days)",
+    description:
+      "Minimum days between today and the vessel departure date on an export Release Order.",
+    multiple: false,
+  },
+];
+
+@Injectable()
+export class DropdownSettingsSeeder {
+  private readonly logger = new Logger(DropdownSettingsSeeder.name);
+
+  constructor(private readonly dataSource: DataSource) {}
+
+  async run() {
+    const settingRepository = this.dataSource.getRepository(DropdownSetting);
+
+    // Seed only into an empty table: any existing rows (including
+    // soft-deleted ones, which would still conflict on the unique `code`)
+    // mean the data is admin-managed, so leave it untouched.
+    const existing = await settingRepository.count({ withDeleted: true });
+    if (existing > 0) {
+      this.logger.log(
+        `dropdown_settings already has ${existing} rows — skipping seed`,
+      );
+      return;
+    }
+
+    // Insert setting rows only — no DropdownOption rows. Options start empty
+    // and are configured by the admin from the backoffice editor.
+    await settingRepository.insert(
+      DEFAULT_DROPDOWN_SETTINGS.map((setting) => ({
+        code: setting.code,
+        label: setting.label,
+        description: setting.description,
+        multiple: setting.multiple,
+        meta: setting.meta ?? null,
+      })),
+    );
+
+    this.logger.log(
+      `Seeded ${DEFAULT_DROPDOWN_SETTINGS.length} dropdown settings with empty options`,
+    );
+  }
+}
diff --git a/apps/edr-freight-api/src/seed/file-upload-settings.seeder.ts b/apps/edr-freight-api/src/seed/file-upload-settings.seeder.ts
index 13759ddb3..d65b2e2d8 100644
--- a/apps/edr-freight-api/src/seed/file-upload-settings.seeder.ts
+++ b/apps/edr-freight-api/src/seed/file-upload-settings.seeder.ts
@@ -1,7 +1,6 @@
 import { Injectable, Logger } from "@nestjs/common";
 import { DataSource } from "typeorm";
 
-import { FileUploadField } from "../modules/file-upload-settings/entities/file-upload-field.entity";
 import { FileUploadSetting } from "../modules/file-upload-settings/entities/file-upload-setting.entity";
 
 interface OnboardingField {
@@ -576,88 +575,66 @@ export class FileUploadSettingsSeeder {
   constructor(private readonly dataSource: DataSource) { }
 
   async run() {
-    await this.dataSource.transaction(async (manager) => {
-      const settingRepository = manager.getRepository(FileUploadSetting);
-      const fieldRepository = manager.getRepository(FileUploadField);
+    const settingRepository = this.dataSource.getRepository(FileUploadSetting);
 
-      const allSettings: Array<
-        OnboardingDocumentSetting & { description: string }
-      > = [
-          ...COMPANY_ONBOARDING_DOCUMENTS.map((s) => ({
-            ...s,
-            description: COMPANY_ONBOARDING_DESCRIPTION,
-          })),
-          ...CLEARANCE_DOCUMENT_SETTINGS.map((s) => ({
-            ...s,
-            description: CLEARANCE_DESCRIPTION,
-          })),
-          ...CONTRACT_CLEARANCE_SETTINGS.map((s) => ({
-            ...s,
-            description:
-              "Pre-booking clearance documents collected on the contract (Path B), by operation and freight type.",
-          })),
-          ...SELF_CLEARANCE_SETTINGS.map((s) => ({
-            ...s,
-            description:
-              "Customer self-clearance documents (Path A, no EDR customs service), reviewed by Operations.",
-          })),
-          ...CONTRACT_INTAKE_SETTINGS.map((s) => ({
-            ...s,
-            description:
-              "Commercial/framework documents attached at contract submission.",
-          })),
-          ...DRIVER_DOCUMENT_SETTINGS.map((s) => ({
-            ...s,
-            description:
-              "Documents uploaded against a driver profile (license, ID, contracts, etc.).",
-          })),
-        ];
+    // Seed only into an empty table: any existing rows (including
+    // soft-deleted ones, which would still conflict on the unique `code`)
+    // mean the data is admin-managed, so leave it untouched.
+    const existing = await settingRepository.count({ withDeleted: true });
+    if (existing > 0) {
+      this.logger.log(
+        `file_upload_settings already has ${existing} rows — skipping seed`,
+      );
+      return;
+    }
 
-      for (const documentSetting of allSettings) {
-        await settingRepository.upsert(
-          {
-            code: documentSetting.code,
-            label: documentSetting.label,
-            description: documentSetting.description,
-            entity: documentSetting.entity,
-          },
-          {
-            conflictPaths: { code: true },
-          },
-        );
+    const allSettings: Array<
+      OnboardingDocumentSetting & { description: string }
+    > = [
+        ...COMPANY_ONBOARDING_DOCUMENTS.map((s) => ({
+          ...s,
+          description: COMPANY_ONBOARDING_DESCRIPTION,
+        })),
+        ...CLEARANCE_DOCUMENT_SETTINGS.map((s) => ({
+          ...s,
+          description: CLEARANCE_DESCRIPTION,
+        })),
+        ...CONTRACT_CLEARANCE_SETTINGS.map((s) => ({
+          ...s,
+          description:
+            "Pre-booking clearance documents collected on the contract (Path B), by operation and freight type.",
+        })),
+        ...SELF_CLEARANCE_SETTINGS.map((s) => ({
+          ...s,
+          description:
+            "Customer self-clearance documents (Path A, no EDR customs service), reviewed by Operations.",
+        })),
+        ...CONTRACT_INTAKE_SETTINGS.map((s) => ({
+          ...s,
+          description:
+            "Commercial/framework documents attached at contract submission.",
+        })),
+        ...DRIVER_DOCUMENT_SETTINGS.map((s) => ({
+          ...s,
+          description:
+            "Documents uploaded against a driver profile (license, ID, contracts, etc.).",
+        })),
+      ];
 
-        const setting = await settingRepository.findOne({
-          where: { code: documentSetting.code },
-          select: { id: true, code: true },
-        });
-
-        if (!setting) {
-          throw new Error(
-            `file_upload_setting_seed_failed:${documentSetting.code}`,
-          );
-        }
-
-        await fieldRepository.delete({ settingId: setting.id });
-
-        await fieldRepository.insert(
-          documentSetting.fields.map((field, index) => ({
-            settingId: setting.id,
-            fileKey: field.fileKey,
-            fileLabel: field.fileLabel,
-            helpText: field.helpText,
-            isRequired: field.isRequired,
-            isMultiple: field.isMultiple,
-            maxFiles: field.maxFiles,
-            allowedExtensions: [...field.allowedExtensions],
-            maxSizeMb: field.maxSizeMb,
-            displayOrder: field.displayOrder ?? index + 1,
-          })),
-        );
-      }
-    });
+    // Insert setting rows only — no FileUploadField rows. Fields start empty
+    // and are configured from the backoffice file-settings editor; the field
+    // definitions above are kept as reference defaults.
+    await settingRepository.insert(
+      allSettings.map((documentSetting) => ({
+        code: documentSetting.code,
+        label: documentSetting.label,
+        description: documentSetting.description,
+        entity: documentSetting.entity,
+      })),
+    );
 
     this.logger.log(
-      "Ensured company onboarding + booking clearance file upload settings",
+      `Seeded ${allSettings.length} file upload settings with empty fields`,
     );
   }
 }
diff --git a/apps/edr-freight-web/backoffice/src/App.tsx b/apps/edr-freight-web/backoffice/src/App.tsx
index 18d382933..18e291872 100644
--- a/apps/edr-freight-web/backoffice/src/App.tsx
+++ b/apps/edr-freight-web/backoffice/src/App.tsx
@@ -52,6 +52,7 @@ import ContractRequestDetailPage from "./pages/contracts/ContractRequestDetailPa
 import ContractViewPage from "./pages/contracts/ContractViewPage";
 import ContractClearanceListPage from "./pages/contracts/ContractClearanceListPage";
 import ContractClearanceDetailPage from "./pages/contracts/ContractClearanceDetailPage";
+import ClearanceDocumentsPage from "./pages/contracts/ClearanceDocumentsPage";
 import GlDjiboutiClearanceListPage from "./pages/contracts/GlDjiboutiClearanceListPage";
 import GlClearanceDetailPage from "./pages/contracts/GlClearanceDetailPage";
 import ShipmentRequestsPage from "./pages/contracts/ShipmentRequestsPage";
@@ -126,6 +127,7 @@ import WarehouseRulesPage from "./pages/warehouses/WarehouseRulesPage";
 import { HealthCheck } from "./features/health/HealthCheck";
 import FaydaCallbackPage from "./pages/FaydaCallbackPage";
 import { UserManagementRoutes } from "./user-management/route";
+import SetPassword from "./shared/components/SetPassword";
 
 const buildSidebarSections = (demoItems: SidebarItem[]): SidebarSection[] => [
   {
@@ -152,6 +154,14 @@ const buildSidebarSections = (demoItems: SidebarItem[]): SidebarSection[] => [
         icon: <FileSignature />,
         permission: FREIGHT_PERMS.contracts.view,
       },
+      // Operations hub: clearance-document review for contracts WITHOUT
+      // customs clearing (contract-level for one-time, per-booking for general).
+      {
+        label: "Clearance Documents",
+        href: "/dashboard/contracts/clearance-documents",
+        icon: <ShieldCheck />,
+        permission: FREIGHT_PERMS.contracts.opsClearanceReview,
+      },
       {
         label: "Customers",
         href: "/dashboard/customers",
@@ -655,6 +665,10 @@ const App = () => {
       <Routes>
         <Route path="/auth" element={<LoginPage />} />
         {/* <Route path="/um/*" element={<UserManagementHostPage />} /> */}
+        <Route
+          path="um/set-password"
+          element={<SetPassword />}
+        />
         <Route path="/callback" element={<FaydaCallbackPage />} />
         <Route path="*" element={<Navigate to="/auth" replace />} />
       </Routes>
@@ -788,6 +802,18 @@ const App = () => {
             </RequirePermission>
           }
         />
+        {/* Operations hub: clearance documents for non-customs contracts —
+            Contracts tab (contract-level) + General tab (per-booking). */}
+        <Route
+          path="contracts/clearance-documents"
+          element={
+            <RequirePermission
+              permission={FREIGHT_PERMS.contracts.opsClearanceReview}
+            >
+              <ClearanceDocumentsPage />
+            </RequirePermission>
+          }
+        />
         {/* GL (Path B) contract clearance review hub */}
         <Route
           path="contracts/clearance"
diff --git a/apps/edr-freight-web/backoffice/src/components/contracts/ExportClearanceStepper.tsx b/apps/edr-freight-web/backoffice/src/components/contracts/ExportClearanceStepper.tsx
index c94e005ae..df8871b07 100644
--- a/apps/edr-freight-web/backoffice/src/components/contracts/ExportClearanceStepper.tsx
+++ b/apps/edr-freight-web/backoffice/src/components/contracts/ExportClearanceStepper.tsx
@@ -149,8 +149,12 @@ export function ExportClearanceStepper({
   const entityId = contractId ?? bookingId ?? "";
   // The booking that carries the post-booking steps (gate pass, T1, invoice).
   const actionBookingId = clearance.linkedBookingId ?? bookingId ?? null;
+  // Per-booking GENERAL clearance runs on a bare instance that only becomes a
+  // real booking once GL completes it — the caller's bookingCreated prop carries
+  // that signal, so a booking-keyed view must NOT count as "created" by itself
+  // (it would lock GL Ethiopia out of the declaration step right after the RO).
   const effectiveBookingCreated =
-    bookingCreated || Boolean(clearance.linkedBookingId) || isBooking;
+    bookingCreated || Boolean(clearance.linkedBookingId);
 
   const activeStep = useMemo(
     () => computeExportActiveStep(clearance, bookingMilestones, effectiveBookingCreated),
diff --git a/apps/edr-freight-web/backoffice/src/components/contracts/GlCreateBookingForm.tsx b/apps/edr-freight-web/backoffice/src/components/contracts/GlCreateBookingForm.tsx
index a520c35e5..223b357c1 100644
--- a/apps/edr-freight-web/backoffice/src/components/contracts/GlCreateBookingForm.tsx
+++ b/apps/edr-freight-web/backoffice/src/components/contracts/GlCreateBookingForm.tsx
@@ -1,13 +1,14 @@
-import { useEffect, useMemo, useRef, useState } from "react";
 import {
-  useNavigate,
-  useParams,
-  useSearchParams,
-} from "react-router-dom";
+  useEffect,
+  useMemo,
+  useRef,
+  useState,
+  type KeyboardEvent,
+} from "react";
+import { useNavigate, useParams, useSearchParams } from "react-router-dom";
 import { useMutation, useQuery } from "@tanstack/react-query";
 import {
   Alert,
-  Badge,
   Box,
   Button,
   Center,
@@ -16,7 +17,6 @@ import {
   Group,
   Loader,
   Modal,
-  NumberInput,
   Paper,
   Select,
   Stack,
@@ -25,6 +25,7 @@ import {
   Textarea,
   TextInput,
   ThemeIcon,
+  Title,
 } from "@mantine/core";
 import {
   AlertCircle,
@@ -49,6 +50,7 @@ import { PageContainer } from "@/components/page";
 import { PageHeader } from "@/components/page/PageHeader";
 import { contractsService } from "@/services/contracts.service";
 import {
+  useContractCapacity,
   useContractDetail,
   useContractMutations,
 } from "@/hooks/contracts/useContracts";
@@ -76,11 +78,27 @@ const EAT_TZ = "Africa/Addis_Ababa";
 // Same rule the customer portal shipment form enforces.
 const ISO_CONTAINER_NUMBER_REGEX = /^[A-Z]{4}\d{7}$/;
 
+/**
+ * Every quantity on this form is a non-negative magnitude. A native number
+ * input's `min` only constrains its stepper, so swallow the minus key before it
+ * can put a negative into the field at all. Same guard as the portal form.
+ */
+const blockNegative = (event: KeyboardEvent<HTMLInputElement>) => {
+  if (event.key === "-") event.preventDefault();
+};
+
 interface UnitErrors {
   containerNumber?: string;
   vgmTons?: string;
 }
 
+interface LineErrors {
+  quantity?: string;
+  hazardousQuantity?: string;
+  reeferQuantity?: string;
+  units?: string;
+}
+
 interface BulkErrors {
   quantity?: string;
   hazardous?: string;
@@ -106,32 +124,37 @@ function fmtWindowOpensAt(iso: string): string {
 interface UnitDraft {
   containerNumber: string;
   sealNumber: string;
-  vgmTons: number | string;
-  /** Per-unit flags — the line's hazardous/reefer counts are derived from these. */
-  hazardous: boolean;
-  reefer: boolean;
+  vgmTons: string;
 }
 
+/** Mirrors the portal shipment form's container line: line-level quantity +
+ * hazardous/reefer counts with per-unit number/seal/VGM details. */
 interface ContainerLineDraft {
   containerSize: string;
+  quantity: string;
+  hazardousQuantity: string;
+  reeferQuantity: string;
   units: UnitDraft[];
 }
 
-interface BulkLineDraft {
-  cargoTypeId: string;
-  cargoWeightTons: number | string;
-  itemCount: number | string;
-  hazardousQuantity: number | string;
-  reeferQuantity: number | string;
+interface BulkDraft {
+  cargoWeightTons: string;
+  itemCount: string;
+  hazardousQuantity: string;
+  reeferQuantity: string;
 }
 
 function emptyUnit(): UnitDraft {
+  return { containerNumber: "", sealNumber: "", vgmTons: "" };
+}
+
+function emptyLine(size: string): ContainerLineDraft {
   return {
-    containerNumber: "",
-    sealNumber: "",
-    vgmTons: "",
-    hazardous: false,
-    reefer: false,
+    containerSize: size,
+    quantity: "1",
+    hazardousQuantity: "0",
+    reeferQuantity: "0",
+    units: [emptyUnit()],
   };
 }
 
@@ -182,12 +205,14 @@ export default function GlCreateBookingForm() {
     enabled: Boolean(requestId),
   });
 
-  // Same window-gating the customer sees: GL may only create a booking while a
-  // booking window is OPEN for one of the contract's routes.
+  // Same window-gating the customer sees: booking is only allowed while a
+  // window is OPEN for one of the contract's routes. Intercity contracts are
+  // never window-gated — the shipment rides a passing train staff pick later.
   const contractId = contract?.id ?? id;
   const { data: bookingWindows, isLoading: windowsLoading } = useQuery({
     ...api.trainScheduling.contractBookingWindows.queryOptions({
       input: { contractId: contractId ?? "" },
+      refetchInterval: 60_000,
     }),
     enabled: Boolean(contractId),
   });
@@ -215,7 +240,12 @@ export default function GlCreateBookingForm() {
   const [contractRouteId, setContractRouteId] = useState<string | null>(null);
   const [notes, setNotes] = useState("");
   const [containerLines, setContainerLines] = useState<ContainerLineDraft[]>([]);
-  const [bulkLines, setBulkLines] = useState<BulkLineDraft[]>([]);
+  const [bulk, setBulk] = useState<BulkDraft>({
+    cargoWeightTons: "",
+    itemCount: "",
+    hazardousQuantity: "0",
+    reeferQuantity: "0",
+  });
   const [withReturn, setWithReturn] = useState(false);
   const [prefilled, setPrefilled] = useState(false);
   const [priceOpen, setPriceOpen] = useState(false);
@@ -231,12 +261,68 @@ export default function GlCreateBookingForm() {
   }, [contract]);
 
   const isContainer = contract?.freightType === "CONTAINER";
+  // Intercity shipments ride a passing import/export train staff pick at
+  // finalize time — no shipment day is chosen and no window gate applies.
+  const isIntercity = contract?.tradeDirection === "DOMESTIC";
+
+  // ONE_TIME split-remainder mode: a previous booking on this contract was
+  // split on train capacity, so the capacity endpoint reports the outstanding
+  // remainder — the EXACT quantity this booking must take (API-enforced).
+  const { data: splitCapacityLines = [] } = useContractCapacity(
+    contract?.contractKind === "ONE_TIME" ? contract?.id : undefined,
+  );
+  const remainderLines = useMemo(
+    () =>
+      contract?.contractKind === "ONE_TIME"
+        ? splitCapacityLines.filter((l) => (l.remaining ?? 0) > 0)
+        : [],
+    [contract?.contractKind, splitCapacityLines],
+  );
+  const remainderMode = remainderLines.length > 0;
+
+  // Bulk: prefill the exact outstanding remainder once — a different amount
+  // would be rejected at create anyway.
+  const remainderSeededRef = useRef(false);
+  useEffect(() => {
+    if (!remainderMode || isContainer || remainderSeededRef.current) return;
+    remainderSeededRef.current = true;
+    setBulk((b) =>
+      b.cargoWeightTons || b.itemCount
+        ? b
+        : { ...b, cargoWeightTons: String(remainderLines[0].remaining) },
+    );
+  }, [remainderMode, isContainer, remainderLines]);
+
+  const remainderNotice = remainderMode ? (
+    <Alert
+      color="yellow"
+      variant="light"
+      radius="md"
+      icon={<AlertTriangle size={16} />}
+      title="This booking must take the whole split remainder"
+    >
+      <Text fz={13}>
+        The previous booking on this one-time contract was split — the paid
+        part is shipping and the rest returned to the contract. This booking
+        must cover exactly the remaining{" "}
+        {remainderLines
+          .map((l) =>
+            isContainer
+              ? `${l.remaining} × ${l.containerSize ?? "container"}`
+              : `${l.remaining} tons`,
+          )
+          .join(", ")}
+        . A different quantity will be rejected, and no other booking can be
+        created on this contract.
+      </Text>
+    </Alert>
+  ) : null;
   const routes = useMemo(
     () =>
       [...(contract?.routes ?? [])].sort((a, b) => a.sortOrder - b.sortOrder),
     [contract?.routes],
   );
-  const needsRouteSelect = contract?.contractKind === "GENERAL" && routes.length > 1;
+  const multiRoute = routes.length > 1;
 
   const containerSizes = useMemo(() => {
     const sizes = new Set<string>();
@@ -246,19 +332,6 @@ export default function GlCreateBookingForm() {
     return [...sizes];
   }, [contract?.cargoScope]);
 
-  const bulkCargoOptions = useMemo(() => {
-    const seen = new Map<string, string>();
-    (contract?.cargoScope ?? []).forEach((s) => {
-      if (s.containerSize || !s.cargoTypeId) return;
-      if (!seen.has(s.cargoTypeId)) {
-        seen.set(s.cargoTypeId, s.cargoFreeText?.trim() || s.cargoTypeId);
-      }
-    });
-    return [...seen.entries()].map(([value, label]) => ({ value, label }));
-  }, [contract?.cargoScope]);
-
-  const defaultBulkCargoTypeId = bulkCargoOptions[0]?.value ?? "";
-
   useEffect(() => {
     if (!bookingRequest || prefilled) return;
     setPrefilled(true);
@@ -267,81 +340,53 @@ export default function GlCreateBookingForm() {
       setContainerLines(
         lines.containers.map((c) => ({
           containerSize: c.containerSize,
-          // The request carries counts; pre-toggle the first N units so GL sees
-          // the customer's declared hazardous/reefer split and can adjust it.
-          units: Array.from({ length: Math.max(1, c.quantity) }, (_, i) => ({
-            ...emptyUnit(),
-            hazardous: i < Number(c.hazardousQuantity ?? 0),
-            reefer: i < Number(c.reeferQuantity ?? 0),
-          })),
+          quantity: String(Math.max(1, c.quantity)),
+          hazardousQuantity: String(c.hazardousQuantity ?? 0),
+          reeferQuantity: String(c.reeferQuantity ?? 0),
+          units: Array.from({ length: Math.max(1, c.quantity) }, emptyUnit),
         })),
       );
     } else if (lines.bulk) {
-      setBulkLines([
-        {
-          cargoTypeId: lines.bulk.cargoTypeId ?? defaultBulkCargoTypeId,
-          cargoWeightTons: lines.bulk.cargoWeightTons ?? "",
-          itemCount: lines.bulk.itemCount ?? "",
-          hazardousQuantity: lines.bulk.hazardousQuantity ?? "0",
-          reeferQuantity: "",
-        },
-      ]);
+      setBulk({
+        cargoWeightTons:
+          lines.bulk.cargoWeightTons != null
+            ? String(lines.bulk.cargoWeightTons)
+            : "",
+        itemCount:
+          lines.bulk.itemCount != null ? String(lines.bulk.itemCount) : "",
+        hazardousQuantity: String(lines.bulk.hazardousQuantity ?? 0),
+        reeferQuantity: "0",
+      });
     }
     if (bookingRequest.contractRouteId)
       setContractRouteId(bookingRequest.contractRouteId);
     if (bookingRequest.notes) setNotes(bookingRequest.notes);
-  }, [bookingRequest, prefilled, defaultBulkCargoTypeId]);
+  }, [bookingRequest, prefilled]);
 
+  // Seed one shipment line per contracted size exactly once — same seeding the
+  // portal form does. Subsequent renders reuse the lines.
   useEffect(() => {
     if (!contract || prefilled || seededRef.current) return;
     seededRef.current = true;
     if (isContainer && containerSizes.length > 0 && containerLines.length === 0) {
-      setContainerLines(
-        containerSizes.map((size) => ({
-          containerSize: size,
-          units: [emptyUnit()],
-        })),
-      );
-    } else if (!isContainer && bulkLines.length === 0) {
-      setBulkLines([
-        {
-          cargoTypeId: defaultBulkCargoTypeId,
-          cargoWeightTons: "",
-          itemCount: "",
-          hazardousQuantity: "0",
-          reeferQuantity: "0",
-        },
-      ]);
+      setContainerLines(containerSizes.map(emptyLine));
     }
-  }, [
-    contract,
-    prefilled,
-    isContainer,
-    containerSizes,
-    containerLines.length,
-    bulkLines.length,
-    defaultBulkCargoTypeId,
-  ]);
+  }, [contract, prefilled, isContainer, containerSizes, containerLines.length]);
 
   const quantities: GlShipmentQuantities = useMemo(
     () => ({
       isContainer: Boolean(isContainer),
       containers: containerLines.map((l) => ({
         containerSize: l.containerSize,
-        quantity: l.units.length,
-        hazardousQuantity: l.units.filter((u) => u.hazardous).length,
-        reeferQuantity: l.units.filter((u) => u.reefer).length,
+        quantity: Number(l.quantity || 0),
+        hazardousQuantity: Number(l.hazardousQuantity || 0),
+        reeferQuantity: Number(l.reeferQuantity || 0),
       })),
-      bulkQuantity: bulkLines.reduce(
-        (s, l) => s + Number(l.cargoWeightTons || l.itemCount || 0),
-        0,
-      ),
-      bulkHazardousQuantity: bulkLines.reduce(
-        (s, l) => s + Number(l.hazardousQuantity || 0),
-        0,
-      ),
+      bulkQuantity: Number(bulk.cargoWeightTons || bulk.itemCount || 0),
+      bulkHazardousQuantity: Number(bulk.hazardousQuantity || 0),
+      bulkReeferQuantity: Number(bulk.reeferQuantity || 0),
     }),
-    [isContainer, containerLines, bulkLines],
+    [isContainer, containerLines, bulk],
   );
 
   const priceTotal = useMemo(
@@ -354,6 +399,8 @@ export default function GlCreateBookingForm() {
     [routes, contractRouteId],
   );
 
+  // Read the cargo entered above so the day list reflects what can actually be
+  // shipped (matching wagons + open train capacity) — portal parity.
   const cargoQuery = useMemo<Freight.AvailableDaysForCargoQuery | null>(() => {
     if (!selectedRoute?.originYardId || !selectedRoute?.destinationYardId)
       return null;
@@ -361,7 +408,7 @@ export default function GlCreateBookingForm() {
       const containers = containerLines
         .map((l) => ({
           containerSize: l.containerSize,
-          quantity: l.units.length,
+          quantity: Number(l.quantity || 0),
         }))
         .filter((c) => c.quantity >= 1);
       if (containers.length === 0) return null;
@@ -372,10 +419,7 @@ export default function GlCreateBookingForm() {
         containers,
       };
     }
-    const tons = bulkLines.reduce(
-      (s, l) => s + Number(l.cargoWeightTons || 0),
-      0,
-    );
+    const tons = Number(bulk.cargoWeightTons || 0);
     if (tons <= 0) return null;
     return {
       originYardId: selectedRoute.originYardId,
@@ -386,15 +430,16 @@ export default function GlCreateBookingForm() {
           ?.cargoTypeCode ?? undefined,
       totalWeightTons: tons,
     };
-  }, [selectedRoute, isContainer, containerLines, bulkLines, contract?.pricingBreakdown]);
+  }, [selectedRoute, isContainer, containerLines, bulk.cargoWeightTons, contract?.pricingBreakdown]);
 
   const { data: availableDays, isLoading: daysLoading } = useQuery({
     ...api.trainScheduling.availableDaysForCargo.queryOptions({
       input: cargoQuery ?? { freightType: "BULK" as const },
     }),
-    enabled: cargoQuery !== null,
+    enabled: cargoQuery !== null && !isIntercity,
   });
 
+  // Keep the units array length in sync with the entered quantity.
   const syncUnits = (lineIdx: number, qty: number) => {
     setContainerLines((prev) =>
       prev.map((line, i) => {
@@ -423,14 +468,11 @@ export default function GlCreateBookingForm() {
       ),
     });
 
-  const patchBulk = (idx: number, patch: Partial<BulkLineDraft>) =>
-    setBulkLines((prev) =>
-      prev.map((l, i) => (i === idx ? { ...l, ...patch } : l)),
-    );
-
-  // Same client-side validation as the customer portal shipment form: ISO
-  // container numbers (unique within the shipment) and a positive VGM per unit;
-  // bulk needs a positive quantity with hazardous/reefer portions bounded by it.
+  // Same client-side validation as the customer portal shipment form
+  // (new-shipment-form/schema.ts): ISO container numbers unique within the
+  // shipment, positive VGM per unit, hazardous/reefer counts bounded by the
+  // line quantity; bulk needs a positive quantity with hazardous/reefer
+  // portions bounded by it. Errors only show after a submit attempt.
   const [showErrors, setShowErrors] = useState(false);
 
   // Excel import: one row per container. All-or-nothing — a file with any bad
@@ -460,21 +502,17 @@ export default function GlCreateBookingForm() {
       containerSizes.map((size) => {
         const imported = rows.filter((r) => r.containerSize === size);
         if (imported.length === 0) {
-          return (
-            prev.find((l) => l.containerSize === size) ?? {
-              containerSize: size,
-              units: [emptyUnit()],
-            }
-          );
+          return prev.find((l) => l.containerSize === size) ?? emptyLine(size);
         }
         return {
           containerSize: size,
+          quantity: String(imported.length),
+          hazardousQuantity: String(imported.filter((r) => r.hazardous).length),
+          reeferQuantity: String(imported.filter((r) => r.reefer).length),
           units: imported.map((r) => ({
             containerNumber: r.containerNumber,
             sealNumber: r.sealNumber,
-            vgmTons: r.vgmTons,
-            hazardous: r.hazardous,
-            reefer: r.reefer,
+            vgmTons: String(r.vgmTons),
           })),
         };
       }),
@@ -507,7 +545,7 @@ export default function GlCreateBookingForm() {
           errs.containerNumber = "Duplicate container number in this shipment.";
         }
         const vgm = Number(u.vgmTons);
-        if (String(u.vgmTons).trim() === "" || Number.isNaN(vgm) || vgm <= 0) {
+        if (u.vgmTons.trim() === "" || Number.isNaN(vgm) || vgm <= 0) {
           errs.vgmTons = "Enter a valid VGM.";
         }
         return errs;
@@ -515,51 +553,94 @@ export default function GlCreateBookingForm() {
     );
   }, [isContainer, containerLines]);
 
-  const bulkErrors = useMemo<BulkErrors[]>(() => {
-    if (isContainer) return [];
-    return bulkLines.map((line) => {
-      const errs: BulkErrors = {};
-      const qty = Number(line.cargoWeightTons || line.itemCount || 0);
-      if (Number.isNaN(qty) || qty <= 0) {
-        errs.quantity = "Enter a quantity greater than 0.";
+  const lineErrors = useMemo<LineErrors[]>(() => {
+    if (!isContainer || !contract) return [];
+    return containerLines.map((line) => {
+      const errs: LineErrors = {};
+      const qty = Number(line.quantity || 0);
+      if (line.quantity.trim() === "") {
+        errs.quantity = "Quantity is required.";
+      } else if (Number.isNaN(qty) || qty < 1) {
+        errs.quantity = "At least 1.";
+      } else if (line.units.length < qty) {
+        errs.units = `Enter details for all ${qty} container(s).`;
       }
-      const h = Number(line.hazardousQuantity || 0);
-      if (Number.isNaN(h) || h < 0) {
-        errs.hazardous = "Enter a valid hazardous quantity.";
-      } else if (qty > 0 && h > qty) {
-        errs.hazardous = `Can't exceed the cargo quantity (${qty}).`;
+      if (contract.isHazardous) {
+        const h = Number(line.hazardousQuantity || 0);
+        if (Number.isNaN(h) || h < 0) {
+          errs.hazardousQuantity = "Enter a valid hazardous quantity.";
+        } else if (h > qty) {
+          errs.hazardousQuantity = `Can't exceed the ${qty} container(s) in this line.`;
+        }
       }
-      const r = Number(line.reeferQuantity || 0);
-      if (Number.isNaN(r) || r < 0) {
-        errs.reefer = "Enter a valid refrigerated quantity.";
-      } else if (qty > 0 && r > qty) {
-        errs.reefer = `Can't exceed the cargo quantity (${qty}).`;
+      if (contract.isReefer) {
+        const r = Number(line.reeferQuantity || 0);
+        if (Number.isNaN(r) || r < 0) {
+          errs.reeferQuantity = "Enter a valid refrigerated quantity.";
+        } else if (r > qty) {
+          errs.reeferQuantity = `Can't exceed the ${qty} container(s) in this line.`;
+        }
       }
       return errs;
     });
-  }, [isContainer, bulkLines]);
+  }, [isContainer, contract, containerLines]);
+
+  const bulkUom = contract ? bulkUnitOfMeasure(contract) : "PER_TON";
+
+  const bulkErrors = useMemo<BulkErrors>(() => {
+    if (isContainer) return {};
+    const errs: BulkErrors = {};
+    const qty =
+      bulkUom === "PER_ITEM"
+        ? Number(bulk.itemCount || 0)
+        : Number(bulk.cargoWeightTons || 0);
+    if (Number.isNaN(qty) || qty <= 0) {
+      errs.quantity = "Enter a quantity greater than 0.";
+    }
+    const h = Number(bulk.hazardousQuantity || 0);
+    if (Number.isNaN(h) || h < 0) {
+      errs.hazardous = "Enter a valid hazardous quantity.";
+    } else if (qty > 0 && h > qty) {
+      errs.hazardous = `Can't exceed the cargo quantity (${qty}).`;
+    }
+    const r = Number(bulk.reeferQuantity || 0);
+    if (Number.isNaN(r) || r < 0) {
+      errs.reefer = "Enter a valid refrigerated quantity.";
+    } else if (qty > 0 && r > qty) {
+      errs.reefer = `Can't exceed the cargo quantity (${qty}).`;
+    }
+    return errs;
+  }, [isContainer, bulk, bulkUom]);
+
+  const dateError =
+    !isIntercity && !scheduledDate ? "Select a shipment date." : undefined;
+  const routeError =
+    multiRoute && !contractRouteId ? "Select a route." : undefined;
 
   const cargoValid = isContainer
-    ? unitErrors.every((line) =>
+    ? lineErrors.every(
+        (e) =>
+          !e.quantity && !e.units && !e.hazardousQuantity && !e.reeferQuantity,
+      ) &&
+      unitErrors.every((line) =>
         line.every((e) => !e.containerNumber && !e.vgmTons),
       )
-    : bulkErrors.every((e) => !e.quantity && !e.hazardous && !e.reefer);
+    : !bulkErrors.quantity && !bulkErrors.hazardous && !bulkErrors.reefer;
 
-  const canSubmit =
-    windowOpen &&
-    Boolean(scheduledDate) &&
-    (!needsRouteSelect || Boolean(contractRouteId)) &&
-    (isContainer ? containerLines.some((l) => l.units.length > 0) : bulkLines.length > 0);
+  const formValid = cargoValid && !dateError && !routeError;
 
   /** The create-booking DTO from the current form state — shared by the
    * authoritative price preview and the actual submit so what GL confirms is
-   * exactly what gets booked. */
+   * exactly what gets booked. Mirrors the portal form's buildDto. */
   const buildPayload = (): Freight.CreateBookingUnderContractDto | null => {
-    if (!scheduledDate || !contract) return null;
+    if (!contract) return null;
 
     const payload: Freight.CreateBookingUnderContractDto = {
-      scheduledDate,
       ...(contractRouteId ? { contractRouteId } : {}),
+      // Intercity bookings carry no date — staff assign a passing train later.
+      ...(scheduledDate
+        ? { scheduledDate: new Date(scheduledDate).toISOString() }
+        : {}),
       ...(notes.trim() ? { notes: notes.trim() } : {}),
       // Equipment return is a container concern — bulk keeps the contract default.
       ...(isContainer
@@ -569,14 +650,12 @@ export default function GlCreateBookingForm() {
 
     if (isContainer) {
       payload.containers = containerLines
-        .filter((l) => l.units.length > 0)
+        .filter((l) => Number(l.quantity) >= 1)
         .map((l) => ({
           containerSize: l.containerSize,
-          quantity: l.units.length,
-          // Counts are derived from the per-unit toggles — they can never
-          // exceed the line quantity.
-          hazardousQuantity: l.units.filter((u) => u.hazardous).length,
-          reeferQuantity: l.units.filter((u) => u.reefer).length,
+          quantity: Number(l.quantity),
+          hazardousQuantity: Number(l.hazardousQuantity || 0) || undefined,
+          reeferQuantity: Number(l.reeferQuantity || 0) || undefined,
           units: l.units.map((u) => ({
             containerNumber: u.containerNumber.trim().toUpperCase(),
             ...(u.sealNumber ? { sealNumber: u.sealNumber } : {}),
@@ -584,28 +663,27 @@ export default function GlCreateBookingForm() {
           })),
         }));
     } else {
-      payload.bulkLines = bulkLines.map((l) => ({
-        ...(l.cargoTypeId ? { cargoTypeId: l.cargoTypeId } : {}),
-        ...(l.cargoWeightTons !== ""
-          ? { cargoWeightTons: Number(l.cargoWeightTons) }
-          : {}),
-        ...(l.itemCount !== "" ? { itemCount: Number(l.itemCount) } : {}),
-        ...(l.hazardousQuantity !== ""
-          ? { hazardousQuantity: Number(l.hazardousQuantity) }
-          : {}),
-        ...(l.reeferQuantity !== ""
-          ? { reeferQuantity: Number(l.reeferQuantity) }
-          : {}),
-      }));
+      payload.bulkLines = [
+        {
+          cargoTypeId: contract.cargoScope?.[0]?.cargoTypeId ?? null,
+          ...(bulk.cargoWeightTons !== ""
+            ? { cargoWeightTons: Number(bulk.cargoWeightTons) }
+            : {}),
+          ...(bulk.itemCount !== "" ? { itemCount: Number(bulk.itemCount) } : {}),
+          hazardousQuantity: Number(bulk.hazardousQuantity || 0) || undefined,
+          reeferQuantity: Number(bulk.reeferQuantity || 0) || undefined,
+        },
+      ];
     }
 
     return payload;
   };
 
   // Authoritative price preview (same pricing pass the booking persists at
-  // create): rail freight + first/last mile + overweight + every surcharge.
-  // Fired when the price modal opens; the modal falls back to the contract
-  // unit-rate estimate while it loads.
+  // create): rail freight + first/last mile + overweight + every surcharge,
+  // plus the hard-block checks (20ft pairing, max capacity, container numbers
+  // already booked on the same train). Fired when the price modal opens; the
+  // modal falls back to the contract unit-rate estimate while it loads.
   const validateShipmentMutation = useMutation({
     mutationFn: (dto: Freight.CreateBookingUnderContractDto) =>
       contractsService.validateShipment(id ?? "", dto),
@@ -629,15 +707,54 @@ export default function GlCreateBookingForm() {
     };
   }, [validation, priceTotal]);
 
-  const displayTotal = serverTotal ?? priceTotal;
+  const overweightSurchargeAmount = validation?.overweightSurchargeAmount ?? 0;
   const pairingErrors = validation?.pairingErrors ?? [];
   const capacityErrors = validation?.capacityErrors ?? [];
+  const containerClashErrors = validation?.containerClashErrors ?? [];
+  const spaceErrors = validation?.spaceErrors ?? [];
   const overweightLines = validation?.overweightLines ?? [];
 
+  // Fallback while the server preview loads: the contract's frozen unit rates
+  // with the overweight surcharge folded in — same fallback the portal shows.
+  const displayTotal = useMemo(() => {
+    if (serverTotal) return serverTotal;
+    if (!priceTotal) return null;
+    if (!(overweightSurchargeAmount > 0)) return priceTotal;
+    return {
+      ...priceTotal,
+      lines: [
+        ...priceTotal.lines,
+        {
+          label: "Overweight surcharge",
+          unitPrice: overweightSurchargeAmount,
+          unit: "flat" as const,
+          quantity: 1,
+          amount: overweightSurchargeAmount,
+        },
+      ],
+      total: priceTotal.total + overweightSurchargeAmount,
+    };
+  }, [serverTotal, priceTotal, overweightSurchargeAmount]);
+
+  const submitPending =
+    mutations.createBooking.isPending || mutations.completeBooking.isPending;
+
+  // Block confirm until the authoritative server price is in hand — the client
+  // estimate is display-only; booking on it would confirm an un-validated,
+  // possibly wrong price. Same guard as the portal form.
+  const confirmDisabled =
+    submitPending ||
+    validateShipmentMutation.isPending ||
+    pairingErrors.length > 0 ||
+    capacityErrors.length > 0 ||
+    containerClashErrors.length > 0 ||
+    spaceErrors.length > 0 ||
+    !serverTotal;
+
   const openPriceModal = () => {
     // Surface the per-field errors (portal-parity validation) instead of
     // sending an invalid payload to the price preview.
-    if (!cargoValid) {
+    if (!formValid) {
       setShowErrors(true);
       return;
     }
@@ -651,11 +768,15 @@ export default function GlCreateBookingForm() {
   };
 
   const handleSubmit = () => {
-    if (!contract || !windowOpen || !cargoValid) return;
+    if (!contract || !formValid) return;
     // Never book past unresolved 20ft pairing hard-blocks.
     if (pairingErrors.length > 0) return;
     // A line above the container type's max capacity can never book.
     if (capacityErrors.length > 0) return;
+    // A container already on another booking of the same train can never book.
+    if (containerClashErrors.length > 0) return;
+    // An export booking no open train can carry whole can never book.
+    if (spaceErrors.length > 0) return;
     const payload = buildPayload();
     if (!payload) return;
 
@@ -692,7 +813,7 @@ export default function GlCreateBookingForm() {
     });
   };
 
-  if (isLoading) {
+  if (isLoading || windowsLoading) {
     return (
       <PageContainer>
         <Center mih="50vh">
@@ -713,32 +834,68 @@ export default function GlCreateBookingForm() {
     );
   }
 
-  const bulkUom = bulkUnitOfMeasure(contract);
+  const header = (
+    <Group justify="space-between" align="flex-end" wrap="wrap" gap="md" mb="lg">
+      <Box>
+        <Title order={1} fw={800} fz={26} style={{ letterSpacing: "-0.01em" }}>
+          {completeBookingId ? "Complete Shipment Booking" : "New Shipment Booking"}
+        </Title>
+        <Text size="sm" c="dimmed" mt={4}>
+          {completeBookingId
+            ? `Clearance is finalized — enter the cargo details and shipment day to complete the booking under contract ${contract.reference}.`
+            : `Book a shipment on behalf of the customer for contract ${contract.reference}.`}
+        </Text>
+      </Box>
+      <Button
+        variant="default"
+        radius="md"
+        leftSection={<ChevronLeft size={16} />}
+        onClick={() => navigate(`/dashboard/contracts/clearance/${contract.id}`)}
+      >
+        Back to clearance
+      </Button>
+    </Group>
+  );
+
+  // Coarse gate — same closed-state notice the customer sees on the portal.
+  // Intercity contracts are never window-gated.
+  if (!isIntercity && !windowOpen) {
+    return (
+      <PageContainer>
+        {header}
+        <Alert
+          color="yellow"
+          variant="light"
+          radius="md"
+          icon={<CalendarDays size={18} />}
+          title="Booking is not open right now"
+        >
+          <Text size="sm">
+            {nextWindow?.windowOpensAt ? (
+              <>
+                Next window: <b>{fmtWindowOpensAt(nextWindow.windowOpensAt)} EAT</b>{" "}
+                for{" "}
+                <b>
+                  {nextWindow.origin ?? "Origin"} →{" "}
+                  {nextWindow.destination ?? "Destination"}
+                </b>
+                .
+              </>
+            ) : (
+              <>No upcoming booking window scheduled.</>
+            )}
+          </Text>
+          <Text size="sm" mt="xs">
+            Come back when the booking window opens to book this shipment.
+          </Text>
+        </Alert>
+      </PageContainer>
+    );
+  }
 
   return (
     <PageContainer>
-      <Group justify="space-between" align="flex-end" wrap="wrap" gap="md" mb="lg">
-        <Box>
-          <Text fw={800} fz={26} style={{ letterSpacing: "-0.01em" }}>
-            {completeBookingId ? "Complete Shipment Booking" : "New Shipment Booking"}
-          </Text>
-          <Text size="sm" c="dimmed" mt={4}>
-            {completeBookingId
-              ? `Clearance is finalized — enter the cargo details and shipment day to complete the booking under contract ${contract.reference}.`
-              : `Book a shipment on behalf of the customer for contract ${contract.reference}.`}
-          </Text>
-        </Box>
-        <Button
-          variant="default"
-          radius="md"
-          leftSection={<ChevronLeft size={16} />}
-          onClick={() =>
-            navigate(`/dashboard/contracts/clearance/${contract.id}`)
-          }
-        >
-          Back to clearance
-        </Button>
-      </Group>
+      {header}
 
       {bookingRequest ? (
         <Alert
@@ -768,50 +925,24 @@ export default function GlCreateBookingForm() {
         </Alert>
       ) : null}
 
-      {!windowsLoading && !windowOpen ? (
-        <Alert
-          color="orange"
-          variant="light"
-          radius="md"
-          icon={<AlertCircle size={16} />}
-          title="Booking window is closed"
-          mb="lg"
-        >
-          GL can create a booking only while a window is open.{" "}
-          {nextWindow?.windowOpensAt ? (
-            <>
-              Next window: <b>{fmtWindowOpensAt(nextWindow.windowOpensAt)} EAT</b>{" "}
-              for{" "}
-              <b>
-                {nextWindow.origin ?? "Origin"} → {nextWindow.destination ?? "Destination"}
-              </b>
-              .
-            </>
-          ) : (
-            <>No upcoming booking window scheduled.</>
-          )}
-        </Alert>
-      ) : null}
-
-      {windowsLoading || windowOpen ? (
-        <>
       <Stack gap="lg" maw={896} mx="auto">
         <StepCard>
           <StepHeader
             icon={<MapPin size={22} />}
             title="Route"
             description={
-              needsRouteSelect
+              multiRoute
                 ? "Choose which contracted route this shipment ships on."
                 : "This shipment ships on the contract's only route."
             }
           />
-          {needsRouteSelect ? (
+          {multiRoute ? (
             <Select
               label="Contract route *"
               placeholder="Select a route..."
               value={contractRouteId}
               onChange={setContractRouteId}
+              error={showErrors ? routeError : undefined}
               data={routes.map((r) => ({
                 value: r.id,
                 label: `${r.originYard?.label ?? r.originYard?.code ?? "Origin"} → ${
@@ -820,7 +951,6 @@ export default function GlCreateBookingForm() {
                   "Destination"
                 }`,
               }))}
-              required
               radius={10}
               styles={fieldStyles}
             />
@@ -927,6 +1057,7 @@ export default function GlCreateBookingForm() {
                   )}
                 </Paper>
               )}
+              {remainderNotice}
               <ContractCapacityNotice contractId={contract.id} isContainer />
               {containerLines.length === 0 ? (
                 <Text fz="sm" c="dimmed">
@@ -942,32 +1073,74 @@ export default function GlCreateBookingForm() {
                     <Text fz={14} fw={700} mb={10}>
                       {line.containerSize} containers
                     </Text>
-                    <Group gap={12} mb={12} align="flex-start">
-                      <NumberInput
+                    <Group gap={12} grow mb={12} align="flex-start">
+                      <TextInput
+                        type="number"
+                        onKeyDown={blockNegative}
                         label="Quantity *"
                         min={1}
-                        value={line.units.length}
-                        onChange={(v) => syncUnits(lineIdx, Number(v) || 0)}
+                        value={line.quantity}
+                        error={
+                          showErrors
+                            ? (lineErrors[lineIdx]?.quantity ??
+                              lineErrors[lineIdx]?.units)
+                            : undefined
+                        }
+                        onChange={(e) => {
+                          patchLine(lineIdx, { quantity: e.currentTarget.value });
+                          syncUnits(lineIdx, Number(e.currentTarget.value || 0));
+                        }}
                         radius={10}
                         styles={fieldStyles}
-                        w={160}
                       />
-                      {contract.isHazardous ? (
-                        <Badge variant="light" color="red" radius="sm" mt={30}>
-                          {line.units.filter((u) => u.hazardous).length} hazardous
-                        </Badge>
-                      ) : null}
-                      {contract.isReefer ? (
-                        <Badge variant="light" color="blue" radius="sm" mt={30}>
-                          {line.units.filter((u) => u.reefer).length} refrigerated
-                        </Badge>
-                      ) : null}
+                      {contract.isHazardous && (
+                        <TextInput
+                          type="number"
+                          onKeyDown={blockNegative}
+                          label="Hazardous qty"
+                          min={0}
+                          value={line.hazardousQuantity}
+                          error={
+                            showErrors
+                              ? lineErrors[lineIdx]?.hazardousQuantity
+                              : undefined
+                          }
+                          onChange={(e) =>
+                            patchLine(lineIdx, {
+                              hazardousQuantity: e.currentTarget.value,
+                            })
+                          }
+                          radius={10}
+                          styles={fieldStyles}
+                        />
+                      )}
+                      {contract.isReefer && (
+                        <TextInput
+                          type="number"
+                          onKeyDown={blockNegative}
+                          label="Reefer qty"
+                          min={0}
+                          value={line.reeferQuantity}
+                          error={
+                            showErrors
+                              ? lineErrors[lineIdx]?.reeferQuantity
+                              : undefined
+                          }
+                          onChange={(e) =>
+                            patchLine(lineIdx, {
+                              reeferQuantity: e.currentTarget.value,
+                            })
+                          }
+                          radius={10}
+                          styles={fieldStyles}
+                        />
+                      )}
                     </Group>
 
                     <StepLabel>Per-container details</StepLabel>
                     <Stack gap={10} mt={8}>
                       {line.units.map((unit, unitIdx) => (
-                        <Group key={unitIdx} gap={10} align="flex-start" wrap="nowrap">
+                        <Group key={unitIdx} gap={10} grow align="flex-start">
                           <TextInput
                             label={unitIdx === 0 ? "Container number *" : undefined}
                             placeholder="e.g. MSCU1234567"
@@ -979,12 +1152,12 @@ export default function GlCreateBookingForm() {
                             }
                             onChange={(e) =>
                               patchUnit(lineIdx, unitIdx, {
-                                containerNumber: e.currentTarget.value,
+                                containerNumber:
+                                  e.currentTarget.value.toUpperCase(),
                               })
                             }
                             radius={10}
                             styles={fieldStyles}
-                            style={{ flex: 1 }}
                           />
                           <TextInput
                             label={unitIdx === 0 ? "Seal number" : undefined}
@@ -997,70 +1170,28 @@ export default function GlCreateBookingForm() {
                             }
                             radius={10}
                             styles={fieldStyles}
-                            style={{ flex: 1 }}
                           />
-                          <NumberInput
+                          <TextInput
+                            type="number"
+                            onKeyDown={blockNegative}
                             label={unitIdx === 0 ? "VGM (tons) *" : undefined}
                             placeholder="e.g. 24.5"
                             min={0}
-                            decimalScale={2}
+                            step={0.01}
                             value={unit.vgmTons}
                             error={
                               showErrors
                                 ? unitErrors[lineIdx]?.[unitIdx]?.vgmTons
                                 : undefined
                             }
-                            onChange={(v) =>
-                              patchUnit(lineIdx, unitIdx, { vgmTons: v })
+                            onChange={(e) =>
+                              patchUnit(lineIdx, unitIdx, {
+                                vgmTons: e.currentTarget.value,
+                              })
                             }
                             radius={10}
                             styles={fieldStyles}
-                            style={{ flex: 1 }}
                           />
-                          {/* Per-unit flags: toggle exactly the containers that are
-                              hazardous / refrigerated; line counts derive from these. */}
-                          {contract.isHazardous ? (
-                            <Stack gap={6} align="center" style={{ flexShrink: 0 }}>
-                              {unitIdx === 0 ? (
-                                <Text fz={12} fw={600} c="#4A5A68">
-                                  Hazardous
-                                </Text>
-                              ) : null}
-                              <Switch
-                                color="red"
-                                size="sm"
-                                mt={unitIdx === 0 ? 0 : 8}
-                                aria-label={`Container ${unitIdx + 1} hazardous`}
-                                checked={unit.hazardous}
-                                onChange={(e) =>
-                                  patchUnit(lineIdx, unitIdx, {
-                                    hazardous: e.currentTarget.checked,
-                                  })
-                                }
-                              />
-                            </Stack>
-                          ) : null}
-                          {contract.isReefer ? (
-                            <Stack gap={6} align="center" style={{ flexShrink: 0 }}>
-                              {unitIdx === 0 ? (
-                                <Text fz={12} fw={600} c="#4A5A68">
-                                  Reefer
-                                </Text>
-                              ) : null}
-                              <Switch
-                                color="blue"
-                                size="sm"
-                                mt={unitIdx === 0 ? 0 : 8}
-                                aria-label={`Container ${unitIdx + 1} refrigerated`}
-                                checked={unit.reefer}
-                                onChange={(e) =>
-                                  patchUnit(lineIdx, unitIdx, {
-                                    reefer: e.currentTarget.checked,
-                                  })
-                                }
-                              />
-                            </Stack>
-                          ) : null}
                         </Group>
                       ))}
                     </Stack>
@@ -1077,68 +1208,84 @@ export default function GlCreateBookingForm() {
               description="Enter the amount you are shipping for this booking."
             />
             <Stack gap={14}>
+              {remainderNotice}
               <ContractCapacityNotice contractId={contract.id} isContainer={false} />
-              {bulkLines.map((line, idx) => (
-                <Stack key={idx} gap={14}>
-                  {bulkCargoOptions.length > 0 ? (
-                    <Select
-                      label="Cargo type"
-                      placeholder="Select cargo type"
-                      value={line.cargoTypeId || null}
-                      onChange={(v) => patchBulk(idx, { cargoTypeId: v ?? "" })}
-                      data={bulkCargoOptions}
-                      radius={10}
-                      styles={fieldStyles}
-                    />
-                  ) : null}
-                  {bulkUom === "PER_TON" ? (
-                    <NumberInput
-                      label="Quantity (tons) *"
-                      placeholder="e.g. 1200"
-                      min={0}
-                      decimalScale={2}
-                      value={line.cargoWeightTons}
-                      error={showErrors ? bulkErrors[idx]?.quantity : undefined}
-                      onChange={(v) => patchBulk(idx, { cargoWeightTons: v })}
-                      radius={10}
-                      styles={fieldStyles}
-                    />
-                  ) : (
-                    <NumberInput
-                      label="Item count *"
-                      placeholder="e.g. 500"
-                      min={0}
-                      value={line.itemCount}
-                      error={showErrors ? bulkErrors[idx]?.quantity : undefined}
-                      onChange={(v) => patchBulk(idx, { itemCount: v })}
-                      radius={10}
-                      styles={fieldStyles}
-                    />
-                  )}
-                  {contract.isHazardous ? (
-                    <NumberInput
-                      label="Hazardous quantity"
-                      min={0}
-                      value={line.hazardousQuantity}
-                      error={showErrors ? bulkErrors[idx]?.hazardous : undefined}
-                      onChange={(v) => patchBulk(idx, { hazardousQuantity: v })}
-                      radius={10}
-                      styles={fieldStyles}
-                    />
-                  ) : null}
-                  {contract.isReefer ? (
-                    <NumberInput
-                      label="Refrigerated quantity"
-                      min={0}
-                      value={line.reeferQuantity}
-                      error={showErrors ? bulkErrors[idx]?.reefer : undefined}
-                      onChange={(v) => patchBulk(idx, { reeferQuantity: v })}
-                      radius={10}
-                      styles={fieldStyles}
-                    />
-                  ) : null}
-                </Stack>
-              ))}
+              <TextInput
+                type="number"
+                onKeyDown={blockNegative}
+                label="Quantity (tons)"
+                placeholder="e.g. 1200"
+                min={0}
+                step={0.01}
+                value={bulk.cargoWeightTons}
+                error={
+                  showErrors && bulkUom === "PER_TON"
+                    ? bulkErrors.quantity
+                    : undefined
+                }
+                onChange={(e) =>
+                  setBulk((b) => ({ ...b, cargoWeightTons: e.currentTarget.value }))
+                }
+                radius={10}
+                styles={fieldStyles}
+              />
+              <TextInput
+                type="number"
+                onKeyDown={blockNegative}
+                label="Item count (if applicable)"
+                placeholder="e.g. 500"
+                min={0}
+                step={1}
+                value={bulk.itemCount}
+                error={
+                  showErrors && bulkUom === "PER_ITEM"
+                    ? bulkErrors.quantity
+                    : undefined
+                }
+                onChange={(e) =>
+                  setBulk((b) => ({ ...b, itemCount: e.currentTarget.value }))
+                }
+                radius={10}
+                styles={fieldStyles}
+              />
+              {contract.isHazardous && (
+                <TextInput
+                  type="number"
+                  onKeyDown={blockNegative}
+                  label="Hazardous quantity"
+                  min={0}
+                  step={1}
+                  value={bulk.hazardousQuantity}
+                  error={showErrors ? bulkErrors.hazardous : undefined}
+                  onChange={(e) =>
+                    setBulk((b) => ({
+                      ...b,
+                      hazardousQuantity: e.currentTarget.value,
+                    }))
+                  }
+                  radius={10}
+                  styles={fieldStyles}
+                />
+              )}
+              {contract.isReefer && (
+                <TextInput
+                  type="number"
+                  onKeyDown={blockNegative}
+                  label="Refrigerated quantity"
+                  min={0}
+                  step={1}
+                  value={bulk.reeferQuantity}
+                  error={showErrors ? bulkErrors.reefer : undefined}
+                  onChange={(e) =>
+                    setBulk((b) => ({
+                      ...b,
+                      reeferQuantity: e.currentTarget.value,
+                    }))
+                  }
+                  radius={10}
+                  styles={fieldStyles}
+                />
+              )}
             </Stack>
           </StepCard>
         )}
@@ -1204,37 +1351,57 @@ export default function GlCreateBookingForm() {
           </StepCard>
         ) : null}
 
-        <StepCard>
-          <StepHeader
-            icon={<CalendarDays size={22} />}
-            title="Schedule"
-            description="Pick the binding shipment day. Only days with an open train that has enough matching wagons for the cargo can be selected."
-          />
-          {cargoQuery === null ? (
-            <Alert
-              color="yellow"
-              variant="light"
-              radius="md"
-              icon={<AlertCircle size={16} />}
-            >
-              Enter your cargo details first — available shipment days depend on
-              the wagons your cargo needs.
+        {isIntercity ? (
+          <StepCard>
+            <StepHeader
+              icon={<CalendarDays size={22} />}
+              title="Schedule"
+              description="Intercity shipments have no fixed day."
+            />
+            <Alert color="blue" variant="light" radius="md" icon={<AlertCircle size={16} />}>
+              The shipment rides the next import/export train passing through
+              the corridor. Operations assign it to a train with free capacity —
+              the customer is notified when it is accepted and payment is due.
             </Alert>
-          ) : (
-            <Box>
-              <StepLabel>Shipment day *</StepLabel>
-              <Box mt={10} w="100%">
-                <OperationDatePicker
-                  fullWidth
-                  availableDays={availableDays ?? []}
-                  isLoading={daysLoading}
-                  value={scheduledDate}
-                  onChange={setScheduledDate}
-                />
+          </StepCard>
+        ) : (
+          <StepCard>
+            <StepHeader
+              icon={<CalendarDays size={22} />}
+              title="Schedule"
+              description="Pick the binding shipment day. Only days with an open train that has enough matching wagons for the cargo can be selected."
+            />
+            {cargoQuery === null ? (
+              <Alert
+                color="yellow"
+                variant="light"
+                radius="md"
+                icon={<AlertCircle size={16} />}
+              >
+                Enter your cargo details first — available shipment days depend
+                on the wagons your cargo needs.
+              </Alert>
+            ) : (
+              <Box>
+                <StepLabel>Shipment day *</StepLabel>
+                <Box mt={10} w="100%">
+                  <OperationDatePicker
+                    fullWidth
+                    availableDays={availableDays ?? []}
+                    isLoading={daysLoading}
+                    value={scheduledDate}
+                    onChange={setScheduledDate}
+                  />
+                </Box>
+                {showErrors && dateError && (
+                  <Text fz="xs" c="red" mt={6}>
+                    {dateError}
+                  </Text>
+                )}
               </Box>
-            </Box>
-          )}
-        </StepCard>
+            )}
+          </StepCard>
+        )}
 
         <StepCard>
           <Textarea
@@ -1261,7 +1428,7 @@ export default function GlCreateBookingForm() {
         }}
       >
         <Box maw={896} mx="auto">
-          {showErrors && !cargoValid ? (
+          {showErrors && !formValid ? (
             <Alert
               color="red"
               variant="light"
@@ -1269,24 +1436,14 @@ export default function GlCreateBookingForm() {
               icon={<AlertCircle size={16} />}
               mb="sm"
             >
-              Fix the highlighted cargo fields before reviewing the price.
+              Fix the highlighted fields before reviewing the price.
             </Alert>
           ) : null}
           <Group justify="flex-end">
-            <Button
-              variant="default"
-              radius="md"
-              onClick={() =>
-                navigate(`/dashboard/contracts/clearance/${contract.id}`)
-              }
-            >
-              Cancel
-            </Button>
             <Button
               color="edr-green"
               radius="md"
               leftSection={<Receipt size={16} />}
-              disabled={!canSubmit}
               onClick={openPriceModal}
             >
               Review price &amp; book
@@ -1298,12 +1455,11 @@ export default function GlCreateBookingForm() {
       <Modal
         opened={priceOpen}
         onClose={() => {
-          if (
-            !mutations.createBooking.isPending &&
-            !mutations.completeBooking.isPending
-          )
-            setPriceOpen(false);
+          if (!submitPending) setPriceOpen(false);
         }}
+        closeOnClickOutside={!submitPending}
+        closeOnEscape={!submitPending}
+        withCloseButton={!submitPending}
         centered
         radius="lg"
         size="lg"
@@ -1379,6 +1535,46 @@ export default function GlCreateBookingForm() {
               </Alert>
             )}
 
+            {containerClashErrors.length > 0 && (
+              <Alert
+                color="red"
+                variant="light"
+                radius="md"
+                icon={<AlertCircle size={16} />}
+                title="Cannot create booking — container already booked"
+              >
+                <Stack gap={6}>
+                  {containerClashErrors.map((msg, i) => (
+                    <Text key={i} fz="sm" c="red.8">
+                      {msg}
+                    </Text>
+                  ))}
+                  <Text fz="xs" c="red.7" mt={2}>
+                    A container can only be on one booking per train — remove it
+                    or pick another shipment day.
+                  </Text>
+                </Stack>
+              </Alert>
+            )}
+
+            {spaceErrors.length > 0 && (
+              <Alert
+                color="red"
+                variant="light"
+                radius="md"
+                icon={<AlertCircle size={16} />}
+                title="Cannot create booking — not enough train space"
+              >
+                <Stack gap={6}>
+                  {spaceErrors.map((msg, i) => (
+                    <Text key={i} fz="sm" c="red.8">
+                      {msg}
+                    </Text>
+                  ))}
+                </Stack>
+              </Alert>
+            )}
+
             {overweightLines.length > 0 && (
               <Alert
                 color="yellow"
@@ -1396,8 +1592,11 @@ export default function GlCreateBookingForm() {
                     </Text>
                   ))}
                   <Text fz="xs" c="#9A5B00" mt={2}>
-                    An overweight surcharge applies (included in the total
-                    below).
+                    {overweightSurchargeAmount > 0
+                      ? `An overweight surcharge of ${overweightSurchargeAmount.toLocaleString()} ${
+                          validation?.currency ?? displayTotal.currency ?? ""
+                        } applies (included in the total below). You can still submit, or go back and adjust weights.`
+                      : "An overweight surcharge applies. You can still submit, or go back and adjust weights."}
                   </Text>
                 </Stack>
               </Alert>
@@ -1454,10 +1653,7 @@ export default function GlCreateBookingForm() {
                 radius="md"
                 leftSection={<X size={16} />}
                 onClick={() => setPriceOpen(false)}
-                disabled={
-                  mutations.createBooking.isPending ||
-                  mutations.completeBooking.isPending
-                }
+                disabled={submitPending}
               >
                 Reject &amp; edit
               </Button>
@@ -1465,15 +1661,8 @@ export default function GlCreateBookingForm() {
                 color="edr-green"
                 radius="md"
                 leftSection={<CheckCircle2 size={16} />}
-                loading={
-                  mutations.createBooking.isPending ||
-                  mutations.completeBooking.isPending
-                }
-                disabled={
-                  validateShipmentMutation.isPending ||
-                  pairingErrors.length > 0 ||
-                  capacityErrors.length > 0
-                }
+                loading={submitPending}
+                disabled={confirmDisabled}
                 onClick={handleSubmit}
               >
                 {completeBookingId ? "Confirm & complete" : "Confirm & book"}
@@ -1482,8 +1671,6 @@ export default function GlCreateBookingForm() {
           </Stack>
         ) : null}
       </Modal>
-        </>
-      ) : null}
     </PageContainer>
   );
 }
diff --git a/apps/edr-freight-web/backoffice/src/components/contracts/gl-booking-form/total.ts b/apps/edr-freight-web/backoffice/src/components/contracts/gl-booking-form/total.ts
index 6747b4112..a734c4f06 100644
--- a/apps/edr-freight-web/backoffice/src/components/contracts/gl-booking-form/total.ts
+++ b/apps/edr-freight-web/backoffice/src/components/contracts/gl-booking-form/total.ts
@@ -24,9 +24,10 @@ export interface GlShipmentQuantities {
     hazardousQuantity: number;
     reeferQuantity: number;
   }>;
-  /** Bulk: tons (or item count) + hazardous qty. */
+  /** Bulk: tons (or item count) + hazardous/reefer qty. */
   bulkQuantity: number;
   bulkHazardousQuantity: number;
+  bulkReeferQuantity: number;
 }
 
 /**
@@ -113,6 +114,30 @@ export function computeGlShipmentTotal(
         amount: rate.unitPrice * qty,
       });
     }
+    if (contract.isHazardous && q.bulkHazardousQuantity > 0) {
+      const hz = rateFor((i) => i.conditionalOn === "is_hazardous");
+      if (hz) {
+        lines.push({
+          label: hz.label,
+          unitPrice: hz.unitPrice,
+          unit: hz.unit,
+          quantity: q.bulkHazardousQuantity,
+          amount: hz.unitPrice * q.bulkHazardousQuantity,
+        });
+      }
+    }
+    if (contract.isReefer && q.bulkReeferQuantity > 0) {
+      const rf = rateFor((i) => i.conditionalOn === "is_reefer");
+      if (rf) {
+        lines.push({
+          label: rf.label,
+          unitPrice: rf.unitPrice,
+          unit: rf.unit,
+          quantity: q.bulkReeferQuantity,
+          amount: rf.unitPrice * q.bulkReeferQuantity,
+        });
+      }
+    }
   }
 
   const total = lines.reduce((s, l) => s + l.amount, 0);
diff --git a/apps/edr-freight-web/backoffice/src/components/operations/ProofOfDeliveryModal.tsx b/apps/edr-freight-web/backoffice/src/components/operations/ProofOfDeliveryModal.tsx
new file mode 100644
index 000000000..7faae79d4
--- /dev/null
+++ b/apps/edr-freight-web/backoffice/src/components/operations/ProofOfDeliveryModal.tsx
@@ -0,0 +1,157 @@
+import { useState } from "react";
+import {
+  Button,
+  FileInput,
+  Group,
+  Modal,
+  Stack,
+  Text,
+  TextInput,
+  Textarea,
+} from "@mantine/core";
+import { useMutation } from "@tanstack/react-query";
+import { Camera, PenLine } from "lucide-react";
+
+import { ContractSignaturePad } from "@/components/bookings/ContractSignaturePad";
+import { lastMileService } from "@/services/last-mile.service";
+import { useToast } from "@/hooks/use-toast";
+
+interface ProofOfDeliveryModalProps {
+  opened: boolean;
+  onClose: () => void;
+  lastMileId: string | null;
+  reference?: string | null;
+  /** Called after a successful capture so the caller can refetch. */
+  onDone: () => void;
+}
+
+/**
+ * Proof of delivery capture for an EDR last-mile leg: recipient name, a drawn
+ * signature, and proof photos. On confirm it uploads everything and completes
+ * the delivery (marks the leg DELIVERED).
+ */
+export function ProofOfDeliveryModal({
+  opened,
+  onClose,
+  lastMileId,
+  reference,
+  onDone,
+}: ProofOfDeliveryModalProps) {
+  const { toast } = useToast();
+  const [recipient, setRecipient] = useState("");
+  const [notes, setNotes] = useState("");
+  const [signatureUrl, setSignatureUrl] = useState<string | null>(null);
+  const [photos, setPhotos] = useState<File[]>([]);
+
+  const reset = () => {
+    setRecipient("");
+    setNotes("");
+    setSignatureUrl(null);
+    setPhotos([]);
+  };
+
+  const close = () => {
+    reset();
+    onClose();
+  };
+
+  const submit = useMutation({
+    mutationFn: async () => {
+      if (!lastMileId) throw new Error("No delivery selected");
+      const signature = signatureUrl
+        ? await (await fetch(signatureUrl)).blob()
+        : null;
+      return lastMileService.recordProofOfDelivery(lastMileId, {
+        recipientName: recipient.trim(),
+        notes: notes.trim() || undefined,
+        signature,
+        photos,
+      });
+    },
+    onSuccess: () => {
+      toast({
+        title: "Proof of delivery recorded",
+        description: "The delivery has been completed.",
+      });
+      reset();
+      onDone();
+      onClose();
+    },
+    onError: (e) =>
+      toast({
+        variant: "destructive",
+        title: "Could not record delivery",
+        description: e instanceof Error ? e.message : undefined,
+      }),
+  });
+
+  // Require a recipient plus at least one form of proof (signature or a photo).
+  const canSubmit =
+    recipient.trim().length > 0 && (Boolean(signatureUrl) || photos.length > 0);
+
+  return (
+    <Modal
+      opened={opened}
+      onClose={close}
+      title={`Record delivery${reference ? ` — ${reference}` : ""}`}
+      size="lg"
+      centered
+    >
+      <Stack gap="md">
+        <TextInput
+          label="Received by"
+          placeholder="Recipient's name"
+          required
+          value={recipient}
+          onChange={(e) => setRecipient(e.currentTarget.value)}
+        />
+
+        <div>
+          <Text size="sm" fw={500} mb={4}>
+            Recipient signature
+          </Text>
+          <ContractSignaturePad onChange={setSignatureUrl} />
+        </div>
+
+        <FileInput
+          label="Proof photos"
+          placeholder="Attach delivery photo(s)"
+          leftSection={<Camera size={16} />}
+          accept="image/*"
+          multiple
+          clearable
+          value={photos}
+          onChange={setPhotos}
+        />
+
+        <Textarea
+          label="Notes"
+          placeholder="Optional delivery notes"
+          autosize
+          minRows={2}
+          value={notes}
+          onChange={(e) => setNotes(e.currentTarget.value)}
+        />
+
+        <Text size="xs" c="dimmed">
+          Provide a signature or at least one photo. Confirming completes the delivery.
+        </Text>
+
+        <Group justify="flex-end">
+          <Button variant="default" onClick={close} disabled={submit.isPending}>
+            Cancel
+          </Button>
+          <Button
+            color="green"
+            leftSection={<PenLine size={16} />}
+            loading={submit.isPending}
+            disabled={!canSubmit}
+            onClick={() => submit.mutate()}
+          >
+            Confirm delivery
+          </Button>
+        </Group>
+      </Stack>
+    </Modal>
+  );
+}
diff --git a/apps/edr-freight-web/backoffice/src/components/trainScheduling/AllocateBookingWizard.tsx b/apps/edr-freight-web/backoffice/src/components/trainScheduling/AllocateBookingWizard.tsx
index ff69d0290..ec4e1b5bc 100644
--- a/apps/edr-freight-web/backoffice/src/components/trainScheduling/AllocateBookingWizard.tsx
+++ b/apps/edr-freight-web/backoffice/src/components/trainScheduling/AllocateBookingWizard.tsx
@@ -137,8 +137,12 @@ export function AllocateBookingWizard({
       enabled: opened,
     }),
   );
+  // Paginated {items, meta} list; the newest 100 schedules comfortably cover
+  // every DRAFT schedule the wizard can attach to.
   const schedulesQuery = useQuery(
-    api.trainScheduling.scheduleList.queryOptions({ input: {} }),
+    api.trainScheduling.scheduleList.queryOptions({
+      input: { filters: { pageSize: 100 } },
+    }),
   );
   const routesQuery = useQuery(
     api.routes.list.queryOptions({ input: { status: "AVAILABLE" } }),
@@ -163,7 +167,7 @@ export function AllocateBookingWizard({
 
   const matchingSchedules = useMemo(
     () =>
-      (schedulesQuery.data ?? []).filter(
+      (schedulesQuery.data?.items ?? []).filter(
         (s: TrainScheduleListItem) =>
           s.status === "DRAFT" &&
           (!s.freightType || s.freightType === "MIXED" || s.freightType === bookingFreightType),
diff --git a/apps/edr-freight-web/backoffice/src/components/trainScheduling/BookingWindowSettingsModal.tsx b/apps/edr-freight-web/backoffice/src/components/trainScheduling/BookingWindowSettingsModal.tsx
index 1bfa392bc..c1232fbba 100644
--- a/apps/edr-freight-web/backoffice/src/components/trainScheduling/BookingWindowSettingsModal.tsx
+++ b/apps/edr-freight-web/backoffice/src/components/trainScheduling/BookingWindowSettingsModal.tsx
@@ -232,6 +232,15 @@ export default function BookingWindowSettingsModal({
         </Alert>
       ) : (
         <Stack gap="lg">
+          {!isExport ? (
+            <Alert variant="light" color="orange" icon={<Info size={16} />}>
+              These settings apply to every train on this route (same origin and
+              destination) departing the same day — they all share one booking
+              window, so it opens, moves to document review, opens for payment,
+              and closes at the same time for all of them.
+            </Alert>
+          ) : null}
+
           {isExport ? (
             <Alert variant="light" color="blue" icon={<Info size={16} />}>
               Export schedules use a single first-come-first-served window: it
diff --git a/apps/edr-freight-web/backoffice/src/components/trainScheduling/PriorityTrackingTab.tsx b/apps/edr-freight-web/backoffice/src/components/trainScheduling/PriorityTrackingTab.tsx
index b02ebbc8f..23b654a55 100644
--- a/apps/edr-freight-web/backoffice/src/components/trainScheduling/PriorityTrackingTab.tsx
+++ b/apps/edr-freight-web/backoffice/src/components/trainScheduling/PriorityTrackingTab.tsx
@@ -1,4 +1,4 @@
-import { useMemo, useState } from "react";
+import { memo, useMemo, useState } from "react";
 import {
   Box,
   Group,
@@ -267,7 +267,13 @@ function CapacityDivider({ used, max }: { used: number; max: number | null }) {
   );
 }
 
-export function PriorityTrackingTab({ data, bookings }: Props) {
+// Memoized: mounted in a keep-mounted Tabs panel, so it re-renders with every
+// page render; both props keep their identity across unrelated page state
+// (React Query structural sharing + the page's useMemo'd bookings).
+export const PriorityTrackingTab = memo(function PriorityTrackingTab({
+  data,
+  bookings,
+}: Props) {
   const phase = data.windowPhase;
   const isPayPhase = phase === "PAYMENT";
 
@@ -558,7 +564,7 @@ export function PriorityTrackingTab({ data, bookings }: Props) {
       ) : null}
     </Stack>
   );
-}
+});
 
 /** Contextual banner describing the current window phase in plain language. */
 function PhaseBanner({ phase }: { phase: string | null }) {
diff --git a/apps/edr-freight-web/backoffice/src/components/warehouses/ZoneOccupancyHeatmap.tsx b/apps/edr-freight-web/backoffice/src/components/warehouses/ZoneOccupancyHeatmap.tsx
new file mode 100644
index 000000000..9fcbd88ed
--- /dev/null
+++ b/apps/edr-freight-web/backoffice/src/components/warehouses/ZoneOccupancyHeatmap.tsx
@@ -0,0 +1,96 @@
+import { Badge, Card, Group, Loader, Progress, SimpleGrid, Stack, Text } from '@mantine/core';
+import { LayoutGrid } from 'lucide-react';
+
+import { useZoneOccupancy } from '@/hooks/useWarehouses';
+import type { ZoneOccupancy } from '@/types/warehouse';
+
+/** Green < 60%, amber 60–85%, red > 85%. */
+function tone(pct: number | null): { color: string; label: string } {
+  if (pct == null) return { color: 'gray', label: 'No capacity set' };
+  if (pct > 85) return { color: 'red', label: 'Full' };
+  if (pct >= 60) return { color: 'orange', label: 'Filling' };
+  return { color: 'teal', label: 'Space' };
+}
+
+function capacityLabel(z: ZoneOccupancy): string {
+  if (z.capacityContainers && z.capacityContainers > 0) {
+    return `${z.usedItems} / ${z.capacityContainers} items`;
+  }
+  if (z.capacityWeight && z.capacityWeight > 0) {
+    return `${z.usedItems} item(s) · ${z.usedWeight.toLocaleString()} kg`;
+  }
+  return `${z.usedItems} item(s)`;
+}
+
+interface ZoneOccupancyHeatmapProps {
+  /** Scope to one yard; omit for all zones. */
+  yardId?: string;
+}
+
+/**
+ * Occupancy heatmap: one tile per zone, coloured by how full it is. Occupancy is
+ * container-count based (unit-consistent); weight is shown as context only.
+ */
+export function ZoneOccupancyHeatmap({ yardId }: ZoneOccupancyHeatmapProps) {
+  const { data: zones = [], isLoading } = useZoneOccupancy(yardId);
+
+  if (isLoading) {
+    return (
+      <Group justify="center" py="lg">
+        <Loader size="sm" />
+      </Group>
+    );
+  }
+
+  if (zones.length === 0) {
+    return (
+      <Text c="dimmed" ta="center" py="lg" size="sm">
+        No active zones to show occupancy for.
+      </Text>
+    );
+  }
+
+  return (
+    <Stack gap="sm">
+      <Group gap="xs">
+        <LayoutGrid size={16} />
+        <Text fw={600} size="sm">
+          Zone occupancy
+        </Text>
+        <Text size="xs" c="dimmed">
+          ({zones.length} zone{zones.length !== 1 ? 's' : ''})
+        </Text>
+      </Group>
+
+      <SimpleGrid cols={{ base: 1, xs: 2, sm: 3, lg: 4 }} spacing="sm">
+        {zones.map((z) => {
+          const t = tone(z.occupancyPct);
+          const pct = z.occupancyPct ?? 0;
+          return (
+            <Card key={z.id} withBorder radius="md" padding="sm">
+              <Stack gap={6}>
+                <Group justify="space-between" wrap="nowrap" gap="xs">
+                  <Text fw={600} size="sm" truncate title={z.name}>
+                    {z.name}
+                  </Text>
+                  <Badge color={t.color} variant="light" size="sm">
+                    {z.occupancyPct == null ? '—' : `${Math.round(pct)}%`}
+                  </Badge>
+                </Group>
+                <Progress value={Math.min(pct, 100)} color={t.color} size="lg" radius="sm" />
+                <Group justify="space-between" gap="xs">
+                  <Text size="xs" c="dimmed">
+                    {capacityLabel(z)}
+                  </Text>
+                  <Text size="xs" c={t.color === 'gray' ? 'dimmed' : t.color}>
+                    {t.label}
+                  </Text>
+                </Group>
+              </Stack>
+            </Card>
+          );
+        })}
+      </SimpleGrid>
+    </Stack>
+  );
+}
diff --git a/apps/edr-freight-web/backoffice/src/components/warehouses/index.ts b/apps/edr-freight-web/backoffice/src/components/warehouses/index.ts
index 44d77c1e9..075237198 100644
--- a/apps/edr-freight-web/backoffice/src/components/warehouses/index.ts
+++ b/apps/edr-freight-web/backoffice/src/components/warehouses/index.ts
@@ -29,3 +29,4 @@ export { VisualEmptyState } from './VisualEmptyState';
 export { WarehouseDashboardCharts } from './WarehouseDashboardCharts';
 export { InspectionReportModal } from './InspectionReportModal';
 export { FeePreviewModal } from './FeePreviewModal';
+export { ZoneOccupancyHeatmap } from './ZoneOccupancyHeatmap';
diff --git a/apps/edr-freight-web/backoffice/src/constants/QUERY_KEYS.ts b/apps/edr-freight-web/backoffice/src/constants/QUERY_KEYS.ts
index dbac021f3..3d064355a 100644
--- a/apps/edr-freight-web/backoffice/src/constants/QUERY_KEYS.ts
+++ b/apps/edr-freight-web/backoffice/src/constants/QUERY_KEYS.ts
@@ -100,7 +100,8 @@ export const QUERY_KEYS = {
     locomotives: (routeId?: string) =>
       ["train-scheduling", "locomotives", routeId ?? "all"] as const,
     stations: () => ["train-scheduling", "stations"] as const,
-    schedules: () => ["train-scheduling", "schedules"] as const,
+    schedules: (filters?: unknown) =>
+      ["train-scheduling", "schedules", filters ?? {}] as const,
     scheduleById: (id: string) => ["train-scheduling", "schedule", id] as const,
     track: (id: string) => ["train-scheduling", "track", id] as const,
     batchBoard: (filters?: unknown) =>
diff --git a/apps/edr-freight-web/backoffice/src/constants/URLS.ts b/apps/edr-freight-web/backoffice/src/constants/URLS.ts
index ca9f6342d..2eaee8090 100644
--- a/apps/edr-freight-web/backoffice/src/constants/URLS.ts
+++ b/apps/edr-freight-web/backoffice/src/constants/URLS.ts
@@ -486,6 +486,10 @@ export const URL_CONSTANTS = {
     MOVE: (id: string) => `/warehouse-inventory/${id}/move`,
     RESERVE: "/warehouse-inventory/reserve",
     ARRIVAL_QUEUE: "/warehouse-inventory/arrival-queue",
+    ZONE_OCCUPANCY: (yardId?: string) =>
+      yardId
+        ? `/warehouse-inventory/zone-occupancy?yardId=${yardId}`
+        : "/warehouse-inventory/zone-occupancy",
     AUTO_UNLOAD_ARRIVED: "/warehouse-inventory/auto-unload-arrived",
     AUTO_LOAD_READY: "/warehouse-inventory/auto-load-ready",
     UNLOAD_BOOKING: (bookingId: string) =>
@@ -617,6 +621,7 @@ export const URL_CONSTANTS = {
     BASE: "/last-mile",
     BY_ID: (id: string) => `/last-mile/${id}`,
     ACCEPT: (reference: string) => `/last-mile/accept/${reference}`,
+    PROOF_OF_DELIVERY: (id: string) => `/last-mile/${id}/proof-of-delivery`,
   },
 
   DRIVERS: {
diff --git a/apps/edr-freight-web/backoffice/src/features/bookingWindows/useBookingWindowSocket.ts b/apps/edr-freight-web/backoffice/src/features/bookingWindows/useBookingWindowSocket.ts
index e6075f06f..d5409584f 100644
--- a/apps/edr-freight-web/backoffice/src/features/bookingWindows/useBookingWindowSocket.ts
+++ b/apps/edr-freight-web/backoffice/src/features/bookingWindows/useBookingWindowSocket.ts
@@ -1,6 +1,7 @@
 import {
   BOOKING_WINDOW_WS_EVENTS,
   BOOKING_WINDOW_WS_NAMESPACE,
+  type BatchBoardChangedEvent,
   type BookingWindowPhaseEvent,
 } from "@edr/types";
 import { useQueryClient } from "@tanstack/react-query";
@@ -82,9 +83,19 @@ export function useBookingWindowSocket(enabled: boolean = true) {
 
     // Deliberate console breadcrumbs: "live updates not arriving" is only
     // diagnosable from the browser when connect/reject outcomes are visible.
-    socket.on("connect", () =>
-      console.debug("[booking-windows] socket connected", socket.id),
-    );
+    let hadConnected = false;
+    socket.on("connect", () => {
+      console.debug("[booking-windows] socket connected", socket.id);
+      // A RE-connect means pushes may have been missed while offline — refetch
+      // every board view (list + any open detail share the "batch-board" key
+      // prefix) once so the gap self-heals immediately.
+      if (hadConnected) {
+        void qc.invalidateQueries({
+          queryKey: ["train-scheduling", "batch-board"],
+        });
+      }
+      hadConnected = true;
+    });
     socket.on("connect_error", (err) =>
       console.warn("[booking-windows] socket connect failed:", err.message),
     );
@@ -144,6 +155,19 @@ export function useBookingWindowSocket(enabled: boolean = true) {
       },
     );
 
+    // Board-data pushes (payment settled, allocation, fill, expiry, …): refetch
+    // the schedule's detail immediately, refresh the list debounced. The event
+    // carries no data — the board views are rich, differently-shaped queries.
+    socket.on(
+      BOOKING_WINDOW_WS_EVENTS.BATCH_CHANGED,
+      (event: BatchBoardChangedEvent) => {
+        void qc.invalidateQueries({
+          queryKey: QUERY_KEYS.TRAIN_SCHEDULING.batchBoardDetail(event.scheduleId),
+        });
+        scheduleRefetch(false);
+      },
+    );
+
     return () => {
       if (refetchTimer) clearTimeout(refetchTimer);
       socket.off();
diff --git a/apps/edr-freight-web/backoffice/src/features/bookings/booking-status.config.ts b/apps/edr-freight-web/backoffice/src/features/bookings/booking-status.config.ts
index 25f4b51bc..f87f96433 100644
--- a/apps/edr-freight-web/backoffice/src/features/bookings/booking-status.config.ts
+++ b/apps/edr-freight-web/backoffice/src/features/bookings/booking-status.config.ts
@@ -62,6 +62,10 @@ export const BOOKING_STATUS_STYLES: Record<string, StatusStyle> = {
     label: "Paid",
     color: "bg-[color:var(--freight-brand-muted)] text-[color:var(--freight-brand)] border-[color:var(--freight-brand-border)]",
   },
+  TRUCK_ASSIGNED: {
+    label: "Truck Assigned",
+    color: "bg-[color:var(--freight-brand-muted)] text-[color:var(--freight-brand)] border-[color:var(--freight-brand-border)]",
+  },
   IN_TRANSIT: {
     label: "In Transit",
     color: "bg-sky-50 text-sky-700 border-sky-200",
@@ -206,6 +210,12 @@ export const BOOKING_STATUS_META: Record<string, StatusMeta> = {
     color: "text-[color:var(--freight-brand)]",
     stage: 4,
   },
+  TRUCK_ASSIGNED: {
+    title: "Truck Assigned",
+    description: "Customer truck assigned for self-haul; ready for operations.",
+    color: "text-[color:var(--freight-brand)]",
+    stage: 4,
+  },
   IN_TRANSIT: {
     title: "In Transit",
     description: "Shipment is on the railway network.",
@@ -300,7 +310,7 @@ export const BOOKING_LIST_TABS = [
   {
     key: "operations",
     label: "Operations",
-    statuses: ["PAID", "IN_TRANSIT", "ARRIVED", "ROAD_DISPATCH_PENDING"],
+    statuses: ["PAID", "TRUCK_ASSIGNED", "IN_TRANSIT", "ARRIVED", "ROAD_DISPATCH_PENDING"],
   },
   { key: "completed", label: "Completed", statuses: ["COMPLETED"] },
   { key: "closed", label: "Closed", statuses: ["REJECTED", "CANCELLED"] },
@@ -338,7 +348,7 @@ export const WORKFLOW_STAGES = [
   },
   {
     label: "Operations",
-    statuses: ["PAID", "IN_TRANSIT", "ARRIVED"],
+    statuses: ["PAID", "TRUCK_ASSIGNED", "IN_TRANSIT", "ARRIVED"],
   },
   { label: "Done", statuses: ["COMPLETED"] },
 ] as const;
diff --git a/apps/edr-freight-web/backoffice/src/hooks/contracts/useContracts.ts b/apps/edr-freight-web/backoffice/src/hooks/contracts/useContracts.ts
index 076316114..c74b5b084 100644
--- a/apps/edr-freight-web/backoffice/src/hooks/contracts/useContracts.ts
+++ b/apps/edr-freight-web/backoffice/src/hooks/contracts/useContracts.ts
@@ -211,7 +211,9 @@ export function useContractMutations(contractId: string) {
       toast.success("Booking created under contract");
       void invalidateContractDetail(qc, contractId);
     },
-    onError: () => toast.error("Failed to create booking"),
+    // Surface the server's reason (e.g. a container already booked on the same
+    // train) instead of a generic failure.
+    onError: (e: Error) => toast.error(e.message || "Failed to create booking"),
   });
 
   const completeBooking = useMutation({
diff --git a/apps/edr-freight-web/backoffice/src/hooks/rule-engine/useRuleEngine.ts b/apps/edr-freight-web/backoffice/src/hooks/rule-engine/useRuleEngine.ts
index dcc8b21ed..4b2532d46 100644
--- a/apps/edr-freight-web/backoffice/src/hooks/rule-engine/useRuleEngine.ts
+++ b/apps/edr-freight-web/backoffice/src/hooks/rule-engine/useRuleEngine.ts
@@ -14,9 +14,6 @@ import {
   patchRuleEngineListRecord,
 } from "@/utils/queryInvalidation";
 
-const CARGO_TYPE_PARENT_PAGE_SIZE = 500;
-const CONTAINER_TYPE_OPTIONS_PAGE_SIZE = 500;
-
 export const useRuleEngineList = (
   resource: RuleEngineResourceSlug,
   params: RuleEngineListParams,
@@ -26,8 +23,7 @@ export const useRuleEngineList = (
     queryFn: () => ruleEngineService.list(resource, params),
   });
 
-const ORDER_LIST_PAGE_SIZE = 500;
-
+/** Full (page-walked) list used by the reorder dialog and create-position picker. */
 export const useRuleEngineOrderList = (
   resource: RuleEngineResourceSlug,
   enabled: boolean,
@@ -36,9 +32,7 @@ export const useRuleEngineOrderList = (
   useQuery({
     queryKey: QUERY_KEYS.RULE_ENGINE.orderList(resource),
     queryFn: () =>
-      ruleEngineService.list(resource, {
-        page: 1,
-        pageSize: ORDER_LIST_PAGE_SIZE,
+      ruleEngineService.listAll(resource, {
         sortBy,
         sortOrder: "ASC",
       }),
@@ -75,15 +69,11 @@ export const useRuleEngineOrderMutations = (resource: RuleEngineResourceSlug) =>
 export const useCargoTypeParentOptions = (excludeId?: string, enabled = true) =>
   useQuery({
     queryKey: QUERY_KEYS.RULE_ENGINE.selectOptions("cargo-types"),
-    queryFn: () =>
-      ruleEngineService.list<RuleEngineRecord>("cargo-types", {
-        page: 1,
-        pageSize: CARGO_TYPE_PARENT_PAGE_SIZE,
-      }),
+    queryFn: () => ruleEngineService.listAll<RuleEngineRecord>("cargo-types"),
     enabled,
-    select: (result) => {
+    select: (rows) => {
       const noneOption = { label: "None", value: RULE_ENGINE_SELECT_NONE };
-      const parents = (result.data ?? [])
+      const parents = rows
         .filter((row) => row.id && String(row.id) !== excludeId)
         .map((row) => {
           const name = String(row.cargoTypeName ?? "").trim();
@@ -104,14 +94,9 @@ export const useCargoTypeParentOptions = (excludeId?: string, enabled = true) =>
 export const useCargoLeafOptions = (enabled = true) =>
   useQuery({
     queryKey: QUERY_KEYS.RULE_ENGINE.selectOptions("cargo-types", { leafOnly: true }),
-    queryFn: () =>
-      ruleEngineService.list<RuleEngineRecord>("cargo-types", {
-        page: 1,
-        pageSize: CARGO_TYPE_PARENT_PAGE_SIZE,
-      }),
+    queryFn: () => ruleEngineService.listAll<RuleEngineRecord>("cargo-types"),
     enabled,
-    select: (result) => {
-      const rows = result.data ?? [];
+    select: (rows) => {
       const parentIds = new Set(
         rows
           .map((row) => row.parentGroupId)
@@ -157,21 +142,12 @@ export const useContainerTypeOptions = (
 ) =>
   useQuery({
     queryKey: QUERY_KEYS.RULE_ENGINE.selectOptions('container-types', {
-      page: 1,
-      pageSize: CONTAINER_TYPE_OPTIONS_PAGE_SIZE,
       includeNone,
     }),
     queryFn: () =>
-      api.ruleEngine.list.call({
-        resource: "container-types",
-        params: {
-          page: 1,
-          pageSize: CONTAINER_TYPE_OPTIONS_PAGE_SIZE,
-        },
-      }),
+      ruleEngineService.listAll<RuleEngineRecord>("container-types"),
     enabled,
-    select: (result) =>
-      buildContainerTypeSelectOptions(result.data ?? [], includeNone),
+    select: (rows) => buildContainerTypeSelectOptions(rows, includeNone),
   });
 
 /**
@@ -191,20 +167,14 @@ export const useWagonTypeOptions = (enabled = true) =>
         })),
   });
 
-const LIVE_RATE_PAGE_SIZE = 500;
-
 export const useLiveRateOptions = (enabled = true) =>
   useQuery({
     queryKey: QUERY_KEYS.RULE_ENGINE.selectOptions("rates", { status: "LIVE" }),
     queryFn: () =>
-      ruleEngineService.list<RuleEngineRecord>("rates", {
-        page: 1,
-        pageSize: LIVE_RATE_PAGE_SIZE,
-        status: "LIVE",
-      }),
+      ruleEngineService.listAll<RuleEngineRecord>("rates", { status: "LIVE" }),
     enabled,
-    select: (result) =>
-      (result.data ?? [])
+    select: (rows) =>
+      rows
         .filter((row) => row.id)
         .map((row) => {
           const rateType = String(row.rateType ?? "").replace(/_/g, " ");
diff --git a/apps/edr-freight-web/backoffice/src/hooks/useWarehouses.ts b/apps/edr-freight-web/backoffice/src/hooks/useWarehouses.ts
index 5ed88d5ac..59709d2d7 100644
--- a/apps/edr-freight-web/backoffice/src/hooks/useWarehouses.ts
+++ b/apps/edr-freight-web/backoffice/src/hooks/useWarehouses.ts
@@ -57,7 +57,7 @@ export function useWarehouse(id?: string) {
 export function useWarehouseFacilities() {
   return useQuery({
     queryKey: warehouseKeys.facilities(),
-    queryFn: () => warehouseService.listFacilities().then((r) => r.data),
+    queryFn: () => warehouseService.listFacilities().then((r) => r.data.items),
   });
 }
 
@@ -136,6 +136,14 @@ export function useAllWarehouseZones() {
   });
 }
 
+/** Live per-zone occupancy for the heatmap (optionally scoped to one yard). */
+export function useZoneOccupancy(yardId?: string) {
+  return useQuery({
+    queryKey: ['warehouse-zones', 'occupancy', yardId ?? 'all'],
+    queryFn: () => warehouseService.zoneOccupancy(yardId).then((r) => r.data),
+  });
+}
+
 export function useCreateZone() {
   const qc = useQueryClient();
   return useMutation({
diff --git a/apps/edr-freight-web/backoffice/src/pages/bookings/BookingRequestsPage.tsx b/apps/edr-freight-web/backoffice/src/pages/bookings/BookingRequestsPage.tsx
index c406b7a4b..72c16215b 100644
--- a/apps/edr-freight-web/backoffice/src/pages/bookings/BookingRequestsPage.tsx
+++ b/apps/edr-freight-web/backoffice/src/pages/bookings/BookingRequestsPage.tsx
@@ -12,6 +12,7 @@ import {
   TextInput,
 } from "@mantine/core";
 import { DateInput } from "@mantine/dates";
+import { useDebouncedValue } from "@mantine/hooks";
 import {
   AlertTriangle,
   ArrowRight,
@@ -125,6 +126,7 @@ export default function BookingRequestsPage() {
   const navigate = useNavigate();
   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").
@@ -158,6 +160,8 @@ export default function BookingRequestsPage() {
       // React Query cache key per kind tab.
       tab: kindTab,
       bookingType: kindTab,
+      // Server-side free-text search (booking ref, customer, contract ref).
+      ...(debouncedQuery.trim() ? { search: debouncedQuery.trim() } : {}),
       ...(statusFilter.length ? { statuses: statusFilter.join(",") } : {}),
       ...(directionFilter ? { tradeDirection: directionFilter } : {}),
       ...(freightTypeFilter ? { freightType: freightTypeFilter } : {}),
@@ -178,6 +182,7 @@ export default function BookingRequestsPage() {
     pagination.pageIndex,
     pagination.pageSize,
     kindTab,
+    debouncedQuery,
     statusFilter,
     directionFilter,
     freightTypeFilter,
@@ -245,17 +250,12 @@ export default function BookingRequestsPage() {
     resetPage();
   }, [resetPage]);
 
-  const rows = useMemo(() => {
-    const items = (data?.items ?? []).map(toBookingListRow);
-    const q = query.trim().toLowerCase();
-    if (!q) return items;
-    return items.filter(
-      (b) =>
-        b.reference.toLowerCase().includes(q) ||
-        b.customerLabel.toLowerCase().includes(q) ||
-        (b.contractReference?.toLowerCase().includes(q) ?? false),
-    );
-  }, [data?.items, query]);
+  // Search is applied server-side (via the `search` filter param) — no
+  // client-side filtering here.
+  const rows = useMemo(
+    () => (data?.items ?? []).map(toBookingListRow),
+    [data?.items],
+  );
 
   const total = data?.total ?? 0;
   const pageCount = Math.max(1, Math.ceil(total / pagination.pageSize));
@@ -496,7 +496,10 @@ export default function BookingRequestsPage() {
                       placeholder="Search booking, contract or customer…"
                       leftSection={<Search size={18} />}
                       value={query}
-                      onChange={(e) => setQuery(e.target.value)}
+                      onChange={(e) => {
+                        setQuery(e.target.value);
+                        resetPage();
+                      }}
                       rightSection={
                         query && (
                           <ActionIcon
@@ -504,7 +507,10 @@ export default function BookingRequestsPage() {
                             color="gray"
                             radius="md"
                             variant="transparent"
-                            onClick={() => setQuery("")}
+                            onClick={() => {
+                              setQuery("");
+                              resetPage();
+                            }}
                           >
                             <X size={16} />
                           </ActionIcon>
diff --git a/apps/edr-freight-web/backoffice/src/pages/bookings/DocumentClearanceDetailPage.tsx b/apps/edr-freight-web/backoffice/src/pages/bookings/DocumentClearanceDetailPage.tsx
index bb271e205..79d35aa7d 100644
--- a/apps/edr-freight-web/backoffice/src/pages/bookings/DocumentClearanceDetailPage.tsx
+++ b/apps/edr-freight-web/backoffice/src/pages/bookings/DocumentClearanceDetailPage.tsx
@@ -248,6 +248,7 @@ export default function DocumentClearanceDetailPage() {
                     // stepper's "Create booking" step must read as NOT-yet-created
                     // so it never claims the booking is done before GL completes it.
                     bookingCreated={Number(booking?.totalAmount ?? 0) > 0}
+                    bookingMilestones={bookingMilestones ?? []}
                     onChanged={() => void refetch()}
                     onViewFile={view}
                     onDownloadFile={(f) => void downloadBookingFile(f.id, f.name)}
diff --git a/apps/edr-freight-web/backoffice/src/pages/contracts/ClearanceDocumentsPage.tsx b/apps/edr-freight-web/backoffice/src/pages/contracts/ClearanceDocumentsPage.tsx
new file mode 100644
index 000000000..5b365bc9d
--- /dev/null
+++ b/apps/edr-freight-web/backoffice/src/pages/contracts/ClearanceDocumentsPage.tsx
@@ -0,0 +1,503 @@
+import {
+  ActionIcon,
+  Box,
+  Card,
+  Group,
+  Select,
+  Stack,
+  Tabs,
+  Text,
+  TextInput,
+  ThemeIcon,
+} from "@mantine/core";
+import { useDebouncedValue } from "@mantine/hooks";
+import { keepPreviousData, useQuery } from "@tanstack/react-query";
+import {
+  ArrowRight,
+  FileText,
+  Inbox,
+  RefreshCw,
+  Repeat,
+  Search,
+  User,
+  X,
+} from "lucide-react";
+import { useCallback, useMemo, useState } from "react";
+import { useNavigate } from "react-router-dom";
+
+import { BookingStatusBadge } from "@/components/bookings/BookingStatusBadge";
+import { bookingTable } from "@/components/bookings/booking-ui.styles";
+import { ContractStatusBadge } from "@/components/contracts/ContractStatusBadge";
+import { PageContainer, PageHeader } from "@/components/page";
+import {
+  toContractListRow,
+  type ContractListRow,
+} from "@/features/contracts/mapContractListRow";
+import { bookingsService } from "@/services/bookings.service";
+import { contractsService } from "@/services/contracts.service";
+import type { BookingDetail } from "@/types/booking";
+import {
+  Badge,
+  DataTable,
+  DataTableFooter,
+  usePagination,
+  type ColumnDef,
+} from "@edr/ui-common";
+
+/**
+ * Operations "Clearance Documents" hub — worklist for clearance-document
+ * review on contracts WITHOUT customs clearing (self-clearance):
+ * Contracts tab = contract-level review (one-time flow), General tab =
+ * per-booking review under GENERAL non-customs contracts. Rows deep-link to
+ * the existing review detail pages; search / status filter / pagination are
+ * all server-side.
+ */
+
+type HubTab = "contracts" | "general";
+
+const PAGE_SIZE = 10;
+
+/** Status filter options for the Contracts tab (values = `statuses` param). */
+const CONTRACT_STATUS_OPTIONS = [
+  {
+    value: [
+      "AWAITING_CLEARANCE_DOCUMENTS",
+      "CLEARANCE_UNDER_REVIEW",
+      "CLEARANCE_READY_FOR_BOOKING",
+      "FULLY_EXECUTED",
+      "CONTRACT_ACTIVE",
+      "ACTIVE_SHIPMENT_IN_PROGRESS",
+      "CONTRACT_CLOSED",
+      "CANCELLED",
+    ].join(","),
+    label: "All statuses",
+  },
+  { value: "AWAITING_CLEARANCE_DOCUMENTS", label: "Awaiting documents" },
+  { value: "CLEARANCE_UNDER_REVIEW", label: "Under review" },
+  { value: "CLEARANCE_READY_FOR_BOOKING", label: "Ready for booking" },
+  { value: "FULLY_EXECUTED,CONTRACT_ACTIVE", label: "Finalized" },
+  {
+    value: "ACTIVE_SHIPMENT_IN_PROGRESS,CONTRACT_CLOSED",
+    label: "In progress / closed",
+  },
+  { value: "CANCELLED", label: "Cancelled" },
+];
+
+/** Status filter options for the General (per-booking) tab. */
+const BOOKING_STATUS_OPTIONS = [
+  {
+    value: "AWAITING_DOCUMENTS,DOCUMENTS_UNDER_REVIEW,CLEARANCE_READY",
+    label: "All statuses",
+  },
+  { value: "AWAITING_DOCUMENTS", label: "Awaiting documents" },
+  { value: "DOCUMENTS_UNDER_REVIEW", label: "Under review" },
+  { value: "CLEARANCE_READY", label: "Clearance ready" },
+];
+
+export default function ClearanceDocumentsPage() {
+  const navigate = useNavigate();
+  const [hubTab, setHubTab] = useState<HubTab>("contracts");
+  const [query, setQuery] = useState("");
+  const [debouncedQuery] = useDebouncedValue(query, 300);
+  const [contractStatuses, setContractStatuses] = useState(
+    CONTRACT_STATUS_OPTIONS[0].value,
+  );
+  const [bookingStatuses, setBookingStatuses] = useState(
+    BOOKING_STATUS_OPTIONS[0].value,
+  );
+  const { pagination, setPagination } = usePagination({ pageSize: PAGE_SIZE });
+
+  const search = debouncedQuery.trim() || undefined;
+
+  const resetPage = useCallback(() => {
+    setPagination({ pageIndex: 0, pageSize: PAGE_SIZE });
+  }, [setPagination]);
+
+  const page = pagination.pageIndex + 1;
+
+  const contractsQuery = useQuery({
+    queryKey: [
+      "clearance-documents",
+      "contracts",
+      contractStatuses,
+      page,
+      search,
+    ],
+    queryFn: () =>
+      contractsService.getOpsClearanceQueue({
+        page,
+        pageSize: PAGE_SIZE,
+        statuses: contractStatuses,
+        search,
+      }),
+    enabled: hubTab === "contracts",
+    placeholderData: keepPreviousData,
+  });
+
+  const generalQuery = useQuery({
+    queryKey: ["clearance-documents", "general", bookingStatuses, page, search],
+    queryFn: () =>
+      bookingsService.list({
+        statuses: bookingStatuses,
+        bookingType: "GENERAL_CONTRACT",
+        customsClearingEnabled: "false",
+        page,
+        pageSize: PAGE_SIZE,
+        search,
+      }),
+    enabled: hubTab === "general",
+    placeholderData: keepPreviousData,
+  });
+
+  const contractRows = useMemo(
+    () => (contractsQuery.data?.items ?? []).map(toContractListRow),
+    [contractsQuery.data?.items],
+  );
+  const bookingRows = generalQuery.data?.items ?? [];
+
+  const contractColumns: ColumnDef<ContractListRow>[] = useMemo(
+    () => [
+      {
+        id: "contract",
+        header: () => <span className={bookingTable.headerCell}>Customer</span>,
+        cell: ({ row }) => {
+          const c = row.original;
+          return (
+            <div className="flex items-center gap-3 py-1.5">
+              <div className={bookingTable.rowIcon}>
+                <User className="size-4" strokeWidth={1.75} />
+              </div>
+              <div className="min-w-0">
+                <p className="truncate font-medium text-foreground">
+                  {c.customerLabel}
+                </p>
+                <p className="mt-0.5 flex items-center gap-1 truncate text-xs text-muted-foreground">
+                  <FileText className="size-3 shrink-0 opacity-70" />
+                  {c.reference}
+                </p>
+              </div>
+            </div>
+          );
+        },
+      },
+      {
+        id: "route",
+        header: () => <span className={bookingTable.headerCell}>Route</span>,
+        cell: ({ row }) => {
+          const c = row.original;
+          return (
+            <div className="space-y-1 py-1">
+              <div className="flex items-center gap-1.5 text-sm font-medium text-foreground">
+                <span className="max-w-[8rem] truncate">{c.originLabel}</span>
+                <ArrowRight className="size-3.5 shrink-0 text-muted-foreground" />
+                <span className="max-w-[8rem] truncate">
+                  {c.destinationLabel}
+                </span>
+              </div>
+              <div className="flex gap-1.5">
+                <Badge
+                  variant="outline"
+                  className="h-5 border-border/50 bg-background/50 px-1.5 text-[10px] font-medium uppercase backdrop-blur-sm"
+                >
+                  {c.tradeDirection}
+                </Badge>
+                <Badge
+                  variant="secondary"
+                  className="h-5 bg-muted/40 px-1.5 text-[10px] font-medium"
+                >
+                  {c.freightType}
+                </Badge>
+              </div>
+            </div>
+          );
+        },
+      },
+      {
+        id: "kind",
+        header: () => <span className={bookingTable.headerCell}>Kind</span>,
+        cell: ({ row }) => (
+          <Badge
+            variant="outline"
+            className="h-5 border-border/50 bg-background/50 px-1.5 text-[10px] font-medium uppercase"
+          >
+            {row.original.contractKind === "GENERAL" ? (
+              <span className="inline-flex items-center gap-1">
+                <Repeat className="size-3" /> General
+              </span>
+            ) : (
+              "One-time"
+            )}
+          </Badge>
+        ),
+      },
+      {
+        id: "status",
+        size: 200,
+        minSize: 180,
+        header: () => <span className={bookingTable.headerCell}>Status</span>,
+        cell: ({ row }) => (
+          <div className="py-1">
+            <ContractStatusBadge
+              status={row.original.status}
+              isRenewal={row.original.isRenewal}
+            />
+          </div>
+        ),
+        meta: {
+          headerClassName: "min-w-[11rem]",
+          cellClassName: "min-w-[11rem]",
+        },
+      },
+    ],
+    [],
+  );
+
+  const bookingColumns: ColumnDef<BookingDetail>[] = useMemo(
+    () => [
+      {
+        id: "booking",
+        header: () => <span className={bookingTable.headerCell}>Customer</span>,
+        cell: ({ row }) => {
+          const b = row.original;
+          const customer = b.isGovernment
+            ? (b.governmentInstitution ?? "Government")
+            : (b.company?.name ?? "—");
+          return (
+            <div className="flex items-center gap-3 py-1.5">
+              <div className={bookingTable.rowIcon}>
+                <User className="size-4" strokeWidth={1.75} />
+              </div>
+              <div className="min-w-0">
+                <p className="truncate font-medium text-foreground">
+                  {customer}
+                </p>
+                <p className="mt-0.5 flex items-center gap-1 truncate text-xs text-muted-foreground">
+                  <FileText className="size-3 shrink-0 opacity-70" />
+                  {b.reference}
+                </p>
+              </div>
+            </div>
+          );
+        },
+      },
+      {
+        id: "contractRef",
+        header: () => <span className={bookingTable.headerCell}>Contract</span>,
+        cell: ({ row }) => (
+          <Text size="sm">{row.original.contractReference ?? "—"}</Text>
+        ),
+      },
+      {
+        id: "shipment",
+        header: () => <span className={bookingTable.headerCell}>Shipment</span>,
+        cell: ({ row }) => {
+          const b = row.original;
+          return (
+            <div className="flex gap-1.5 py-1">
+              <Badge
+                variant="outline"
+                className="h-5 border-border/50 bg-background/50 px-1.5 text-[10px] font-medium uppercase backdrop-blur-sm"
+              >
+                {b.tradeDirection ?? "—"}
+              </Badge>
+              <Badge
+                variant="secondary"
+                className="h-5 bg-muted/40 px-1.5 text-[10px] font-medium"
+              >
+                {b.freightType ?? "—"}
+              </Badge>
+            </div>
+          );
+        },
+      },
+      {
+        id: "status",
+        size: 200,
+        minSize: 180,
+        header: () => <span className={bookingTable.headerCell}>Status</span>,
+        cell: ({ row }) => (
+          <div className="py-1">
+            <BookingStatusBadge status={row.original.status} />
+          </div>
+        ),
+        meta: {
+          headerClassName: "min-w-[11rem]",
+          cellClassName: "min-w-[11rem]",
+        },
+      },
+    ],
+    [],
+  );
+
+  const isContracts = hubTab === "contracts";
+  const activeQuery = isContracts ? contractsQuery : generalQuery;
+  const total = activeQuery.data?.total ?? 0;
+  const pageCount = Math.max(1, Math.ceil(total / PAGE_SIZE));
+  const showEmpty =
+    !activeQuery.isLoading &&
+    !activeQuery.isError &&
+    (isContracts ? contractRows.length : bookingRows.length) === 0;
+  const tableStatus = activeQuery.isLoading
+    ? "loading"
+    : activeQuery.isError
+      ? "error"
+      : "success";
+
+  const statusOptions = isContracts
+    ? CONTRACT_STATUS_OPTIONS
+    : BOOKING_STATUS_OPTIONS;
+  const statusValue = isContracts ? contractStatuses : bookingStatuses;
+  const setStatusValue = isContracts ? setContractStatuses : setBookingStatuses;
+
+  return (
+    <PageContainer>
+      <Stack gap="lg">
+        <PageHeader
+          title="Clearance Documents"
+          subtitle="Operations review of customer clearance documents for contracts without customs clearing."
+          action={
+            <ActionIcon
+              variant="default"
+              size="lg"
+              radius="md"
+              loading={activeQuery.isFetching}
+              onClick={() => void activeQuery.refetch()}
+              aria-label="Refresh"
+            >
+              <RefreshCw size={16} />
+            </ActionIcon>
+          }
+        />
+
+        <Tabs
+          value={hubTab}
+          onChange={(v) => {
+            setHubTab((v as HubTab) ?? "contracts");
+            resetPage();
+          }}
+        >
+          <Tabs.List>
+            <Tabs.Tab value="contracts">Contracts</Tabs.Tab>
+            <Tabs.Tab value="general">General</Tabs.Tab>
+          </Tabs.List>
+        </Tabs>
+
+        <Card p={0}>
+          <Stack gap={0}>
+            <Box px="md" pt="md" pb="sm" w="100%">
+              <Group justify="space-between" gap="md" wrap="wrap">
+                <TextInput
+                  placeholder={
+                    isContracts
+                      ? "Search reference or customer…"
+                      : "Search booking, contract or customer…"
+                  }
+                  leftSection={<Search size={18} />}
+                  value={query}
+                  onChange={(e) => {
+                    setQuery(e.target.value);
+                    resetPage();
+                  }}
+                  rightSection={
+                    query && (
+                      <ActionIcon
+                        size="sm"
+                        color="gray"
+                        radius="md"
+                        variant="transparent"
+                        onClick={() => {
+                          setQuery("");
+                          resetPage();
+                        }}
+                      >
+                        <X size={16} />
+                      </ActionIcon>
+                    )
+                  }
+                  style={{ flex: 1, minWidth: "200px" }}
+                  radius="lg"
+                />
+                <Select
+                  data={statusOptions}
+                  value={statusValue}
+                  onChange={(v) => {
+                    setStatusValue(v ?? statusOptions[0].value);
+                    resetPage();
+                  }}
+                  allowDeselect={false}
+                  radius="lg"
+                  w={220}
+                  aria-label="Filter by status"
+                />
+                <Text size="sm" c="dimmed">
+                  {total} record{total !== 1 ? "s" : ""}
+                </Text>
+              </Group>
+            </Box>
+
+            {showEmpty ? (
+              <Stack align="center" gap={8} py={48}>
+                <ThemeIcon variant="light" color="gray" radius="xl" size={48}>
+                  <Inbox size={22} />
+                </ThemeIcon>
+                <Text c="dimmed">
+                  No {isContracts ? "contracts" : "bookings"} match this view.
+                </Text>
+              </Stack>
+            ) : (
+              <Box style={{ overflowX: "auto" }} w="100%">
+                {isContracts ? (
+                  <DataTable
+                    columns={contractColumns}
+                    data={contractRows}
+                    status={tableStatus}
+                    onRowClick={(row) =>
+                      navigate(`/dashboard/contracts/clearance/${row.id}`)
+                    }
+                    pagination={{
+                      pageIndex: pagination.pageIndex,
+                      pageSize: pagination.pageSize,
+                      pageCount,
+                      totalCount: total,
+                    }}
+                    tableOptions={{
+                      state: { pagination },
+                      onPaginationChange: setPagination,
+                      manualPagination: true,
+                      pageCount,
+                    }}
+                    containerClassName="border-0 shadow-none bg-transparent"
+                    footer={DataTableFooter}
+                  />
+                ) : (
+                  <DataTable
+                    columns={bookingColumns}
+                    data={bookingRows}
+                    status={tableStatus}
+                    onRowClick={(row) =>
+                      navigate(`/dashboard/clearance/${row.id}`)
+                    }
+                    pagination={{
+                      pageIndex: pagination.pageIndex,
+                      pageSize: pagination.pageSize,
+                      pageCount,
+                      totalCount: total,
+                    }}
+                    tableOptions={{
+                      state: { pagination },
+                      onPaginationChange: setPagination,
+                      manualPagination: true,
+                      pageCount,
+                    }}
+                    containerClassName="border-0 shadow-none bg-transparent"
+                    footer={DataTableFooter}
+                  />
+                )}
+              </Box>
+            )}
+          </Stack>
+        </Card>
+      </Stack>
+    </PageContainer>
+  );
+}
diff --git a/apps/edr-freight-web/backoffice/src/pages/contracts/ContractRequestsPage.tsx b/apps/edr-freight-web/backoffice/src/pages/contracts/ContractRequestsPage.tsx
index c4f87c3d6..ea4e78691 100644
--- a/apps/edr-freight-web/backoffice/src/pages/contracts/ContractRequestsPage.tsx
+++ b/apps/edr-freight-web/backoffice/src/pages/contracts/ContractRequestsPage.tsx
@@ -9,6 +9,7 @@ import {
   TextInput,
   ThemeIcon,
 } from "@mantine/core";
+import { useDebouncedValue } from "@mantine/hooks";
 import {
   AlertTriangle,
   ArrowRight,
@@ -76,10 +77,15 @@ export default function ContractRequestsPage() {
   const navigate = useNavigate();
   const { pagination, setPagination } = usePagination({ pageSize: 10 });
   const [query, setQuery] = useState("");
+  const [debouncedQuery] = useDebouncedValue(query, 300);
   const [activeTab, setActiveTab] = useState<ContractStatusTabKey>("all");
 
   const tabStatuses = getStatusesForTab(activeTab);
 
+  const resetPage = useCallback(() => {
+    setPagination({ pageIndex: 0, pageSize: pagination.pageSize });
+  }, [setPagination, pagination.pageSize]);
+
   const filter: ContractListFilter = useMemo(
     () => ({
       page: pagination.pageIndex + 1,
@@ -87,9 +93,17 @@ export default function ContractRequestsPage() {
       sortBy: "createdAt",
       sortOrder: "DESC",
       tab: activeTab,
+      // Server-side free-text search (contract reference, customer name).
+      ...(debouncedQuery.trim() ? { search: debouncedQuery.trim() } : {}),
       ...(tabStatuses ? { statuses: tabStatuses } : {}),
     }),
-    [pagination.pageIndex, pagination.pageSize, activeTab, tabStatuses],
+    [
+      pagination.pageIndex,
+      pagination.pageSize,
+      activeTab,
+      tabStatuses,
+      debouncedQuery,
+    ],
   );
 
   const { data, isLoading, isError, refetch, isFetching } =
@@ -100,16 +114,10 @@ export default function ContractRequestsPage() {
     refetch: refetchSummary,
   } = useContractListSummary(filter);
 
-  const rows = useMemo(() => {
-    const items = (data?.items ?? []).map(toContractListRow);
-    const q = query.trim().toLowerCase();
-    if (!q) return items;
-    return items.filter(
-      (c) =>
-        c.reference.toLowerCase().includes(q) ||
-        c.customerLabel.toLowerCase().includes(q),
-    );
-  }, [data?.items, query]);
+  const rows = useMemo(
+    () => (data?.items ?? []).map(toContractListRow),
+    [data?.items],
+  );
 
   const total = data?.total ?? 0;
   const pageCount = Math.max(1, Math.ceil(total / pagination.pageSize));
@@ -346,7 +354,10 @@ export default function ContractRequestsPage() {
                   placeholder="Search reference or customer…"
                   leftSection={<Search size={18} />}
                   value={query}
-                  onChange={(e) => setQuery(e.target.value)}
+                  onChange={(e) => {
+                    setQuery(e.target.value);
+                    resetPage();
+                  }}
                   rightSection={
                     query && (
                       <ActionIcon
@@ -354,7 +365,10 @@ export default function ContractRequestsPage() {
                         color="gray"
                         radius="md"
                         variant="transparent"
-                        onClick={() => setQuery("")}
+                        onClick={() => {
+                          setQuery("");
+                          resetPage();
+                        }}
                       >
                         <X size={16} />
                       </ActionIcon>
diff --git a/apps/edr-freight-web/backoffice/src/pages/dropdown_settings/DropdownSettingsPage.tsx b/apps/edr-freight-web/backoffice/src/pages/dropdown_settings/DropdownSettingsPage.tsx
index 751b94886..a9ef97843 100644
--- a/apps/edr-freight-web/backoffice/src/pages/dropdown_settings/DropdownSettingsPage.tsx
+++ b/apps/edr-freight-web/backoffice/src/pages/dropdown_settings/DropdownSettingsPage.tsx
@@ -26,6 +26,7 @@ import {
   TextInput,
   ThemeIcon,
 } from "@mantine/core";
+import { useDebouncedValue } from "@mantine/hooks";
 
 import { KpiStrip, PageContainer, PageHeader } from "@/components/page";
 import EditDropdownSettingDialog from "./EditDropdownSettingDialog";
@@ -46,6 +47,7 @@ type ActiveDialog = "edit" | "options" | "delete";
 export default function DropdownSettingsPage() {
   const { pagination, setPagination } = usePagination({ pageSize: 10 });
   const [query, setQuery] = useState("");
+  const [debouncedQuery] = useDebouncedValue(query, 300);
 
   const [createOpen, setCreateOpen] = useState(false);
   const [activeDialog, setActiveDialog] = useState<ActiveDialog | null>(null);
@@ -59,36 +61,35 @@ export default function DropdownSettingsPage() {
   };
   const closeDialog = () => setActiveDialog(null);
 
+  // Table data: server-side pagination + search via GET /dropdown-settings/paged.
+  const listQuery = useMemo(
+    () => ({
+      page: pagination.pageIndex + 1,
+      pageSize: pagination.pageSize,
+      search: debouncedQuery.trim() || undefined,
+    }),
+    [pagination.pageIndex, pagination.pageSize, debouncedQuery],
+  );
+
   const { data, isLoading, isError, error } = useQuery(
+    api.dropdownSettings.listPaged.queryOptions({ input: { query: listQuery } }),
+  );
+
+  // Full (unpaged) list feeds the KPI strip only — its aggregates span every
+  // setting, not just the current page.
+  const { data: allSettings, isLoading: kpiLoading } = useQuery(
     api.dropdownSettings.list.queryOptions(),
   );
   const deleteMutation = useMutation(api.dropdownSettings.remove.mutationOptions());
 
   const dropdownSettings = useMemo<DropdownSetting[]>(
-    () => (Array.isArray(data) ? data : []),
-    [data],
+    () => (Array.isArray(allSettings) ? allSettings : []),
+    [allSettings],
   );
 
-  const filtered = useMemo(() => {
-    const q = query.trim().toLowerCase();
-    if (!q) return dropdownSettings;
-    return dropdownSettings.filter(
-      (s) =>
-        s.code.toLowerCase().includes(q) ||
-        s.label.toLowerCase().includes(q) ||
-        (s.description ?? "").toLowerCase().includes(q),
-    );
-  }, [dropdownSettings, query]);
-
-  const total = filtered.length;
-  const pageCount = Math.max(1, Math.ceil(total / pagination.pageSize));
-  const start = pagination.pageIndex * pagination.pageSize;
-  const end = Math.min(start + pagination.pageSize, total);
-
-  const paginatedData = useMemo(
-    () => filtered.slice(start, end),
-    [start, end, filtered],
-  );
+  const rows = data?.items ?? [];
+  const total = data?.meta.total ?? 0;
+  const pageCount = Math.max(1, data?.meta.totalPages ?? 1);
 
   const totalOptions = dropdownSettings.reduce(
     (sum, s) => sum + (s.children?.length ?? 0),
@@ -269,7 +270,7 @@ export default function DropdownSettingsPage() {
       />
 
       <KpiStrip
-        loading={isLoading}
+        loading={kpiLoading}
         items={[
           { label: "Settings", value: dropdownSettings.length, icon: Settings },
           { label: "Total Options", value: totalOptions, icon: Boxes },
@@ -299,7 +300,7 @@ export default function DropdownSettingsPage() {
 
         <DataTable
           columns={columns}
-          data={paginatedData}
+          data={rows}
           status={status}
           error={
             isError
diff --git a/apps/edr-freight-web/backoffice/src/pages/operations/LastMilePage.tsx b/apps/edr-freight-web/backoffice/src/pages/operations/LastMilePage.tsx
index f3235e0d1..062332107 100644
--- a/apps/edr-freight-web/backoffice/src/pages/operations/LastMilePage.tsx
+++ b/apps/edr-freight-web/backoffice/src/pages/operations/LastMilePage.tsx
@@ -57,6 +57,7 @@ import { vehiclesService } from "@/services/vehicles.service";
 import { driversService, type Driver } from "@/services/drivers.service";
 import { ReleaseOrderModal, type ReleaseOrderTruckPrefill } from "@/components/warehouses/ReleaseOrderModal";
 import { TruckDetentionModal } from "@/components/operations/TruckDetentionModal";
+import { ProofOfDeliveryModal } from "@/components/operations/ProofOfDeliveryModal";
 import { LastMileStepper, type LastMileStepState } from "@/components/operations/LastMileSteps";
 
 const formatPrice = (amount: number | string | null | undefined, currency = "ETB") =>
@@ -546,6 +547,7 @@ const buildTripSlipHtml = (record: LastMileRecord, vehicle?: TripSlipVehicle | n
 const LastMilePage = () => {
   const { toast } = useToast();
   const qc = useQueryClient();
+  const [podRecord, setPodRecord] = useState<LastMileRecord | null>(null);
   const navigate = useNavigate();
   const { pagination, setPagination } = usePagination({ pageSize: 10 });
 
@@ -1031,6 +1033,12 @@ const LastMilePage = () => {
   const handleAdvanceStatus = (record: LastMileRecord) => {
     const next = NEXT_STATUS[record.status];
     if (!next) return;
+    // Completing a delivery requires proof of delivery — open the capture modal
+    // instead of advancing straight to DELIVERED.
+    if (next === "DELIVERED") {
+      setPodRecord(record);
+      return;
+    }
     updateMutation.mutate(
       { id: record.id, data: { status: next } },
       {
@@ -2080,6 +2088,17 @@ const LastMilePage = () => {
         onClose={() => setDetentionRecord(null)}
         record={detentionRecord}
       />
+
+      <ProofOfDeliveryModal
+        opened={Boolean(podRecord)}
+        onClose={() => setPodRecord(null)}
+        lastMileId={podRecord?.id ?? null}
+        reference={podRecord?.booking?.reference ?? null}
+        onDone={() => {
+          void qc.invalidateQueries({ queryKey: QUERY_KEYS.LAST_MILE.ROOT });
+          void qc.invalidateQueries({ queryKey: ["vehicles"] });
+        }}
+      />
     </Stack>
   );
 };
diff --git a/apps/edr-freight-web/backoffice/src/pages/ruleEngine/CargoTypesPage.tsx b/apps/edr-freight-web/backoffice/src/pages/ruleEngine/CargoTypesPage.tsx
index 421885310..1002387a2 100644
--- a/apps/edr-freight-web/backoffice/src/pages/ruleEngine/CargoTypesPage.tsx
+++ b/apps/edr-freight-web/backoffice/src/pages/ruleEngine/CargoTypesPage.tsx
@@ -38,8 +38,8 @@ import {
   type FormFieldDef,
 } from "@/pages/ruleEngine/config/resources";
 import {
-  useRuleEngineList,
   useRuleEngineMutations,
+  useRuleEngineOrderList,
   useWagonTypeOptions,
 } from "@/hooks/rule-engine/useRuleEngine";
 import type { RuleEngineRecord } from "@/types/rule-engine";
@@ -108,14 +108,14 @@ const CargoTypesPage = () => {
   const canView = canAccessRuleEngineResource(user, CARGO_SLUG, "view");
   const canManage = canAccessRuleEngineResource(user, CARGO_SLUG, "manage");
 
-  // One fetch of the whole (small) set; the tree, ancestry and each level are
-  // derived client-side so drilling between levels is instant.
-  const { data, isLoading, isError } = useRuleEngineList(CARGO_SLUG, {
-    page: 1,
-    pageSize: 500,
-    sortBy: "displayOrder",
-    sortOrder: "ASC",
-  });
+  // One fetch of the whole (small) set — page-walked because the API caps
+  // pageSize at 100; the tree, ancestry and each level are derived client-side
+  // so drilling between levels is instant.
+  const { data, isLoading, isError } = useRuleEngineOrderList(
+    CARGO_SLUG,
+    true,
+    "displayOrder",
+  );
 
   const { create, update, remove } = useRuleEngineMutations(CARGO_SLUG);
 
@@ -141,7 +141,7 @@ const CargoTypesPage = () => {
   const [formMode, setFormMode] = useState<FormMode | null>(null);
   const [deleteTarget, setDeleteTarget] = useState<CargoNode | null>(null);
 
-  const all = (data?.data ?? []) as CargoNode[];
+  const all = (data ?? []) as CargoNode[];
 
   const { byId, childrenOf } = useMemo(() => {
     const byId = new Map<string, CargoNode>(all.map((n) => [n.id, n]));
diff --git a/apps/edr-freight-web/backoffice/src/pages/ruleEngine/RuleEngineResourcePage.tsx b/apps/edr-freight-web/backoffice/src/pages/ruleEngine/RuleEngineResourcePage.tsx
index 253cdffcc..ddd61b91f 100644
--- a/apps/edr-freight-web/backoffice/src/pages/ruleEngine/RuleEngineResourcePage.tsx
+++ b/apps/edr-freight-web/backoffice/src/pages/ruleEngine/RuleEngineResourcePage.tsx
@@ -210,7 +210,7 @@ const RuleEngineResourcePage = () => {
     });
   }, [config, cargoParentOptions, cargoLeafOptions, containerTypeOptions, liveRateOptions, wagonTypeOptions]);
 
-  const rows = data?.data ?? [];
+  const rows = data?.items ?? [];
   const meta = data?.meta;
   const pageCount = meta?.totalPages ?? 1;
   const totalCount = meta?.total ?? rows.length;
@@ -223,15 +223,15 @@ const RuleEngineResourcePage = () => {
     );
 
   const createPositionOptions = useMemo(() => {
-    if (!config?.orderConfig || !createPositionList?.data?.length)
+    if (!config?.orderConfig || !createPositionList?.length)
       return undefined;
-    return createPositionList.data
+    return createPositionList
       .filter((row) => row.id)
       .map((row) => ({
         label: getOrderItemLabel(row, config.slug),
         value: String(row.id),
       }));
-  }, [config?.orderConfig, config?.slug, createPositionList?.data]);
+  }, [config?.orderConfig, config?.slug, createPositionList]);
 
   const handleApproveRate = useCallback(
     (record: RuleEngineRecord) => {
@@ -528,7 +528,7 @@ const RuleEngineResourcePage = () => {
           open={orderDialogOpen}
           onOpenChange={setOrderDialogOpen}
           config={config}
-          items={orderListData?.data ?? []}
+          items={orderListData ?? []}
           isLoading={orderListLoading}
           isSaving={reorder.isPending}
           onSave={(payload) => {
diff --git a/apps/edr-freight-web/backoffice/src/pages/ruleEngine/config/resources.ts b/apps/edr-freight-web/backoffice/src/pages/ruleEngine/config/resources.ts
index b5eb71862..6992c67e1 100644
--- a/apps/edr-freight-web/backoffice/src/pages/ruleEngine/config/resources.ts
+++ b/apps/edr-freight-web/backoffice/src/pages/ruleEngine/config/resources.ts
@@ -244,6 +244,7 @@ export const RULE_ENGINE_RESOURCES: RuleEngineResourceConfig[] = [
     category: "configuration",
     subtitle: "Configure container sizes",
     searchPlaceholder: "Search container types...",
+    supportsSearch: true,
     orderConfig: { field: "displayOrder", label: "Display order" },
     columns: [
       codeColumn("code"),
@@ -273,6 +274,8 @@ export const RULE_ENGINE_RESOURCES: RuleEngineResourceConfig[] = [
     category: "configuration",
     subtitle: "Configure wagon classes used for capacity and train planning",
     searchPlaceholder: "Search wagon types by name or code...",
+    // No supportsSearch: wagon-types is served by its own module, which does
+    // not implement server-side search (unlike the 9 rule-engine resources).
     cardTitleKey: "name",
     columns: [
       codeColumn("code"),
@@ -316,6 +319,7 @@ export const RULE_ENGINE_RESOURCES: RuleEngineResourceConfig[] = [
     category: "rules",
     subtitle: "Wagon-count, payment-currency, and customs scoring rules",
     searchPlaceholder: "Search priority rules...",
+    supportsSearch: true,
     orderConfig: { field: "displayOrder", label: "Display order" },
     columns: [
       { id: "type", header: "Type", accessorKey: "type" },
@@ -379,6 +383,7 @@ export const RULE_ENGINE_RESOURCES: RuleEngineResourceConfig[] = [
     category: "rules",
     subtitle: "VGM limits by container and trade direction",
     searchPlaceholder: "Search weight limit rules...",
+    supportsSearch: true,
     cardTitleKey: "containerType",
     cardSubtitleKey: "tradeDirection",
     columns: [
@@ -429,6 +434,7 @@ export const RULE_ENGINE_RESOURCES: RuleEngineResourceConfig[] = [
     category: "configuration",
     subtitle: "Terminal and yard locations",
     searchPlaceholder: "Search yards...",
+    supportsSearch: true,
     orderConfig: { field: "displayOrder", label: "Display order" },
     columns: [
       codeColumn("code"),
@@ -455,6 +461,7 @@ export const RULE_ENGINE_RESOURCES: RuleEngineResourceConfig[] = [
     category: "configuration",
     subtitle: "Shipping line codes and pricing mappings",
     searchPlaceholder: "Search shipping lines...",
+    supportsSearch: true,
     columns: [
       codeColumn("code"),
       { id: "label", header: "Label", accessorKey: "label" },
@@ -483,6 +490,7 @@ export const RULE_ENGINE_RESOURCES: RuleEngineResourceConfig[] = [
     cardSubtitleKey: "currency",
     subtitle: "Freight rates and approval workflow",
     searchPlaceholder: "Search rates by type or status...",
+    supportsSearch: true,
     columns: [
       { id: "appliesTo", header: "Applies to", accessorKey: "appliesTo", format: "code" },
       { id: "trigger", header: "Trigger", accessorKey: "trigger" },
@@ -560,6 +568,7 @@ export const RULE_ENGINE_RESOURCES: RuleEngineResourceConfig[] = [
     cardSubtitleKey: "requiredRole",
     subtitle: "Multi-step booking approval chain",
     searchPlaceholder: "Search approval rules...",
+    supportsSearch: true,
     orderConfig: {
       field: "stepOrder",
       scopeField: "requiresDirectorApproval",
diff --git a/apps/edr-freight-web/backoffice/src/pages/trainScheduling/BatchBoardPage.tsx b/apps/edr-freight-web/backoffice/src/pages/trainScheduling/BatchBoardPage.tsx
index 9f3f862c4..6520c208e 100644
--- a/apps/edr-freight-web/backoffice/src/pages/trainScheduling/BatchBoardPage.tsx
+++ b/apps/edr-freight-web/backoffice/src/pages/trainScheduling/BatchBoardPage.tsx
@@ -55,6 +55,7 @@ import { ruleEngineTable } from "@/components/ruleEngine/ruleEngineStyles";
 import { FREIGHT_BRAND, FREIGHT_BRAND_DARK } from "@/theme/freight-brand";
 import { keepPreviousData, useQuery } from "@tanstack/react-query";
 import { api } from "@/services/api";
+import { useBookingWindowSocket } from "@/features/bookingWindows/useBookingWindowSocket";
 import type {
   BatchBoardFilters,
   BatchBoardSchedule,
@@ -424,6 +425,8 @@ function CardSkeleton() {
 
 export default function BatchBoardPage() {
   const navigate = useNavigate();
+  // Live board: phase + batch-changed pushes invalidate the list query below.
+  useBookingWindowSocket();
   const { viewMode, setViewMode } = useFleetViewMode("batch-board");
   const { pagination, setPagination } = usePagination({ pageSize: 12 });
   const [search, setSearch] = useState("");
@@ -484,13 +487,17 @@ export default function BatchBoardPage() {
 
   const { data, isLoading, isError, isFetching, refetch } = useQuery({
     ...api.trainScheduling.batchBoard.queryOptions({ input: { filters } }),
-    refetchInterval: 30_000,
+    // Real-time updates come from the booking-window socket (batch-board:changed
+    // + PHASE pushes invalidate this query); 60s is only a self-heal safety net
+    // for a missed emit.
+    refetchInterval: 60_000,
     placeholderData: keepPreviousData,
   });
 
   const schedules = data?.items ?? [];
-  const total = data?.total ?? 0;
-  const pageCount = data?.totalPages ?? 1;
+  const total = data?.meta.total ?? 0;
+  // The table footer expects at least one page even when the board is empty.
+  const pageCount = Math.max(1, data?.meta.totalPages ?? 1);
 
   const summary = useMemo(() => {
     const openWindows = schedules.filter((s) => s.bookingWindowStatus === "OPEN").length;
diff --git a/apps/edr-freight-web/backoffice/src/pages/trainScheduling/BatchScheduleDetailPage.tsx b/apps/edr-freight-web/backoffice/src/pages/trainScheduling/BatchScheduleDetailPage.tsx
index 114b2e742..ae75debb1 100644
--- a/apps/edr-freight-web/backoffice/src/pages/trainScheduling/BatchScheduleDetailPage.tsx
+++ b/apps/edr-freight-web/backoffice/src/pages/trainScheduling/BatchScheduleDetailPage.tsx
@@ -1,4 +1,4 @@
-import { useMemo, useState } from "react";
+import { memo, useCallback, useMemo, useState } from "react";
 import { useNavigate, useParams } from "react-router-dom";
 import {
   Accordion,
@@ -377,7 +377,15 @@ const BOOKING_COLUMNS: ColumnDef<BatchBoardBookingDetail>[] = [
   },
 ];
 
-function BookingTable({ bookings }: { bookings: BatchBoardBookingDetail[] }) {
+// Memoized: the page re-renders on unrelated state (tab switch, composition
+// booking selection, background-fetch flags) while the bookings arrays keep
+// their identity (useMemo + React Query structural sharing) — skip re-rendering
+// the whole table in those cases.
+const BookingTable = memo(function BookingTable({
+  bookings,
+}: {
+  bookings: BatchBoardBookingDetail[];
+}) {
   return (
     <DataTable
       columns={BOOKING_COLUMNS}
@@ -387,7 +395,7 @@ function BookingTable({ bookings }: { bookings: BatchBoardBookingDetail[] }) {
       containerClassName="overflow-x-auto rounded-lg border border-edr-border"
     />
   );
-}
+});
 
 function WindowCountChips({ counts }: { counts: BatchWindowGroup["counts"] }) {
   const chips: Array<{ value: number; color: string; label: string }> = [
@@ -581,18 +589,10 @@ export default function BatchScheduleDetailPage() {
     api.trainScheduling.batchBoardDetail.queryOptions({
       input: { scheduleId: scheduleId ?? "" },
       enabled: Boolean(scheduleId),
-      // Poll fast while a window cycle is actively moving (open / doc-review /
-      // payment) so the priority ranking + pay countdowns stay live; back off to
-      // 30s once the cycle is idle (pre-window / closed / done).
-      refetchInterval: (query) => {
-        const phase = (query.state.data as BatchBoardScheduleDetail | undefined)
-          ?.windowPhase;
-        return phase === "OPEN" ||
-          phase === "DOC_REVIEW" ||
-          phase === "PAYMENT"
-          ? 5_000
-          : 30_000;
-      },
+      // Real-time updates come from the booking-window socket (batch-board:changed
+      // + PHASE pushes invalidate this query); 60s is only a self-heal safety net
+      // for a missed emit.
+      refetchInterval: 60_000,
     }),
   );
   // Keep the board in sync with server-pushed window-phase transitions too
@@ -688,6 +688,10 @@ export default function BatchScheduleDetailPage() {
     null,
   );
 
+  // Stable identity so the memoized BookingsManager isn't re-rendered by
+  // unrelated page state (tab switches, composition selection, fetch flags).
+  const handleBookingsChanged = useCallback(() => void refetch(), [refetch]);
+
   const handleCompleteDocReview = () => {
     completeDocReview
       .mutateAsync(scheduleId ?? "")
@@ -1002,7 +1006,7 @@ export default function BatchScheduleDetailPage() {
               <BookingsManager
                 scheduleId={scheduleId ?? ""}
                 bookings={allBookings}
-                onChanged={() => void refetch()}
+                onChanged={handleBookingsChanged}
                 readOnly={bookingsReadOnly}
               />
             </Paper>
diff --git a/apps/edr-freight-web/backoffice/src/pages/trainScheduling/BookingsManager.tsx b/apps/edr-freight-web/backoffice/src/pages/trainScheduling/BookingsManager.tsx
index f1eb91ba6..05502a691 100644
--- a/apps/edr-freight-web/backoffice/src/pages/trainScheduling/BookingsManager.tsx
+++ b/apps/edr-freight-web/backoffice/src/pages/trainScheduling/BookingsManager.tsx
@@ -1,4 +1,4 @@
-import { useMemo, useState } from "react";
+import { memo, useMemo, useState } from "react";
 import {
   ActionIcon,
   Badge,
@@ -118,8 +118,11 @@ export interface BookingsManagerProps {
  * allocation status, and remove or re-assign bookings individually or in bulk.
  * Wraps the shared DataTable; selection + actions are handled locally so the
  * surrounding accordion / tab layout stays untouched.
+ *
+ * Memoized: the detail page passes stable props (memoized bookings array +
+ * useCallback onChanged), so its unrelated re-renders skip this subtree.
  */
-export function BookingsManager({
+export const BookingsManager = memo(function BookingsManager({
   scheduleId,
   bookings,
   onChanged,
@@ -620,6 +623,6 @@ export function BookingsManager({
       </Modal>
     </Stack>
   );
-}
+});
 
 export default BookingsManager;
diff --git a/apps/edr-freight-web/backoffice/src/pages/trainScheduling/TrainScheduleV2ListPage.tsx b/apps/edr-freight-web/backoffice/src/pages/trainScheduling/TrainScheduleV2ListPage.tsx
index 859efece1..e42fc1a0b 100644
--- a/apps/edr-freight-web/backoffice/src/pages/trainScheduling/TrainScheduleV2ListPage.tsx
+++ b/apps/edr-freight-web/backoffice/src/pages/trainScheduling/TrainScheduleV2ListPage.tsx
@@ -15,6 +15,7 @@ import {
   TextInput,
   ThemeIcon,
 } from "@mantine/core";
+import { useDebouncedValue } from "@mantine/hooks";
 import { isAxiosError } from "axios";
 import {
   ArrowRight,
@@ -29,7 +30,7 @@ import {
   Train,
   Weight,
 } from "lucide-react";
-import { useEffect, useMemo, useState } from "react";
+import { useCallback, useEffect, useMemo, useState } from "react";
 import { useNavigate } from "react-router-dom";
 
 import FleetToolbar from "@/components/fleet/FleetToolbar";
@@ -48,11 +49,16 @@ import {
   RouteCorridor,
   StatusPill,
 } from "@/components/trainScheduling/scheduleVisuals";
-import { useMutation, useQuery } from "@tanstack/react-query";
+import { keepPreviousData, useMutation, useQuery } from "@tanstack/react-query";
 import { api } from "@/services/api";
 import { formatRouteLabel } from "@/services/routes.service";
 import { useToast } from "@/hooks/use-toast";
-import type { TrainScheduleListItem } from "@/types/trainScheduling";
+import type {
+  FreightType,
+  TrainScheduleListFilters,
+  TrainScheduleListItem,
+  TrainScheduleStatus,
+} from "@/types/trainScheduling";
 import { DataTable, DataTableFooter, usePagination } from "@edr/ui-common";
 
 /** `min` for a `datetime-local` input: now, in the browser's local zone. */
@@ -94,14 +100,18 @@ export default function TrainScheduleV2ListPage() {
   const { viewMode, setViewMode } = useFleetViewMode("train-scheduling-v2");
   const { pagination, setPagination } = usePagination({ pageSize: 10 });
   const [search, setSearch] = useState("");
-  const [statusFilter, setStatusFilter] = useState("ALL");
-  const [freightFilter, setFreightFilter] = useState("ALL");
+  const [debouncedSearch] = useDebouncedValue(search, 300);
+  const [statusFilter, setStatusFilter] = useState<"ALL" | TrainScheduleStatus>("ALL");
+  const [freightFilter, setFreightFilter] = useState<"ALL" | FreightType>("ALL");
+  // Origin/destination hold yard IDs ("ALL" = no filter); the server matches
+  // the schedule's origin_station_id / destination_station_id exactly.
   const [originFilter, setOriginFilter] = useState("ALL");
   const [destinationFilter, setDestinationFilter] = useState("ALL");
-  // Default: newest-created first, matching the API's default order.
-  const [sortBy, setSortBy] = useState<"createdAt" | "scheduleDate" | "reference">(
-    "createdAt",
-  );
+  // Default: newest-created first, matching the API's default order. Values
+  // are the server sort fields (see TRAIN_SCHEDULE_SORT_FIELDS).
+  const [sortBy, setSortBy] = useState<
+    "createdAt" | "scheduledDepartureDate" | "reference"
+  >("createdAt");
   const [sortDir, setSortDir] = useState<"desc" | "asc">("desc");
   const [createOpen, setCreateOpen] = useState(false);
   const [windowSettingsId, setWindowSettingsId] = useState<string | null>(null);
@@ -117,8 +127,61 @@ export default function TrainScheduleV2ListPage() {
     [createOpen],
   );
 
+  const resetPage = useCallback(() => {
+    setPagination((prev) =>
+      prev.pageIndex === 0 ? prev : { ...prev, pageIndex: 0 },
+    );
+  }, [setPagination]);
+
+  // Search resets the page only once the debounced value settles — resetting
+  // per keystroke would refetch page 1 mid-typing.
+  useEffect(() => {
+    resetPage();
+  }, [debouncedSearch, resetPage]);
+
+  // Fully server-driven list: pagination, search, filters, and sort all travel
+  // as query params; the response envelope carries the page + totals.
+  const filters = useMemo<TrainScheduleListFilters>(
+    () => ({
+      page: pagination.pageIndex + 1,
+      pageSize: pagination.pageSize,
+      ...(debouncedSearch.trim() ? { search: debouncedSearch.trim() } : {}),
+      ...(statusFilter !== "ALL" ? { status: statusFilter } : {}),
+      ...(freightFilter !== "ALL" ? { freightType: freightFilter } : {}),
+      ...(originFilter !== "ALL" ? { originStationId: originFilter } : {}),
+      ...(destinationFilter !== "ALL"
+        ? { destinationStationId: destinationFilter }
+        : {}),
+      sortBy,
+      sortOrder: sortDir === "asc" ? "ASC" : "DESC",
+    }),
+    [
+      pagination.pageIndex,
+      pagination.pageSize,
+      debouncedSearch,
+      statusFilter,
+      freightFilter,
+      originFilter,
+      destinationFilter,
+      sortBy,
+      sortDir,
+    ],
+  );
+
   const schedulesQuery = useQuery(
-    api.trainScheduling.scheduleList.queryOptions({ input: {} }),
+    api.trainScheduling.scheduleList.queryOptions({
+      input: { filters },
+      // Keep the previous page on screen while the next page/filter result
+      // loads instead of flashing the empty state; 30s staleTime spares
+      // back-and-forth navigation from refetching an unchanged list.
+      placeholderData: keepPreviousData,
+      staleTime: 30_000,
+    }),
+  );
+  // Yard options for the origin/destination filters (shared routes reference
+  // list, so the choices don't shrink to whatever the current page shows).
+  const yardsQuery = useQuery(
+    api.routes.yards.queryOptions({ staleTime: 5 * 60_000 }),
   );
   const routesQuery = useQuery(
     api.routes.list.queryOptions({ input: { status: "AVAILABLE" } }),
@@ -153,96 +216,40 @@ export default function TrainScheduleV2ListPage() {
     setLocomotiveIds([]);
   }, [routeId]);
 
-  const allSchedules = schedulesQuery.data ?? [];
+  // Filtering, sorting, and paging all happen server-side — `schedules` IS the
+  // current page, and the meta envelope carries the totals.
+  const schedules = schedulesQuery.data?.items ?? [];
+  const totalSchedules = schedulesQuery.data?.meta.total ?? 0;
+  const pageCount = Math.max(1, schedulesQuery.data?.meta.totalPages ?? 1);
 
+  // Status/weight tiles count the visible page only — board-wide numbers would
+  // need a dedicated summary endpoint now that the list is server-paginated.
   const stats = useMemo(() => {
     const base = {
-      total: allSchedules.length,
       scheduled: 0,
       dispatched: 0,
       draft: 0,
       weight: 0,
     };
-    for (const s of allSchedules) {
+    for (const s of schedules) {
       if (s.status === "SCHEDULED") base.scheduled += 1;
       if (s.status === "DISPATCHED") base.dispatched += 1;
       if (s.status === "DRAFT") base.draft += 1;
       base.weight += s.totalWeightTons ?? 0;
     }
     return base;
-  }, [allSchedules]);
+  }, [schedules]);
 
-  // Distinct origins/destinations present in the loaded schedules, for the
-  // corridor filters. Sorted A→Z; "ALL" prepended by the Select data below.
-  const originOptions = useMemo(
+  // Corridor filter options: every yard from the shared reference list, sent
+  // to the server as origin/destination station IDs.
+  const yardOptions = useMemo(
     () =>
-      [...new Set(allSchedules.map((s) => s.origin).filter(Boolean))].sort() as string[],
-    [allSchedules],
+      (yardsQuery.data ?? []).map((y) => ({
+        value: y.id,
+        label: y.label ?? y.code,
+      })),
+    [yardsQuery.data],
   );
-  const destinationOptions = useMemo(
-    () =>
-      [
-        ...new Set(allSchedules.map((s) => s.destination).filter(Boolean)),
-      ].sort() as string[],
-    [allSchedules],
-  );
-
-  const filtered = useMemo(() => {
-    const query = search.trim().toLowerCase();
-    const matched = allSchedules.filter((s) => {
-      if (statusFilter !== "ALL" && s.status !== statusFilter) return false;
-      if (freightFilter !== "ALL" && s.freightType !== freightFilter) return false;
-      if (originFilter !== "ALL" && s.origin !== originFilter) return false;
-      if (destinationFilter !== "ALL" && s.destination !== destinationFilter)
-        return false;
-      if (!query) return true;
-      const haystack = [
-        s.reference,
-        s.trainNumber,
-        s.routeName,
-        s.origin,
-        s.destination,
-        s.locomotive?.code,
-        ...(s.locomotives ?? []).map((l) => l.code),
-        s.freightType,
-        s.status,
-      ]
-        .filter(Boolean)
-        .join(" ")
-        .toLowerCase();
-      return haystack.includes(query);
-    });
-
-    const dir = sortDir === "asc" ? 1 : -1;
-    const sorted = [...matched].sort((a, b) => {
-      let cmp = 0;
-      if (sortBy === "reference") {
-        cmp = (a.reference ?? "").localeCompare(b.reference ?? "");
-      } else {
-        // createdAt or scheduleDate — compare as timestamps (missing sorts last).
-        const av = new Date(a[sortBy] ?? 0).getTime();
-        const bv = new Date(b[sortBy] ?? 0).getTime();
-        cmp = av - bv;
-      }
-      return cmp * dir;
-    });
-    return sorted;
-  }, [
-    allSchedules,
-    search,
-    statusFilter,
-    freightFilter,
-    originFilter,
-    destinationFilter,
-    sortBy,
-    sortDir,
-  ]);
-
-  const pageCount = Math.max(1, Math.ceil(filtered.length / pagination.pageSize));
-  const paged = useMemo(() => {
-    const start = pagination.pageIndex * pagination.pageSize;
-    return filtered.slice(start, start + pagination.pageSize);
-  }, [filtered, pagination]);
 
   const columns = useMemo((): ColumnDef<TrainScheduleListItem>[] => {
     const headerClassName = ruleEngineTable.headerCell;
@@ -504,7 +511,7 @@ export default function TrainScheduleV2ListPage() {
 
       <KpiStrip
         items={[
-          { label: "Total trains", value: stats.total, icon: Train },
+          { label: "Total trains", value: totalSchedules, icon: Train },
           { label: "Scheduled", value: stats.scheduled, icon: CalendarClock },
           { label: "Dispatched", value: stats.dispatched, icon: Send },
           { label: "Planned load", value: `${Math.round(stats.weight)}T`, icon: Weight },
@@ -526,12 +533,17 @@ export default function TrainScheduleV2ListPage() {
                     size="sm"
                     radius="lg"
                     value={statusFilter}
-                    onChange={(v) => v && setStatusFilter(v)}
+                    onChange={(v) => {
+                      if (!v) return;
+                      setStatusFilter(v as "ALL" | TrainScheduleStatus);
+                      resetPage();
+                    }}
                     data={[
                       { value: "ALL", label: "All statuses" },
                       { value: "DRAFT", label: "Draft" },
                       { value: "SCHEDULED", label: "Scheduled" },
                       { value: "DISPATCHED", label: "Dispatched" },
+                      { value: "ARRIVED", label: "Arrived" },
                       { value: "CANCELLED", label: "Cancelled" },
                     ]}
                     w={150}
@@ -541,7 +553,11 @@ export default function TrainScheduleV2ListPage() {
                     size="sm"
                     radius="lg"
                     value={freightFilter}
-                    onChange={(v) => v && setFreightFilter(v)}
+                    onChange={(v) => {
+                      if (!v) return;
+                      setFreightFilter(v as "ALL" | FreightType);
+                      resetPage();
+                    }}
                     data={[
                       { value: "ALL", label: "All freight" },
                       { value: "CONTAINER", label: "Container" },
@@ -557,10 +573,13 @@ export default function TrainScheduleV2ListPage() {
                     placeholder="Origin"
                     searchable
                     value={originFilter}
-                    onChange={(v) => setOriginFilter(v ?? "ALL")}
+                    onChange={(v) => {
+                      setOriginFilter(v ?? "ALL");
+                      resetPage();
+                    }}
                     data={[
                       { value: "ALL", label: "All origins" },
-                      ...originOptions.map((o) => ({ value: o, label: o })),
+                      ...yardOptions,
                     ]}
                     w={160}
                     styles={{ input: { borderColor: "var(--mantine-color-gray-3)" } }}
@@ -571,10 +590,13 @@ export default function TrainScheduleV2ListPage() {
                     placeholder="Destination"
                     searchable
                     value={destinationFilter}
-                    onChange={(v) => setDestinationFilter(v ?? "ALL")}
+                    onChange={(v) => {
+                      setDestinationFilter(v ?? "ALL");
+                      resetPage();
+                    }}
                     data={[
                       { value: "ALL", label: "All destinations" },
-                      ...destinationOptions.map((d) => ({ value: d, label: d })),
+                      ...yardOptions,
                     ]}
                     w={170}
                     styles={{ input: { borderColor: "var(--mantine-color-gray-3)" } }}
@@ -591,12 +613,13 @@ export default function TrainScheduleV2ListPage() {
                       ];
                       setSortBy(by);
                       setSortDir(dir);
+                      resetPage();
                     }}
                     data={[
                       { value: "createdAt:desc", label: "Newest created" },
                       { value: "createdAt:asc", label: "Oldest created" },
-                      { value: "scheduleDate:desc", label: "Departure ↓" },
-                      { value: "scheduleDate:asc", label: "Departure ↑" },
+                      { value: "scheduledDepartureDate:desc", label: "Departure ↓" },
+                      { value: "scheduledDepartureDate:asc", label: "Departure ↑" },
                       { value: "reference:asc", label: "Reference ↑" },
                       { value: "reference:desc", label: "Reference ↓" },
                     ]}
@@ -611,7 +634,7 @@ export default function TrainScheduleV2ListPage() {
           {viewMode === "table" ? (
             <DataTable
               columns={columns}
-              data={paged}
+              data={schedules}
               status={tableStatus}
               onRowClick={(schedule) =>
                 navigate(`/dashboard/operations/train-scheduling-v2/${schedule.id}`)
@@ -629,7 +652,7 @@ export default function TrainScheduleV2ListPage() {
                 pageIndex: pagination.pageIndex,
                 pageSize: pagination.pageSize,
                 pageCount,
-                totalCount: filtered.length,
+                totalCount: totalSchedules,
               }}
               tableOptions={{
                 manualPagination: true,
@@ -648,13 +671,13 @@ export default function TrainScheduleV2ListPage() {
             />
           ) : (
             <Stack gap={0}>
-              {!paged.length ? (
+              {!schedules.length ? (
                 <Text py="xl" ta="center" c="dimmed" size="sm">
                   No train schedules found
                 </Text>
               ) : (
                 <SimpleGrid cols={{ base: 1, sm: 2, lg: 3 }} spacing="md" p="md">
-                  {paged.map((schedule) => (
+                  {schedules.map((schedule) => (
                     <ScheduleCard
                       key={schedule.id}
                       schedule={schedule}
@@ -675,7 +698,7 @@ export default function TrainScheduleV2ListPage() {
               <RuleEngineListFooter
                 pagination={pagination}
                 pageCount={pageCount}
-                totalCount={filtered.length}
+                totalCount={totalSchedules}
                 itemLabel="schedules"
                 onPaginationChange={setPagination}
               />
diff --git a/apps/edr-freight-web/backoffice/src/pages/warehouses/WarehouseDetailPage.tsx b/apps/edr-freight-web/backoffice/src/pages/warehouses/WarehouseDetailPage.tsx
index be597bb77..e3680fe73 100644
--- a/apps/edr-freight-web/backoffice/src/pages/warehouses/WarehouseDetailPage.tsx
+++ b/apps/edr-freight-web/backoffice/src/pages/warehouses/WarehouseDetailPage.tsx
@@ -23,6 +23,7 @@ import {
   InventoryWorkbench,
   WarehouseStatusBadge,
   WarehouseTypeBadge,
+  ZoneOccupancyHeatmap,
   formatCapacity,
   humanizeEnum,
 } from '@/components/warehouses';
@@ -298,6 +299,8 @@ export default function WarehouseDetailPage() {
                 </Button>
               </Group>
 
+              <ZoneOccupancyHeatmap yardId={selectedYardId ?? undefined} />
+
               {!selectedYardId ? (
                 <Text c="dimmed" ta="center" py="lg">
                   Select a yard to view its zones.
diff --git a/apps/edr-freight-web/backoffice/src/services/api.ts b/apps/edr-freight-web/backoffice/src/services/api.ts
index dd157ed02..dbb6fb819 100644
--- a/apps/edr-freight-web/backoffice/src/services/api.ts
+++ b/apps/edr-freight-web/backoffice/src/services/api.ts
@@ -20,6 +20,8 @@ import {
   CreateDropdownSettingDto,
   DropdownOption,
   DropdownSetting,
+  DropdownSettingListQuery,
+  PaginatedDropdownSettings,
   UpdateDropdownOptionDto,
   UpdateDropdownSettingDto,
 } from "@/types/dropdownSettings";
@@ -61,7 +63,8 @@ import type {
   StaffBookingWindow,
   TrainScheduleDetail,
   TrainScheduleFilters,
-  TrainScheduleListItem,
+  TrainScheduleListFilters,
+  TrainScheduleListResponse,
   UpdateScheduleWindowRulePayload,
   TrainSchedulePreviewPayload,
   TrainSchedulePreviewResponse,
@@ -214,13 +217,14 @@ export const api = {
   trainScheduling: {
     // ── Queries ────────────────────────────────────────────────────────────
     scheduleList: endpoint<
-      { freightType?: FreightType },
-      TrainScheduleListItem[]
+      { freightType?: FreightType; filters?: TrainScheduleListFilters },
+      TrainScheduleListResponse
     >(
       "train-scheduling",
       "schedules",
-      ({ freightType }) => trainSchedulingService.listSchedules(freightType),
-      () => QUERY_KEYS.TRAIN_SCHEDULING.schedules(),
+      ({ freightType, filters }) =>
+        trainSchedulingService.listSchedules(freightType, filters),
+      ({ filters }) => QUERY_KEYS.TRAIN_SCHEDULING.schedules(filters),
     ),
 
     batchBoard: endpoint<
@@ -1398,7 +1402,7 @@ export const api = {
     yards: endpoint<void, YardRef[]>(
       "routes",
       "yards",
-      () => routesService.getYards().then((r) => r.data.data),
+      () => routesService.getYards(),
       () => ["routes", "yards"],
     ),
 
@@ -1970,6 +1974,15 @@ export const api = {
       dropdownSettingsService.list,
     ),
 
+    listPaged: endpoint<
+      { query: DropdownSettingListQuery },
+      PaginatedDropdownSettings
+    >(
+      "dropdown-settings",
+      "listPaged",
+      ({ query }) => dropdownSettingsService.listPaged(query),
+    ),
+
     getById: endpoint<{ id: string }, DropdownSetting>(
       "dropdown-settings",
       "getById",
diff --git a/apps/edr-freight-web/backoffice/src/services/bookings.service.ts b/apps/edr-freight-web/backoffice/src/services/bookings.service.ts
index b97ac2bc3..db7441721 100644
--- a/apps/edr-freight-web/backoffice/src/services/bookings.service.ts
+++ b/apps/edr-freight-web/backoffice/src/services/bookings.service.ts
@@ -19,6 +19,8 @@ export interface BookingListFilter {
   freightType?: string;
   /** ONE_TIME | GENERAL_CONTRACT — the booking-kind tab filter. */
   bookingType?: string;
+  /** 'true' → customs bookings, 'false' → self-clearance (non-customs). */
+  customsClearingEnabled?: "true" | "false";
   tradeDirection?: string;
   paymentCurrency?: string;
   paymentStatus?: string;
@@ -34,6 +36,8 @@ export interface BookingListFilter {
   destinationYardId?: string;
   /** "true" = government bookings only, "false" = private only. */
   isGovernment?: "true" | "false";
+  /** Free-text search: booking reference, customer name, contract reference (server-side). */
+  search?: string;
   page?: number;
   pageSize?: number;
   sortBy?: string;
@@ -183,6 +187,9 @@ export const bookingsService = {
       if (filter.originYardId) params.originYardId = filter.originYardId;
       if (filter.destinationYardId) params.destinationYardId = filter.destinationYardId;
       if (filter.isGovernment) params.isGovernment = filter.isGovernment;
+      if (filter.customsClearingEnabled)
+        params.customsClearingEnabled = filter.customsClearingEnabled;
+      if (filter.search) params.search = filter.search;
     }
     const response = await client.get<PaginatedBookings>(B.BASE, {
       params,
diff --git a/apps/edr-freight-web/backoffice/src/services/cargo-types.service.ts b/apps/edr-freight-web/backoffice/src/services/cargo-types.service.ts
index d9d9ea046..d7d17691f 100644
--- a/apps/edr-freight-web/backoffice/src/services/cargo-types.service.ts
+++ b/apps/edr-freight-web/backoffice/src/services/cargo-types.service.ts
@@ -1,15 +1,8 @@
-import { api } from "../auth/http";
-
-type ListResponse<T> = T[] | { data: T[] };
-
-const asList = <T>(payload: ListResponse<T>): T[] =>
-  Array.isArray(payload) ? payload : payload.data;
+import { ruleEngineService } from "./ruleEngine/ruleEngine.service";
 
 export const cargoTypesService = {
+  /** All active cargo types (page-walked — the API caps pageSize at 100). */
   async getCargoTypes() {
-    const response = await api.get<ListResponse<unknown>>('/cargo-types', {
-      params: { isActive: true, pageSize: 500 },
-    });
-    return asList(response.data);
+    return ruleEngineService.listAll("cargo-types", { isActive: true });
   },
 };
diff --git a/apps/edr-freight-web/backoffice/src/services/container-types.service.ts b/apps/edr-freight-web/backoffice/src/services/container-types.service.ts
index 2d6247351..f3f43f48b 100644
--- a/apps/edr-freight-web/backoffice/src/services/container-types.service.ts
+++ b/apps/edr-freight-web/backoffice/src/services/container-types.service.ts
@@ -1,15 +1,8 @@
-import { api } from "../auth/http";
-
-type ListResponse<T> = T[] | { data: T[] };
-
-const asList = <T>(payload: ListResponse<T>): T[] =>
-  Array.isArray(payload) ? payload : payload.data;
+import { ruleEngineService } from "./ruleEngine/ruleEngine.service";
 
 export const containerTypesService = {
+  /** All active container types (page-walked — the API caps pageSize at 100). */
   async getContainerTypes() {
-    const response = await api.get<ListResponse<unknown>>('/container-types', {
-      params: { isActive: true, pageSize: 500 },
-    });
-    return asList(response.data);
+    return ruleEngineService.listAll("container-types", { isActive: true });
   },
 };
diff --git a/apps/edr-freight-web/backoffice/src/services/contracts.service.ts b/apps/edr-freight-web/backoffice/src/services/contracts.service.ts
index f08e4f9a0..b3e2fbbd3 100644
--- a/apps/edr-freight-web/backoffice/src/services/contracts.service.ts
+++ b/apps/edr-freight-web/backoffice/src/services/contracts.service.ts
@@ -16,6 +16,8 @@ export interface ContractListFilter {
   tradeDirection?: string;
   contractKind?: string;
   paymentCurrency?: string;
+  /** Server-side free-text search (contract reference, company name). */
+  search?: string;
   page?: number;
   pageSize?: number;
   sortBy?: string;
@@ -58,6 +60,10 @@ export interface ShipmentValidation {
   pairingErrors: string[];
   /** Lines above the container type's hard max capacity — booking cannot be created. */
   capacityErrors?: string[];
+  /** Containers already on another active booking for the same day + route — booking cannot be created. */
+  containerClashErrors?: string[];
+  /** EXPORT only: no single open train on the chosen day can carry the whole booking — booking cannot be created. */
+  spaceErrors?: string[];
   lineItems?: ShipmentPriceLine[];
   totalAmount?: number;
 }
@@ -123,6 +129,7 @@ function buildListParams(filter?: ContractListFilter) {
   if (filter) {
     if (filter.statuses) params.statuses = filter.statuses;
     else if (filter.status) params.status = filter.status;
+    if (filter.search) params.search = filter.search;
     if (filter.page != null) params.page = filter.page;
     if (filter.pageSize != null) params.pageSize = filter.pageSize;
     if (filter.sortBy) params.sortBy = filter.sortBy;
@@ -450,9 +457,16 @@ export const contractsService = {
   },
 
   // ── Path A self-clearance (Operations review) ──
-  getOpsClearanceQueue: async (): Promise<PaginatedContracts> => {
+  getOpsClearanceQueue: async (filter?: {
+    page?: number;
+    pageSize?: number;
+    search?: string;
+    /** Comma-separated ops-clearance lifecycle statuses; omitted → under-review queue. */
+    statuses?: string;
+  }): Promise<PaginatedContracts> => {
     const response = await client.get<PaginatedContracts>(
       C.OPS_CLEARANCE_QUEUE,
+      { params: filter },
     );
     const data = unwrap(response.data);
     return {
@@ -467,8 +481,15 @@ export const contractsService = {
     return { items: (data.items ?? []) as Freight.IContract[], total: data.total ?? 0 };
   },
 
-  getOpsClearanceHistory: async (): Promise<PaginatedContracts> => {
-    const response = await client.get<PaginatedContracts>(C.OPS_CLEARANCE_HISTORY);
+  getOpsClearanceHistory: async (filter?: {
+    page?: number;
+    pageSize?: number;
+    search?: string;
+  }): Promise<PaginatedContracts> => {
+    const response = await client.get<PaginatedContracts>(
+      C.OPS_CLEARANCE_HISTORY,
+      { params: filter },
+    );
     const data = unwrap(response.data);
     return { items: (data.items ?? []) as Freight.IContract[], total: data.total ?? 0 };
   },
diff --git a/apps/edr-freight-web/backoffice/src/services/dropdownSettings.service.ts b/apps/edr-freight-web/backoffice/src/services/dropdownSettings.service.ts
index 841eec309..2b913ee0c 100644
--- a/apps/edr-freight-web/backoffice/src/services/dropdownSettings.service.ts
+++ b/apps/edr-freight-web/backoffice/src/services/dropdownSettings.service.ts
@@ -7,6 +7,8 @@ import type {
   CreateDropdownSettingDto,
   DropdownOption,
   DropdownSetting,
+  DropdownSettingListQuery,
+  PaginatedDropdownSettings,
   UpdateDropdownOptionDto,
   UpdateDropdownSettingDto,
 } from "@/types/dropdownSettings";
@@ -19,6 +21,16 @@ export const dropdownSettingsService = {
     return unwrap(response.data);
   },
 
+  listPaged: async (
+    query: DropdownSettingListQuery,
+  ): Promise<PaginatedDropdownSettings> => {
+    const response = await client.get<ApiResponse<PaginatedDropdownSettings>>(
+      `${BASE}/paged`,
+      { params: query },
+    );
+    return unwrap(response.data);
+  },
+
   getById: async (id: string): Promise<DropdownSetting> => {
     const response = await client.get<ApiResponse<DropdownSetting>>(
       URL_CONSTANTS.DROPDOWN_SETTINGS.BY_ID(id),
diff --git a/apps/edr-freight-web/backoffice/src/services/last-mile.service.ts b/apps/edr-freight-web/backoffice/src/services/last-mile.service.ts
index 4b4133b6a..ea43b3dbe 100644
--- a/apps/edr-freight-web/backoffice/src/services/last-mile.service.ts
+++ b/apps/edr-freight-web/backoffice/src/services/last-mile.service.ts
@@ -108,6 +108,20 @@ export const lastMileService = {
   ) => api.post<LastMileRecord>(`${LM.BASE}/${id}/distances`, { distances, remainingPayment }),
   generateInvoice: (id: string) =>
     api.post<{ id: string; invoiceNumber?: string } | null>(`${LM.BASE}/${id}/invoice`),
+  /** Record proof of delivery (recipient signature + photos) and complete the leg. */
+  recordProofOfDelivery: (
+    id: string,
+    payload: { recipientName: string; notes?: string; signature?: Blob | null; photos?: File[] },
+  ) => {
+    const form = new FormData();
+    form.append("recipientName", payload.recipientName);
+    if (payload.notes) form.append("notes", payload.notes);
+    if (payload.signature) form.append("signature", payload.signature, "signature.png");
+    (payload.photos ?? []).forEach((photo) => form.append("photos", photo));
+    return api.post<LastMileRecord>(LM.PROOF_OF_DELIVERY(id), form, {
+      headers: { "Content-Type": "multipart/form-data" },
+    });
+  },
   /** Generate a truck-detention invoice (per truck per day after the grace window). */
   generateTruckDetentionInvoice: (id: string) =>
     api.post<{ id: string; invoiceNumber?: string } | null>(
diff --git a/apps/edr-freight-web/backoffice/src/services/routes.service.ts b/apps/edr-freight-web/backoffice/src/services/routes.service.ts
index 2317c693d..5fda0c7b2 100644
--- a/apps/edr-freight-web/backoffice/src/services/routes.service.ts
+++ b/apps/edr-freight-web/backoffice/src/services/routes.service.ts
@@ -1,6 +1,7 @@
 import { api as apiClient } from '../auth/http';
 
 import { URL_CONSTANTS } from '@/constants/URLS';
+import { ruleEngineService } from './ruleEngine/ruleEngine.service';
 
 export type RouteStatus = 'AVAILABLE' | 'MAINTENANCE' | 'DAMAGED' | 'STOP_WORKING';
 
@@ -76,10 +77,6 @@ export const ROUTE_STATUS_OPTIONS: Array<{ value: RouteStatus; label: string }>
   { value: 'STOP_WORKING', label: 'Stop working' },
 ];
 
-interface YardListResponse {
-  data: YardRef[];
-}
-
 export const routesService = {
   getAll: (params?: { status?: RouteStatus; search?: string }) =>
     apiClient.get<RouteRecord[]>(URL_CONSTANTS.ROUTES.BASE, { params }),
@@ -88,8 +85,9 @@ export const routesService = {
   update: (id: string, data: Partial<SaveRoutePayload>) =>
     apiClient.patch(URL_CONSTANTS.ROUTES.BY_ID(id), data),
   deactivate: (id: string) => apiClient.delete(URL_CONSTANTS.ROUTES.BY_ID(id)),
-  getYards: () =>
-    apiClient.get<YardListResponse>(URL_CONSTANTS.RULE_ENGINE.YARDS, {
-      params: { isActive: true, pageSize: 200 },
-    }),
+  /** All active yards (page-walked — the yards list API caps pageSize at 100). */
+  getYards: async (): Promise<YardRef[]> => {
+    const rows = await ruleEngineService.listAll("yards", { isActive: true });
+    return rows as unknown as YardRef[];
+  },
 };
diff --git a/apps/edr-freight-web/backoffice/src/services/ruleEngine/ruleEngine.service.ts b/apps/edr-freight-web/backoffice/src/services/ruleEngine/ruleEngine.service.ts
index e8e50f53a..a19896732 100644
--- a/apps/edr-freight-web/backoffice/src/services/ruleEngine/ruleEngine.service.ts
+++ b/apps/edr-freight-web/backoffice/src/services/ruleEngine/ruleEngine.service.ts
@@ -68,50 +68,63 @@ const defaultMeta = (
   dataLength: number,
   page = 1,
   pageSize = 10,
-): RuleEngineListMeta => ({
-  total: dataLength,
-  page,
-  pageSize,
-  totalPages: Math.max(1, Math.ceil(dataLength / pageSize)),
-});
+): RuleEngineListMeta => {
+  const totalPages = Math.max(1, Math.ceil(dataLength / pageSize));
+  return {
+    total: dataLength,
+    page,
+    pageSize,
+    totalPages,
+    hasNextPage: page < totalPages,
+    hasPreviousPage: page > 1,
+  };
+};
 
-const isPaginatedListResult = <T extends RuleEngineRecord>(
+/** Standard envelope from the shared pagination toolkit: `{ items, meta }`. */
+const isItemsEnvelope = <T extends RuleEngineRecord>(
   value: unknown,
 ): value is RuleEngineListResult<T> =>
   Boolean(value) &&
   typeof value === "object" &&
-  "data" in (value ?? {}) &&
-  Array.isArray((value as RuleEngineListResult<T>).data);
+  Array.isArray((value as { items?: unknown }).items);
+
+/** Legacy envelope (`{ data, meta }`) — still returned by wagon-types. */
+const isLegacyEnvelope = <T extends RuleEngineRecord>(
+  value: unknown,
+): value is { data: T[]; meta?: RuleEngineListMeta } =>
+  Boolean(value) &&
+  typeof value === "object" &&
+  Array.isArray((value as { data?: unknown }).data);
 
 const normalizeList = <T extends RuleEngineRecord>(
   payload: unknown,
   page = 1,
   pageSize = 10,
 ): RuleEngineListResult<T> => {
-  if (isPaginatedListResult<T>(payload)) {
-    return {
-      data: payload.data,
-      meta: payload.meta ?? defaultMeta(payload.data.length, page, pageSize),
-    };
+  const candidates: unknown[] = [payload, unwrap(payload as { data: unknown })];
+
+  for (const body of candidates) {
+    if (isItemsEnvelope<T>(body)) {
+      return {
+        items: body.items,
+        meta: body.meta ?? defaultMeta(body.items.length, page, pageSize),
+      };
+    }
+    if (isLegacyEnvelope<T>(body)) {
+      return {
+        items: body.data,
+        meta: body.meta ?? defaultMeta(body.data.length, page, pageSize),
+      };
+    }
+    if (Array.isArray(body)) {
+      return {
+        items: body as T[],
+        meta: defaultMeta(body.length, page, pageSize),
+      };
+    }
   }
 
-  const body = unwrap(payload as { data: unknown }) as unknown;
-
-  if (isPaginatedListResult<T>(body)) {
-    return {
-      data: body.data,
-      meta: body.meta ?? defaultMeta(body.data.length, page, pageSize),
-    };
-  }
-
-  if (Array.isArray(body)) {
-    return {
-      data: body as T[],
-      meta: defaultMeta(body.length, page, pageSize),
-    };
-  }
-
-  return { data: [], meta: defaultMeta(0, page, pageSize) };
+  return { items: [], meta: defaultMeta(0, page, pageSize) };
 };
 
 const normalizeEntity = <T extends RuleEngineRecord>(payload: unknown): T => {
@@ -140,6 +153,34 @@ export const ruleEngineService = {
     return normalizeList<T>(response.data, page, pageSize);
   },
 
+  /**
+   * Fetch every row of a resource by walking the pages. The API caps pageSize
+   * at 100, so option/dropdown consumers that used to ask for 200-500 rows in
+   * one shot go through here instead of getting silently capped (or a 400).
+   */
+  listAll: async <T extends RuleEngineRecord>(
+    resource: RuleEngineResourceSlug,
+    params?: Omit<RuleEngineListParams, "page" | "pageSize">,
+  ): Promise<T[]> => {
+    const pageSize = 100;
+    const first = await ruleEngineService.list<T>(resource, {
+      ...params,
+      page: 1,
+      pageSize,
+    });
+    const items = [...first.items];
+    const totalPages = first.meta.totalPages ?? 1;
+    for (let page = 2; page <= totalPages; page += 1) {
+      const next = await ruleEngineService.list<T>(resource, {
+        ...params,
+        page,
+        pageSize,
+      });
+      items.push(...next.items);
+    }
+    return items;
+  },
+
   getById: async <T extends RuleEngineRecord>(
     resource: RuleEngineResourceSlug,
     id: string,
diff --git a/apps/edr-freight-web/backoffice/src/services/trainScheduling.service.ts b/apps/edr-freight-web/backoffice/src/services/trainScheduling.service.ts
index fb26b9605..76f87a008 100644
--- a/apps/edr-freight-web/backoffice/src/services/trainScheduling.service.ts
+++ b/apps/edr-freight-web/backoffice/src/services/trainScheduling.service.ts
@@ -30,7 +30,8 @@ import type {
   TrainScheduleDetail,
   UpdateScheduleWindowRulePayload,
   TrainScheduleFilters,
-  TrainScheduleListItem,
+  TrainScheduleListFilters,
+  TrainScheduleListResponse,
   TrainSchedulePreviewPayload,
   TrainSchedulePreviewResponse,
   TrainSchedulingGlobalRules,
@@ -94,9 +95,22 @@ export const trainSchedulingService = {
 
   listSchedules: async (
     freightType: FreightType = "CONTAINER",
-  ): Promise<TrainScheduleListItem[]> => {
-    const response = await client.get<TrainScheduleListItem[]>(
+    filters: TrainScheduleListFilters = {},
+  ): Promise<TrainScheduleListResponse> => {
+    const params: Record<string, string | number> = {};
+    if (filters.page) params.page = filters.page;
+    if (filters.pageSize) params.pageSize = filters.pageSize;
+    if (filters.search?.trim()) params.search = filters.search.trim();
+    if (filters.status) params.status = filters.status;
+    if (filters.freightType) params.freightType = filters.freightType;
+    if (filters.originStationId) params.originStationId = filters.originStationId;
+    if (filters.destinationStationId)
+      params.destinationStationId = filters.destinationStationId;
+    if (filters.sortBy) params.sortBy = filters.sortBy;
+    if (filters.sortOrder) params.sortOrder = filters.sortOrder;
+    const response = await client.get<TrainScheduleListResponse>(
       pathsFor(freightType === "MIXED" ? undefined : freightType).SCHEDULES,
+      { params },
     );
     return unwrap(response.data);
   },
diff --git a/apps/edr-freight-web/backoffice/src/services/warehouse.service.ts b/apps/edr-freight-web/backoffice/src/services/warehouse.service.ts
index 6797f1743..ea0baa32e 100644
--- a/apps/edr-freight-web/backoffice/src/services/warehouse.service.ts
+++ b/apps/edr-freight-web/backoffice/src/services/warehouse.service.ts
@@ -4,6 +4,7 @@ import { api as apiClient } from '../auth/http';
 
 import { URL_CONSTANTS } from '@/constants/URLS';
 import type {
+  ZoneOccupancy,
   AllocationCriteria,
   AllocationPreviewResult,
   AllocationRule,
@@ -219,7 +220,11 @@ export const warehouseService = {
     apiClient.post<Warehouse>(URL_CONSTANTS.WAREHOUSES.BASE, payload),
   update: (id: string, payload: Partial<SaveWarehousePayload>) =>
     apiClient.patch<Warehouse>(URL_CONSTANTS.WAREHOUSES.BY_ID(id), payload),
-  listFacilities: () => apiClient.get<WarehouseFacility[]>(URL_CONSTANTS.RULE_ENGINE.YARDS),
+  // Yards list now returns the standard paginated envelope ({ items, meta }).
+  listFacilities: () =>
+    apiClient.get<{ items: WarehouseFacility[] }>(URL_CONSTANTS.RULE_ENGINE.YARDS, {
+      params: { pageSize: 100 },
+    }),
 
   // ── Yards ────────────────────────────────────────────────────────────────
   listYards: (warehouseId: string) =>
@@ -361,6 +366,10 @@ export const warehouseService = {
   // ── Batch 4.5: Arrival / Unload / Load automation ──────────────────────────
   arrivalQueue: () =>
     apiClient.get<ArrivalQueueItem[]>(URL_CONSTANTS.WAREHOUSE_INVENTORY.ARRIVAL_QUEUE),
+  zoneOccupancy: (yardId?: string) =>
+    apiClient.get<ZoneOccupancy[]>(
+      URL_CONSTANTS.WAREHOUSE_INVENTORY.ZONE_OCCUPANCY(yardId),
+    ),
   autoUnloadArrived: () =>
     apiClient.post<AutoUnloadResult>(URL_CONSTANTS.WAREHOUSE_INVENTORY.AUTO_UNLOAD_ARRIVED),
   autoLoadReady: () =>
diff --git a/apps/edr-freight-web/backoffice/src/types/dropdownSettings.ts b/apps/edr-freight-web/backoffice/src/types/dropdownSettings.ts
index 175fd2256..99f41922a 100644
--- a/apps/edr-freight-web/backoffice/src/types/dropdownSettings.ts
+++ b/apps/edr-freight-web/backoffice/src/types/dropdownSettings.ts
@@ -1,6 +1,6 @@
 // Re-export the shared types from @edr/types so existing local imports keep
 // working. Canonical source: packages/types/src/freight/dropdown_settings.ts
-import type { Freight } from "@edr/types";
+import type { Freight, PaginatedResponse } from "@edr/types";
 
 export type DropdownOptionMeta = Freight.IDropdownOptionMeta;
 export type DropdownOption = Freight.IDropdownOption;
@@ -10,3 +10,13 @@ export type CreateDropdownOptionDto = Freight.CreateDropdownOptionDto;
 export type CreateDropdownSettingDto = Freight.CreateDropdownSettingDto;
 export type UpdateDropdownOptionDto = Freight.UpdateDropdownOptionDto;
 export type UpdateDropdownSettingDto = Freight.UpdateDropdownSettingDto;
+
+/** Query params for GET /dropdown-settings/paged (server-side search). */
+export interface DropdownSettingListQuery {
+  page?: number;
+  pageSize?: number;
+  search?: string;
+}
+
+/** Shared paginated envelope returned by GET /dropdown-settings/paged. */
+export type PaginatedDropdownSettings = PaginatedResponse<DropdownSetting>;
diff --git a/apps/edr-freight-web/backoffice/src/types/rule-engine/index.ts b/apps/edr-freight-web/backoffice/src/types/rule-engine/index.ts
index b422c5880..3a55880d3 100644
--- a/apps/edr-freight-web/backoffice/src/types/rule-engine/index.ts
+++ b/apps/edr-freight-web/backoffice/src/types/rule-engine/index.ts
@@ -10,15 +10,23 @@ export type RuleEngineResourceSlug =
   | "rates"
   | "approval-rules";
 
+/**
+ * Mirrors the API's shared `PaginationMeta` (@edr/types). The `has*` flags are
+ * optional because the legacy wagon-types endpoint still returns the old
+ * four-field meta.
+ */
 export interface RuleEngineListMeta {
   total: number;
   page: number;
   pageSize: number;
   totalPages: number;
+  hasNextPage?: boolean;
+  hasPreviousPage?: boolean;
 }
 
+/** Standard paginated envelope (`items` + `meta`) shared by all rule-engine lists. */
 export interface RuleEngineListResult<T> {
-  data: T[];
+  items: T[];
   meta: RuleEngineListMeta;
 }
 
diff --git a/apps/edr-freight-web/backoffice/src/types/trainScheduling.ts b/apps/edr-freight-web/backoffice/src/types/trainScheduling.ts
index 129171b7f..73a08d569 100644
--- a/apps/edr-freight-web/backoffice/src/types/trainScheduling.ts
+++ b/apps/edr-freight-web/backoffice/src/types/trainScheduling.ts
@@ -1,3 +1,5 @@
+import type { PaginatedResponse } from "@edr/types";
+
 export type FreightType = "CONTAINER" | "BULK" | "MIXED";
 
 export type SchedulingStatus =
@@ -182,6 +184,33 @@ export interface TrainScheduleListItem {
   status: TrainScheduleStatus | string;
 }
 
+export type TrainScheduleSortField =
+  | "createdAt"
+  | "scheduledDepartureDate"
+  | "reference"
+  | "trainNumber"
+  | "status";
+
+/** Server-side query for the paginated train-schedule list. */
+export interface TrainScheduleListFilters {
+  page?: number;
+  pageSize?: number;
+  /** Matches schedule reference, train number, route yards, stations, locomotive code. */
+  search?: string;
+  /** Lifecycle status (exact match). */
+  status?: TrainScheduleStatus;
+  /** Derived from the bookings aboard: CONTAINER/BULK = only that kind; MIXED = both. */
+  freightType?: FreightType;
+  /** Origin station/yard id (exact match). */
+  originStationId?: string;
+  /** Destination station/yard id (exact match). */
+  destinationStationId?: string;
+  sortBy?: TrainScheduleSortField;
+  sortOrder?: "ASC" | "DESC";
+}
+
+export type TrainScheduleListResponse = PaginatedResponse<TrainScheduleListItem>;
+
 export interface BookableSchedule {
   id: string;
   scheduleDate: string;
@@ -326,13 +355,8 @@ export interface BatchBoardFilters {
   sortOrder?: "ASC" | "DESC";
 }
 
-export interface BatchBoardListResponse {
-  items: BatchBoardSchedule[];
-  total: number;
-  page: number;
-  pageSize: number;
-  totalPages: number;
-}
+/** Paginated batch-board list in the shared `{items, meta}` envelope. */
+export type BatchBoardListResponse = PaginatedResponse<BatchBoardSchedule>;
 
 export type BookingAllocationStatus =
   | "NOT_ATTEMPTED"
diff --git a/apps/edr-freight-web/backoffice/src/types/warehouse.ts b/apps/edr-freight-web/backoffice/src/types/warehouse.ts
index 2802a0355..4023bf986 100644
--- a/apps/edr-freight-web/backoffice/src/types/warehouse.ts
+++ b/apps/edr-freight-web/backoffice/src/types/warehouse.ts
@@ -1092,3 +1092,18 @@ export interface InventoryInquiryFilter {
   zoneId?: string;
   status?: InventoryStatus;
 }
+
+/** Live occupancy of a single warehouse zone (heatmap data). */
+export interface ZoneOccupancy {
+  id: string;
+  name: string;
+  code: string;
+  type: string;
+  yardId: string;
+  capacityWeight: number | null;
+  capacityContainers: number | null;
+  usedWeight: number;
+  usedItems: number;
+  /** 0–100+, container-count based (weight is a rough fallback). Null if no capacity set. */
+  occupancyPct: number | null;
+}
diff --git a/apps/edr-freight-web/backoffice/src/utils/queryInvalidation.ts b/apps/edr-freight-web/backoffice/src/utils/queryInvalidation.ts
index bead8a8a0..f3b20ce3a 100644
--- a/apps/edr-freight-web/backoffice/src/utils/queryInvalidation.ts
+++ b/apps/edr-freight-web/backoffice/src/utils/queryInvalidation.ts
@@ -31,24 +31,31 @@ export function patchRuleEngineListRecord(
   qc.setQueriesData<RuleEngineListResult<RuleEngineRecord>>(
     { queryKey: ["rule-engine", "list", resource] },
     (old) => {
-      if (!old?.data?.length) return old;
-      const index = old.data.findIndex((row) => String(row.id) === updatedId);
+      if (!old?.items?.length) return old;
+      const index = old.items.findIndex((row) => String(row.id) === updatedId);
       if (index === -1) return old;
-      const data = old.data.slice();
-      data[index] = { ...data[index], ...updated };
-      return { ...old, data };
+      const items = old.items.slice();
+      items[index] = { ...items[index], ...updated };
+      return { ...old, items };
     },
   );
 }
 
-/** Invalidate and refetch active rule-engine list queries for a resource. */
+/**
+ * Invalidate and refetch active rule-engine list queries for a resource.
+ * Also covers the page-walked order/full lists (order-list key), which show
+ * the same rows and must refresh after any create/update/delete.
+ */
 export async function invalidateRuleEngineList(
   qc: QueryClient,
   resource: RuleEngineResourceSlug | string,
 ): Promise<void> {
-  const queryKey = ["rule-engine", "list", resource] as const;
-  await qc.invalidateQueries({ queryKey });
-  await qc.refetchQueries({ queryKey, type: "active" });
+  const listKey = ["rule-engine", "list", resource] as const;
+  const orderListKey = ["rule-engine", "order-list", resource] as const;
+  await qc.invalidateQueries({ queryKey: listKey });
+  await qc.invalidateQueries({ queryKey: orderListKey });
+  await qc.refetchQueries({ queryKey: listKey, type: "active" });
+  await qc.refetchQueries({ queryKey: orderListKey, type: "active" });
 }
 
 export function invalidateRuleEngineRoot(qc: QueryClient): Promise<void> {
diff --git a/apps/edr-freight-web/portal/src/App.tsx b/apps/edr-freight-web/portal/src/App.tsx
index 637a42816..c52268649 100644
--- a/apps/edr-freight-web/portal/src/App.tsx
+++ b/apps/edr-freight-web/portal/src/App.tsx
@@ -4,7 +4,7 @@ import {
   Home,
   Layers,
   Loader2,
-  MapPin,
+  // MapPin,
   Package,
   Receipt,
   Settings,
@@ -196,11 +196,11 @@ const sidebarItems: SidebarItem[] = [
     href: "/bookings",
     icon: <Package size={18} />,
   },
-  {
-    label: "Tracking",
-    href: "/tracking",
-    icon: <MapPin size={18} />,
-  },
+  // {
+  //   label: "Tracking",
+  //   href: "/tracking",
+  //   icon: <MapPin size={18} />,
+  // },
   {
     label: "Invoices",
     href: "/billing",
diff --git a/apps/edr-freight-web/portal/src/pages/MyPortalPage/components/UpcomingWindowsSection.tsx b/apps/edr-freight-web/portal/src/pages/MyPortalPage/components/UpcomingWindowsSection.tsx
index 391e7665b..ad2d5ace9 100644
--- a/apps/edr-freight-web/portal/src/pages/MyPortalPage/components/UpcomingWindowsSection.tsx
+++ b/apps/edr-freight-web/portal/src/pages/MyPortalPage/components/UpcomingWindowsSection.tsx
@@ -292,6 +292,19 @@ export const UpcomingWindowsSection = memo(function UpcomingWindowsSection({
                   <Text fz={14} fw={700} style={{ color: INK }} truncate>
                     {w.destination ?? "—"}
                   </Text>
+                  {w.reference && (
+                    <Text
+                      fz={11}
+                      fw={600}
+                      style={{
+                        color: MUTED,
+                        flexShrink: 0,
+                        fontVariantNumeric: "tabular-nums",
+                      }}
+                    >
+                      {w.reference}
+                    </Text>
+                  )}
                 </Group>
                 <Group gap={5} wrap="nowrap" mt={2}>
                   <CalendarClock size={12} color={MUTED} style={{ flexShrink: 0 }} />
diff --git a/apps/edr-freight-web/portal/src/pages/MyPortalPage/constants.ts b/apps/edr-freight-web/portal/src/pages/MyPortalPage/constants.ts
index 64ec1b0dd..7be5a0aed 100644
--- a/apps/edr-freight-web/portal/src/pages/MyPortalPage/constants.ts
+++ b/apps/edr-freight-web/portal/src/pages/MyPortalPage/constants.ts
@@ -172,7 +172,7 @@ export const STATUS_CONFIG: Record<string, StageConfig> = {
     tile: "edr-amber-soft",
     hint: "Clearance documents needed",
     step: "edr-accent",
-    badgeLabel: "Docs needed",
+    badgeLabel: "Upload documents",
     badgeBg: "edr-amber-soft",
     badgeText: "edr-amber-text",
     badgeDot: "edr-accent",
diff --git a/apps/edr-freight-web/portal/src/pages/bookings/BookingClearanceWorkflowBanner.tsx b/apps/edr-freight-web/portal/src/pages/bookings/BookingClearanceWorkflowBanner.tsx
index b4dc80074..1e6fc1439 100644
--- a/apps/edr-freight-web/portal/src/pages/bookings/BookingClearanceWorkflowBanner.tsx
+++ b/apps/edr-freight-web/portal/src/pages/bookings/BookingClearanceWorkflowBanner.tsx
@@ -18,9 +18,12 @@ export function BookingClearanceWorkflowBanner({
 }: {
   booking: Freight.IBooking;
 }) {
+  // Drawdown bookings under a GENERAL contract keep bookingType = ONE_TIME —
+  // the denormalized contractKind is what marks them as phased (Path B).
   const isPhased =
     booking.customsClearingEnabled &&
-    booking.bookingType === "GENERAL_CONTRACT";
+    (booking.bookingType === "GENERAL_CONTRACT" ||
+      booking.contractKind === "GENERAL");
 
   const { view, viewer } = useFileViewer();
 
diff --git a/apps/edr-freight-web/portal/src/pages/bookings/BookingDetailPage/ReadonlyBookingView.tsx b/apps/edr-freight-web/portal/src/pages/bookings/BookingDetailPage/ReadonlyBookingView.tsx
index f135078c1..d0ecb12a6 100644
--- a/apps/edr-freight-web/portal/src/pages/bookings/BookingDetailPage/ReadonlyBookingView.tsx
+++ b/apps/edr-freight-web/portal/src/pages/bookings/BookingDetailPage/ReadonlyBookingView.tsx
@@ -1,6 +1,6 @@
-import { Group } from "@mantine/core";
+import { Group, Tabs } from "@mantine/core";
 import { useMutation, useQuery } from "@tanstack/react-query";
-import { CreditCard } from "lucide-react";
+import { CreditCard, FileText, LayoutGrid } from "lucide-react";
 import { useState } from "react";
 import { useNavigate } from "react-router-dom";
 
@@ -14,6 +14,7 @@ import type { Freight } from "@edr/types";
 import { ApproveDeliveryButton } from "../delivery/ApproveDeliveryButton";
 import { ActivityCard } from "./components/ActivityCard";
 import { ClearanceCard } from "./components/ClearanceCard";
+import { DocumentsTab } from "./components/DocumentsTab";
 import { ContainersCard } from "./components/ContainersCard";
 import { ContractCard } from "./components/ContractCard";
 import { CustomerTruckAssignmentCard } from "./components/CustomerTruckAssignmentCard";
@@ -122,9 +123,14 @@ export function ReadonlyBookingView({
   const canAssignCustomerTruck =
     booking.paymentStatus === "PAID" &&
     usesCustomerTruck &&
-    ["PAID", "IN_TRANSIT", "ARRIVED", "COMPLETED", "TRUCK_ASSIGNED"].includes(
-      status,
-    );
+    (booking.tradeDirection === "IMPORT"
+      ? // Import self-haul: pickup trucks are assigned only after the train has
+        // arrived at the destination.
+        status === "ARRIVED"
+      : // Export / domestic self-haul: delivery trucks are assigned only before
+        // the cargo is loaded onto the train (PAID / TRUCK_ASSIGNED). Once loaded
+        // (IN_TRANSIT and beyond) assignment is closed.
+        ["PAID", "TRUCK_ASSIGNED"].includes(status));
   const showCountdown = canPay && !!booking.paymentDeadline;
   const isExpired = status === "EXPIRED";
   const isPendingConsolidation = status === "PENDING_CONSOLIDATION";
@@ -201,50 +207,76 @@ export function ReadonlyBookingView({
 
       <KeyFactsStrip booking={booking} />
 
-      <ContractCard booking={booking} />
+      <Tabs
+        defaultValue="overview"
+        keepMounted={false}
+        styles={{
+          list: { gap: 6, borderBottom: "1px solid #E6ECF2" },
+          tab: { borderRadius: "10px 10px 0 0", fontWeight: 700, padding: "10px 16px" },
+        }}
+      >
+        <Tabs.List mb="lg">
+          <Tabs.Tab value="overview" leftSection={<LayoutGrid size={15} />}>
+            Overview
+          </Tabs.Tab>
+          <Tabs.Tab value="documents" leftSection={<FileText size={15} />}>
+            Documents
+          </Tabs.Tab>
+        </Tabs.List>
 
-      {isClearance && <ClearanceCard booking={booking} />}
+        <Tabs.Panel value="overview">
+          <div className="flex flex-col gap-6">
+            <ContractCard booking={booking} />
 
-      <BodyGrid
-        left={
-          <>
-            <ShipmentDetailsCard booking={booking} />
+            {isClearance && <ClearanceCard booking={booking} />}
 
-            <ContainersCard booking={booking} />
+            <BodyGrid
+              left={
+                <>
+                  <ShipmentDetailsCard booking={booking} />
 
-            <ShipmentTrackingCard bookingId={booking.id} />
+                  <ContainersCard booking={booking} />
 
-            {canAssignCustomerTruck && (
-              <CustomerTruckAssignmentCard
-                booking={booking}
-                onAssigned={onBookingUpdated ?? (() => {})}
-              />
-            )}
-            <WarehousePaymentsSection bookingId={booking.id} />
+                  <ShipmentTrackingCard bookingId={booking.id} />
 
-            <ActivityCard booking={booking} />
+                  {canAssignCustomerTruck && (
+                    <CustomerTruckAssignmentCard
+                      booking={booking}
+                      onAssigned={onBookingUpdated ?? (() => {})}
+                    />
+                  )}
+                  <WarehousePaymentsSection bookingId={booking.id} />
 
-            <MileSummaryCard booking={booking} />
-          </>
-        }
-        right={
-          <>
-            <BookingPaymentPanel
-              booking={booking}
-              pricing={pricing}
-              onPay={() => setPayModalOpen(true)}
-              paying={payMutation.isPending}
-              showCountdown={showCountdown}
+                  <ActivityCard booking={booking} />
+
+                  <MileSummaryCard booking={booking} />
+                </>
+              }
+              right={
+                <>
+                  <BookingPaymentPanel
+                    booking={booking}
+                    pricing={pricing}
+                    onPay={() => setPayModalOpen(true)}
+                    paying={payMutation.isPending}
+                    showCountdown={showCountdown}
+                  />
+                  <ScheduleCard
+                    booking={booking}
+                    title="Consignment & Schedule"
+                    consignment
+                  />
+                  <SupportCard />
+                </>
+              }
             />
-            <ScheduleCard
-              booking={booking}
-              title="Consignment & Schedule"
-              consignment
-            />
-            <SupportCard />
-          </>
-        }
-      />
+          </div>
+        </Tabs.Panel>
+
+        <Tabs.Panel value="documents">
+          <DocumentsTab booking={booking} />
+        </Tabs.Panel>
+      </Tabs>
 
       <PaymentMethodModal
         opened={payModalOpen}
diff --git a/apps/edr-freight-web/portal/src/pages/bookings/BookingDetailPage/components/CustomerTruckAssignmentCard.tsx b/apps/edr-freight-web/portal/src/pages/bookings/BookingDetailPage/components/CustomerTruckAssignmentCard.tsx
index a8cee69eb..a73057fcd 100644
--- a/apps/edr-freight-web/portal/src/pages/bookings/BookingDetailPage/components/CustomerTruckAssignmentCard.tsx
+++ b/apps/edr-freight-web/portal/src/pages/bookings/BookingDetailPage/components/CustomerTruckAssignmentCard.tsx
@@ -97,13 +97,17 @@ export function CustomerTruckAssignmentCard({
     setError(null);
   };
 
+  // Bulk bookings have no containers — the truck hauls loose tonnage (weighed on
+  // departure), so the container picker and its validation are skipped.
+  const isBulk = String(booking.freightType) === "BULK";
+
   const addMutation = useMutation({
     mutationFn: () => {
       const payload = {
         truckPlateNumber: plateNumber.trim().toUpperCase(),
         driverName: driverName.trim(),
         truckType: truckType.trim(),
-        containerNumbers: containers,
+        containerNumbers: isBulk ? [] : containers,
       };
       return editingId
         ? customerTrucksService.update(booking.id, editingId, payload)
@@ -138,7 +142,7 @@ export function CustomerTruckAssignmentCard({
       setError("Plate number, driver name and truck type are required.");
       return;
     }
-    if (containers.length < 1 || containers.length > 2) {
+    if (!isBulk && (containers.length < 1 || containers.length > 2)) {
       setError("Select 1 or 2 container numbers for this truck.");
       return;
     }
@@ -232,8 +236,9 @@ export function CustomerTruckAssignmentCard({
           </Alert>
         )}
 
-        {/* Add-truck form — both directions assign the containers each truck carries. */}
-        {availableContainers.length > 0 ? (
+        {/* Add-truck form. Container bookings assign 1–2 containers per truck;
+            bulk bookings just register the truck (no container picker). */}
+        {isBulk || availableContainers.length > 0 ? (
           <>
             <Divider label={editingId ? "Edit truck" : "Add a truck"} labelPosition="center" />
             <SimpleGrid cols={{ base: 1, sm: 2 }} spacing="sm">
@@ -256,18 +261,20 @@ export function CustomerTruckAssignmentCard({
                 value={truckType || null}
                 onChange={(value) => setTruckType(value ?? "")}
               />
-              <MultiSelect
-                label="Containers to load"
-                description="20ft: up to 2 per truck · 40ft: 1 per truck"
-                required
-                placeholder="Select container numbers"
-                data={availableContainers}
-                value={containers}
-                onChange={setContainers}
-                maxValues={2}
-                searchable
-                nothingFoundMessage="No unassigned containers"
-              />
+              {!isBulk && (
+                <MultiSelect
+                  label="Containers to load"
+                  description="20ft: up to 2 per truck · 40ft: 1 per truck"
+                  required
+                  placeholder="Select container numbers"
+                  data={availableContainers}
+                  value={containers}
+                  onChange={setContainers}
+                  maxValues={2}
+                  searchable
+                  nothingFoundMessage="No unassigned containers"
+                />
+              )}
             </SimpleGrid>
             <Group justify="flex-end">
               {editingId && (
diff --git a/apps/edr-freight-web/portal/src/pages/bookings/BookingDetailPage/components/DocumentsTab.tsx b/apps/edr-freight-web/portal/src/pages/bookings/BookingDetailPage/components/DocumentsTab.tsx
new file mode 100644
index 000000000..a24f34763
--- /dev/null
+++ b/apps/edr-freight-web/portal/src/pages/bookings/BookingDetailPage/components/DocumentsTab.tsx
@@ -0,0 +1,573 @@
+import { useMemo, useState } from "react";
+import { Alert, Badge, Box, Button, Group, Stack, Text } from "@mantine/core";
+import { useQuery } from "@tanstack/react-query";
+import {
+  Building2,
+  Check,
+  ClipboardList,
+  Download,
+  Eye,
+  FileText,
+  Info,
+} from "lucide-react";
+
+import type { Freight } from "@edr/types";
+import { isViewable } from "@edr/ui-common";
+
+import { api } from "@/services/api";
+import { fileViewUrl } from "@/constants/apiConfig";
+import { useFileViewer } from "@/hooks/useFileViewer";
+import { BookingActionModal } from "@/pages/bookings/clearance/BookingActionModal";
+import { getBookingNextAction } from "@/pages/bookings/clearance/bookingNextAction";
+import { ClearanceUploadedDocumentsPanel } from "@/components/contracts/ClearanceUploadedDocumentsPanel";
+
+import { fmtDate } from "../utils";
+import { IconSquare } from "./Documents";
+import { CardTitle, SectionCard } from "./layout";
+
+const BORDER = "#E6ECF2";
+
+type AnyFile = {
+  id: string;
+  code: string;
+  name: string;
+  url: string;
+  signedUrl?: string | null;
+};
+
+// ── shared row chrome ─────────────────────────────────────────────────────────
+
+type PillTone = "green" | "red" | "blue" | "gray";
+
+const PILL_TONES: Record<PillTone, { bg: string; fg: string; border?: string }> =
+  {
+    green: { bg: "#ECF6F1", fg: "#0A6F4D", border: "#CDEBDD" },
+    red: { bg: "#FBEAE7", fg: "#A93226", border: "#F3C8C1" },
+    blue: { bg: "#EAF1FB", fg: "#2E5B96" },
+    gray: { bg: "#F1F4F7", fg: "#6B7C8E" },
+  };
+
+function Pill({ tone, label }: { tone: PillTone; label: string }) {
+  const t = PILL_TONES[tone];
+  return (
+    <Box
+      component="span"
+      style={{
+        display: "inline-flex",
+        flexShrink: 0,
+        borderRadius: 999,
+        backgroundColor: t.bg,
+        border: t.border ? `1px solid ${t.border}` : undefined,
+        padding: "4px 10px",
+        fontSize: 11.5,
+        fontWeight: 700,
+        color: t.fg,
+        whiteSpace: "nowrap",
+      }}
+    >
+      {label}
+    </Box>
+  );
+}
+
+function reviewPill(doc: Freight.ClearanceDocument) {
+  if (!doc.file) return <Pill tone="gray" label="Not uploaded" />;
+  switch (doc.reviewStatus) {
+    case "APPROVED":
+      return <Pill tone="green" label="Approved" />;
+    case "QUERIED":
+      return <Pill tone="red" label="Query — re-upload" />;
+    default:
+      return <Pill tone="blue" label="Pending review" />;
+  }
+}
+
+/** One document row: icon tile, title/meta, status pill, view/download. */
+function FileRow({
+  title,
+  meta,
+  file,
+  pill,
+  last,
+  onView,
+}: {
+  title: string;
+  meta?: string | null;
+  file: { id: string; name: string } | null;
+  pill?: React.ReactNode;
+  last?: boolean;
+  onView: (f: { name: string; url: string }) => void;
+}) {
+  const viewUrl = file ? fileViewUrl(file.id) : null;
+  return (
+    <Group
+      gap={13}
+      align="center"
+      wrap="nowrap"
+      py={12}
+      style={{ borderBottom: last ? undefined : "1px solid #F2F5F8" }}
+    >
+      <Box
+        style={{
+          flexShrink: 0,
+          width: 40,
+          height: 40,
+          display: "flex",
+          alignItems: "center",
+          justifyContent: "center",
+          borderRadius: 10,
+          backgroundColor: file ? "#EAF1FB" : "#F1F4F7",
+          color: file ? "#2E5B96" : "#9AA8B5",
+        }}
+      >
+        <FileText size={20} />
+      </Box>
+      <Box miw={0} flex={1}>
+        <Text truncate fz="13.5px" fw={700} c={file ? "#10202F" : "#6B7C8E"}>
+          {title}
+        </Text>
+        <Text truncate fz="12px" c="#9AA8B5">
+          {meta || file?.name || "—"}
+        </Text>
+      </Box>
+      {pill}
+      {file && viewUrl && isViewable({ name: file.name, url: viewUrl }) && (
+        <IconSquare
+          icon={<Eye size={15} />}
+          onClick={() => onView({ name: file.name, url: viewUrl })}
+        />
+      )}
+      {file && <IconSquare href={fileViewUrl(file.id, true)} icon={<Download size={15} />} />}
+    </Group>
+  );
+}
+
+// ── customs clearance progress timeline ──────────────────────────────────────
+
+const REGION_LABELS: Record<string, string> = {
+  CUST: "You",
+  ET: "GL Ethiopia",
+  DJ: "GL Djibouti",
+  OPS: "Operations",
+};
+
+function MilestoneTimeline({
+  milestones,
+}: {
+  milestones: Freight.IClearanceMilestone[];
+}) {
+  const ordered = [...milestones].sort((a, b) => a.sortOrder - b.sortOrder);
+  const currentIdx = ordered.findIndex((m) => m.status === "PENDING");
+  return (
+    <Stack gap={0}>
+      {ordered.map((m, idx) => {
+        const done = m.status === "COMPLETED";
+        const skipped = m.status === "SKIPPED";
+        const active = idx === currentIdx;
+        const last = idx === ordered.length - 1;
+        return (
+          <Group key={m.id} gap={12} align="stretch" wrap="nowrap">
+            {/* rail: circle + connector */}
+            <Box
+              style={{
+                display: "flex",
+                flexDirection: "column",
+                alignItems: "center",
+                width: 26,
+                flexShrink: 0,
+              }}
+            >
+              <Box
+                style={{
+                  width: 22,
+                  height: 22,
+                  borderRadius: 999,
+                  display: "flex",
+                  alignItems: "center",
+                  justifyContent: "center",
+                  backgroundColor: done
+                    ? "#0EA371"
+                    : active
+                      ? "#0C1A2B"
+                      : "#EEF2F6",
+                  color: done || active ? "#fff" : "#9AA8B5",
+                  boxShadow: active ? "0 0 0 4px #D9E0E7" : undefined,
+                  fontSize: 10.5,
+                  fontWeight: 700,
+                }}
+              >
+                {done ? <Check size={13} strokeWidth={3} /> : idx + 1}
+              </Box>
+              {!last && (
+                <Box
+                  style={{
+                    width: 2,
+                    flex: 1,
+                    minHeight: 14,
+                    backgroundColor: done ? "#0EA371" : "#E1E7EE",
+                  }}
+                />
+              )}
+            </Box>
+            <Box pb={last ? 0 : 14} miw={0} flex={1}>
+              <Group gap={8} wrap="nowrap" align="center">
+                <Text
+                  fz="13.5px"
+                  fw={active ? 800 : 700}
+                  c={done || active ? "#10202F" : "#9AA8B5"}
+                  td={skipped ? "line-through" : undefined}
+                  truncate
+                >
+                  {m.milestoneLabel}
+                </Text>
+                {m.ownerRegion && REGION_LABELS[m.ownerRegion] && (
+                  <Badge
+                    size="xs"
+                    variant="light"
+                    color={m.ownerRegion === "CUST" ? "orange" : "gray"}
+                    radius="sm"
+                    tt="none"
+                  >
+                    {REGION_LABELS[m.ownerRegion]}
+                  </Badge>
+                )}
+              </Group>
+              <Text fz="11.5px" c="#9AA8B5" mt={1}>
+                {skipped
+                  ? "Skipped"
+                  : done
+                    ? `Completed${m.triggeredAt ? ` · ${fmtDate(m.triggeredAt)}` : ""}`
+                    : active
+                      ? "Current step"
+                      : "Upcoming"}
+                {m.note ? ` · ${m.note}` : ""}
+              </Text>
+            </Box>
+          </Group>
+        );
+      })}
+    </Stack>
+  );
+}
+
+// ── contract & profile document grouping ─────────────────────────────────────
+
+// Mirrors ContractDetailPage's grouping: onboarding/profile codes seeded by
+// file-upload-settings vs the generated contract PDF vs everything else.
+const BUSINESS_LICENSE_DOC_CODES = new Set([
+  "business_license",
+  "commercial_license",
+  "investment_license",
+]);
+const PROFILE_DOC_CODES = new Set([
+  "tin_certificate",
+  "national_id",
+  "national_id_passport",
+  "passport",
+]);
+
+const KNOWN_FILE_LABELS: Record<string, string> = {
+  contract: "Signed contract",
+  tin_certificate: "TIN certificate",
+  business_license: "Business licence",
+  commercial_license: "Commercial licence",
+  investment_license: "Investment licence",
+  national_id: "National ID",
+  national_id_passport: "National ID / Passport",
+  passport: "Passport",
+  commercial_invoice: "Commercial Invoice",
+  packing_list: "Packing List",
+  certificate_of_origin: "Certificate of Origin",
+  letter_of_credit: "Letter of Credit / LC",
+};
+
+function fileLabel(f: AnyFile) {
+  if (KNOWN_FILE_LABELS[f.code]) return KNOWN_FILE_LABELS[f.code];
+  // Ad-hoc uploads carry a generated code (custom_<ts>_<i>) — use the filename.
+  if (f.code.startsWith("custom_")) return f.name;
+  return f.code
+    .replace(/_/g, " ")
+    .replace(/\b\w/g, (m) => m.toUpperCase());
+}
+
+// ── the tab ───────────────────────────────────────────────────────────────────
+
+/**
+ * Documents tab of the booking detail page. Pulls together every document that
+ * belongs to this shipment, in sections:
+ *
+ *  1. Clearance documents — the per-booking clearance grid (your uploads with
+ *     their review state, GL output documents), the customs progress timeline,
+ *     and the phased customs files (declaration, duty, transit permit, DO).
+ *  2. Contract & company documents — the signed contract plus the company
+ *     documents the contract carries from your profile (TIN certificate,
+ *     business licence, national ID, …).
+ *  3. Other booking documents — anything uploaded directly on the booking that
+ *     isn't already shown above.
+ */
+export function DocumentsTab({ booking }: { booking: Freight.IBooking }) {
+  const { view, viewer } = useFileViewer();
+  const [modalOpen, setModalOpen] = useState(false);
+
+  const hasContract = Boolean(booking.contractId);
+
+  const { data: clearance } = useQuery(
+    api.bookings.getClearance.queryOptions({
+      input: { id: booking.id },
+      enabled: hasContract,
+    }),
+  );
+
+  const { data: contract } = useQuery(
+    api.contracts.get.queryOptions({
+      input: { id: booking.contractId ?? "" },
+      enabled: hasContract,
+    }),
+  );
+
+  const customerDocs = useMemo(
+    () => (clearance?.documents ?? []).filter((d) => d.uploadedBy === "customer"),
+    [clearance],
+  );
+  const glDocs = useMemo(
+    () =>
+      (clearance?.documents ?? []).filter(
+        (d) => d.uploadedBy === "gl" && d.file,
+      ),
+    [clearance],
+  );
+
+  // The clearance action button (upload / re-upload / view) mirrors the
+  // Overview tab's ClearanceCard so documents can be managed from here too.
+  const action = getBookingNextAction(booking);
+  const showManage = action && action.kind !== "BOOK";
+
+  const contractFiles = (contract?.files ?? []) as AnyFile[];
+  const contractPdf = contractFiles.find((f) => f.code === "contract");
+  const licenseFiles = contractFiles.filter((f) =>
+    BUSINESS_LICENSE_DOC_CODES.has(f.code),
+  );
+  const profileFiles = contractFiles.filter((f) => PROFILE_DOC_CODES.has(f.code));
+
+  // Booking files not already represented in the clearance grid (those rows
+  // show review state, so they win) and not contract signatures/PDF.
+  const clearanceKeys = useMemo(
+    () => new Set((clearance?.documents ?? []).map((d) => d.fileKey)),
+    [clearance],
+  );
+  const otherBookingFiles = ((booking.files ?? []) as AnyFile[]).filter(
+    (f) => !clearanceKeys.has(f.code) && !f.code.startsWith("signature_"),
+  );
+
+  const company = contract?.company;
+
+  return (
+    <Stack gap="lg">
+      {/* ── 1. Clearance documents ──────────────────────────────────────── */}
+      {hasContract && clearance && (
+        <SectionCard>
+          <Group justify="space-between" align="center" mb={4}>
+            <CardTitle>Clearance documents</CardTitle>
+            {showManage && (
+              <Button
+                color="edr-green"
+                radius="md"
+                size="xs"
+                leftSection={<ClipboardList size={14} />}
+                onClick={() => setModalOpen(true)}
+              >
+                {action.label}
+              </Button>
+            )}
+          </Group>
+          <Text fz="12.5px" c="dimmed" mb="sm">
+            Documents required to clear this shipment, with their review state.
+          </Text>
+
+          {customerDocs.length > 0 ? (
+            <Stack gap={0}>
+              {customerDocs.map((doc, i) => (
+                <FileRow
+                  key={doc.fileKey}
+                  title={`${doc.label}${doc.required ? " *" : ""}`}
+                  meta={doc.note ? `Note: ${doc.note}` : doc.file?.name}
+                  file={doc.file}
+                  pill={reviewPill(doc)}
+                  last={i === customerDocs.length - 1 && glDocs.length === 0}
+                  onView={view}
+                />
+              ))}
+              {glDocs.map((doc, i) => (
+                <FileRow
+                  key={doc.fileKey}
+                  title={doc.label}
+                  meta="Provided by Global Logistics"
+                  file={doc.file}
+                  pill={<Pill tone="green" label="Available" />}
+                  last={i === glDocs.length - 1}
+                  onView={view}
+                />
+              ))}
+            </Stack>
+          ) : (
+            <Alert color="gray" radius="md" icon={<Info size={16} />}>
+              No clearance documents are required for this booking.
+            </Alert>
+          )}
+        </SectionCard>
+      )}
+
+      {/* ── customs progress (Path B phased clearance) ──────────────────── */}
+      {(clearance?.milestones?.length ?? 0) > 0 && (
+        <SectionCard>
+          <CardTitle>Customs clearance progress</CardTitle>
+          <Text fz="12.5px" c="dimmed" mt={4} mb="md">
+            Every customs step for this shipment — completed steps are ticked,
+            the highlighted one is where it currently stands.
+          </Text>
+          <MilestoneTimeline milestones={clearance!.milestones!} />
+        </SectionCard>
+      )}
+
+      {(clearance?.workflowFiles?.length ?? 0) > 0 && (
+        <SectionCard>
+          <CardTitle>Customs documents</CardTitle>
+          <Box mt="md">
+            <ClearanceUploadedDocumentsPanel
+              embedded
+              files={clearance!.workflowFiles ?? []}
+              tradeDirection={booking.tradeDirection}
+              onView={(f) => view(f)}
+              onDownload={({ id, name }) => {
+                const a = document.createElement("a");
+                a.href = fileViewUrl(id, true);
+                a.download = name;
+                a.click();
+              }}
+            />
+          </Box>
+        </SectionCard>
+      )}
+
+      {/* ── 2. Contract & company documents ─────────────────────────────── */}
+      {hasContract && contract && (
+        <SectionCard>
+          <Group gap={10} align="center" mb={4}>
+            <Building2 size={16} color="#6B7C8E" />
+            <CardTitle>Contract & company documents</CardTitle>
+          </Group>
+          <Text fz="12.5px" c="dimmed" mb="sm">
+            Attached to contract {contract.reference} — including the company
+            documents it carries from your profile (TIN, licence, ID).
+          </Text>
+
+          {(company?.name || company?.tin) && (
+            <Group
+              gap={24}
+              mb="sm"
+              px={14}
+              py={10}
+              style={{ borderRadius: 10, border: `1px solid ${BORDER}` }}
+            >
+              {company?.name && (
+                <Box>
+                  <Text fz="10.5px" fw={700} c="#6B7C8E" tt="uppercase">
+                    Company
+                  </Text>
+                  <Text fz="13.5px" fw={700} c="#10202F">
+                    {company.name}
+                  </Text>
+                </Box>
+              )}
+              {company?.tin && (
+                <Box>
+                  <Text fz="10.5px" fw={700} c="#6B7C8E" tt="uppercase">
+                    TIN number
+                  </Text>
+                  <Text fz="13.5px" fw={700} c="#10202F">
+                    {company.tin}
+                  </Text>
+                </Box>
+              )}
+            </Group>
+          )}
+
+          {contractPdf || licenseFiles.length || profileFiles.length ? (
+            <Stack gap={0}>
+              {contractPdf && (
+                <FileRow
+                  title="Signed contract"
+                  meta={contractPdf.name}
+                  file={contractPdf}
+                  pill={<Pill tone="green" label="Executed" />}
+                  last={!licenseFiles.length && !profileFiles.length}
+                  onView={view}
+                />
+              )}
+              {[...licenseFiles, ...profileFiles].map((f, i, arr) => (
+                <FileRow
+                  key={f.id}
+                  title={fileLabel(f)}
+                  meta={
+                    PROFILE_DOC_CODES.has(f.code) ||
+                    BUSINESS_LICENSE_DOC_CODES.has(f.code)
+                      ? "From your company profile"
+                      : f.name
+                  }
+                  file={f}
+                  pill={<Pill tone="green" label="On file" />}
+                  last={i === arr.length - 1}
+                  onView={view}
+                />
+              ))}
+            </Stack>
+          ) : (
+            <Alert color="gray" radius="md" icon={<Info size={16} />}>
+              No documents are attached to this contract yet.
+            </Alert>
+          )}
+        </SectionCard>
+      )}
+
+      {/* ── 3. Other booking documents ──────────────────────────────────── */}
+      {otherBookingFiles.length > 0 && (
+        <SectionCard>
+          <CardTitle>Other booking documents</CardTitle>
+          <Text fz="12.5px" c="dimmed" mt={4} mb="sm">
+            Documents uploaded directly on this booking.
+          </Text>
+          <Stack gap={0}>
+            {otherBookingFiles.map((f, i) => (
+              <FileRow
+                key={f.id}
+                title={fileLabel(f)}
+                meta={f.name}
+                file={f}
+                pill={<Pill tone="green" label="Uploaded" />}
+                last={i === otherBookingFiles.length - 1}
+                onView={view}
+              />
+            ))}
+          </Stack>
+        </SectionCard>
+      )}
+
+      {!hasContract && otherBookingFiles.length === 0 && (
+        <SectionCard>
+          <Alert color="gray" radius="md" icon={<Info size={16} />}>
+            No documents have been uploaded for this booking yet.
+          </Alert>
+        </SectionCard>
+      )}
+
+      {showManage && (
+        <BookingActionModal
+          booking={booking}
+          opened={modalOpen}
+          onClose={() => setModalOpen(false)}
+        />
+      )}
+      {viewer}
+    </Stack>
+  );
+}
diff --git a/apps/edr-freight-web/portal/src/pages/bookings/BookingDetailPage/components/KeyFactsStrip.tsx b/apps/edr-freight-web/portal/src/pages/bookings/BookingDetailPage/components/KeyFactsStrip.tsx
index 1ad53c0c8..27f76ae2d 100644
--- a/apps/edr-freight-web/portal/src/pages/bookings/BookingDetailPage/components/KeyFactsStrip.tsx
+++ b/apps/edr-freight-web/portal/src/pages/bookings/BookingDetailPage/components/KeyFactsStrip.tsx
@@ -1,5 +1,6 @@
-import { Box, SimpleGrid, Text } from "@mantine/core";
+import { Anchor, Box, SimpleGrid, Text } from "@mantine/core";
 import type { ReactNode } from "react";
+import { Link } from "react-router-dom";
 
 import type { Freight } from "@edr/types";
 
@@ -39,14 +40,42 @@ function Fact({ label, value }: { label: string; value: ReactNode }) {
  */
 export function KeyFactsStrip({ booking }: { booking: BookingLike }) {
   const isContract = booking.bookingType === "GENERAL_CONTRACT";
+  // A drawdown under a GENERAL contract stays bookingType = ONE_TIME; its
+  // "General" nature lives in the denormalized contractKind.
+  const isGeneralDrawdown = !isContract && booking.contractKind === "GENERAL";
   const freight = booking.freightType === "BULK" ? "Bulk" : "Container";
   const payment = paymentStatusLabel(booking.paymentStatus);
 
   return (
     <SectionCard p="lg">
       <SimpleGrid cols={{ base: 2, md: 3, xl: 6 }} spacing={0} verticalSpacing="lg">
-        <Fact label="Type" value={isContract ? "General Contract" : "One-Time"} />
+        <Fact
+          label="Type"
+          value={
+            isContract
+              ? "General Contract"
+              : isGeneralDrawdown
+                ? "General"
+                : "One-Time"
+          }
+        />
         <Fact label="Cargo" value={freight} />
+        {booking.contractId ? (
+          <Fact
+            label="Contract"
+            value={
+              <Anchor
+                component={Link}
+                to={`/contracts/${booking.contractId}`}
+                fz="15px"
+                fw={700}
+                underline="hover"
+              >
+                {booking.contractReference ?? "View contract"}
+              </Anchor>
+            }
+          />
+        ) : null}
         <Fact
           label="Route"
           value={`${yardLabel(booking.originYard)} → ${yardLabel(booking.destinationYard)}`}
diff --git a/apps/edr-freight-web/portal/src/pages/bookings/BookingDetailPage/components/StatusHero.tsx b/apps/edr-freight-web/portal/src/pages/bookings/BookingDetailPage/components/StatusHero.tsx
index 16d412703..b9d7ee8e8 100644
--- a/apps/edr-freight-web/portal/src/pages/bookings/BookingDetailPage/components/StatusHero.tsx
+++ b/apps/edr-freight-web/portal/src/pages/bookings/BookingDetailPage/components/StatusHero.tsx
@@ -104,7 +104,7 @@ export function StatusHero({
         }
       : isInitiatedInstance
         ? {
-            title: "Booking initiated — clearance documents needed",
+            title: "Upload clearance documents",
             description:
               "Upload the required clearance documents to start the review. Once the review is finalized you can book your shipment.",
             stage,
@@ -194,7 +194,11 @@ function ProgressTracker({
         } as React.CSSProperties
       }
     >
-      <div className="flex items-start" style={{ minWidth: 640 }}>
+      {/* ~84px per stage keeps 2-word labels readable; the box scrolls on mobile. */}
+      <div
+        className="flex items-start"
+        style={{ minWidth: Math.max(640, stages.length * 84) }}
+      >
         {stages.map((stage, idx) => {
           const state =
             idx < current ? "done" : idx === current ? "active" : "idle";
diff --git a/apps/edr-freight-web/portal/src/pages/bookings/BookingDetailPage/constants.ts b/apps/edr-freight-web/portal/src/pages/bookings/BookingDetailPage/constants.ts
index ae3d20e4e..14a595a66 100644
--- a/apps/edr-freight-web/portal/src/pages/bookings/BookingDetailPage/constants.ts
+++ b/apps/edr-freight-web/portal/src/pages/bookings/BookingDetailPage/constants.ts
@@ -1,6 +1,9 @@
 import {
+  BadgeCheck,
   ClipboardCheck,
+  FileSearch,
   FileText,
+  FileUp,
   MapPin,
   PackageCheck,
   PackageOpen,
@@ -54,6 +57,7 @@ export const PROGRESS_STAGES = [
     icon: Ship,
     statuses: [
       "PAID",
+      "TRUCK_ASSIGNED",
       "PNR_GENERATED",
       "PENDING_CONSOLIDATION",
       "CONSOLIDATED",
@@ -105,18 +109,25 @@ export const ARRIVAL_STAGE = PROGRESS_STAGES.findIndex(
  */
 export const CONTRACT_PROGRESS_STAGES = [
   {
-    // The instance was initiated with one click and is going through per-booking
-    // clearance (upload → review → ready). One-time drawdowns without clearance
-    // start here too until they are booked.
-    label: "Initiated",
-    icon: FileText,
-    statuses: [
-      "DRAFT",
-      "CHANGES_REQUESTED",
-      "AWAITING_DOCUMENTS",
-      "DOCUMENTS_UNDER_REVIEW",
-      "CLEARANCE_READY",
-    ],
+    // The instance was initiated with one click and now sits in the clearance
+    // gate: the customer must upload the required clearance documents.
+    label: "Upload Documents",
+    icon: FileUp,
+    statuses: ["DRAFT", "CHANGES_REQUESTED", "AWAITING_DOCUMENTS"],
+  },
+  {
+    // Staff/GL are reviewing the uploaded clearance documents; the customer
+    // only re-uploads queried ones.
+    label: "Document Review",
+    icon: FileSearch,
+    statuses: ["DOCUMENTS_UNDER_REVIEW"],
+  },
+  {
+    // Clearance finished — the customer books (Path A) or GL completes the
+    // booking on their behalf (Path B customs).
+    label: "Cleared",
+    icon: BadgeCheck,
+    statuses: ["CLEARANCE_READY"],
   },
   {
     // The customer (or GL) completed the booking — cargo + shipment day — and it
@@ -152,6 +163,7 @@ export const CONTRACT_PROGRESS_STAGES = [
     icon: Ship,
     statuses: [
       "PAID",
+      "TRUCK_ASSIGNED",
       "PNR_GENERATED",
       "PENDING_CONSOLIDATION",
       "CONSOLIDATED",
@@ -315,6 +327,11 @@ export const STATUS_MAP: Record<
     description: "Payment has been confirmed for this booking.",
     stage: 5,
   },
+  TRUCK_ASSIGNED: {
+    title: "Truck assigned",
+    description: "Customer truck assigned for self-haul; ready for loading.",
+    stage: 5,
+  },
   IN_TRANSIT: {
     title: "Cargo moving",
     description: "Your shipment is currently moving through the rail network.",
@@ -360,13 +377,13 @@ export const STATUS_MAP: Record<
     stage: 5,
   },
   AWAITING_DOCUMENTS: {
-    title: "Clearance documents needed",
+    title: "Upload clearance documents",
     description:
       "Upload the required clearance documents so your shipment can be reviewed.",
     stage: 1,
   },
   DOCUMENTS_UNDER_REVIEW: {
-    title: "Documents under review",
+    title: "Clearance documents under review",
     description:
       "Your clearance documents are being reviewed. Re-upload any queried documents to proceed.",
     stage: 2,
diff --git a/apps/edr-freight-web/portal/src/pages/bookings/BookingsListPage.tsx b/apps/edr-freight-web/portal/src/pages/bookings/BookingsListPage.tsx
index bd68632f7..d2f944690 100644
--- a/apps/edr-freight-web/portal/src/pages/bookings/BookingsListPage.tsx
+++ b/apps/edr-freight-web/portal/src/pages/bookings/BookingsListPage.tsx
@@ -17,6 +17,7 @@ import {
   ThemeIcon,
   Title,
 } from "@mantine/core";
+import { useDebouncedValue } from "@mantine/hooks";
 import type { LucideIcon } from "lucide-react";
 import {
   ArrowRight,
@@ -37,6 +38,7 @@ import { PayNowButton } from "./payments/PayNowButton";
 import { BookingActionButton } from "./clearance/BookingActionButton";
 import { bookingHasInlineAction } from "./clearance/bookingNextAction";
 import {
+  BookingStatusBadge as StatusBadge,
   BookingTypeBadge,
   CargoModeCell,
   PaymentBadge,
@@ -45,7 +47,6 @@ import {
 
 import { api } from "@/services/api";
 import type { BookingListFilter } from "@/services/bookings.service";
-import { STATUS_CONFIG } from "@/pages/MyPortalPage/constants";
 import type { Freight } from "@edr/types";
 import {
   DataTable,
@@ -156,46 +157,6 @@ const STAT_CARDS: Array<{
   },
 ];
 
-// ── Status badge (reuses the shared portal status config) ─────────────────────
-
-function StatusBadge({ status }: { status: string }) {
-  const cfg = STATUS_CONFIG[status];
-  const label = cfg?.badgeLabel ?? status.replace(/_/g, " ");
-  const bg = cfg ? `var(--mantine-color-${cfg.badgeBg}-0, #F1F4F7)` : "#F1F4F7";
-  const text = cfg
-    ? `var(--mantine-color-${cfg.badgeText}-7, #475569)`
-    : "#475569";
-  const dot = cfg
-    ? `var(--mantine-color-${cfg.badgeDot}-6, #94A3B8)`
-    : "#94A3B8";
-  return (
-    <Group
-      gap={6}
-      align="center"
-      wrap="nowrap"
-      style={{
-        display: "inline-flex",
-        borderRadius: 999,
-        backgroundColor: bg,
-        padding: "5px 11px",
-      }}
-    >
-      <Box
-        style={{
-          width: 6,
-          height: 6,
-          borderRadius: "50%",
-          backgroundColor: dot,
-          flexShrink: 0,
-        }}
-      />
-      <Text fz={11} fw={700} style={{ color: text, whiteSpace: "nowrap" }}>
-        {label}
-      </Text>
-    </Group>
-  );
-}
-
 // ── Context-sensitive action button ───────────────────────────────────────────
 
 function PrimaryAction({
@@ -364,6 +325,7 @@ export default function BookingsListPage() {
   const { pagination, setPagination } = usePagination({ pageSize: 10 });
   const [statusFilter, setStatusFilter] = useState<StatusFilterKey>("all");
   const [query, setQuery] = useState("");
+  const [debouncedQuery] = useDebouncedValue(query, 300);
   const [typeFilter, setTypeFilter] = useState<string | null>(null);
   const [freightFilter, setFreightFilter] = useState<string | null>(null);
   const [sort, setSort] = useState<string>("createdAt:DESC");
@@ -401,6 +363,8 @@ export default function BookingsListPage() {
       createdFrom: createdFrom || undefined,
       // include the whole selected end day
       createdTo: createdTo ? `${createdTo}T23:59:59.999Z` : undefined,
+      // Server-side free-text search (booking ref, company, contract ref).
+      search: debouncedQuery.trim() || undefined,
       page: pagination.pageIndex + 1,
       pageSize: pagination.pageSize,
       sortBy,
@@ -412,6 +376,7 @@ export default function BookingsListPage() {
       freightFilter,
       createdFrom,
       createdTo,
+      debouncedQuery,
       pagination.pageIndex,
       pagination.pageSize,
       sortBy,
@@ -450,22 +415,9 @@ export default function BookingsListPage() {
   const allItems = data?.items ?? [];
   const total = data?.meta?.total ?? allItems.length;
 
-  // Server handles status + pagination; reference search is applied on the page
-  // (matches booking reference, contract reference, and route yards).
-  const rows = useMemo(() => {
-    const q = query.trim().toLowerCase();
-    if (!q) return allItems;
-    return allItems.filter((b) =>
-      [
-        b.reference,
-        b.contractReference,
-        b.originYard?.label,
-        b.destinationYard?.label,
-      ]
-        .filter(Boolean)
-        .some((v) => String(v).toLowerCase().includes(q)),
-    );
-  }, [allItems, query]);
+  // Server handles status + pagination + search (booking reference, company
+  // name, contract reference) — no client-side filtering.
+  const rows = allItems;
 
   const pageCount = Math.max(1, Math.ceil(total / pagination.pageSize));
   const dataTableStatus = isLoading ? "loading" : isError ? "error" : "success";
@@ -753,14 +705,20 @@ export default function BookingsListPage() {
                 placeholder="Search booking, contract, or route…"
                 leftSection={<Search size={16} />}
                 value={query}
-                onChange={(e) => setQuery(e.currentTarget.value)}
+                onChange={(e) => {
+                  setQuery(e.currentTarget.value);
+                  resetPage();
+                }}
                 rightSection={
                   query ? (
                     <ActionIcon
                       size="sm"
                       variant="transparent"
                       color="gray"
-                      onClick={() => setQuery("")}
+                      onClick={() => {
+                        setQuery("");
+                        resetPage();
+                      }}
                     >
                       <X size={14} />
                     </ActionIcon>
diff --git a/apps/edr-freight-web/portal/src/pages/bookings/booking-display.tsx b/apps/edr-freight-web/portal/src/pages/bookings/booking-display.tsx
index e8c047726..780099d1f 100644
--- a/apps/edr-freight-web/portal/src/pages/bookings/booking-display.tsx
+++ b/apps/edr-freight-web/portal/src/pages/bookings/booking-display.tsx
@@ -1,4 +1,4 @@
-import { Badge, Group, Text } from "@mantine/core";
+import { Badge, Box, Group, Text } from "@mantine/core";
 import type { Freight } from "@edr/types";
 
 import { STATUS_CONFIG } from "@/pages/MyPortalPage/constants";
@@ -34,17 +34,20 @@ type BookingLike = Freight.IBooking & {
   paymentStatus?: string;
 };
 
-/** One-Time vs General Contract. */
+/** One-Time vs General Contract (or a drawdown under a GENERAL contract). */
 export function BookingTypeBadge({ booking }: { booking: BookingLike }) {
   const isContract = booking.bookingType === "GENERAL_CONTRACT";
+  // Drawdown bookings keep bookingType = ONE_TIME; the parent contract's kind
+  // (denormalized onto the booking) is what makes them "General".
+  const isGeneralDrawdown = !isContract && booking.contractKind === "GENERAL";
   return (
     <Badge
       variant="light"
       radius="sm"
-      color={isContract ? "violet" : "gray"}
+      color={isContract || isGeneralDrawdown ? "violet" : "gray"}
       styles={{ root: { textTransform: "none", fontWeight: 600, letterSpacing: 0 } }}
     >
-      {isContract ? "General Contract" : "One-Time"}
+      {isContract ? "General Contract" : isGeneralDrawdown ? "General" : "One-Time"}
     </Badge>
   );
 }
@@ -121,6 +124,45 @@ export function PaymentBadge({ status }: { status?: string | null }) {
   );
 }
 
+/** Booking status pill (dot + label) driven by the shared STATUS_CONFIG. */
+export function BookingStatusBadge({ status }: { status: string }) {
+  const cfg = STATUS_CONFIG[status];
+  const label = cfg?.badgeLabel ?? titleCaseStatus(status);
+  const bg = cfg ? `var(--mantine-color-${cfg.badgeBg}-0, #F1F4F7)` : "#F1F4F7";
+  const text = cfg
+    ? `var(--mantine-color-${cfg.badgeText}-7, #475569)`
+    : "#475569";
+  const dot = cfg
+    ? `var(--mantine-color-${cfg.badgeDot}-6, #94A3B8)`
+    : "#94A3B8";
+  return (
+    <Group
+      gap={6}
+      align="center"
+      wrap="nowrap"
+      style={{
+        display: "inline-flex",
+        borderRadius: 999,
+        backgroundColor: bg,
+        padding: "5px 11px",
+      }}
+    >
+      <Box
+        style={{
+          width: 6,
+          height: 6,
+          borderRadius: "50%",
+          backgroundColor: dot,
+          flexShrink: 0,
+        }}
+      />
+      <Text fz={11} fw={700} style={{ color: text, whiteSpace: "nowrap" }}>
+        {label}
+      </Text>
+    </Group>
+  );
+}
+
 /** Whether a booking is assigned to a train yet (scheduling progress). */
 export function SchedulingCell({ booking }: { booking: BookingLike & { trainScheduleId?: string | null; schedulingStatus?: string } }) {
   const assigned = !!booking.trainScheduleId;
diff --git a/apps/edr-freight-web/portal/src/pages/contracts/ContractDetailPage.tsx b/apps/edr-freight-web/portal/src/pages/contracts/ContractDetailPage.tsx
index 0eb06ea79..64c64ce26 100644
--- a/apps/edr-freight-web/portal/src/pages/contracts/ContractDetailPage.tsx
+++ b/apps/edr-freight-web/portal/src/pages/contracts/ContractDetailPage.tsx
@@ -7,6 +7,7 @@ import {
 } from "react-router-dom";
 import { useQuery } from "@tanstack/react-query";
 import {
+  Alert,
   Badge,
   Box,
   Button,
@@ -20,6 +21,7 @@ import {
   RingProgress,
   SimpleGrid,
   Stack,
+  Table,
   Tabs,
   Text,
   Title,
@@ -44,6 +46,7 @@ import {
   PackagePlus,
   Ship,
   Snowflake,
+  Split,
   Upload,
   Weight,
 } from "lucide-react";
@@ -58,6 +61,13 @@ import { fileViewUrl } from "@/constants/apiConfig";
 import { useFileViewer } from "@/hooks/useFileViewer";
 import toast from "react-hot-toast";
 import { labelForDocCode } from "@/pages/bookings/resubmit";
+import {
+  BookingStatusBadge,
+  BookingTypeBadge,
+  CargoModeCell,
+  PaymentBadge,
+  SchedulingCell,
+} from "@/pages/bookings/booking-display";
 import { ContractClearancePanel } from "./ContractClearancePanel";
 import { ContractClearanceWorkflowBanner } from "./ContractClearanceWorkflowBanner";
 import { ClearanceUploadedDocumentsPanel } from "@/components/contracts/ClearanceUploadedDocumentsPanel";
@@ -146,8 +156,15 @@ interface DocGroup {
  * contract PDF, company profile / onboarding documents, and clearance documents
  * (everything else — the clearance set uses dynamic per-contract codes). Empty
  * groups are dropped so the tab only renders sections that have files.
+ *
+ * GENERAL contracts clear per booking, so their contract-level "clearance"
+ * leftovers are not shown — pass includeClearance: false to keep only the
+ * profile / business-licence sections.
  */
-function groupContractDocuments(files: ContractFile[]): DocGroup[] {
+function groupContractDocuments(
+  files: ContractFile[],
+  { includeClearance = true }: { includeClearance?: boolean } = {},
+): DocGroup[] {
   const businessLicense: ContractFile[] = [];
   const profile: ContractFile[] = [];
   const clearance: ContractFile[] = [];
@@ -157,7 +174,7 @@ function groupContractDocuments(files: ContractFile[]): DocGroup[] {
     if (f.code === "contract" || f.code.startsWith("signature_")) continue;
     else if (BUSINESS_LICENSE_DOC_CODES.has(f.code)) businessLicense.push(f);
     else if (PROFILE_DOC_CODES.has(f.code)) profile.push(f);
-    else clearance.push(f);
+    else if (includeClearance) clearance.push(f);
   }
   return [
     { key: "clearance", title: "Clearance documents", files: clearance },
@@ -248,17 +265,6 @@ export default function ContractDetailPage() {
     contract?.tradeDirection === "DOMESTIC" ||
     hasOpenWindow(bookingWindows);
 
-  // Draw-down capacity per cargo line (GENERAL contracts only). The backend
-  // excludes CANCELLED/REJECTED/EXPIRED bookings, so a shipment that never ships
-  // releases its share and the tracker fills back up. Refetched on window focus so
-  // it reflects newly created / cancelled shipments.
-  const { data: capacityLines = [] } = useQuery({
-    queryKey: ["contract-capacity", id],
-    queryFn: () => contractsService.getCapacity(id!),
-    enabled: !!id && contract?.contractKind === "GENERAL",
-    refetchOnWindowFocus: true,
-  });
-
   const contractBookings = useMemo(
     () =>
       (bookingsPage?.items ?? []).filter(
@@ -267,6 +273,32 @@ export default function ContractDetailPage() {
     [bookingsPage, id],
   );
 
+  // A booking reduced by a paid partial split that still holds quantity. On a
+  // ONE_TIME contract this switches the contract into remainder-only booking;
+  // on a GENERAL contract it is informational (the leftover simply returned).
+  const splitBooking = useMemo(
+    () =>
+      contractBookings.find(
+        (b) =>
+          (b as { isSplit?: boolean }).isSplit &&
+          !["CANCELLED", "REJECTED", "EXPIRED"].includes(b.status),
+      ),
+    [contractBookings],
+  );
+
+  // Draw-down capacity per cargo line (GENERAL contracts), or the outstanding
+  // split remainder of a ONE_TIME contract. The backend excludes CANCELLED/
+  // REJECTED/EXPIRED bookings, so a shipment that never ships releases its
+  // share and the tracker fills back up. Refetched on window focus so it
+  // reflects newly created / cancelled shipments.
+  const { data: capacityLines = [] } = useQuery({
+    queryKey: ["contract-capacity", id],
+    queryFn: () => contractsService.getCapacity(id!),
+    enabled:
+      !!id && (contract?.contractKind === "GENERAL" || Boolean(splitBooking)),
+    refetchOnWindowFocus: true,
+  });
+
   if (isLoading) {
     return (
       <Center mih={400} p="xl">
@@ -311,7 +343,12 @@ export default function ContractDetailPage() {
   const routes = contract.routes ?? [];
   const pricing = contract.pricingBreakdown;
   const files = contract.files ?? [];
-  const docGroups = groupContractDocuments(files);
+  // GENERAL contracts clear per booking — clearance documents live on each
+  // booking's detail page, so this tab keeps only profile/licence documents.
+  const docGroups = groupContractDocuments(files, {
+    includeClearance: contract.contractKind !== "GENERAL",
+  });
+  const docCount = docGroups.reduce((sum, g) => sum + g.files.length, 0);
   // The generated contract PDF — surfaced via a dedicated "View contract" button
   // in the header (it's excluded from the Documents tab groups).
   const contractPdf = files.find((f) => f.code === "contract");
@@ -604,7 +641,7 @@ export default function ContractDetailPage() {
               active={tab === "documents"}
               icon={<Download size={16} />}
               label="Documents"
-              count={files.length + (isPhasedCustomsClearance ? workflowFileCount : 0)}
+              count={docCount + (isPhasedCustomsClearance ? workflowFileCount : 0)}
             />
             <DetailTab
               value="bookings"
@@ -959,10 +996,45 @@ export default function ContractDetailPage() {
           </Card>
         </SimpleGrid>
 
-        {/* Draw-down capacity — GENERAL contracts with a per-line quantity cap.
+        {/* Booking-was-split notice. ONE_TIME: the customer may only book the
+            whole outstanding remainder (API-enforced). GENERAL: informational —
+            the leftover returned to the contract and books like any drawdown. */}
+        {splitBooking && (
+          <Alert
+            color={isGeneral ? "edr-green" : "yellow"}
+            variant="light"
+            radius="md"
+            icon={<Split size={16} />}
+            title="A booking on this contract was split"
+          >
+            <Text fz={13}>
+              Shipment {splitBooking.reference} was split because the train
+              could not carry it whole — the paid part is shipping and the
+              rest returned to this contract.{" "}
+              {isGeneral
+                ? "You can book the remaining quantity any time before the contract validity expires."
+                : capacityLines.length > 0
+                  ? `Your next booking must take the whole remainder: ${capacityLines
+                      .filter((l) => (l.remaining ?? 0) > 0)
+                      .map(
+                        (l) =>
+                          `${l.remaining} ${
+                            isContainer
+                              ? `× ${l.containerSize ?? "container"}`
+                              : "tons"
+                          }`,
+                      )
+                      .join(", ")}. No other booking can be created on this contract.`
+                  : "Your next booking must take the whole remaining quantity — no other booking can be created on this contract."}
+            </Text>
+          </Alert>
+        )}
+
+        {/* Draw-down capacity — GENERAL contracts with a per-line quantity cap,
+            or the outstanding remainder of a split ONE_TIME contract.
             Fills as shipments consume capacity; empties again when a shipment is
             cancelled/rejected/expired (backend releases it). */}
-        {isGeneral && capacityLines.length > 0 && (
+        {(isGeneral || Boolean(splitBooking)) && capacityLines.length > 0 && (
           <Card
             withBorder
             radius="lg"
@@ -1139,8 +1211,9 @@ export default function ContractDetailPage() {
                     No documents yet
                   </Text>
                   <Text fz={13} c="dimmed" ta="center" maw={420}>
-                    The signed contract and any uploaded clearance documents will
-                    appear here.
+                    {isGeneral
+                      ? "Your company profile documents (TIN certificate, business licence, ID) appear here. Clearance documents are managed on each booking."
+                      : "The signed contract and any uploaded clearance documents will appear here."}
                   </Text>
                 </Stack>
               ) : (
@@ -1347,49 +1420,113 @@ export default function ContractDetailPage() {
                   </Text>
                 </Stack>
               ) : (
-                <Stack gap={10}>
-                  {contractBookings.map((booking) => (
-                    <Group
-                      key={booking.id}
-                      justify="space-between"
-                      wrap="nowrap"
-                      p="sm"
-                      style={{
-                        borderRadius: 12,
-                        border: `1px solid ${BORDER}`,
-                        cursor: "pointer",
-                      }}
-                      onClick={() => navigate(`/bookings/${booking.id}`)}
-                    >
-                      <Group gap={12} wrap="nowrap" style={{ minWidth: 0 }}>
-                        <Package
-                          size={16}
-                          color={MUTED}
-                          style={{ flexShrink: 0 }}
-                        />
-                        <Box style={{ minWidth: 0 }}>
-                          <Text
-                            fz={14}
-                            fw={700}
-                            style={{ color: INK }}
-                            truncate
+                <Table.ScrollContainer minWidth={980}>
+                  <Table
+                    verticalSpacing="sm"
+                    horizontalSpacing="md"
+                    highlightOnHover
+                    style={{ fontSize: 13 }}
+                  >
+                    <Table.Thead>
+                      <Table.Tr>
+                        <BookingsTh label="Booking" />
+                        <BookingsTh label="Type" />
+                        <BookingsTh label="Cargo" />
+                        <BookingsTh label="Route" />
+                        <BookingsTh label="Payment" />
+                        <BookingsTh label="Train" />
+                        <BookingsTh label="Status" />
+                        <BookingsTh label="Amount" right />
+                      </Table.Tr>
+                    </Table.Thead>
+                    <Table.Tbody>
+                      {contractBookings.map((booking) => {
+                        const origin =
+                          booking.originYard?.label ??
+                          booking.originYard?.code ??
+                          "—";
+                        const dest =
+                          booking.destinationYard?.label ??
+                          booking.destinationYard?.code ??
+                          "—";
+                        const amount = Number(booking.totalAmount ?? 0);
+                        return (
+                          <Table.Tr
+                            key={booking.id}
+                            style={{ cursor: "pointer" }}
+                            onClick={() => navigate(`/bookings/${booking.id}`)}
                           >
-                            {booking.reference}
-                          </Text>
-                          {booking.scheduledDate && (
-                            <Text fz={12} c="dimmed" truncate>
-                              Ship{" "}
-                              {new Date(
-                                booking.scheduledDate,
-                              ).toLocaleDateString()}
-                            </Text>
-                          )}
-                        </Box>
-                      </Group>
-                      <ContractStatusBadge status={booking.status} />
-                    </Group>
-                  ))}
-                </Stack>
+                            <Table.Td>
+                              <Group gap={10} wrap="nowrap">
+                                <Package
+                                  size={16}
+                                  color={MUTED}
+                                  style={{ flexShrink: 0 }}
+                                />
+                                <Box style={{ minWidth: 0 }}>
+                                  <Text
+                                    fz={13.5}
+                                    fw={700}
+                                    style={{ color: INK }}
+                                    truncate
+                                  >
+                                    {booking.reference}
+                                  </Text>
+                                  <Text fz={11.5} c="dimmed">
+                                    {booking.freightType === "BULK"
+                                      ? "Bulk cargo"
+                                      : "Container"}
+                                  </Text>
+                                </Box>
+                              </Group>
+                            </Table.Td>
+                            <Table.Td>
+                              <BookingTypeBadge booking={booking} />
+                            </Table.Td>
+                            <Table.Td>
+                              <CargoModeCell booking={booking} />
+                            </Table.Td>
+                            <Table.Td>
+                              <Text fz={13} fw={600} style={{ color: INK }}>
+                                {origin} → {dest}
+                              </Text>
+                              {booking.scheduledDate && (
+                                <Text fz={11.5} c="dimmed">
+                                  {new Date(
+                                    booking.scheduledDate,
+                                  ).toLocaleDateString()}
+                                </Text>
+                              )}
+                            </Table.Td>
+                            <Table.Td>
+                              <PaymentBadge status={booking.paymentStatus} />
+                            </Table.Td>
+                            <Table.Td>
+                              <SchedulingCell booking={booking} />
+                            </Table.Td>
+                            <Table.Td>
+                              <BookingStatusBadge status={booking.status} />
+                            </Table.Td>
+                            <Table.Td style={{ textAlign: "right" }}>
+                              <Text
+                                fz={13.5}
+                                fw={700}
+                                style={{
+                                  color: amount > 0 ? INK : "#94A3B8",
+                                  whiteSpace: "nowrap",
+                                }}
+                              >
+                                {amount > 0
+                                  ? `ETB ${amount.toLocaleString()}`
+                                  : "—"}
+                              </Text>
+                            </Table.Td>
+                          </Table.Tr>
+                        );
+                      })}
+                    </Table.Tbody>
+                  </Table>
+                </Table.ScrollContainer>
               )}
             </Card>
           </Tabs.Panel>
@@ -1520,6 +1657,23 @@ function SectionLabel({
   );
 }
 
+/** Column header for the bookings table — mirrors the /bookings list styling. */
+function BookingsTh({ label, right }: { label: string; right?: boolean }) {
+  return (
+    <Table.Th style={{ textAlign: right ? "right" : "left" }}>
+      <Text
+        fz={11}
+        fw={700}
+        tt="uppercase"
+        c="dimmed"
+        style={{ letterSpacing: "0.06em", whiteSpace: "nowrap" }}
+      >
+        {label}
+      </Text>
+    </Table.Th>
+  );
+}
+
 /**
  * Unit noun for a capacity line: "containers" for CONTAINER freight, else the
  * bulk cargo's unit of measure ("tons" for PER_TON, "items" for PER_ITEM).
diff --git a/apps/edr-freight-web/portal/src/pages/contracts/ContractsList.tsx b/apps/edr-freight-web/portal/src/pages/contracts/ContractsList.tsx
index 40a519840..cdef9136e 100644
--- a/apps/edr-freight-web/portal/src/pages/contracts/ContractsList.tsx
+++ b/apps/edr-freight-web/portal/src/pages/contracts/ContractsList.tsx
@@ -17,6 +17,7 @@ import {
   TextInput,
   Title,
 } from "@mantine/core";
+import { useDebouncedValue } from "@mantine/hooks";
 import {
   AlertTriangle,
   CheckCircle2,
@@ -64,6 +65,7 @@ export default function ContractsList() {
   const { company } = useAuth();
   const { pagination, setPagination } = usePagination({ pageSize: 10 });
   const [query, setQuery] = useState("");
+  const [debouncedQuery] = useDebouncedValue(query, 300);
   const [disclaimerOpen, setDisclaimerOpen] = useState(false);
   const [freightFilter, setFreightFilter] = useState<string | null>(null);
   const [kindFilter, setKindFilter] = useState<string | null>(null);
@@ -107,6 +109,8 @@ export default function ContractsList() {
       freightType: freightFilter ?? undefined,
       createdFrom: createdFrom || undefined,
       createdTo: createdTo ? `${createdTo}T23:59:59.999Z` : undefined,
+      // Server-side free-text search (contract reference, company name).
+      search: debouncedQuery.trim() || undefined,
       page: pagination.pageIndex + 1,
       pageSize: pagination.pageSize,
       sortBy: "createdAt",
@@ -117,6 +121,7 @@ export default function ContractsList() {
       freightFilter,
       createdFrom,
       createdTo,
+      debouncedQuery,
       pagination.pageIndex,
       pagination.pageSize,
     ],
@@ -135,19 +140,8 @@ export default function ContractsList() {
   );
   const bookings = bookingsData?.items ?? [];
 
-  const rows = useMemo(() => {
-    const items = data?.items ?? [];
-    if (!query.trim()) return items;
-    const q = query.toLowerCase();
-    return items.filter((c) => {
-      const { origin, destination } = primaryRoute(c);
-      return (
-        c.reference?.toLowerCase().includes(q) ||
-        origin.toLowerCase().includes(q) ||
-        destination.toLowerCase().includes(q)
-      );
-    });
-  }, [data, query]);
+  // Search + pagination are fully server-side — rows are the page as returned.
+  const rows = data?.items ?? [];
 
   const stats = useMemo(() => {
     const items = data?.items ?? [];
@@ -279,10 +273,13 @@ export default function ContractsList() {
         <Paper withBorder radius="lg" p="sm" style={{ borderColor: BORDER }}>
           <Group gap={10} wrap="wrap" align="center">
             <TextInput
-              placeholder="Search by reference or route…"
+              placeholder="Search by reference or customer…"
               leftSection={<Search size={16} />}
               value={query}
-              onChange={(e) => setQuery(e.currentTarget.value)}
+              onChange={(e) => {
+                setQuery(e.currentTarget.value);
+                resetPage();
+              }}
               radius="md"
               styles={{ input: { height: 42 } }}
               style={{ flex: 1, minWidth: 220, maxWidth: 360 }}
diff --git a/apps/edr-freight-web/portal/src/pages/contracts/NewShipmentPage.tsx b/apps/edr-freight-web/portal/src/pages/contracts/NewShipmentPage.tsx
index 0e0a3a1f3..8233b83d6 100644
--- a/apps/edr-freight-web/portal/src/pages/contracts/NewShipmentPage.tsx
+++ b/apps/edr-freight-web/portal/src/pages/contracts/NewShipmentPage.tsx
@@ -40,7 +40,10 @@ import {
 import type { Freight } from "@edr/types";
 import { OperationDatePicker } from "@edr/ui-common";
 import { api } from "@/services/api";
-import type { ShipmentValidation } from "@/services/contracts.service";
+import {
+  contractsService,
+  type ShipmentValidation,
+} from "@/services/contracts.service";
 import {
   SelectField,
   StepCard,
@@ -357,6 +360,10 @@ function NewShipmentBookingForm({
     if ((validateMutation.data?.pairingErrors.length ?? 0) > 0) return;
     // Guard: a line above the container type's max capacity can never book.
     if ((validateMutation.data?.capacityErrors?.length ?? 0) > 0) return;
+    // Guard: a container already on another booking of the same train can never book.
+    if ((validateMutation.data?.containerClashErrors?.length ?? 0) > 0) return;
+    // Guard: an export booking no open train can carry whole can never book.
+    if ((validateMutation.data?.spaceErrors?.length ?? 0) > 0) return;
     submitMutation.mutate(buildDto(pendingValues));
   };
 
@@ -511,6 +518,10 @@ function PriceConfirmModal({
   const hasPairingBlock = pairingErrors.length > 0;
   const capacityErrors = validation?.capacityErrors ?? [];
   const hasCapacityBlock = capacityErrors.length > 0;
+  const containerClashErrors = validation?.containerClashErrors ?? [];
+  const hasClashBlock = containerClashErrors.length > 0;
+  const spaceErrors = validation?.spaceErrors ?? [];
+  const hasSpaceBlock = spaceErrors.length > 0;
 
   // Authoritative server breakdown — the SAME BookingPricingService pass that
   // prices the booking on create, so it carries every line the booking will be
@@ -542,6 +553,8 @@ function PriceConfirmModal({
     validationLoading ||
     hasPairingBlock ||
     hasCapacityBlock ||
+    hasClashBlock ||
+    hasSpaceBlock ||
     !serverTotal;
 
   // Fallback while the server preview loads: the contract's frozen unit rates
@@ -649,6 +662,46 @@ function PriceConfirmModal({
             </Alert>
           )}
 
+          {hasClashBlock && (
+            <Alert
+              color="red"
+              variant="light"
+              radius="md"
+              icon={<AlertCircle size={16} />}
+              title="Cannot create booking — container already booked"
+            >
+              <Stack gap={6}>
+                {containerClashErrors.map((msg, i) => (
+                  <Text key={i} fz="sm" c="red.8">
+                    {msg}
+                  </Text>
+                ))}
+                <Text fz="xs" c="red.7" mt={2}>
+                  A container can only be on one booking per train — remove it
+                  or pick another shipment day.
+                </Text>
+              </Stack>
+            </Alert>
+          )}
+
+          {hasSpaceBlock && (
+            <Alert
+              color="red"
+              variant="light"
+              radius="md"
+              icon={<AlertCircle size={16} />}
+              title="Cannot create booking — not enough train space"
+            >
+              <Stack gap={6}>
+                {spaceErrors.map((msg, i) => (
+                  <Text key={i} fz="sm" c="red.8">
+                    {msg}
+                  </Text>
+                ))}
+              </Stack>
+            </Alert>
+          )}
+
           {overweightLines.length > 0 && (
             <Alert
               color="yellow"
@@ -948,6 +1001,65 @@ function CargoStep({
     [contract],
   );
 
+  // ONE_TIME split-remainder mode: the previous booking was split on train
+  // capacity, so the capacity endpoint reports the outstanding remainder — the
+  // EXACT quantity this booking must take (the API rejects anything else).
+  const { data: capacityLines = [] } = useQuery({
+    queryKey: ["contract-capacity", contract.id],
+    queryFn: () => contractsService.getCapacity(contract.id),
+    enabled: contract.contractKind === "ONE_TIME",
+  });
+  const remainderLines = useMemo(
+    () =>
+      contract.contractKind === "ONE_TIME"
+        ? capacityLines.filter((l) => (l.remaining ?? 0) > 0)
+        : [],
+    [contract.contractKind, capacityLines],
+  );
+  const remainderMode = remainderLines.length > 0;
+
+  // Bulk: prefill the exact outstanding remainder once (the customer cannot
+  // book a different amount anyway). Containers keep manual entry — each unit
+  // still needs its container number.
+  useEffect(() => {
+    if (!remainderMode || isContainer) return;
+    const field =
+      bulkUnitOfMeasure(contract) === "PER_ITEM" ? "itemCount" : "cargoWeightTons";
+    if (!form.getValues(field)) {
+      form.setValue(field, String(remainderLines[0].remaining), {
+        shouldValidate: false,
+      });
+    }
+    // eslint-disable-next-line react-hooks/exhaustive-deps
+  }, [remainderMode]);
+
+  const remainderNotice = remainderMode ? (
+    <Alert
+      color="yellow"
+      variant="light"
+      radius="md"
+      icon={<AlertTriangle size={16} />}
+      title="This booking must take the whole split remainder"
+    >
+      <Text fz={13}>
+        Your previous booking on this one-time contract was split — the paid
+        part is shipping and the rest returned to the contract. This booking
+        must cover exactly the remaining{" "}
+        {remainderLines
+          .map((l) =>
+            isContainer
+              ? `${l.remaining} × ${l.containerSize ?? "container"}`
+              : `${l.remaining} ${
+                  bulkUnitOfMeasure(contract) === "PER_ITEM" ? "items" : "tons"
+                }`,
+          )
+          .join(", ")}
+        . A different quantity will be rejected, and no other booking can be
+        created on this contract.
+      </Text>
+    </Alert>
+  ) : null;
+
   // Seed one shipment line per contracted size exactly once (never during
   // render — appending in render loops). Subsequent renders reuse the lines.
   const seededRef = useRef(false);
@@ -1112,6 +1224,7 @@ function CargoStep({
               )}
             </Paper>
           )}
+          {remainderNotice}
           <ContractCapacityNotice contractId={contract.id} isContainer />
           {lines.map((line, index) => (
             <ContainerLineEditor
@@ -1141,6 +1254,7 @@ function CargoStep({
         description="Enter the amount you are shipping for this booking."
       />
       <Stack gap={14}>
+        {remainderNotice}
         <ContractCapacityNotice contractId={contract.id} isContainer={false} />
         <Controller
           name="cargoWeightTons"
diff --git a/apps/edr-freight-web/portal/src/pages/contracts/contract-booking-action.ts b/apps/edr-freight-web/portal/src/pages/contracts/contract-booking-action.ts
index 1a128e84f..c7374d510 100644
--- a/apps/edr-freight-web/portal/src/pages/contracts/contract-booking-action.ts
+++ b/apps/edr-freight-web/portal/src/pages/contracts/contract-booking-action.ts
@@ -15,6 +15,9 @@ export const TERMINAL_BOOKING_STATUSES = [
 /** Path A statuses where a customer (no customs) may book against the contract. */
 const PATH_A_BOOKABLE = ["FULLY_EXECUTED", "CONTRACT_ACTIVE"];
 
+/** Split bookings in these statuses released their quantity — no remainder to book. */
+const RELEASING_BOOKING_STATUSES = ["CANCELLED", "REJECTED", "EXPIRED"];
+
 export type ContractBookingActionKind =
   | "book"
   | "rebook"
@@ -25,6 +28,12 @@ export type ContractBookingActionKind =
 export interface ContractBookingAction {
   kind: ContractBookingActionKind;
   to: string;
+  /**
+   * ONE_TIME contract whose booking was split (partial batch payment): the
+   * customer may book again, but ONLY the whole outstanding remainder — the
+   * exact quantities come from the contract capacity endpoint.
+   */
+  remainderOnly?: boolean;
 }
 
 /**
@@ -60,6 +69,14 @@ export function getContractBookingAction(
 
   if (contract.contractKind === "ONE_TIME") {
     const mine = bookings.filter((b) => b.contractId === contract.id);
+    // Split chain: a paid partial split frees the single-booking slot for the
+    // remainder. The API enforces that the next booking takes the whole
+    // leftover; once it is booked the contract closes (CONTRACT_CLOSED), which
+    // the PATH_A_BOOKABLE gate above already excludes.
+    const hasLiveSplit = mine.some(
+      (b) => b.isSplit && !RELEASING_BOOKING_STATUSES.includes(b.status),
+    );
+    if (hasLiveSplit) return { kind: "book", to, remainderOnly: true };
     const hasActive = mine.some(
       (b) => !TERMINAL_BOOKING_STATUSES.includes(b.status),
     );
diff --git a/apps/edr-freight-web/portal/src/services/bookings.service.ts b/apps/edr-freight-web/portal/src/services/bookings.service.ts
index 852452099..1128b0883 100644
--- a/apps/edr-freight-web/portal/src/services/bookings.service.ts
+++ b/apps/edr-freight-web/portal/src/services/bookings.service.ts
@@ -73,6 +73,8 @@ export interface PriceLineItem {
  */
 export interface MyBookingWindow {
   scheduleId: string;
+  /** Train schedule reference (e.g. TS-2026-000123), shown on the window card. */
+  reference: string | null;
   /**
    * The customer's active contract on this lane, when they hold one — enables
    * "Book now" to target it. Null for lanes they have no contract on.
@@ -153,6 +155,8 @@ export interface BookingListFilter {
   /** Created-date range (ISO). */
   createdFrom?: string;
   createdTo?: string;
+  /** Free-text search: booking reference, company name, contract reference (server-side). */
+  search?: string;
   page?: number;
   pageSize?: number;
   sortBy?: string;
diff --git a/apps/edr-freight-web/portal/src/services/contracts.service.ts b/apps/edr-freight-web/portal/src/services/contracts.service.ts
index 616a202db..34f5071fd 100644
--- a/apps/edr-freight-web/portal/src/services/contracts.service.ts
+++ b/apps/edr-freight-web/portal/src/services/contracts.service.ts
@@ -73,6 +73,10 @@ export interface ShipmentValidation {
   pairingErrors: string[];
   /** Lines above the container type's hard max capacity — booking cannot be created. */
   capacityErrors?: string[];
+  /** Containers already on another active booking for the same day + route — booking cannot be created. */
+  containerClashErrors?: string[];
+  /** EXPORT only: no single open train on the chosen day can carry the whole booking — booking cannot be created. */
+  spaceErrors?: string[];
   lineItems?: ShipmentPriceLine[];
   totalAmount?: number;
 }
@@ -89,6 +93,8 @@ export interface ContractListFilter {
   companyProfileId?: string;
   createdFrom?: string;
   createdTo?: string;
+  /** Server-side free-text search (contract reference, company name). */
+  search?: string;
   page?: number;
   pageSize?: number;
   sortBy?: string;
diff --git a/apps/edr-passenger-api/src/app.module.ts b/apps/edr-passenger-api/src/app.module.ts
index 59d73c55f..cce0f5e7d 100644
--- a/apps/edr-passenger-api/src/app.module.ts
+++ b/apps/edr-passenger-api/src/app.module.ts
@@ -1,79 +1,72 @@
-import {Logger, Module, OnApplicationBootstrap} from '@nestjs/common';
-import { ThrottlerModule } from '@nestjs/throttler';
-import { DynamicThrottlerGuard } from './common/dynamic-throttler.guard';
-import { APP_GUARD, APP_FILTER } from '@nestjs/core';
-import { ConfigModule, ConfigService } from '@nestjs/config';
-import { ScheduleModule } from '@nestjs/schedule';
-import { EventEmitterModule } from '@nestjs/event-emitter';
-import { TypeOrmModule, TypeOrmModuleOptions } from '@nestjs/typeorm';
-import { IamModule as TriaIamModule } from '@tria-plc/iamapi-common/iam.module';
-import { DataSeeder } from '@tria-plc/iamapi-common/db/seed/seeder';
-import { SharedAuthModule } from '@tria-plc/api-common/modules/auth/shared-auth.module';
+import { Logger, Module, OnApplicationBootstrap } from "@nestjs/common";
+import { APP_FILTER } from "@nestjs/core";
+import { ConfigModule, ConfigService } from "@nestjs/config";
+import { ScheduleModule } from "@nestjs/schedule";
+import { EventEmitterModule } from "@nestjs/event-emitter";
+import { TypeOrmModule, TypeOrmModuleOptions } from "@nestjs/typeorm";
+import { IamModule as TriaIamModule } from "@tria-plc/iamapi-common/iam.module";
+import { DataSeeder } from "@tria-plc/iamapi-common/db/seed/seeder";
+import { SharedAuthModule } from "@tria-plc/api-common/modules/auth/shared-auth.module";
 import {
   EDR_PASSENGER_APPLICATION,
   EDR_PASSENGER_PERMISSIONS,
-} from './seed/edr-passenger.seed';
-import { EdrPassengerOrgSeeder } from './seed/edr-passenger-org.seeder';
-import { PassengerStaffUsersSeeder } from './seed/passenger-staff-users.seeder';
-import { PrismaModule } from './common/prisma.module';
-import { AuditModule } from './common/audit.module';
-import { I18nModule } from './common/i18n/i18n.module';
-import { LocaleMiddleware } from './common/i18n/locale.middleware';
-import { DeleteExceptionFilter } from './common/exceptions/delete-exception.filter';
-import appConfig from './config/app.config';
-import dbConfig from './config/database.config';
-import iamDatabaseConfig from './config/iam-database.config';
-import telebirrConfig from './config/telebirr.config';
-import cbeConfig from './config/cbe.config';
-import ebirrConfig from './config/ebirr.config';
-import cardConfig from './config/card.config';
-import waafiConfig from './config/waafi.config';
-import faydaConfig from './config/fayda.config';
-import rabbitmqConfig from './config/rabbitmq.config';
-import { AuthModule } from './modules/auth/auth.module';
-import { StationsModule } from './modules/stations/stations.module';
-import { FleetModule } from './modules/fleet/fleet.module';
-import { SchedulesModule } from './modules/schedules/schedules.module';
-import { SearchModule } from './modules/search/search.module';
-import { SeatsModule } from './modules/seats/seats.module';
-import { BookingsModule } from './modules/bookings/bookings.module';
-import { PaymentsModule } from './modules/payments/payments.module';
-import { TicketsModule } from './modules/tickets/tickets.module';
-import { PassengersModule } from './modules/passengers/passengers.module';
-import { NotificationsModule } from './modules/notifications/notifications.module';
-import { LoyaltyModule } from './modules/loyalty/loyalty.module';
-import { WalletModule } from './modules/wallet/wallet.module';
-import { PromosModule } from './modules/promos/promos.module';
-import { LiveModule } from './modules/live/live.module';
-import { SupportModule } from './modules/support/support.module';
-import { DashboardModule } from './modules/dashboard/dashboard.module';
-import { SegmentsModule } from './modules/segments/segments.module';
-import { AgentsModule } from './modules/agents/agents.module';
-import { ReportsModule } from './modules/reports/reports.module';
-import { FraudModule } from './modules/fraud/fraud.module';
-import { SeatClassesModule } from './modules/seat-classes/seat-classes.module';
-import { FareEngineModule } from './modules/fare-engine/fare-engine.module';
-import { VerifaydaModule } from './modules/verifayda/verifayda.module';
-import { AuditModuleFeature } from './modules/audit/audit.module';
-import { CurrenciesModule } from './modules/currencies/currencies.module';
-import { SystemConfigModule } from './modules/system-config/system-config.module';
-import { PackagesModule } from './modules/packages/packages.module';
-import { ExcessBaggageModule } from './modules/excess-baggage/excess-baggage.module';
-import { HealthModule } from './modules/health/health.module';
-import { TasksModule } from './modules/tasks/tasks.module';
-import { AppReleasesModule } from './modules/app-releases/app-releases.module';
-import { ConfigurableFareModule } from './modules/configurable-fare/configurable-fare.module';
-import { SegmentFareSeeder } from './seed/segment-fare.seeder';
+} from "./seed/edr-passenger.seed";
+import { EdrPassengerOrgSeeder } from "./seed/edr-passenger-org.seeder";
+import { PassengerStaffUsersSeeder } from "./seed/passenger-staff-users.seeder";
+import { PrismaModule } from "./common/prisma.module";
+import { AuditModule } from "./common/audit.module";
+import { I18nModule } from "./common/i18n/i18n.module";
+import { LocaleMiddleware } from "./common/i18n/locale.middleware";
+import { DeleteExceptionFilter } from "./common/exceptions/delete-exception.filter";
+import appConfig from "./config/app.config";
+import dbConfig from "./config/database.config";
+import iamDatabaseConfig from "./config/iam-database.config";
+import telebirrConfig from "./config/telebirr.config";
+import cbeConfig from "./config/cbe.config";
+import ebirrConfig from "./config/ebirr.config";
+import cardConfig from "./config/card.config";
+import waafiConfig from "./config/waafi.config";
+import faydaConfig from "./config/fayda.config";
+import rabbitmqConfig from "./config/rabbitmq.config";
+import { AuthModule } from "./modules/auth/auth.module";
+import { StationsModule } from "./modules/stations/stations.module";
+import { FleetModule } from "./modules/fleet/fleet.module";
+import { SchedulesModule } from "./modules/schedules/schedules.module";
+import { SearchModule } from "./modules/search/search.module";
+import { SeatsModule } from "./modules/seats/seats.module";
+import { BookingsModule } from "./modules/bookings/bookings.module";
+import { PaymentsModule } from "./modules/payments/payments.module";
+import { TicketsModule } from "./modules/tickets/tickets.module";
+import { PassengersModule } from "./modules/passengers/passengers.module";
+import { NotificationsModule } from "./modules/notifications/notifications.module";
+import { LoyaltyModule } from "./modules/loyalty/loyalty.module";
+import { WalletModule } from "./modules/wallet/wallet.module";
+import { PromosModule } from "./modules/promos/promos.module";
+import { LiveModule } from "./modules/live/live.module";
+import { SupportModule } from "./modules/support/support.module";
+import { DashboardModule } from "./modules/dashboard/dashboard.module";
+import { SegmentsModule } from "./modules/segments/segments.module";
+import { AgentsModule } from "./modules/agents/agents.module";
+import { ReportsModule } from "./modules/reports/reports.module";
+import { FraudModule } from "./modules/fraud/fraud.module";
+import { SeatClassesModule } from "./modules/seat-classes/seat-classes.module";
+import { FareEngineModule } from "./modules/fare-engine/fare-engine.module";
+import { VerifaydaModule } from "./modules/verifayda/verifayda.module";
+import { AuditModuleFeature } from "./modules/audit/audit.module";
+import { CurrenciesModule } from "./modules/currencies/currencies.module";
+import { SystemConfigModule } from "./modules/system-config/system-config.module";
+import { PackagesModule } from "./modules/packages/packages.module";
+import { ExcessBaggageModule } from "./modules/excess-baggage/excess-baggage.module";
+import { HealthModule } from "./modules/health/health.module";
+import { TasksModule } from "./modules/tasks/tasks.module";
+import { AppReleasesModule } from "./modules/app-releases/app-releases.module";
+import { ConfigurableFareModule } from "./modules/configurable-fare/configurable-fare.module";
+import { SegmentFareSeeder } from "./seed/segment-fare.seeder";
 
 import { EOtpType } from "@tria-plc/iamapi-common";
 
 @Module({
   imports: [
-    ThrottlerModule.forRoot([
-      { name: 'auth',     ttl: 60_000, limit: 5   },
-      { name: 'strict',  ttl: 60_000, limit: 20  },
-      { name: 'default', ttl: 60_000, limit: 100 },
-    ]),
     ConfigModule.forRoot({
       isGlobal: true,
       load: [
@@ -94,27 +87,27 @@ import { EOtpType } from "@tria-plc/iamapi-common";
     TypeOrmModule.forRootAsync({
       inject: [ConfigService],
       useFactory: (config: ConfigService): TypeOrmModuleOptions =>
-        config.get<TypeOrmModuleOptions>('iamDatabase')!,
+        config.get<TypeOrmModuleOptions>("iamDatabase")!,
     }),
     TriaIamModule.forRoot({
       applications: [EDR_PASSENGER_APPLICATION],
       permissions: EDR_PASSENGER_PERMISSIONS,
       otpMessages: {
         [EOtpType.MFA_LOGIN]: ({ otp }) =>
-            `Your EDR Passenger login code is ${otp}. It will expire in 5 minutes.`,
+          `Your EDR Passenger login code is ${otp}. It will expire in 5 minutes.`,
         [EOtpType.VERIFY_PHONE_NUMBER]: ({ otp }) =>
-            `Your EDR Passenger phone verification code is ${otp}. It will expire in 5 minutes.`,
+          `Your EDR Passenger phone verification code is ${otp}. It will expire in 5 minutes.`,
         [EOtpType.RESET_PASSWORD]: ({ route }) =>
-            `Reset your EDR Passenger password using this link: ${route}`,
+          `Reset your EDR Passenger password using this link: ${route}`,
         [EOtpType.SET_PASSWORD]: ({ route }) =>
-            `Set your EDR Passenger password using this link: ${route}`,
+          `Set your EDR Passenger password using this link: ${route}`,
       },
     }),
     SharedAuthModule,
     PrismaModule,
     AuditModule,
     I18nModule,
-      AuthModule,
+    AuthModule,
     StationsModule,
     FleetModule,
     SchedulesModule,
@@ -149,9 +142,7 @@ import { EOtpType } from "@tria-plc/iamapi-common";
     ConfigurableFareModule,
   ],
   providers: [
-    { provide: APP_GUARD, useClass: DynamicThrottlerGuard },
     { provide: APP_FILTER, useClass: DeleteExceptionFilter },
-    DynamicThrottlerGuard,
     EdrPassengerOrgSeeder,
     PassengerStaffUsersSeeder,
     SegmentFareSeeder,
@@ -170,22 +161,34 @@ export class AppModule implements OnApplicationBootstrap {
     try {
       await this.seeder.run();
     } catch (err) {
-      this.logger.error('[DataSeeder] Seed failed (non-fatal):', (err as Error).message);
+      this.logger.error(
+        "[DataSeeder] Seed failed (non-fatal):",
+        (err as Error).message,
+      );
     }
     try {
       await this.edrPassengerOrgSeeder.run();
     } catch (err) {
-      this.logger.error('[EdrPassengerOrgSeeder] Seed failed (non-fatal):', (err as Error).message);
+      this.logger.error(
+        "[EdrPassengerOrgSeeder] Seed failed (non-fatal):",
+        (err as Error).message,
+      );
     }
     try {
       await this.passengerStaffUsersSeeder.run();
     } catch (err) {
-      this.logger.error('[PassengerStaffUsersSeeder] Seed failed (non-fatal):', (err as Error).message);
+      this.logger.error(
+        "[PassengerStaffUsersSeeder] Seed failed (non-fatal):",
+        (err as Error).message,
+      );
     }
     try {
       await this.segmentFareSeeder.run();
     } catch (err) {
-      this.logger.error('[SegmentFareSeeder] Seed failed (non-fatal):', (err as Error).message);
+      this.logger.error(
+        "[SegmentFareSeeder] Seed failed (non-fatal):",
+        (err as Error).message,
+      );
     }
   }
 }
diff --git a/apps/edr-passenger-api/src/common/dynamic-throttler.guard.ts b/apps/edr-passenger-api/src/common/dynamic-throttler.guard.ts
deleted file mode 100644
index 5ad8232ec..000000000
--- a/apps/edr-passenger-api/src/common/dynamic-throttler.guard.ts
+++ /dev/null
@@ -1,57 +0,0 @@
-import { Injectable, ExecutionContext, Inject } from '@nestjs/common';
-import { Reflector } from '@nestjs/core';
-import { ThrottlerGuard, ThrottlerStorage, getOptionsToken, getStorageToken } from '@nestjs/throttler';
-import { SystemConfigService, CONFIG_KEYS } from '../modules/system-config/system-config.service';
-
-// Route-prefix → throttler tier mapping.
-// Evaluated in order; first match wins.
-const ROUTE_TIERS: Array<{ prefix: string; tier: 'auth' | 'strict' | 'default' }> = [
-  { prefix: '/auth',              tier: 'auth'   },
-  { prefix: '/fayda/verification',tier: 'auth'   },
-  { prefix: '/bookings',          tier: 'strict' },
-  { prefix: '/passengers',        tier: 'strict' },
-  { prefix: '/payments',          tier: 'strict' },
-  { prefix: '/wallet',            tier: 'strict' },
-];
-
-@Injectable()
-export class DynamicThrottlerGuard extends ThrottlerGuard {
-  constructor(
-    @Inject(getOptionsToken()) options: any,
-    @Inject(getStorageToken()) storageService: ThrottlerStorage,
-    reflector: Reflector,
-    private readonly systemConfig: SystemConfigService,
-  ) {
-    super(options, storageService, reflector);
-  }
-
-  async canActivate(context: ExecutionContext): Promise<boolean> {
-    if (context.getType() !== 'http') {
-      return true;
-    }
-
-    const [authLimit, authTtl, strictLimit, strictTtl, defaultLimit, defaultTtl] =
-      await Promise.all([
-        this.systemConfig.getNumber(CONFIG_KEYS.THROTTLE_AUTH_LIMIT),
-        this.systemConfig.getNumber(CONFIG_KEYS.THROTTLE_AUTH_TTL_MS),
-        this.systemConfig.getNumber(CONFIG_KEYS.THROTTLE_STRICT_LIMIT),
-        this.systemConfig.getNumber(CONFIG_KEYS.THROTTLE_STRICT_TTL_MS),
-        this.systemConfig.getNumber(CONFIG_KEYS.THROTTLE_DEFAULT_LIMIT),
-        this.systemConfig.getNumber(CONFIG_KEYS.THROTTLE_DEFAULT_TTL_MS),
-      ]);
-
-    const url: string = context.switchToHttp().getRequest<{ url: string }>().url ?? '';
-    const matched = ROUTE_TIERS.find(({ prefix }) => url.startsWith(prefix));
-    const tier = matched?.tier ?? 'default';
-
-    if (tier === 'auth') {
-      this.throttlers = [{ name: 'auth', ttl: authTtl, limit: authLimit }];
-    } else if (tier === 'strict') {
-      this.throttlers = [{ name: 'strict', ttl: strictTtl, limit: strictLimit }];
-    } else {
-      this.throttlers = [{ name: 'default', ttl: defaultTtl, limit: defaultLimit }];
-    }
-
-    return super.canActivate(context);
-  }
-}
diff --git a/apps/edr-passenger-api/src/modules/auth/auth.controller.ts b/apps/edr-passenger-api/src/modules/auth/auth.controller.ts
index a6f596bf6..96ad8a178 100644
--- a/apps/edr-passenger-api/src/modules/auth/auth.controller.ts
+++ b/apps/edr-passenger-api/src/modules/auth/auth.controller.ts
@@ -1,155 +1,231 @@
-import { Body, Controller, Post, HttpCode, HttpStatus, UseGuards, Get, Patch, Delete, Param, Request, Query, UnauthorizedException } from '@nestjs/common';
-import { ApiTags, ApiOperation, ApiResponse, ApiBody, ApiBearerAuth } from '@nestjs/swagger';
-import { Throttle, SkipThrottle } from '@nestjs/throttler';
-import { IsPublic } from '@tria-plc/api-common/modules/auth/decorators/public.decorator';
-import { PassengerAuthService } from './passenger-auth.service';
-import { RegisterDto, LoginDto, ResendRegistrationCodeDto, FaydaRequestPasswordSetupDto, FaydaVerifyAndLoginDto } from './auth.dto';
-import { JwtGuard } from '../../common/jwt.guard';
+import {
+  Body,
+  Controller,
+  Post,
+  HttpCode,
+  HttpStatus,
+  UseGuards,
+  Get,
+  Patch,
+  Delete,
+  Param,
+  Request,
+  Query,
+  UnauthorizedException,
+} from "@nestjs/common";
+import {
+  ApiTags,
+  ApiOperation,
+  ApiResponse,
+  ApiBody,
+  ApiBearerAuth,
+} from "@nestjs/swagger";
+import { IsPublic } from "@tria-plc/api-common/modules/auth/decorators/public.decorator";
+import { PassengerAuthService } from "./passenger-auth.service";
+import {
+  RegisterDto,
+  LoginDto,
+  ResendRegistrationCodeDto,
+  FaydaRequestPasswordSetupDto,
+  FaydaVerifyAndLoginDto,
+} from "./auth.dto";
+import { JwtGuard } from "../../common/jwt.guard";
 
-@ApiTags('Passenger Auth')
-@Controller('auth')
-@Throttle({ auth: { limit: 5, ttl: 60_000 } })
+@ApiTags("Passenger Auth")
+@Controller("auth")
+// @Throttle({ auth: { limit: 5, ttl: 60_000 } })
 export class AuthController {
   constructor(private passengerAuthService: PassengerAuthService) {}
 
-  @Post('register')
+  @Post("register")
   @IsPublic()
-  @ApiOperation({ summary: 'Register new passenger account (sends SMS verification code)' })
+  @ApiOperation({
+    summary: "Register new passenger account (sends SMS verification code)",
+  })
   @ApiResponse({
     status: 201,
     description:
-      'Account created as pending. A verification code is sent via SMS — complete signup via PATCH /v1/auth/set-password.',
+      "Account created as pending. A verification code is sent via SMS — complete signup via PATCH /v1/auth/set-password.",
+  })
+  @ApiResponse({
+    status: 409,
+    description: "Email or phone already registered",
   })
-  @ApiResponse({ status: 409, description: 'Email or phone already registered' })
   @ApiBody({ type: RegisterDto })
   register(@Request() req: any, @Body() dto: RegisterDto) {
     return this.passengerAuthService.register(dto, req);
   }
 
-  @Post('register/resend-code')
+  @Post("register/resend-code")
   @IsPublic()
   @HttpCode(HttpStatus.OK)
-  @ApiOperation({ summary: 'Resend the registration verification code for a pending account' })
-  @ApiResponse({ status: 200, description: 'Verification code re-sent if the account is pending.' })
+  @ApiOperation({
+    summary: "Resend the registration verification code for a pending account",
+  })
+  @ApiResponse({
+    status: 200,
+    description: "Verification code re-sent if the account is pending.",
+  })
   @ApiBody({ type: ResendRegistrationCodeDto })
-  resendRegistrationCode(@Request() req: any, @Body() dto: ResendRegistrationCodeDto) {
+  resendRegistrationCode(
+    @Request() req: any,
+    @Body() dto: ResendRegistrationCodeDto,
+  ) {
     return this.passengerAuthService.resendRegistrationCode(dto, req);
   }
 
-  @Post('login')
+  @Post("login")
   @IsPublic()
   @HttpCode(HttpStatus.OK)
-  @ApiOperation({ summary: 'Login with email and password' })
-  @ApiResponse({ status: 200, description: 'Login successful. Returns token + passengerId.' })
-  @ApiResponse({ status: 401, description: 'Invalid credentials' })
+  @ApiOperation({ summary: "Login with email and password" })
+  @ApiResponse({
+    status: 200,
+    description: "Login successful. Returns token + passengerId.",
+  })
+  @ApiResponse({ status: 401, description: "Invalid credentials" })
   @ApiBody({ type: LoginDto })
   login(@Request() req: any, @Body() dto: LoginDto) {
     return this.passengerAuthService.login(dto, req);
   }
 
-  @Post('logout')
+  @Post("logout")
   @HttpCode(HttpStatus.OK)
   @UseGuards(JwtGuard)
-  @ApiBearerAuth('JWT-auth')
-  @ApiOperation({ summary: 'Logout current user' })
-  @ApiResponse({ status: 200, description: 'Logout successful' })
-  @ApiResponse({ status: 401, description: 'Unauthorized' })
+  @ApiBearerAuth("JWT-auth")
+  @ApiOperation({ summary: "Logout current user" })
+  @ApiResponse({ status: 200, description: "Logout successful" })
+  @ApiResponse({ status: 401, description: "Unauthorized" })
   logout(@Request() req: any) {
-    if (!req.user?.id) throw new UnauthorizedException('User not authenticated');
+    if (!req.user?.id)
+      throw new UnauthorizedException("User not authenticated");
     return this.passengerAuthService.logout(req.user, req);
   }
 
-  @Get('me')
+  @Get("me")
   @UseGuards(JwtGuard)
-  @ApiBearerAuth('JWT-auth')
-  @ApiOperation({ summary: '[DEV] Inspect raw JWT payload — shows full req.user from JwtGuard' })
-  @ApiResponse({ status: 200, description: 'Returns the full req.user object set by JwtGuard' })
-  @ApiResponse({ status: 401, description: 'Unauthorized' })
+  @ApiBearerAuth("JWT-auth")
+  @ApiOperation({
+    summary:
+      "[DEV] Inspect raw JWT payload — shows full req.user from JwtGuard",
+  })
+  @ApiResponse({
+    status: 200,
+    description: "Returns the full req.user object set by JwtGuard",
+  })
+  @ApiResponse({ status: 401, description: "Unauthorized" })
   getMe(@Request() req: any) {
     return { user: req.user };
   }
 
-  @Get('profile')
+  @Get("profile")
   @UseGuards(JwtGuard)
-  @ApiBearerAuth('JWT-auth')
-  @ApiOperation({ summary: 'Get current user profile' })
-  @ApiResponse({ status: 200, description: 'User profile retrieved successfully' })
-  @ApiResponse({ status: 401, description: 'Unauthorized' })
+  @ApiBearerAuth("JWT-auth")
+  @ApiOperation({ summary: "Get current user profile" })
+  @ApiResponse({
+    status: 200,
+    description: "User profile retrieved successfully",
+  })
+  @ApiResponse({ status: 401, description: "Unauthorized" })
   getProfile(@Request() req: any) {
     const userId = req.user?.id;
-    if (!userId) throw new UnauthorizedException('User not authenticated');
+    if (!userId) throw new UnauthorizedException("User not authenticated");
     return this.passengerAuthService.getProfile(userId);
   }
 
   // TODO: admin user management endpoints — implement when admin module is ready
 
-  @Get('users')
+  @Get("users")
   @UseGuards(JwtGuard)
-  @ApiBearerAuth('JWT-auth')
-  @ApiOperation({ summary: 'List all users (admin)' })
+  @ApiBearerAuth("JWT-auth")
+  @ApiOperation({ summary: "List all users (admin)" })
   listUsers(
-    @Query('search') search?: string,
-    @Query('role') role?: string,
-    @Query('status') status?: string,
-    @Query('page') page?: string,
-    @Query('pageSize') pageSize?: string,
+    @Query("search") search?: string,
+    @Query("role") role?: string,
+    @Query("status") status?: string,
+    @Query("page") page?: string,
+    @Query("pageSize") pageSize?: string,
   ) {
     return this.passengerAuthService.listUsers({
-      search, role, status,
+      search,
+      role,
+      status,
       page: page ? +page : 1,
       pageSize: pageSize ? +pageSize : 20,
     });
   }
 
-  @Post('users')
+  @Post("users")
   @UseGuards(JwtGuard)
-  @ApiBearerAuth('JWT-auth')
-  @ApiOperation({ summary: 'Create user (admin)' })
+  @ApiBearerAuth("JWT-auth")
+  @ApiOperation({ summary: "Create user (admin)" })
   createUser(@Body() body: any) {
     return this.passengerAuthService.createUser(body);
   }
 
-  @Patch('users/:id')
+  @Patch("users/:id")
   @UseGuards(JwtGuard)
-  @ApiBearerAuth('JWT-auth')
-  @ApiOperation({ summary: 'Update user (admin)' })
-  updateUser(@Param('id') id: string, @Body() body: any) {
+  @ApiBearerAuth("JWT-auth")
+  @ApiOperation({ summary: "Update user (admin)" })
+  updateUser(@Param("id") id: string, @Body() body: any) {
     return this.passengerAuthService.updateUser(id, body);
   }
 
-  @Delete('users/:id')
+  @Delete("users/:id")
   @UseGuards(JwtGuard)
-  @ApiBearerAuth('JWT-auth')
-  @ApiOperation({ summary: 'Delete user (admin)' })
-  deleteUser(@Param('id') id: string) {
+  @ApiBearerAuth("JWT-auth")
+  @ApiOperation({ summary: "Delete user (admin)" })
+  deleteUser(@Param("id") id: string) {
     return this.passengerAuthService.deleteUser(id);
   }
 
-  @Post('users/:id/reset-password')
+  @Post("users/:id/reset-password")
   @UseGuards(JwtGuard)
-  @ApiBearerAuth('JWT-auth')
-  @ApiOperation({ summary: 'Reset user password (admin)' })
-  resetPassword(@Param('id') id: string, @Body() body: { tempPassword: string }) {
+  @ApiBearerAuth("JWT-auth")
+  @ApiOperation({ summary: "Reset user password (admin)" })
+  resetPassword(
+    @Param("id") id: string,
+    @Body() body: { tempPassword: string },
+  ) {
     return this.passengerAuthService.resetUserPassword(id, body.tempPassword);
   }
 
-  @Post('fayda/request-password-setup')
+  @Post("fayda/request-password-setup")
   @IsPublic()
   @HttpCode(HttpStatus.OK)
-  @ApiOperation({ summary: 'Send OTP to phone for Fayda-verified account password setup' })
-  @ApiResponse({ status: 200, description: 'OTP sent to registered phone number' })
+  @ApiOperation({
+    summary: "Send OTP to phone for Fayda-verified account password setup",
+  })
+  @ApiResponse({
+    status: 200,
+    description: "OTP sent to registered phone number",
+  })
   @ApiBody({ type: FaydaRequestPasswordSetupDto })
-  requestFaydaPasswordSetup(@Body() dto: FaydaRequestPasswordSetupDto, @Request() req: any) {
-    return this.passengerAuthService.requestFaydaPasswordSetup(dto.phoneNumber, req);
+  requestFaydaPasswordSetup(
+    @Body() dto: FaydaRequestPasswordSetupDto,
+    @Request() req: any,
+  ) {
+    return this.passengerAuthService.requestFaydaPasswordSetup(
+      dto.phoneNumber,
+      req,
+    );
   }
 
-  @Post('fayda/verify-and-login')
+  @Post("fayda/verify-and-login")
   @IsPublic()
   @HttpCode(HttpStatus.OK)
-  @ApiOperation({ summary: 'Verify OTP and receive session token for Fayda-verified account' })
-  @ApiResponse({ status: 200, description: 'Returns token + requiresPassword flag. Use token with POST /v1/auth/set-fayda-password.' })
+  @ApiOperation({
+    summary: "Verify OTP and receive session token for Fayda-verified account",
+  })
+  @ApiResponse({
+    status: 200,
+    description:
+      "Returns token + requiresPassword flag. Use token with POST /v1/auth/set-fayda-password.",
+  })
   @ApiBody({ type: FaydaVerifyAndLoginDto })
   verifyFaydaAndLogin(@Body() dto: FaydaVerifyAndLoginDto) {
-    return this.passengerAuthService.verifyFaydaAndLogin(dto.phoneNumber, dto.otp);
+    return this.passengerAuthService.verifyFaydaAndLogin(
+      dto.phoneNumber,
+      dto.otp,
+    );
   }
 }
diff --git a/apps/edr-passenger-api/src/modules/bookings/bookings.controller.ts b/apps/edr-passenger-api/src/modules/bookings/bookings.controller.ts
index 7789fd56b..854621e0d 100644
--- a/apps/edr-passenger-api/src/modules/bookings/bookings.controller.ts
+++ b/apps/edr-passenger-api/src/modules/bookings/bookings.controller.ts
@@ -1,41 +1,84 @@
-import { Body, Controller, Delete, Get, Param, Post, Patch, UseGuards, Query, Req, SetMetadata, BadRequestException, UnauthorizedException } from '@nestjs/common';
-import { ApiTags, ApiOperation, ApiBearerAuth, ApiResponse, ApiQuery, ApiBody } from '@nestjs/swagger';
-import { IsPublic } from '@tria-plc/api-common/modules/auth/decorators/public.decorator';
-import { Throttle } from '@nestjs/throttler';
-import { BookingsService } from './bookings.service';
-import { GuestBookingService } from './guest-booking.service';
-import { CreateBookingDto, ModifyBookingDto, CancelBookingDto } from './bookings.dto';
-import { CreateGuestBookingDto, GetSavedPassengersDto } from './guest-booking.dto';
-import { JwtGuard } from '../../common/jwt.guard';
-import { PassengerAdmin } from '../../common/passenger-guards';
+import {
+  Body,
+  Controller,
+  Delete,
+  Get,
+  Param,
+  Post,
+  Patch,
+  UseGuards,
+  Query,
+  Req,
+  SetMetadata,
+  BadRequestException,
+  UnauthorizedException,
+} from "@nestjs/common";
+import {
+  ApiTags,
+  ApiOperation,
+  ApiBearerAuth,
+  ApiResponse,
+  ApiQuery,
+  ApiBody,
+} from "@nestjs/swagger";
+import { IsPublic } from "@tria-plc/api-common/modules/auth/decorators/public.decorator";
+import { BookingsService } from "./bookings.service";
+import { GuestBookingService } from "./guest-booking.service";
+import {
+  CreateBookingDto,
+  ModifyBookingDto,
+  CancelBookingDto,
+} from "./bookings.dto";
+import {
+  CreateGuestBookingDto,
+  GetSavedPassengersDto,
+} from "./guest-booking.dto";
+import { JwtGuard } from "../../common/jwt.guard";
+import { PassengerAdmin } from "../../common/passenger-guards";
 
-@ApiTags('Booking')
-@Controller('bookings')
-@Throttle({ strict: { limit: 20, ttl: 60_000 } })
+@ApiTags("Booking")
+@Controller("bookings")
+// @Throttle({ strict: { limit: 20, ttl: 60_000 } })
 export class BookingsController {
   constructor(
     private service: BookingsService,
     private guestService: GuestBookingService,
   ) {}
-  
-  @Get('my')
+
+  @Get("my")
   @UseGuards(JwtGuard)
-  @ApiBearerAuth('JWT-auth')
-  @ApiOperation({ 
-    summary: 'Get logged-in user\'s booking history',
-    description: 'Returns all bookings for the authenticated user with schedule and payment details'
+  @ApiBearerAuth("JWT-auth")
+  @ApiOperation({
+    summary: "Get logged-in user's booking history",
+    description:
+      "Returns all bookings for the authenticated user with schedule and payment details",
+  })
+  @ApiQuery({
+    name: "search",
+    required: false,
+    description: "Search by booking reference or station names",
+  })
+  @ApiQuery({
+    name: "status",
+    required: false,
+    description: "Filter by booking status",
+  })
+  @ApiQuery({ name: "page", required: false, description: "Page number" })
+  @ApiQuery({
+    name: "pageSize",
+    required: false,
+    description: "Items per page",
+  })
+  @ApiResponse({
+    status: 200,
+    description: "List of user bookings with schedule and passenger details",
   })
-  @ApiQuery({ name: 'search', required: false, description: 'Search by booking reference or station names' })
-  @ApiQuery({ name: 'status', required: false, description: 'Filter by booking status' })
-  @ApiQuery({ name: 'page', required: false, description: 'Page number' })
-  @ApiQuery({ name: 'pageSize', required: false, description: 'Items per page' })
-  @ApiResponse({ status: 200, description: 'List of user bookings with schedule and passenger details' })
   getMyBookings(
     @Req() req: any,
-    @Query('search') search?: string,
-    @Query('status') status?: string,
-    @Query('page') page?: string,
-    @Query('pageSize') pageSize?: string,
+    @Query("search") search?: string,
+    @Query("status") status?: string,
+    @Query("page") page?: string,
+    @Query("pageSize") pageSize?: string,
   ) {
     const iamUserId = req.user?.id;
     if (!iamUserId) throw new UnauthorizedException();
@@ -43,81 +86,103 @@ export class BookingsController {
       search,
       status,
       page: page ? parseInt(page) : 1,
-      pageSize: pageSize ? parseInt(pageSize) : 20
+      pageSize: pageSize ? parseInt(pageSize) : 20,
     });
   }
 
-  @Get('by-device')
-  @SetMetadata('isPublic', true)
+  @Get("by-device")
+  @SetMetadata("isPublic", true)
   @ApiOperation({
-    summary: 'Get bookings by device ID',
-    description: 'Returns all bookings associated with a device ID (for guest users). Includes saved passenger details and booking history.'
+    summary: "Get bookings by device ID",
+    description:
+      "Returns all bookings associated with a device ID (for guest users). Includes saved passenger details and booking history.",
   })
-  @ApiQuery({ name: 'deviceId', required: true, description: 'Device identifier' })
-  @ApiQuery({ name: 'search', required: false, description: 'Search by booking reference or station names' })
-  @ApiQuery({ name: 'status', required: false, description: 'Filter by booking status' })
-  @ApiQuery({ name: 'page', required: false, description: 'Page number' })
-  @ApiQuery({ name: 'pageSize', required: false, description: 'Items per page' })
-  @ApiResponse({ status: 200, description: 'List of guest bookings and saved passengers for device' })
-  @ApiResponse({ status: 400, description: 'Device ID is required' })
+  @ApiQuery({
+    name: "deviceId",
+    required: true,
+    description: "Device identifier",
+  })
+  @ApiQuery({
+    name: "search",
+    required: false,
+    description: "Search by booking reference or station names",
+  })
+  @ApiQuery({
+    name: "status",
+    required: false,
+    description: "Filter by booking status",
+  })
+  @ApiQuery({ name: "page", required: false, description: "Page number" })
+  @ApiQuery({
+    name: "pageSize",
+    required: false,
+    description: "Items per page",
+  })
+  @ApiResponse({
+    status: 200,
+    description: "List of guest bookings and saved passengers for device",
+  })
+  @ApiResponse({ status: 400, description: "Device ID is required" })
   getByDevice(
-    @Query('deviceId') deviceId?: string,
-    @Query('search') search?: string,
-    @Query('status') status?: string,
-    @Query('page') page?: string,
-    @Query('pageSize') pageSize?: string,
+    @Query("deviceId") deviceId?: string,
+    @Query("search") search?: string,
+    @Query("status") status?: string,
+    @Query("page") page?: string,
+    @Query("pageSize") pageSize?: string,
   ) {
-    if (!deviceId) throw new BadRequestException('Device ID is required');
-    return this.service.findByDeviceId(deviceId, { 
-      search, 
-      status, 
-      page: page ? parseInt(page) : 1, 
-      pageSize: pageSize ? parseInt(pageSize) : 20 
+    if (!deviceId) throw new BadRequestException("Device ID is required");
+    return this.service.findByDeviceId(deviceId, {
+      search,
+      status,
+      page: page ? parseInt(page) : 1,
+      pageSize: pageSize ? parseInt(pageSize) : 20,
     });
   }
-  
+
   @Get()
-  @SetMetadata('isPublic', true)
+  @SetMetadata("isPublic", true)
   @ApiOperation({
-    description: 'Returns paginated list of bookings. Use `returnLegStatus=OUTBOUND_ONLY` to find round-trip no-shows on the return leg, `INBOUND_ONLY` for passengers who only used the return leg, `BOTH_USED` for fully completed round-trips, and `NEITHER_USED` for confirmed but not yet boarded.'
+    description:
+      "Returns paginated list of bookings. Use `returnLegStatus=OUTBOUND_ONLY` to find round-trip no-shows on the return leg, `INBOUND_ONLY` for passengers who only used the return leg, `BOTH_USED` for fully completed round-trips, and `NEITHER_USED` for confirmed but not yet boarded.",
   })
-  @ApiQuery({ name: 'search', required: false })
-  @ApiQuery({ name: 'status', required: false })
-  @ApiQuery({ name: 'returnLegStatus', required: false })
-  @ApiQuery({ name: 'bookingType', required: false })
-  @ApiQuery({ name: 'paymentStatus', required: false })
-  @ApiQuery({ name: 'dateFrom', required: false })
-  @ApiQuery({ name: 'dateTo', required: false })
-  @ApiQuery({ name: 'page', required: false })
-  @ApiQuery({ name: 'pageSize', required: false })
+  @ApiQuery({ name: "search", required: false })
+  @ApiQuery({ name: "status", required: false })
+  @ApiQuery({ name: "returnLegStatus", required: false })
+  @ApiQuery({ name: "bookingType", required: false })
+  @ApiQuery({ name: "paymentStatus", required: false })
+  @ApiQuery({ name: "dateFrom", required: false })
+  @ApiQuery({ name: "dateTo", required: false })
+  @ApiQuery({ name: "page", required: false })
+  @ApiQuery({ name: "pageSize", required: false })
   findAll(
-    @Query('search') search?: string,
-    @Query('status') status?: string,
-    @Query('returnLegStatus') returnLegStatus?: string,
-    @Query('bookingType') bookingType?: string,
-    @Query('paymentStatus') paymentStatus?: string,
-    @Query('dateFrom') dateFrom?: string,
-    @Query('dateTo') dateTo?: string,
-    @Query('page') page?: string,
-    @Query('pageSize') pageSize?: string,
+    @Query("search") search?: string,
+    @Query("status") status?: string,
+    @Query("returnLegStatus") returnLegStatus?: string,
+    @Query("bookingType") bookingType?: string,
+    @Query("paymentStatus") paymentStatus?: string,
+    @Query("dateFrom") dateFrom?: string,
+    @Query("dateTo") dateTo?: string,
+    @Query("page") page?: string,
+    @Query("pageSize") pageSize?: string,
   ) {
-    return this.service.findAll({ 
-      search, 
+    return this.service.findAll({
+      search,
       status,
       returnLegStatus,
       bookingType,
       paymentStatus,
       dateFrom,
       dateTo,
-      page: page ? parseInt(page) : 1, 
-      pageSize: pageSize ? parseInt(pageSize) : 20 
+      page: page ? parseInt(page) : 1,
+      pageSize: pageSize ? parseInt(pageSize) : 20,
     });
   }
-  
-  @Post('guest')
-  @SetMetadata('isPublic', true)
+
+  @Post("guest")
+  @SetMetadata("isPublic", true)
   @ApiOperation({
-    summary: 'Create guest booking — ONE_WAY | ROUND_TRIP | TRANSIT | ROUND_TRIP_TRANSIT (no login required)',
+    summary:
+      "Create guest booking — ONE_WAY | ROUND_TRIP | TRANSIT | ROUND_TRIP_TRANSIT (no login required)",
     description: `Creates a booking without requiring login. Supports all four booking types.
 
 **bookingType: ONE_WAY (default)**
@@ -138,152 +203,170 @@ export class BookingsController {
 
 **Optional account creation:** set createAccount=true with password — creates account from first passenger details, loyalty + wallet initialised.
 
-**Verifayda:** Ethiopian nationals verified; international passengers require passportNumber + passportCountry.`
+**Verifayda:** Ethiopian nationals verified; international passengers require passportNumber + passportCountry.`,
   })
   @ApiBody({
     type: CreateGuestBookingDto,
     examples: {
       ONE_WAY: {
-        summary: 'ONE_WAY — single direct journey (guest)',
+        summary: "ONE_WAY — single direct journey (guest)",
         value: {
-          scheduleId: 'schedule-uuid',
-          holdId: 'hold-uuid',
-          originStationId: 'station-uuid',
-          destinationStationId: 'station-uuid',
-          seatClassId: 'seat-class-uuid',
-          bookingType: 'ONE_WAY',
-          displayCurrency: 'ETB',
-          passengers: [{
-            seatId: 'seat-uuid',
-            passengerName: 'Abebe Kebede',
-            dateOfBirth: '1990-05-15',
-            idDocumentType: 'NATIONAL_ID',
-            idDocumentNumber: 'ET123456789',
-            nationality: 'Ethiopian',
-            phone: '+251911234567',
-            email: 'abebe@email.com',
-          }],
+          scheduleId: "schedule-uuid",
+          holdId: "hold-uuid",
+          originStationId: "station-uuid",
+          destinationStationId: "station-uuid",
+          seatClassId: "seat-class-uuid",
+          bookingType: "ONE_WAY",
+          displayCurrency: "ETB",
+          passengers: [
+            {
+              seatId: "seat-uuid",
+              passengerName: "Abebe Kebede",
+              dateOfBirth: "1990-05-15",
+              idDocumentType: "NATIONAL_ID",
+              idDocumentNumber: "ET123456789",
+              nationality: "Ethiopian",
+              phone: "+251911234567",
+              email: "abebe@email.com",
+            },
+          ],
           savePassengerDetails: true,
-          deviceId: 'device-uuid-123',
+          deviceId: "device-uuid-123",
         },
       },
       ROUND_TRIP: {
-        summary: 'ROUND_TRIP — outbound + return, single PNR (guest)',
+        summary: "ROUND_TRIP — outbound + return, single PNR (guest)",
         value: {
-          scheduleId: 'outbound-schedule-uuid',
-          holdId: 'outbound-hold-uuid',
-          originStationId: 'addis-station-uuid',
-          destinationStationId: 'djibouti-station-uuid',
-          seatClassId: 'seat-class-uuid',
-          bookingType: 'ROUND_TRIP',
-          returnScheduleId: 'return-schedule-uuid',
-          returnHoldId: 'return-hold-uuid',
-          returnOriginStationId: 'djibouti-station-uuid',
-          returnDestinationStationId: 'addis-station-uuid',
-          returnSeatClassId: 'seat-class-uuid',
-          displayCurrency: 'ETB',
-          passengers: [{
-            seatId: 'outbound-seat-uuid',
-            returnSeatId: 'return-seat-uuid',
-            passengerName: 'Abebe Kebede',
-            dateOfBirth: '1990-05-15',
-            idDocumentType: 'NATIONAL_ID',
-            idDocumentNumber: 'ET123456789',
-            nationality: 'Ethiopian',
-            phone: '+251911234567',
-          }],
+          scheduleId: "outbound-schedule-uuid",
+          holdId: "outbound-hold-uuid",
+          originStationId: "addis-station-uuid",
+          destinationStationId: "djibouti-station-uuid",
+          seatClassId: "seat-class-uuid",
+          bookingType: "ROUND_TRIP",
+          returnScheduleId: "return-schedule-uuid",
+          returnHoldId: "return-hold-uuid",
+          returnOriginStationId: "djibouti-station-uuid",
+          returnDestinationStationId: "addis-station-uuid",
+          returnSeatClassId: "seat-class-uuid",
+          displayCurrency: "ETB",
+          passengers: [
+            {
+              seatId: "outbound-seat-uuid",
+              returnSeatId: "return-seat-uuid",
+              passengerName: "Abebe Kebede",
+              dateOfBirth: "1990-05-15",
+              idDocumentType: "NATIONAL_ID",
+              idDocumentNumber: "ET123456789",
+              nationality: "Ethiopian",
+              phone: "+251911234567",
+            },
+          ],
           savePassengerDetails: true,
-          deviceId: 'device-uuid-123',
+          deviceId: "device-uuid-123",
         },
       },
       TRANSIT: {
-        summary: 'TRANSIT — connecting train, single PNR (guest)',
+        summary: "TRANSIT — connecting train, single PNR (guest)",
         value: {
-          scheduleId: 'leg1-schedule-uuid',
-          holdId: 'leg1-hold-uuid',
-          originStationId: 'addis-station-uuid',
-          destinationStationId: 'diredawa-station-uuid',
-          seatClassId: 'seat-class-uuid',
-          bookingType: 'TRANSIT',
-          leg2ScheduleId: 'leg2-schedule-uuid',
-          leg2HoldId: 'leg2-hold-uuid',
-          transitStationId: 'diredawa-station-uuid',
-          leg2DestinationStationId: 'djibouti-station-uuid',
-          displayCurrency: 'ETB',
-          passengers: [{
-            seatId: 'leg1-seat-uuid',
-            leg2SeatId: 'leg2-seat-uuid',
-            passengerName: 'Abebe Kebede',
-            dateOfBirth: '1990-05-15',
-            idDocumentType: 'NATIONAL_ID',
-            idDocumentNumber: 'ET123456789',
-            nationality: 'Ethiopian',
-            phone: '+251911234567',
-          }],
-          deviceId: 'device-uuid-123',
+          scheduleId: "leg1-schedule-uuid",
+          holdId: "leg1-hold-uuid",
+          originStationId: "addis-station-uuid",
+          destinationStationId: "diredawa-station-uuid",
+          seatClassId: "seat-class-uuid",
+          bookingType: "TRANSIT",
+          leg2ScheduleId: "leg2-schedule-uuid",
+          leg2HoldId: "leg2-hold-uuid",
+          transitStationId: "diredawa-station-uuid",
+          leg2DestinationStationId: "djibouti-station-uuid",
+          displayCurrency: "ETB",
+          passengers: [
+            {
+              seatId: "leg1-seat-uuid",
+              leg2SeatId: "leg2-seat-uuid",
+              passengerName: "Abebe Kebede",
+              dateOfBirth: "1990-05-15",
+              idDocumentType: "NATIONAL_ID",
+              idDocumentNumber: "ET123456789",
+              nationality: "Ethiopian",
+              phone: "+251911234567",
+            },
+          ],
+          deviceId: "device-uuid-123",
         },
       },
       ROUND_TRIP_TRANSIT: {
-        summary: 'ROUND_TRIP_TRANSIT — round trip via connecting trains, 4 holds (guest)',
+        summary:
+          "ROUND_TRIP_TRANSIT — round trip via connecting trains, 4 holds (guest)",
         value: {
-          scheduleId: 'ob-leg1-schedule-uuid',
-          holdId: 'ob-leg1-hold-uuid',
-          originStationId: 'addis-station-uuid',
-          destinationStationId: 'diredawa-station-uuid',
-          seatClassId: 'seat-class-uuid',
-          bookingType: 'ROUND_TRIP_TRANSIT',
-          leg2ScheduleId: 'ob-leg2-schedule-uuid',
-          leg2HoldId: 'ob-leg2-hold-uuid',
-          transitStationId: 'diredawa-station-uuid',
-          leg2DestinationStationId: 'djibouti-station-uuid',
-          returnScheduleId: 'ret-leg1-schedule-uuid',
-          returnHoldId: 'ret-leg1-hold-uuid',
-          returnOriginStationId: 'djibouti-station-uuid',
-          returnDestinationStationId: 'diredawa-station-uuid',
-          returnLeg2ScheduleId: 'ret-leg2-schedule-uuid',
-          returnLeg2HoldId: 'ret-leg2-hold-uuid',
-          returnTransitStationId: 'diredawa-station-uuid',
-          returnLeg2DestinationStationId: 'addis-station-uuid',
-          displayCurrency: 'ETB',
-          passengers: [{
-            seatId: 'ob-leg1-seat-uuid',
-            leg2SeatId: 'ob-leg2-seat-uuid',
-            returnSeatId: 'ret-leg1-seat-uuid',
-            returnLeg2SeatId: 'ret-leg2-seat-uuid',
-            passengerName: 'Abebe Kebede',
-            dateOfBirth: '1990-05-15',
-            idDocumentType: 'NATIONAL_ID',
-            idDocumentNumber: 'ET123456789',
-            nationality: 'Ethiopian',
-            phone: '+251911234567',
-          }],
-          deviceId: 'device-uuid-123',
+          scheduleId: "ob-leg1-schedule-uuid",
+          holdId: "ob-leg1-hold-uuid",
+          originStationId: "addis-station-uuid",
+          destinationStationId: "diredawa-station-uuid",
+          seatClassId: "seat-class-uuid",
+          bookingType: "ROUND_TRIP_TRANSIT",
+          leg2ScheduleId: "ob-leg2-schedule-uuid",
+          leg2HoldId: "ob-leg2-hold-uuid",
+          transitStationId: "diredawa-station-uuid",
+          leg2DestinationStationId: "djibouti-station-uuid",
+          returnScheduleId: "ret-leg1-schedule-uuid",
+          returnHoldId: "ret-leg1-hold-uuid",
+          returnOriginStationId: "djibouti-station-uuid",
+          returnDestinationStationId: "diredawa-station-uuid",
+          returnLeg2ScheduleId: "ret-leg2-schedule-uuid",
+          returnLeg2HoldId: "ret-leg2-hold-uuid",
+          returnTransitStationId: "diredawa-station-uuid",
+          returnLeg2DestinationStationId: "addis-station-uuid",
+          displayCurrency: "ETB",
+          passengers: [
+            {
+              seatId: "ob-leg1-seat-uuid",
+              leg2SeatId: "ob-leg2-seat-uuid",
+              returnSeatId: "ret-leg1-seat-uuid",
+              returnLeg2SeatId: "ret-leg2-seat-uuid",
+              passengerName: "Abebe Kebede",
+              dateOfBirth: "1990-05-15",
+              idDocumentType: "NATIONAL_ID",
+              idDocumentNumber: "ET123456789",
+              nationality: "Ethiopian",
+              phone: "+251911234567",
+            },
+          ],
+          deviceId: "device-uuid-123",
         },
       },
     },
   })
-  @ApiResponse({ status: 201, description: 'Booking created successfully with fareBreakdown' })
-  @ApiResponse({ status: 400, description: 'Missing required seat IDs for bookingType, or Verifayda verification failed' })
+  @ApiResponse({
+    status: 201,
+    description: "Booking created successfully with fareBreakdown",
+  })
+  @ApiResponse({
+    status: 400,
+    description:
+      "Missing required seat IDs for bookingType, or Verifayda verification failed",
+  })
   createGuest(@Req() req: any, @Body() dto: CreateGuestBookingDto) {
     return this.guestService.createGuestBooking(dto, req);
   }
 
-  @Get('saved-passengers')
-  @SetMetadata('isPublic', true)
+  @Get("saved-passengers")
+  @SetMetadata("isPublic", true)
   @ApiOperation({
-    summary: 'Get saved passenger profiles',
-    description: 'Retrieve saved passenger details by userId (if logged in) or deviceId (for guest users)'
+    summary: "Get saved passenger profiles",
+    description:
+      "Retrieve saved passenger details by userId (if logged in) or deviceId (for guest users)",
   })
-  @ApiResponse({ status: 200, description: 'List of saved passenger profiles' })
+  @ApiResponse({ status: 200, description: "List of saved passenger profiles" })
   getSavedPassengers(@Query() query: GetSavedPassengersDto) {
     return this.guestService.getSavedPassengers(undefined, query.deviceId);
   }
-  
+
   @Post()
   @UseGuards(JwtGuard)
-  @ApiBearerAuth('JWT-auth')
-  @ApiOperation({ 
-    summary: 'Create booking — ONE_WAY | ROUND_TRIP | TRANSIT | ROUND_TRIP_TRANSIT',
+  @ApiBearerAuth("JWT-auth")
+  @ApiOperation({
+    summary:
+      "Create booking — ONE_WAY | ROUND_TRIP | TRANSIT | ROUND_TRIP_TRANSIT",
     description: `Creates a booking for a logged-in passenger. bookingType controls which fields are required.
 
 **ONE_WAY**
@@ -306,164 +389,193 @@ export class BookingsController {
 
 **Age-Based Pricing (all types)**
 - ADULT (≥5 years): full fare per leg
-- CHILD (<5 years): first child FREE per booking, subsequent children full fare`
+- CHILD (<5 years): first child FREE per booking, subsequent children full fare`,
   })
   @ApiBody({
     type: CreateBookingDto,
     examples: {
       ONE_WAY: {
-        summary: 'ONE_WAY — single direct journey',
+        summary: "ONE_WAY — single direct journey",
         value: {
-          passengerId: 'passenger-uuid',
-          scheduleId: 'schedule-uuid',
-          holdId: 'hold-uuid',
-          originStationId: 'station-uuid',
-          destinationStationId: 'station-uuid',
-          seatClassId: 'seat-class-uuid',
-          bookingType: 'ONE_WAY',
-          displayCurrency: 'ETB',
-          passengers: [{
-            seatId: 'seat-uuid',
-            passengerName: 'Abebe Kebede',
-            dateOfBirth: '1990-05-15',
-            idDocumentType: 'NATIONAL_ID',
-            idDocumentNumber: 'ET123456789',
-            nationality: 'Ethiopian',
-          }],
+          passengerId: "passenger-uuid",
+          scheduleId: "schedule-uuid",
+          holdId: "hold-uuid",
+          originStationId: "station-uuid",
+          destinationStationId: "station-uuid",
+          seatClassId: "seat-class-uuid",
+          bookingType: "ONE_WAY",
+          displayCurrency: "ETB",
+          passengers: [
+            {
+              seatId: "seat-uuid",
+              passengerName: "Abebe Kebede",
+              dateOfBirth: "1990-05-15",
+              idDocumentType: "NATIONAL_ID",
+              idDocumentNumber: "ET123456789",
+              nationality: "Ethiopian",
+            },
+          ],
         },
       },
       ROUND_TRIP: {
-        summary: 'ROUND_TRIP — outbound + return, single PNR',
+        summary: "ROUND_TRIP — outbound + return, single PNR",
         value: {
-          passengerId: 'passenger-uuid',
-          scheduleId: 'outbound-schedule-uuid',
-          holdId: 'outbound-hold-uuid',
-          originStationId: 'addis-station-uuid',
-          destinationStationId: 'djibouti-station-uuid',
-          seatClassId: 'seat-class-uuid',
-          bookingType: 'ROUND_TRIP',
-          returnScheduleId: 'return-schedule-uuid',
-          returnHoldId: 'return-hold-uuid',
-          returnOriginStationId: 'djibouti-station-uuid',
-          returnDestinationStationId: 'addis-station-uuid',
-          returnSeatClassId: 'seat-class-uuid',
-          displayCurrency: 'ETB',
-          passengers: [{
-            seatId: 'outbound-seat-uuid',
-            returnSeatId: 'return-seat-uuid',
-            passengerName: 'Abebe Kebede',
-            dateOfBirth: '1990-05-15',
-            idDocumentType: 'NATIONAL_ID',
-            idDocumentNumber: 'ET123456789',
-            nationality: 'Ethiopian',
-          }],
+          passengerId: "passenger-uuid",
+          scheduleId: "outbound-schedule-uuid",
+          holdId: "outbound-hold-uuid",
+          originStationId: "addis-station-uuid",
+          destinationStationId: "djibouti-station-uuid",
+          seatClassId: "seat-class-uuid",
+          bookingType: "ROUND_TRIP",
+          returnScheduleId: "return-schedule-uuid",
+          returnHoldId: "return-hold-uuid",
+          returnOriginStationId: "djibouti-station-uuid",
+          returnDestinationStationId: "addis-station-uuid",
+          returnSeatClassId: "seat-class-uuid",
+          displayCurrency: "ETB",
+          passengers: [
+            {
+              seatId: "outbound-seat-uuid",
+              returnSeatId: "return-seat-uuid",
+              passengerName: "Abebe Kebede",
+              dateOfBirth: "1990-05-15",
+              idDocumentType: "NATIONAL_ID",
+              idDocumentNumber: "ET123456789",
+              nationality: "Ethiopian",
+            },
+          ],
         },
       },
       TRANSIT: {
-        summary: 'TRANSIT — connecting train, single PNR',
+        summary: "TRANSIT — connecting train, single PNR",
         value: {
-          passengerId: 'passenger-uuid',
-          scheduleId: 'leg1-schedule-uuid',
-          holdId: 'leg1-hold-uuid',
-          originStationId: 'addis-station-uuid',
-          destinationStationId: 'diredawa-station-uuid',
-          seatClassId: 'seat-class-uuid',
-          bookingType: 'TRANSIT',
-          leg2ScheduleId: 'leg2-schedule-uuid',
-          leg2HoldId: 'leg2-hold-uuid',
-          transitStationId: 'diredawa-station-uuid',
-          leg2DestinationStationId: 'djibouti-station-uuid',
-          displayCurrency: 'ETB',
-          passengers: [{
-            seatId: 'leg1-seat-uuid',
-            leg2SeatId: 'leg2-seat-uuid',
-            passengerName: 'Abebe Kebede',
-            dateOfBirth: '1990-05-15',
-            idDocumentType: 'NATIONAL_ID',
-            idDocumentNumber: 'ET123456789',
-            nationality: 'Ethiopian',
-          }],
+          passengerId: "passenger-uuid",
+          scheduleId: "leg1-schedule-uuid",
+          holdId: "leg1-hold-uuid",
+          originStationId: "addis-station-uuid",
+          destinationStationId: "diredawa-station-uuid",
+          seatClassId: "seat-class-uuid",
+          bookingType: "TRANSIT",
+          leg2ScheduleId: "leg2-schedule-uuid",
+          leg2HoldId: "leg2-hold-uuid",
+          transitStationId: "diredawa-station-uuid",
+          leg2DestinationStationId: "djibouti-station-uuid",
+          displayCurrency: "ETB",
+          passengers: [
+            {
+              seatId: "leg1-seat-uuid",
+              leg2SeatId: "leg2-seat-uuid",
+              passengerName: "Abebe Kebede",
+              dateOfBirth: "1990-05-15",
+              idDocumentType: "NATIONAL_ID",
+              idDocumentNumber: "ET123456789",
+              nationality: "Ethiopian",
+            },
+          ],
         },
       },
       ROUND_TRIP_TRANSIT: {
-        summary: 'ROUND_TRIP_TRANSIT — round trip via connecting trains, 4 holds',
+        summary:
+          "ROUND_TRIP_TRANSIT — round trip via connecting trains, 4 holds",
         value: {
-          passengerId: 'passenger-uuid',
-          scheduleId: 'ob-leg1-schedule-uuid',
-          holdId: 'ob-leg1-hold-uuid',
-          originStationId: 'addis-station-uuid',
-          destinationStationId: 'diredawa-station-uuid',
-          seatClassId: 'seat-class-uuid',
-          bookingType: 'ROUND_TRIP_TRANSIT',
-          leg2ScheduleId: 'ob-leg2-schedule-uuid',
-          leg2HoldId: 'ob-leg2-hold-uuid',
-          transitStationId: 'diredawa-station-uuid',
-          leg2DestinationStationId: 'djibouti-station-uuid',
-          returnScheduleId: 'ret-leg1-schedule-uuid',
-          returnHoldId: 'ret-leg1-hold-uuid',
-          returnOriginStationId: 'djibouti-station-uuid',
-          returnDestinationStationId: 'diredawa-station-uuid',
-          returnLeg2ScheduleId: 'ret-leg2-schedule-uuid',
-          returnLeg2HoldId: 'ret-leg2-hold-uuid',
-          returnTransitStationId: 'diredawa-station-uuid',
-          returnLeg2DestinationStationId: 'addis-station-uuid',
-          displayCurrency: 'ETB',
-          passengers: [{
-            seatId: 'ob-leg1-seat-uuid',
-            leg2SeatId: 'ob-leg2-seat-uuid',
-            returnSeatId: 'ret-leg1-seat-uuid',
-            returnLeg2SeatId: 'ret-leg2-seat-uuid',
-            passengerName: 'Abebe Kebede',
-            dateOfBirth: '1990-05-15',
-            idDocumentType: 'NATIONAL_ID',
-            idDocumentNumber: 'ET123456789',
-            nationality: 'Ethiopian',
-          }],
+          passengerId: "passenger-uuid",
+          scheduleId: "ob-leg1-schedule-uuid",
+          holdId: "ob-leg1-hold-uuid",
+          originStationId: "addis-station-uuid",
+          destinationStationId: "diredawa-station-uuid",
+          seatClassId: "seat-class-uuid",
+          bookingType: "ROUND_TRIP_TRANSIT",
+          leg2ScheduleId: "ob-leg2-schedule-uuid",
+          leg2HoldId: "ob-leg2-hold-uuid",
+          transitStationId: "diredawa-station-uuid",
+          leg2DestinationStationId: "djibouti-station-uuid",
+          returnScheduleId: "ret-leg1-schedule-uuid",
+          returnHoldId: "ret-leg1-hold-uuid",
+          returnOriginStationId: "djibouti-station-uuid",
+          returnDestinationStationId: "diredawa-station-uuid",
+          returnLeg2ScheduleId: "ret-leg2-schedule-uuid",
+          returnLeg2HoldId: "ret-leg2-hold-uuid",
+          returnTransitStationId: "diredawa-station-uuid",
+          returnLeg2DestinationStationId: "addis-station-uuid",
+          displayCurrency: "ETB",
+          passengers: [
+            {
+              seatId: "ob-leg1-seat-uuid",
+              leg2SeatId: "ob-leg2-seat-uuid",
+              returnSeatId: "ret-leg1-seat-uuid",
+              returnLeg2SeatId: "ret-leg2-seat-uuid",
+              passengerName: "Abebe Kebede",
+              dateOfBirth: "1990-05-15",
+              idDocumentType: "NATIONAL_ID",
+              idDocumentNumber: "ET123456789",
+              nationality: "Ethiopian",
+            },
+          ],
         },
       },
     },
   })
-  @ApiResponse({ status: 201, description: 'Booking created with fare breakdown' })
-  @ApiResponse({ status: 400, description: 'Missing required fields for bookingType, or Verifayda verification failed' })
-  @ApiResponse({ status: 404, description: 'Schedule or seat hold not found' })
-  create(@Body() dto: CreateBookingDto) { 
-    return this.service.create(dto); 
-  }
-  
-  @Get(':id/usage')
-  @SetMetadata('isPublic', true)
-  @ApiOperation({
-    description: 'Returns list of modules/data that reference this booking'
+  @ApiResponse({
+    status: 201,
+    description: "Booking created with fare breakdown",
   })
-  @ApiResponse({ status: 200, description: 'Usage information retrieved' })
-  @ApiResponse({ status: 404, description: 'Booking not found' })
-  checkUsage(@Param('id') id: string) {
+  @ApiResponse({
+    status: 400,
+    description:
+      "Missing required fields for bookingType, or Verifayda verification failed",
+  })
+  @ApiResponse({ status: 404, description: "Schedule or seat hold not found" })
+  create(@Body() dto: CreateBookingDto) {
+    return this.service.create(dto);
+  }
+
+  @Get(":id/usage")
+  @SetMetadata("isPublic", true)
+  @ApiOperation({
+    description: "Returns list of modules/data that reference this booking",
+  })
+  @ApiResponse({ status: 200, description: "Usage information retrieved" })
+  @ApiResponse({ status: 404, description: "Booking not found" })
+  checkUsage(@Param("id") id: string) {
     return this.service.checkBookingUsage(id);
   }
 
-  @Get('by-phone')
-  @SetMetadata('isPublic', true)
+  @Get("by-phone")
+  @SetMetadata("isPublic", true)
   @ApiOperation({
-    summary: 'Find bookings by phone number (no auth required)',
+    summary: "Find bookings by phone number (no auth required)",
     description: `Returns all bookings where the contact phone matches the provided number.
 Accepts Ethiopian local format (09XXXXXXXX) and international format (+251XXXXXXXXX).
-Results are ordered most-recent first. Use the returned \`bookingRef\` to open booking detail.`
+Results are ordered most-recent first. Use the returned \`bookingRef\` to open booking detail.`,
   })
-  @ApiQuery({ name: 'phone', required: true, description: 'Phone number in local (09…) or international (+251…) format' })
-  @ApiQuery({ name: 'status', required: false, description: 'Filter by booking status' })
-  @ApiQuery({ name: 'page', required: false })
-  @ApiQuery({ name: 'pageSize', required: false })
-  @ApiResponse({ status: 200, description: 'Paginated list of bookings for this phone number' })
-  @ApiResponse({ status: 400, description: 'Phone number missing or invalid' })
+  @ApiQuery({
+    name: "phone",
+    required: true,
+    description: "Phone number in local (09…) or international (+251…) format",
+  })
+  @ApiQuery({
+    name: "status",
+    required: false,
+    description: "Filter by booking status",
+  })
+  @ApiQuery({ name: "page", required: false })
+  @ApiQuery({ name: "pageSize", required: false })
+  @ApiResponse({
+    status: 200,
+    description: "Paginated list of bookings for this phone number",
+  })
+  @ApiResponse({ status: 400, description: "Phone number missing or invalid" })
   findByPhone(
-    @Query('phone') phone?: string,
-    @Query('status') status?: string,
-    @Query('page') page?: string,
-    @Query('pageSize') pageSize?: string,
+    @Query("phone") phone?: string,
+    @Query("status") status?: string,
+    @Query("page") page?: string,
+    @Query("pageSize") pageSize?: string,
   ) {
-    if (!phone?.trim()) throw new BadRequestException('Phone number is required');
-    const digits = phone.replace(/[^\d]/g, '');
-    if (digits.length < 7) throw new BadRequestException('Phone number is too short');
+    if (!phone?.trim())
+      throw new BadRequestException("Phone number is required");
+    const digits = phone.replace(/[^\d]/g, "");
+    if (digits.length < 7)
+      throw new BadRequestException("Phone number is too short");
     return this.service.findByPhone(phone.trim(), {
       status,
       page: page ? parseInt(page) : 1,
@@ -471,65 +583,82 @@ Results are ordered most-recent first. Use the returned \`bookingRef\` to open b
     });
   }
 
-  @Get(':bookingRef')
-  @SetMetadata('isPublic', true)
+  @Get(":bookingRef")
+  @SetMetadata("isPublic", true)
   @ApiOperation({
-    summary: 'Get booking details by reference (no auth required)',
-    description: 'Returns booking with passenger categories, Verifayda verification status, and multi-currency amounts. Works for both guest and authenticated bookings.'
+    summary: "Get booking details by reference (no auth required)",
+    description:
+      "Returns booking with passenger categories, Verifayda verification status, and multi-currency amounts. Works for both guest and authenticated bookings.",
   })
-  @ApiResponse({ status: 200, description: 'Booking details with adult/child counts and currency conversion' })
-  @ApiResponse({ status: 404, description: 'Booking not found' })
-  getByRef(@Param('bookingRef') ref: string) { 
-    return this.service.getByRef(ref); 
+  @ApiResponse({
+    status: 200,
+    description:
+      "Booking details with adult/child counts and currency conversion",
+  })
+  @ApiResponse({ status: 404, description: "Booking not found" })
+  getByRef(@Param("bookingRef") ref: string) {
+    return this.service.getByRef(ref);
   }
-  
-  @Patch(':bookingRef/modify')
+
+  @Patch(":bookingRef/modify")
   @UseGuards(JwtGuard)
-  @ApiBearerAuth('JWT-auth')
-  @ApiOperation({ 
-    summary: 'Modify booking seats or trip',
-    description: 'Allows modification of confirmed bookings before departure'
+  @ApiBearerAuth("JWT-auth")
+  @ApiOperation({
+    summary: "Modify booking seats or trip",
+    description: "Allows modification of confirmed bookings before departure",
+  })
+  @ApiResponse({ status: 200, description: "Booking modified successfully" })
+  @ApiResponse({
+    status: 400,
+    description: "Cannot modify cancelled or past bookings",
   })
-  @ApiResponse({ status: 200, description: 'Booking modified successfully' })
-  @ApiResponse({ status: 400, description: 'Cannot modify cancelled or past bookings' })
   modify(@Body() dto: ModifyBookingDto) {
     return this.service.modify(dto);
   }
-  
-  @Delete(':id')
+
+  @Delete(":id")
   @PassengerAdmin()
-  @ApiBearerAuth('IAM-auth')
+  @ApiBearerAuth("IAM-auth")
   @ApiOperation({
-    description: 'Permanently deletes a booking record'
+    description: "Permanently deletes a booking record",
   })
-  @ApiQuery({ name: 'cascade', required: false, type: Boolean, description: 'Force delete with all related data' })
-  @ApiResponse({ status: 200, description: 'Booking deleted successfully' })
-  @ApiResponse({ status: 404, description: 'Booking not found' })
-  delete(@Param('id') id: string, @Query('cascade') cascade?: string) { 
-    return this.service.delete(id, cascade === 'true'); 
+  @ApiQuery({
+    name: "cascade",
+    required: false,
+    type: Boolean,
+    description: "Force delete with all related data",
+  })
+  @ApiResponse({ status: 200, description: "Booking deleted successfully" })
+  @ApiResponse({ status: 404, description: "Booking not found" })
+  delete(@Param("id") id: string, @Query("cascade") cascade?: string) {
+    return this.service.delete(id, cascade === "true");
   }
 
-  @Patch(':id')
-  @SetMetadata('isPublic', true)
+  @Patch(":id")
+  @SetMetadata("isPublic", true)
   @ApiOperation({
-    description: 'Updates booking information for admin/agent operations'
+    description: "Updates booking information for admin/agent operations",
   })
-  @ApiResponse({ status: 200, description: 'Booking updated successfully' })
-  @ApiResponse({ status: 404, description: 'Booking not found' })
-  update(@Param('id') id: string, @Body() dto: any) { 
-    return this.service.update(id, dto); 
+  @ApiResponse({ status: 200, description: "Booking updated successfully" })
+  @ApiResponse({ status: 404, description: "Booking not found" })
+  update(@Param("id") id: string, @Body() dto: any) {
+    return this.service.update(id, dto);
   }
 
-  @Delete(':bookingRef')
+  @Delete(":bookingRef")
   @UseGuards(JwtGuard)
-  @ApiBearerAuth('JWT-auth')
-  @ApiOperation({ 
-    summary: 'Cancel booking with refund',
-    description: 'Cancels booking and processes refund (80% for confirmed bookings)'
+  @ApiBearerAuth("JWT-auth")
+  @ApiOperation({
+    summary: "Cancel booking with refund",
+    description:
+      "Cancels booking and processes refund (80% for confirmed bookings)",
   })
-  @ApiResponse({ status: 200, description: 'Booking cancelled with refund amount' })
-  @ApiResponse({ status: 400, description: 'Booking already cancelled' })
-  cancel(@Param('bookingRef') ref: string, @Body() dto: CancelBookingDto) { 
-    return this.service.cancel(ref, dto.reason); 
+  @ApiResponse({
+    status: 200,
+    description: "Booking cancelled with refund amount",
+  })
+  @ApiResponse({ status: 400, description: "Booking already cancelled" })
+  cancel(@Param("bookingRef") ref: string, @Body() dto: CancelBookingDto) {
+    return this.service.cancel(ref, dto.reason);
   }
 }
diff --git a/apps/edr-passenger-api/src/modules/bookings/bookings.service.ts b/apps/edr-passenger-api/src/modules/bookings/bookings.service.ts
index c5c8a0b49..114c0cc9d 100644
--- a/apps/edr-passenger-api/src/modules/bookings/bookings.service.ts
+++ b/apps/edr-passenger-api/src/modules/bookings/bookings.service.ts
@@ -1734,6 +1734,7 @@ export class BookingsService {
       where: isUuid ? { id: bookingRefOrId } : { bookingRef: bookingRefOrId },
       include: {
         schedule: { include: { originStation: true, destinationStation: true, train: true } },
+        returnSchedule: { include: { originStation: true, destinationStation: true, train: true } },
         seats: { include: { seat: { include: { coach: { include: { coachType: { include: { seatClasses: true } } } } } } } },
         paymentIntent: true, tickets: true,
         priceTier: { select: { priceMinor: true } },
@@ -1822,6 +1823,16 @@ export class BookingsService {
         destination: { id: (booking as any).schedule.destinationStation.id, name: (booking as any).schedule.destinationStation.name, code: (booking as any).schedule.destinationStation.code, city: (booking as any).schedule.destinationStation.city },
         departureAt: (booking as any).schedule.departureAt, arrivalAt: (booking as any).schedule.arrivalAt,
       },
+      returnSchedule: (booking as any).returnSchedule
+        ? {
+            id: (booking as any).returnSchedule.id,
+            trainNumber: (booking as any).returnSchedule.train.number,
+            trainName: (booking as any).returnSchedule.train.name,
+            origin: { id: (booking as any).returnSchedule.originStation.id, name: (booking as any).returnSchedule.originStation.name, code: (booking as any).returnSchedule.originStation.code, city: (booking as any).returnSchedule.originStation.city },
+            destination: { id: (booking as any).returnSchedule.destinationStation.id, name: (booking as any).returnSchedule.destinationStation.name, code: (booking as any).returnSchedule.destinationStation.code, city: (booking as any).returnSchedule.destinationStation.city },
+            departureAt: (booking as any).returnSchedule.departureAt, arrivalAt: (booking as any).returnSchedule.arrivalAt,
+          }
+        : null,
       passengers: (booking as any).seats?.map((bs: any) => ({
         fullName: bs.passengerName,
         category: bs.passengerCategory,
@@ -1844,11 +1855,14 @@ export class BookingsService {
             currency: (booking as any).paymentIntent.currency,
           }
         : undefined,
-      // One ticket per passenger — matched on the frontend by passengerName, not array
-      // position, since tickets are grouped/created independently of the passengers array.
+      // One ticket per passenger per leg (round trips have a separate ticket — and
+      // barcode — for the return leg) — matched on the frontend by passengerName +
+      // leg, not array position, since tickets are grouped/created independently of
+      // the passengers array.
       tickets: (booking as any).tickets?.map((t: any) => ({
         id: t.id,
         passengerName: t.passengerName,
+        leg: t.leg ?? 1,
         qrPayload: t.qrPayload,
         barcodePayload: t.barcodePayload,
         status: t.status,
diff --git a/apps/edr-passenger-api/src/modules/health/health.controller.ts b/apps/edr-passenger-api/src/modules/health/health.controller.ts
index a918fa76c..02e020d4f 100644
--- a/apps/edr-passenger-api/src/modules/health/health.controller.ts
+++ b/apps/edr-passenger-api/src/modules/health/health.controller.ts
@@ -1,13 +1,11 @@
 import { Controller, Get, HttpStatus, Res } from '@nestjs/common';
 import { ApiTags, ApiOperation } from '@nestjs/swagger';
-import { SkipThrottle } from '@nestjs/throttler';
 import { IsPublic } from '@tria-plc/api-common/modules/auth/decorators/public.decorator';
 import { PrismaService } from '../../common/prisma.service';
 import { Response } from 'express';
 
 @ApiTags('Health')
 @Controller('health')
-@SkipThrottle()
 export class HealthController {
   constructor(private readonly prisma: PrismaService) {}
 
diff --git a/apps/edr-passenger-api/src/modules/notifications/notifications.service.ts b/apps/edr-passenger-api/src/modules/notifications/notifications.service.ts
index fc8bffa27..a1678d131 100644
--- a/apps/edr-passenger-api/src/modules/notifications/notifications.service.ts
+++ b/apps/edr-passenger-api/src/modules/notifications/notifications.service.ts
@@ -303,7 +303,7 @@ export class NotificationsService {
     const booking = await this.prisma.booking.findUnique({
       where: { id: bookingId },
       include: {
-        schedule: { include: { originStation: true, destinationStation: true, train: true } },
+        schedule: { include: { originStation: true, destinationStation: true, train: true, stopTimes: { include: { station: true } } } },
         seats: { include: { seat: { include: { coach: { include: { coachType: true } } } } } },
       },
     });
@@ -353,6 +353,27 @@ export class NotificationsService {
     }
   }
 
+  /**
+   * Resolves the user's actual boarding/alighting stations from the booking's originStationId /
+   * destinationStationId via stopTimes, falling back to the schedule's full-route endpoints when
+   * the booking has no segment override (e.g. older records or packages).
+   */
+  private resolveSegmentStations(booking: any): { originStation: any; destinationStation: any } {
+    const s = booking?.schedule ?? {};
+    const stopTimes: any[] = s.stopTimes ?? [];
+    const findStation = (stationId: string | null | undefined, fallback: any) => {
+      if (stationId && stopTimes.length > 0) {
+        const stop = stopTimes.find((st: any) => st.stationId === stationId);
+        if (stop?.station) return stop.station;
+      }
+      return fallback ?? null;
+    };
+    return {
+      originStation: findStation(booking?.originStationId, s.originStation),
+      destinationStation: findStation(booking?.destinationStationId, s.destinationStation),
+    };
+  }
+
   /**
    * Builds the interpolation context for the `booking.created` template. `trainSeatLines` is a
    * pre-joined block of one "Train/Seat: …" line per booked seat (multi-passenger bookings get
@@ -379,12 +400,13 @@ export class NotificationsService {
     // Lead passenger (leg-1 seat). Booking has no contactName; the traveller name lives on the seat.
     const passengerName = seats[0]?.passengerName ?? 'Passenger';
     const payLink = `${process.env.PORTAL_URL ?? 'http://localhost:5174'}/booking/detail?ref=${ref}`;
+    const { originStation: originSt, destinationStation: destSt } = this.resolveSegmentStations(booking);
 
     return {
       passengerName,
       bookingRef: ref,
-      origin: s.originStation?.name ?? '',
-      destination: s.destinationStation?.name ?? '',
+      origin: originSt?.name ?? '',
+      destination: destSt?.name ?? '',
       trainSeatLines,
       travelDate: fmtDate(s.departureAt),
       departureTime: fmtTime(s.departureAt),
@@ -406,7 +428,7 @@ export class NotificationsService {
     const booking = await this.prisma.booking.findUnique({
       where: { id: bookingId },
       include: {
-        schedule: { include: { originStation: true, destinationStation: true, train: true } },
+        schedule: { include: { originStation: true, destinationStation: true, train: true, stopTimes: { include: { station: true } } } },
         seats: { include: { seat: { include: { coach: { include: { coachType: true } } } } } },
       },
     });
@@ -489,9 +511,10 @@ export class NotificationsService {
     const s = booking.schedule ?? {};
     const dep = s.departureAt ? new Date(s.departureAt).toLocaleString('en-GB') : 'TBD';
     const passengers = (booking.seats ?? []).map((bs: any) => bs.passengerName).filter(Boolean).join(', ');
+    const { originStation: originSt, destinationStation: destSt } = this.resolveSegmentStations(booking);
     return [
       `Booking ${booking.bookingRef} confirmed.`,
-      `${s.originStation?.name ?? ''} -> ${s.destinationStation?.name ?? ''}`,
+      `${originSt?.name ?? ''} -> ${destSt?.name ?? ''}`,
       `Train: ${s.train?.name ?? s.train?.number ?? ''}`,
       `Departs: ${dep}`,
       passengers ? `Passengers: ${passengers}` : '',
@@ -504,6 +527,7 @@ export class NotificationsService {
     const s = booking.schedule ?? {};
     const fmt = (d: any) =>
       d ? new Date(d).toLocaleString('en-GB', { dateStyle: 'medium', timeStyle: 'short' }) : 'TBD';
+    const { originStation: originSt, destinationStation: destSt } = this.resolveSegmentStations(booking);
     const seatRows = (booking.seats ?? [])
       .map((bs: any) => {
         const coach = bs.seat?.coach?.number ?? '-';
@@ -532,11 +556,11 @@ export class NotificationsService {
         <table style="width:100%;border-collapse:collapse;margin:16px 0;">
           <tr>
             <td style="padding:8px 0;color:#666;">From</td>
-            <td style="padding:8px 0;text-align:right;"><strong>${s.originStation?.name ?? ''}</strong> (${s.originStation?.code ?? ''})</td>
+            <td style="padding:8px 0;text-align:right;"><strong>${originSt?.name ?? ''}</strong> (${originSt?.code ?? ''})</td>
           </tr>
           <tr>
             <td style="padding:8px 0;color:#666;">To</td>
-            <td style="padding:8px 0;text-align:right;"><strong>${s.destinationStation?.name ?? ''}</strong> (${s.destinationStation?.code ?? ''})</td>
+            <td style="padding:8px 0;text-align:right;"><strong>${destSt?.name ?? ''}</strong> (${destSt?.code ?? ''})</td>
           </tr>
           <tr>
             <td style="padding:8px 0;color:#666;">Train</td>
@@ -612,8 +636,9 @@ export class NotificationsService {
     const fmt = (d: any) =>
       d ? new Date(d).toLocaleString('en-GB', { dateStyle: 'medium', timeStyle: 'short' }) : 'TBD';
     const legLabel = leg ? ` (${leg.replace(/_/g, ' ')})` : '';
-    const origin = s.originStation?.name ?? '';
-    const dest = s.destinationStation?.name ?? '';
+    const { originStation: originSt, destinationStation: destSt } = this.resolveSegmentStations(booking);
+    const origin = originSt?.name ?? '';
+    const dest = destSt?.name ?? '';
     const train = s.train?.name ?? s.train?.number ?? '';
     const dep = fmt(s.departureAt);
     const arr = fmt(s.arrivalAt);
diff --git a/apps/edr-passenger-api/src/modules/passengers/passengers.controller.ts b/apps/edr-passenger-api/src/modules/passengers/passengers.controller.ts
index cfa4a8805..20de8ec23 100644
--- a/apps/edr-passenger-api/src/modules/passengers/passengers.controller.ts
+++ b/apps/edr-passenger-api/src/modules/passengers/passengers.controller.ts
@@ -1,17 +1,41 @@
-import { Body, Controller, Get, Param, Post, UseGuards, Query, Request, UnauthorizedException, Patch, Delete, SetMetadata } from '@nestjs/common';
-import { ApiTags, ApiOperation, ApiBearerAuth, ApiResponse, ApiQuery } from '@nestjs/swagger';
-import { SkipThrottle, Throttle } from '@nestjs/throttler';
-import { PassengersService } from './passengers.service';
-import { CreateTravelerProfileDto, CreateSavedRouteDto, VerifyFaydaDto, SavePassengersDto, RegisterPassengerDto } from './passengers.dto';
-import { JwtGuard } from '../../common/jwt.guard';
-import { PassengerAdmin } from '../../common/passenger-guards';
-import { VerifaydaService } from '../verifayda/verifayda.service';
-import { OptionalJwtGuard } from '../verifayda/optional-jwt.guard';
-import { PrismaService } from '../../common/prisma.service';
+import {
+  Body,
+  Controller,
+  Get,
+  Param,
+  Post,
+  UseGuards,
+  Query,
+  Request,
+  UnauthorizedException,
+  Patch,
+  Delete,
+  SetMetadata,
+} from "@nestjs/common";
+import {
+  ApiTags,
+  ApiOperation,
+  ApiBearerAuth,
+  ApiResponse,
+  ApiQuery,
+} from "@nestjs/swagger";
+import { PassengersService } from "./passengers.service";
+import {
+  CreateTravelerProfileDto,
+  CreateSavedRouteDto,
+  VerifyFaydaDto,
+  SavePassengersDto,
+  RegisterPassengerDto,
+} from "./passengers.dto";
+import { JwtGuard } from "../../common/jwt.guard";
+import { PassengerAdmin } from "../../common/passenger-guards";
+import { VerifaydaService } from "../verifayda/verifayda.service";
+import { OptionalJwtGuard } from "../verifayda/optional-jwt.guard";
+import { PrismaService } from "../../common/prisma.service";
 
-@ApiTags('Passengers')
-@Controller('passengers')
-@Throttle({ strict: { limit: 20, ttl: 60_000 } })
+@ApiTags("Passengers")
+@Controller("passengers")
+// @Throttle({ strict: { limit: 20, ttl: 60_000 } })
 export class PassengersController {
   constructor(
     private service: PassengersService,
@@ -20,9 +44,9 @@ export class PassengersController {
   ) {}
 
   @Get()
-  @SetMetadata('isPublic', true)
-  @ApiOperation({ 
-    summary: 'List all travelers with filters (Admin/Agent)',
+  @SetMetadata("isPublic", true)
+  @ApiOperation({
+    summary: "List all travelers with filters (Admin/Agent)",
     description: `**Returns paginated list of all travelers in the system**
 
 ---
@@ -54,90 +78,114 @@ export class PassengersController {
 - **faydaVerified**: Whether verified via Verifayda
 - **loyaltyTier/loyaltyPoints**: If linked to user account
 - **totalBookings**: Number of bookings
-- **createdAt**: When traveler was first added to system`
+- **createdAt**: When traveler was first added to system`,
+  })
+  @ApiQuery({
+    name: "search",
+    required: false,
+    description: "Search by name, email, or phone",
+  })
+  @ApiQuery({
+    name: "gender",
+    required: false,
+    description: "Filter by gender (Male, Female, Other)",
+  })
+  @ApiQuery({
+    name: "dateFrom",
+    required: false,
+    description: "Filter by creation date from (YYYY-MM-DD)",
+  })
+  @ApiQuery({
+    name: "dateTo",
+    required: false,
+    description: "Filter by creation date to (YYYY-MM-DD)",
+  })
+  @ApiQuery({
+    name: "page",
+    required: false,
+    description: "Page number (default: 1)",
+  })
+  @ApiQuery({
+    name: "pageSize",
+    required: false,
+    description: "Items per page (default: 20)",
   })
-  @ApiQuery({ name: 'search', required: false, description: 'Search by name, email, or phone' })
-  @ApiQuery({ name: 'gender', required: false, description: 'Filter by gender (Male, Female, Other)' })
-  @ApiQuery({ name: 'dateFrom', required: false, description: 'Filter by creation date from (YYYY-MM-DD)' })
-  @ApiQuery({ name: 'dateTo', required: false, description: 'Filter by creation date to (YYYY-MM-DD)' })
-  @ApiQuery({ name: 'page', required: false, description: 'Page number (default: 1)' })
-  @ApiQuery({ name: 'pageSize', required: false, description: 'Items per page (default: 20)' })
   @ApiResponse({
     status: 200,
-    description: 'Travelers retrieved successfully',
+    description: "Travelers retrieved successfully",
     schema: {
       example: {
         items: [
           {
-            id: 'uuid-123',
-            fullName: 'Abebe Kebede',
-            email: 'abebe@example.com',
-            phone: '+251911234567',
-            gender: 'Male',
-            dateOfBirth: '1985-03-15',
-            nationality: 'Ethiopian',
+            id: "uuid-123",
+            fullName: "Abebe Kebede",
+            email: "abebe@example.com",
+            phone: "+251911234567",
+            gender: "Male",
+            dateOfBirth: "1985-03-15",
+            nationality: "Ethiopian",
             faydaVerified: true,
-            loyaltyTier: 'SILVER',
+            loyaltyTier: "SILVER",
             loyaltyPoints: 1500,
             totalBookings: 5,
-            createdAt: '2024-01-10T12:00:00.000Z'
-          }
+            createdAt: "2024-01-10T12:00:00.000Z",
+          },
         ],
         meta: {
           page: 1,
           pageSize: 20,
           total: 150,
-          totalPages: 8
-        }
-      }
-    }
+          totalPages: 8,
+        },
+      },
+    },
   })
   @ApiResponse({
     status: 200,
-    description: 'Travelers retrieved successfully',
+    description: "Travelers retrieved successfully",
     schema: {
       example: {
         items: [
           {
-            id: 'uuid-123',
-            fullName: 'Abebe Kebede',
-            email: 'abebe@example.com',
-            phone: '+251911234567',
-            gender: 'Male',
-            dateOfBirth: '1985-03-15',
-            nationality: 'Ethiopian',
-            nationalityCode: 'ET',
+            id: "uuid-123",
+            fullName: "Abebe Kebede",
+            email: "abebe@example.com",
+            phone: "+251911234567",
+            gender: "Male",
+            dateOfBirth: "1985-03-15",
+            nationality: "Ethiopian",
+            nationalityCode: "ET",
             faydaVerified: true,
-            faydaVerifiedAt: '2024-01-15T10:30:00.000Z',
+            faydaVerifiedAt: "2024-01-15T10:30:00.000Z",
             passportNumber: null,
             passportCountry: null,
             passportExpiryDate: null,
-            idDocumentType: 'NATIONAL_ID',
+            idDocumentType: "NATIONAL_ID",
             verified: true,
-            lastLoginAt: '2024-01-20T08:15:00.000Z',
-            role: 'PASSENGER',
+            lastLoginAt: "2024-01-20T08:15:00.000Z",
+            role: "PASSENGER",
             loyalty: {
-              tier: 'SILVER',
+              tier: "SILVER",
               pointsBalance: 1500,
-              lifetimePoints: 3000
+              lifetimePoints: 3000,
             },
             wallet: {
               balanceMinor: 50000,
-              currency: 'ETB'
+              currency: "ETB",
             },
-            loyaltyTier: 'SILVER',
+            loyaltyTier: "SILVER",
             loyaltyPoints: 1500,
             totalBookings: 5,
-            createdAt: '2024-01-10T12:00:00.000Z'
+            createdAt: "2024-01-10T12:00:00.000Z",
           },
           {
-            id: 'uuid-456',
-            fullName: 'Sara Ketsela',
+            id: "uuid-456",
+            fullName: "Sara Ketsela",
             email: null,
             phone: null,
-            gender: 'Female',
-            dateOfBirth: '1990-08-22',
-            nationality: 'Ethiopian',
+            gender: "Female",
+            dateOfBirth: "1990-08-22",
+            nationality: "Ethiopian",
             nationalityCode: null,
             faydaVerified: false,
             faydaVerifiedAt: null,
@@ -150,54 +198,59 @@ export class PassengersController {
             role: null,
             loyalty: null,
             wallet: null,
-            loyaltyTier: 'BRONZE',
+            loyaltyTier: "BRONZE",
             loyaltyPoints: 0,
             totalBookings: 1,
-            createdAt: '2024-01-18T14:30:00.000Z'
-          }
+            createdAt: "2024-01-18T14:30:00.000Z",
+          },
         ],
         meta: {
           page: 1,
           pageSize: 20,
           total: 150,
-          totalPages: 8
-        }
-      }
-    }
+          totalPages: 8,
+        },
+      },
+    },
   })
   findAll(
-    @Query('search') search?: string,
-    @Query('gender') gender?: string,
-    @Query('dateFrom') dateFrom?: string,
-    @Query('dateTo') dateTo?: string,
-    @Query('page') page?: string,
-    @Query('pageSize') pageSize?: string,
+    @Query("search") search?: string,
+    @Query("gender") gender?: string,
+    @Query("dateFrom") dateFrom?: string,
+    @Query("dateTo") dateTo?: string,
+    @Query("page") page?: string,
+    @Query("pageSize") pageSize?: string,
   ) {
-    return this.service.findAll({ 
-      search, 
+    return this.service.findAll({
+      search,
       gender,
       dateFrom,
       dateTo,
-      page: page ? parseInt(page) : 1, 
-      pageSize: pageSize ? parseInt(pageSize) : 20 
+      page: page ? parseInt(page) : 1,
+      pageSize: pageSize ? parseInt(pageSize) : 20,
     });
   }
 
-  @Get('me')
+  @Get("me")
   @UseGuards(JwtGuard)
-  @ApiBearerAuth('JWT-auth')
-  @ApiOperation({ 
-    summary: 'Get current passenger profile',
-    description: 'Returns complete profile for authenticated passenger including passport details and verification status. Returns null if no passenger profile exists.'
+  @ApiBearerAuth("JWT-auth")
+  @ApiOperation({
+    summary: "Get current passenger profile",
+    description:
+      "Returns complete profile for authenticated passenger including passport details and verification status. Returns null if no passenger profile exists.",
   })
-  @ApiResponse({ 
-    status: 200, 
-    description: 'Passenger profile retrieved successfully or null if not found'
+  @ApiResponse({
+    status: 200,
+    description:
+      "Passenger profile retrieved successfully or null if not found",
+  })
+  @ApiResponse({
+    status: 401,
+    description: "Unauthorized - Invalid or missing token",
   })
-  @ApiResponse({ status: 401, description: 'Unauthorized - Invalid or missing token' })
   async getMe(@Request() req: any) {
     if (!req.user || !req.user.id) {
-      throw new UnauthorizedException('User not authenticated');
+      throw new UnauthorizedException("User not authenticated");
     }
 
     try {
@@ -211,26 +264,26 @@ export class PassengersController {
     }
   }
 
-  @Get(':id/profile')
+  @Get(":id/profile")
   @UseGuards(JwtGuard)
-  @ApiBearerAuth('JWT-auth')
-  @ApiOperation({ summary: 'Get passenger profile' })
-  getProfile(@Param('id') id: string) {
+  @ApiBearerAuth("JWT-auth")
+  @ApiOperation({ summary: "Get passenger profile" })
+  getProfile(@Param("id") id: string) {
     return this.service.getProfile(id);
   }
 
-  @Get(':id/stats')
+  @Get(":id/stats")
   @UseGuards(JwtGuard)
-  @ApiBearerAuth('JWT-auth')
-  @ApiOperation({ summary: 'Get passenger stats' })
-  getStats(@Param('id') id: string) {
+  @ApiBearerAuth("JWT-auth")
+  @ApiOperation({ summary: "Get passenger stats" })
+  getStats(@Param("id") id: string) {
     return this.service.getStats(id);
   }
 
-  @Post('verify-fayda')
-  @SetMetadata('isPublic', true)
+  @Post("verify-fayda")
+  @SetMetadata("isPublic", true)
   @ApiOperation({
-    summary: 'Verify Ethiopian national ID via Verifayda 2.0',
+    summary: "Verify Ethiopian national ID via Verifayda 2.0",
     description: `**Standalone endpoint for pre-verification of Ethiopian national IDs**
 
 ---
@@ -277,32 +330,35 @@ Pre-verify national ID to auto-fill passenger registration form before submissio
 - **Public endpoint** (no authentication required)
 - Can be called before login/registration`,
   })
-  @ApiResponse({ 
-    status: 200, 
-    description: 'Verification successful with passenger data',
+  @ApiResponse({
+    status: 200,
+    description: "Verification successful with passenger data",
     schema: {
       example: {
         verified: true,
         passengerData: {
-          fullName: 'Abebe Kebede',
-          dateOfBirth: '1985-03-15T00:00:00.000Z',
-          gender: 'Male',
-          nationality: 'Ethiopian'
-        }
-      }
-    }
+          fullName: "Abebe Kebede",
+          dateOfBirth: "1985-03-15T00:00:00.000Z",
+          gender: "Male",
+          nationality: "Ethiopian",
+        },
+      },
+    },
+  })
+  @ApiResponse({
+    status: 400,
+    description: "Verification failed or Verifayda disabled",
   })
-  @ApiResponse({ status: 400, description: 'Verification failed or Verifayda disabled' })
   verifyFayda(@Body() dto: VerifyFaydaDto) {
     return this.verifaydaService.verifyNationalId(dto.nationalId);
   }
 
-  @Post('register')
-  @SetMetadata('isPublic', true)
+  @Post("register")
+  @SetMetadata("isPublic", true)
   @UseGuards(OptionalJwtGuard)
-  @ApiBearerAuth('JWT-auth')
+  @ApiBearerAuth("JWT-auth")
   @ApiOperation({
-    summary: 'Universal passenger registration endpoint',
+    summary: "Universal passenger registration endpoint",
     description: `**Single endpoint for all passenger registration scenarios**
 
 ---
@@ -357,45 +413,45 @@ The API automatically detects:
 ### Replaces
 - Manual verification + save flows`,
   })
-  @ApiResponse({ 
-    status: 201, 
-    description: 'Passenger registered successfully',
+  @ApiResponse({
+    status: 201,
+    description: "Passenger registered successfully",
     schema: {
       example: {
-        id: 'uuid-123',
-        passengerName: 'Abebe Kebede',
-        dateOfBirth: '1985-03-15T00:00:00.000Z',
-        nationality: 'Ethiopian',
+        id: "uuid-123",
+        passengerName: "Abebe Kebede",
+        dateOfBirth: "1985-03-15T00:00:00.000Z",
+        nationality: "Ethiopian",
         verified: true,
         linked: false,
-        message: 'Passenger details saved for guest booking'
-      }
-    }
+        message: "Passenger details saved for guest booking",
+      },
+    },
   })
-  @ApiResponse({ 
-    status: 400, 
-    description: 'Validation error or verification failed',
+  @ApiResponse({
+    status: 400,
+    description: "Validation error or verification failed",
     schema: {
       example: {
         statusCode: 400,
-        message: 'Validation failed',
-        error: 'Bad Request'
-      }
-    }
+        message: "Validation failed",
+        error: "Bad Request",
+      },
+    },
   })
-  @ApiResponse({ 
-    status: 401, 
-    description: 'Invalid JWT token (only if token provided but invalid)' 
+  @ApiResponse({
+    status: 401,
+    description: "Invalid JWT token (only if token provided but invalid)",
   })
   registerPassenger(@Body() dto: RegisterPassengerDto, @Request() req: any) {
     const userId = req.user?.id;
     return this.service.registerPassenger({ ...dto, userId });
   }
 
-  @Post('save-details')
-  @SetMetadata('isPublic', true)
+  @Post("save-details")
+  @SetMetadata("isPublic", true)
   @ApiOperation({
-    summary: 'Bulk save passenger details from booking flow',
+    summary: "Bulk save passenger details from booking flow",
     description: `**Endpoint for saving multiple passengers in a single booking**
 
 ---
@@ -427,105 +483,117 @@ Save all passenger details for a multi-passenger booking before proceeding to se
 ### Response
 Returns saved passenger details with generated IDs and confirmation.`,
   })
-  @ApiResponse({ 
-    status: 201, 
-    description: 'All passenger details saved successfully',
+  @ApiResponse({
+    status: 201,
+    description: "All passenger details saved successfully",
     schema: {
       example: {
         count: 2,
-        passengerIds: ['uuid-1', 'uuid-2'],
+        passengerIds: ["uuid-1", "uuid-2"],
         passengers: [
           {
-            id: 'uuid-1',
-            passengerName: 'Abebe Kebede',
-            dateOfBirth: '1985-03-15T00:00:00.000Z',
-            nationality: 'Ethiopian',
-            nationalId: 'ET123456789'
+            id: "uuid-1",
+            passengerName: "Abebe Kebede",
+            dateOfBirth: "1985-03-15T00:00:00.000Z",
+            nationality: "Ethiopian",
+            nationalId: "ET123456789",
           },
           {
-            id: 'uuid-2',
-            passengerName: 'Sara Ketsela',
-            dateOfBirth: '1990-08-22T00:00:00.000Z',
-            nationality: 'Ethiopian',
-            nationalId: 'ET987654321'
-          }
+            id: "uuid-2",
+            passengerName: "Sara Ketsela",
+            dateOfBirth: "1990-08-22T00:00:00.000Z",
+            nationality: "Ethiopian",
+            nationalId: "ET987654321",
+          },
         ],
-        message: 'Passenger details saved successfully'
-      }
-    }
+        message: "Passenger details saved successfully",
+      },
+    },
+  })
+  @ApiResponse({
+    status: 400,
+    description: "Validation error - passengers array required",
   })
-  @ApiResponse({ status: 400, description: 'Validation error - passengers array required' })
   savePassengers(@Body() dto: SavePassengersDto) {
-    return this.service.savePassengers(dto.passengers, dto.userId, dto.deviceId);
+    return this.service.savePassengers(
+      dto.passengers,
+      dto.userId,
+      dto.deviceId,
+    );
   }
 
-  @Post('traveler-profiles')
+  @Post("traveler-profiles")
   @UseGuards(JwtGuard)
-  @ApiBearerAuth('JWT-auth')
-  @ApiOperation({ summary: 'Add traveler profile (family member)' })
+  @ApiBearerAuth("JWT-auth")
+  @ApiOperation({ summary: "Add traveler profile (family member)" })
   createTravelerProfile(@Body() dto: CreateTravelerProfileDto) {
     return this.service.createTravelerProfile(dto);
   }
 
-  @Get(':id/traveler-profiles')
+  @Get(":id/traveler-profiles")
   @UseGuards(JwtGuard)
-  @ApiBearerAuth('JWT-auth')
-  @ApiOperation({ summary: 'Get traveler profiles for passenger' })
-  getTravelerProfiles(@Param('id') id: string) {
+  @ApiBearerAuth("JWT-auth")
+  @ApiOperation({ summary: "Get traveler profiles for passenger" })
+  getTravelerProfiles(@Param("id") id: string) {
     return this.service.getTravelerProfiles(id);
   }
 
-  @Post('saved-routes')
+  @Post("saved-routes")
   @UseGuards(JwtGuard)
-  @ApiBearerAuth('JWT-auth')
-  @ApiOperation({ summary: 'Save a route' })
+  @ApiBearerAuth("JWT-auth")
+  @ApiOperation({ summary: "Save a route" })
   createSavedRoute(@Body() dto: CreateSavedRouteDto) {
     return this.service.createSavedRoute(dto);
   }
 
-  @Get(':id/saved-routes')
+  @Get(":id/saved-routes")
   @UseGuards(JwtGuard)
-  @ApiBearerAuth('JWT-auth')
-  @ApiOperation({ summary: 'Get saved routes' })
-  getSavedRoutes(@Param('id') id: string) {
+  @ApiBearerAuth("JWT-auth")
+  @ApiOperation({ summary: "Get saved routes" })
+  getSavedRoutes(@Param("id") id: string) {
     return this.service.getSavedRoutes(id);
   }
 
-  @Patch(':id')
-  @SetMetadata('isPublic', true)
-  @ApiOperation({ 
-    summary: 'Update passenger details',
-    description: 'Updates passenger information for admin/agent operations'
+  @Patch(":id")
+  @SetMetadata("isPublic", true)
+  @ApiOperation({
+    summary: "Update passenger details",
+    description: "Updates passenger information for admin/agent operations",
   })
-  @ApiResponse({ status: 200, description: 'Passenger updated successfully' })
-  @ApiResponse({ status: 404, description: 'Passenger not found' })
-  updatePassenger(@Param('id') id: string, @Body() dto: any) {
+  @ApiResponse({ status: 200, description: "Passenger updated successfully" })
+  @ApiResponse({ status: 404, description: "Passenger not found" })
+  updatePassenger(@Param("id") id: string, @Body() dto: any) {
     return this.service.updatePassenger(id, dto);
   }
 
-  @Delete(':id')
+  @Delete(":id")
   @PassengerAdmin()
-  @ApiBearerAuth('IAM-auth')
-  @ApiOperation({ 
-    summary: 'Delete passenger (admin only)',
-    description: 'Permanently deletes a passenger record and associated data'
+  @ApiBearerAuth("IAM-auth")
+  @ApiOperation({
+    summary: "Delete passenger (admin only)",
+    description: "Permanently deletes a passenger record and associated data",
   })
-  @ApiQuery({ name: 'cascade', required: false, type: Boolean, description: 'Force delete with all related bookings and data' })
-  @ApiResponse({ status: 200, description: 'Passenger deleted successfully' })
-  @ApiResponse({ status: 404, description: 'Passenger not found' })
-  deletePassenger(@Param('id') id: string, @Query('cascade') cascade?: string) {
-    return this.service.deletePassenger(id, cascade === 'true');
+  @ApiQuery({
+    name: "cascade",
+    required: false,
+    type: Boolean,
+    description: "Force delete with all related bookings and data",
+  })
+  @ApiResponse({ status: 200, description: "Passenger deleted successfully" })
+  @ApiResponse({ status: 404, description: "Passenger not found" })
+  deletePassenger(@Param("id") id: string, @Query("cascade") cascade?: string) {
+    return this.service.deletePassenger(id, cascade === "true");
   }
 
-  @Get(':id/usage')
-  @SetMetadata('isPublic', true)
-  @ApiOperation({ 
-    summary: 'Check if passenger is in use',
-    description: 'Returns list of modules/data that reference this passenger'
+  @Get(":id/usage")
+  @SetMetadata("isPublic", true)
+  @ApiOperation({
+    summary: "Check if passenger is in use",
+    description: "Returns list of modules/data that reference this passenger",
   })
-  @ApiResponse({ status: 200, description: 'Usage information retrieved' })
-  @ApiResponse({ status: 404, description: 'Passenger not found' })
-  checkUsage(@Param('id') id: string) {
+  @ApiResponse({ status: 200, description: "Usage information retrieved" })
+  @ApiResponse({ status: 404, description: "Passenger not found" })
+  checkUsage(@Param("id") id: string) {
     return this.service.checkPassengerUsage(id);
   }
 }
diff --git a/apps/edr-passenger-api/src/modules/payments/internal-payments.controller.ts b/apps/edr-passenger-api/src/modules/payments/internal-payments.controller.ts
index 04b721f0c..98262c4c3 100644
--- a/apps/edr-passenger-api/src/modules/payments/internal-payments.controller.ts
+++ b/apps/edr-passenger-api/src/modules/payments/internal-payments.controller.ts
@@ -7,7 +7,6 @@ import {
   UseGuards,
 } from "@nestjs/common";
 import { ApiOperation, ApiTags } from "@nestjs/swagger";
-import { SkipThrottle } from "@nestjs/throttler";
 import { ServiceAuthGuard } from "../../common/guards/service-auth.guard";
 import { PaymentEventDto, MarkPaidResponseDto } from "./internal-payments.dto";
 import { PaymentsService } from "./payments.service";
@@ -21,7 +20,6 @@ import { PaymentsService } from "./payments.service";
 @ApiTags("Internal Payments")
 @UseGuards(ServiceAuthGuard)
 @Controller("internal/payments")
-@SkipThrottle()
 export class InternalPaymentsController {
   constructor(private readonly paymentsService: PaymentsService) {}
 
diff --git a/apps/edr-passenger-api/src/modules/payments/payments.controller.ts b/apps/edr-passenger-api/src/modules/payments/payments.controller.ts
index 58be16c05..3c3135832 100644
--- a/apps/edr-passenger-api/src/modules/payments/payments.controller.ts
+++ b/apps/edr-passenger-api/src/modules/payments/payments.controller.ts
@@ -21,7 +21,6 @@ import {
   ApiProduces,
 } from "@nestjs/swagger";
 
-import { SkipThrottle, Throttle } from "@nestjs/throttler";
 import { Response } from "express";
 import { PaymentsService } from "./payments.service";
 import {
@@ -41,7 +40,7 @@ import { PASSENGER_PERMS } from "../../seed/passenger-permissions.registry";
 
 @ApiTags("Payment")
 @Controller("payments")
-@Throttle({ strict: { limit: 20, ttl: 60_000 } })
+// @Throttle({ strict: { limit: 20, ttl: 60_000 } })
 export class PaymentsController {
   constructor(private service: PaymentsService) {}
 
@@ -79,7 +78,7 @@ export class PaymentsController {
   }
 
   @Post("initiate")
-  @SetMetadata('isPublic', true)
+  @SetMetadata("isPublic", true)
   @ApiOperation({
     summary: "Initiate payment with nationality-based payment methods",
     description: `Initiates payment for a booking with support for multiple payment providers:\n\n**Ethiopian Payment Methods:**\n- TELEBIRR - Ethiopia's leading mobile money\n- CBE_BIRR - Commercial Bank of Ethiopia\n- EBIRR - Electronic payment gateway\n\n**Djiboutian Payment Methods:**\n- WAAFI - Djibouti's mobile money service\n\n**International Payment Methods:**\n- CARD - Visa, Mastercard\n- WALLET - Internal wallet balance\n\n**Multi-Currency:**\n- All transactions processed in ETB\n- Display amounts in ETB, DJF, or USD\n- Real-time exchange rate conversion`,
@@ -89,14 +88,14 @@ export class PaymentsController {
   }
 
   @Get("intents/:bookingId")
-  @SetMetadata('isPublic', true)
+  @SetMetadata("isPublic", true)
   @ApiOperation({ summary: "Get payment intent status for a booking" })
   getIntent(@Param("bookingId") bookingId: string) {
     return this.service.getIntentByBookingId(bookingId);
   }
 
   @Post(":bookingId/confirm")
-  @SetMetadata('isPublic', true)
+  @SetMetadata("isPublic", true)
   @ApiOperation({
     summary: "Confirm an OTP-debit payment (CAC Bank)",
     description:
@@ -111,7 +110,7 @@ export class PaymentsController {
   }
 
   @Get("waafi/return")
-  @SetMetadata('isPublic', true)
+  @SetMetadata("isPublic", true)
   @ApiOperation({
     summary:
       "DEMO ONLY — confirm a Waafi payment from the browser-return params and return JSON for the " +
@@ -142,7 +141,10 @@ export class PaymentsController {
   }
 
   @Post(":bookingId/force-confirm")
-  @PassengerStaff([PASSENGER_PERMS.payments.manageMethods, PASSENGER_PERMS.admin])
+  @PassengerStaff([
+    PASSENGER_PERMS.payments.manageMethods,
+    PASSENGER_PERMS.admin,
+  ])
   @ApiBearerAuth("IAM-auth")
   @ApiOperation({
     summary: "Force-confirm payment & generate ticket (back-office only)",
@@ -150,12 +152,18 @@ export class PaymentsController {
       "Marks the payment as SUCCEEDED, confirms the booking, and generates the ticket. " +
       "Use when a vendor payment completed but the webhook was never delivered. Idempotent.",
   })
-  forceConfirm(@Param("bookingId") bookingId: string, @Body() dto: ForceConfirmDto) {
+  forceConfirm(
+    @Param("bookingId") bookingId: string,
+    @Body() dto: ForceConfirmDto,
+  ) {
     return this.service.forceConfirmPayment(bookingId, dto);
   }
 
   @Post("methods")
-  @PassengerStaff([PASSENGER_PERMS.payments.manageMethods, PASSENGER_PERMS.admin])
+  @PassengerStaff([
+    PASSENGER_PERMS.payments.manageMethods,
+    PASSENGER_PERMS.admin,
+  ])
   @ApiBearerAuth("IAM-auth")
   @ApiOperation({
     summary: "Add a payment system to the platform catalog (admin only)",
@@ -165,17 +173,23 @@ export class PaymentsController {
   }
 
   @Patch("methods/:id")
-  @PassengerStaff([PASSENGER_PERMS.payments.manageMethods, PASSENGER_PERMS.admin])
+  @PassengerStaff([
+    PASSENGER_PERMS.payments.manageMethods,
+    PASSENGER_PERMS.admin,
+  ])
   @ApiBearerAuth("IAM-auth")
   @ApiOperation({
     summary: "Update a payment method configuration (admin only)",
   })
-  updateMethod(@Param("id") id: string, @Body() dto: Partial<AddPaymentMethodDto>) {
+  updateMethod(
+    @Param("id") id: string,
+    @Body() dto: Partial<AddPaymentMethodDto>,
+  ) {
     return this.service.updatePaymentMethod(id, dto);
   }
 
   @Get("methods")
-  @SetMetadata('isPublic', true)
+  @SetMetadata("isPublic", true)
   @ApiOperation({
     summary: "List payment systems supported by the platform",
     description:
@@ -183,14 +197,12 @@ export class PaymentsController {
   })
   @ApiQuery({ name: "region", enum: PaymentRegionEnum, required: false })
   @ApiOkResponse({ type: [SupportedPaymentMethodDto] })
-  getMethods(
-    @Query("region") region?: PaymentRegionEnum,
-  ) {
+  getMethods(@Query("region") region?: PaymentRegionEnum) {
     return this.service.getSupportedPaymentMethods(region);
   }
 
   @Get("booking-amount")
-  @SetMetadata('isPublic', true)
+  @SetMetadata("isPublic", true)
   @ApiOperation({
     summary: "Get booking amount in a specific currency",
     description:
@@ -199,7 +211,12 @@ export class PaymentsController {
       "Amounts are returned in major currency units (e.g. 162.50 DJF, not centimes).",
   })
   @ApiQuery({ name: "bookingId", required: true, description: "Booking UUID" })
-  @ApiQuery({ name: "currency", required: true, example: "DJF", description: "Target currency: ETB, DJF, or USD" })
+  @ApiQuery({
+    name: "currency",
+    required: true,
+    example: "DJF",
+    description: "Target currency: ETB, DJF, or USD",
+  })
   @ApiOkResponse({ type: BookingAmountResponseDto })
   getBookingAmount(
     @Query("bookingId") bookingId: string,
@@ -209,7 +226,7 @@ export class PaymentsController {
   }
 
   @Get("checkout")
-  @SetMetadata('isPublic', true)
+  @SetMetadata("isPublic", true)
   @ApiOperation({
     summary: "Browser checkout redirect",
     description:
diff --git a/apps/edr-passenger-api/src/modules/system-config/system-config.controller.ts b/apps/edr-passenger-api/src/modules/system-config/system-config.controller.ts
index 6f2bbb73d..0114c03f9 100644
--- a/apps/edr-passenger-api/src/modules/system-config/system-config.controller.ts
+++ b/apps/edr-passenger-api/src/modules/system-config/system-config.controller.ts
@@ -1,6 +1,5 @@
 import { Body, Controller, Get, Patch, SetMetadata, UseGuards } from '@nestjs/common';
 import { ApiTags, ApiBearerAuth, ApiOperation } from '@nestjs/swagger';
-import { SkipThrottle } from '@nestjs/throttler';
 import { SystemConfigService } from './system-config.service';
 import { IamGuard } from '../../common/iam-adapter';
 import { Roles } from '../../common/roles.decorator';
@@ -12,7 +11,6 @@ export class SystemConfigController {
 
   @Get('fayda-status')
   @SetMetadata('isPublic', true)
-  @SkipThrottle()
   @ApiOperation({ summary: 'Get Fayda verification enabled status (public)' })
   getFaydaStatus() {
     const enabled = process.env.VERIFAYDA_ENABLED !== 'false';
diff --git a/apps/edr-passenger-api/src/modules/tickets/tickets.service.ts b/apps/edr-passenger-api/src/modules/tickets/tickets.service.ts
index 1a9c88d4e..656e726ab 100644
--- a/apps/edr-passenger-api/src/modules/tickets/tickets.service.ts
+++ b/apps/edr-passenger-api/src/modules/tickets/tickets.service.ts
@@ -386,7 +386,7 @@ export class TicketsService {
       let booking = await this.prisma.booking.findUnique({
         where: { bookingRef },
         include: {
-          schedule: { include: { originStation: true, destinationStation: true, train: true } },
+          schedule: { include: { originStation: true, destinationStation: true, train: true, stopTimes: { include: { station: true } } } },
           returnSchedule: { include: { originStation: true, destinationStation: true } },
           tickets: true,
           seats: { include: { seat: { include: { coach: true } } } },
@@ -400,7 +400,7 @@ export class TicketsService {
           booking = await this.prisma.booking.findUnique({
             where: { bookingRef: ticket.bookingRef },
             include: {
-              schedule: { include: { originStation: true, destinationStation: true, train: true } },
+              schedule: { include: { originStation: true, destinationStation: true, train: true, stopTimes: { include: { station: true } } } },
               returnSchedule: { include: { originStation: true, destinationStation: true } },
               tickets: true,
               seats: { include: { seat: { include: { coach: true } } } },
@@ -453,6 +453,18 @@ export class TicketsService {
       // Send notifications after successful boarding
       await this.sendBoardingNotifications(booking, ticket, result.leg || 'OUTBOUND');
 
+      // Resolve user-selected segment rather than the full schedule route
+      const _schedStops = (booking as any).schedule?.stopTimes ?? [];
+      const _resolveStation = (id: string | null | undefined, fallback: any) => {
+        if (id) {
+          const found = _schedStops.find((st: any) => st.stationId === id)?.station;
+          if (found) return found;
+        }
+        return fallback;
+      };
+      const boardingOrigin = _resolveStation((booking as any).originStationId, (booking as any).schedule?.originStation);
+      const boardingDest = _resolveStation((booking as any).destinationStationId, (booking as any).schedule?.destinationStation);
+
       return {
         success: true,
         message: `Passenger boarded successfully (${result.leg || 'OUTBOUND'} leg)`,
@@ -461,7 +473,7 @@ export class TicketsService {
           ticketNumber: ticket.barcodePayload,
           bookingRef: booking.bookingRef,
           passengerName: seatInfo?.passengerName || ticket.passengerName || 'N/A',
-          route: `${(booking as any).schedule?.originStation?.name || 'N/A'} → ${(booking as any).schedule?.destinationStation?.name || 'N/A'}`,
+          route: `${boardingOrigin?.name || 'N/A'} → ${boardingDest?.name || 'N/A'}`,
           seat: seatNumber,
           coach: coachNumber,
           trainName: (booking as any).schedule?.train?.name || (booking as any).schedule?.train?.number || 'N/A',
diff --git a/apps/edr-passenger-api/src/modules/verifayda/verifayda.controller.ts b/apps/edr-passenger-api/src/modules/verifayda/verifayda.controller.ts
index 9ba4cd515..13de29616 100644
--- a/apps/edr-passenger-api/src/modules/verifayda/verifayda.controller.ts
+++ b/apps/edr-passenger-api/src/modules/verifayda/verifayda.controller.ts
@@ -8,25 +8,24 @@ import {
   Query,
   Req,
   UseGuards,
-} from '@nestjs/common';
+} from "@nestjs/common";
 import {
   ApiBearerAuth,
   ApiOkResponse,
   ApiOperation,
   ApiTags,
-} from '@nestjs/swagger';
-import { Throttle } from '@nestjs/throttler';
-import type { TCurrentUser } from '@tria-plc/api-common/modules/auth/types/current-user.type';
-import { IsPublic } from '@tria-plc/api-common/modules/auth/decorators/public.decorator';
-import { JwtGuard } from '../../common/jwt.guard';
-import { OptionalJwtGuard } from './optional-jwt.guard';
+} from "@nestjs/swagger";
+import type { TCurrentUser } from "@tria-plc/api-common/modules/auth/types/current-user.type";
+import { IsPublic } from "@tria-plc/api-common/modules/auth/decorators/public.decorator";
+import { JwtGuard } from "../../common/jwt.guard";
+import { OptionalJwtGuard } from "./optional-jwt.guard";
 import {
   CompleteVerificationResultDto,
   StartVerificationDto,
   VerifaydaCallbackDto,
   VerificationStatusDto,
-} from './verifayda.dto';
-import { VerifaydaService } from './verifayda.service';
+} from "./verifayda.dto";
+import { VerifaydaService } from "./verifayda.service";
 
 /** Minimal slices of the Express req we touch (avoids a hard dependency on
  * `@types/express`, which isn't resolved in this package). */
@@ -37,19 +36,19 @@ interface RequestWithUser {
   user: TCurrentUser;
 }
 
-@ApiTags('Fayda Verification')
-@Controller('fayda/verification')
-@Throttle({ auth: { limit: 5, ttl: 60_000 } })
+@ApiTags("Fayda Verification")
+@Controller("fayda/verification")
+// @Throttle({ auth: { limit: 5, ttl: 60_000 } })
 export class VerifaydaController {
   constructor(private readonly service: VerifaydaService) {}
 
-  @Post('start')
+  @Post("start")
   @IsPublic()
   @HttpCode(HttpStatus.OK)
   @UseGuards(OptionalJwtGuard)
-  @ApiBearerAuth('JWT-auth')
+  @ApiBearerAuth("JWT-auth")
   @ApiOperation({
-    summary: 'Start a VeriFayda 2.0 verification session',
+    summary: "Start a VeriFayda 2.0 verification session",
     description: `Creates a verification session and returns the eSignet authorize URL the frontend should send the user to.
 
 - Works for **logged-in users** and **guests**. If a valid bearer token is present, the verification is tied to that user.
@@ -58,11 +57,11 @@ export class VerifaydaController {
 - The returned \`authorizationUrl\` already carries the PKCE \`code_challenge\`, CSRF \`state\`, requested \`claims\`, and \`code_challenge_method=S256\`. The frontend simply navigates to it (full page or popup).`,
   })
   @ApiOkResponse({
-    description: 'Authorize URL the frontend should redirect the user to.',
+    description: "Authorize URL the frontend should redirect the user to.",
     schema: {
       example: {
         authorizationUrl:
-          'https://esignet.example.com/authorize?client_id=...&state=...&code_challenge=...',
+          "https://esignet.example.com/authorize?client_id=...&state=...&code_challenge=...",
       },
     },
   })
@@ -71,18 +70,19 @@ export class VerifaydaController {
     @Req() req: RequestWithOptionalUser,
   ): Promise<{ authorizationUrl: string }> {
     const authorizationUrl = await this.service.startVerification({
-      purpose: dto.purpose ?? 'VERIFY',
-      platform: dto.platform ?? 'WEB',
+      purpose: dto.purpose ?? "VERIFY",
+      platform: dto.platform ?? "WEB",
       userId: req.user?.id,
       wantsPasswordSetup: dto.wantsPasswordSetup ?? false,
     });
     return { authorizationUrl };
   }
 
-  @Get('complete')
+  @Get("complete")
   @IsPublic()
   @ApiOperation({
-    summary: 'Complete a verification (Fayda redirect / client callback lands here)',
+    summary:
+      "Complete a verification (Fayda redirect / client callback lands here)",
     description: `This is the registered Fayda \`redirect_uri\`. Fayda redirects the browser here with \`?code&state\``,
   })
   @ApiOkResponse({ type: CompleteVerificationResultDto })
@@ -92,18 +92,16 @@ export class VerifaydaController {
     return this.service.completeVerification(dto);
   }
 
-  @Get('status')
+  @Get("status")
   @UseGuards(JwtGuard)
-  @ApiBearerAuth('JWT-auth')
+  @ApiBearerAuth("JWT-auth")
   @ApiOperation({
     summary: "Get the current user's Fayda verification status",
     description:
-      'Returns whether the authenticated user has linked a verified Fayda identity to their account, when, and the name on file.',
+      "Returns whether the authenticated user has linked a verified Fayda identity to their account, when, and the name on file.",
   })
   @ApiOkResponse({ type: VerificationStatusDto })
-  async status(
-    @Req() req: RequestWithUser,
-  ): Promise<VerificationStatusDto> {
+  async status(@Req() req: RequestWithUser): Promise<VerificationStatusDto> {
     return this.service.getVerificationStatus(req.user.id);
   }
 }
diff --git a/apps/edr-passenger-api/src/modules/wallet/wallet.controller.ts b/apps/edr-passenger-api/src/modules/wallet/wallet.controller.ts
index 8b0c5ed2e..d539203f1 100644
--- a/apps/edr-passenger-api/src/modules/wallet/wallet.controller.ts
+++ b/apps/edr-passenger-api/src/modules/wallet/wallet.controller.ts
@@ -1,18 +1,46 @@
-import { Body, Controller, Get, Param, Post, Delete, UseGuards, SetMetadata, Query } from '@nestjs/common';
-import { ApiTags, ApiOperation, ApiBearerAuth } from '@nestjs/swagger';
-import { Throttle } from '@nestjs/throttler';
-import { WalletService } from './wallet.service';
-import { JwtGuard } from '../../common/jwt.guard';
+import {
+  Body,
+  Controller,
+  Get,
+  Param,
+  Post,
+  Delete,
+  UseGuards,
+  SetMetadata,
+  Query,
+} from "@nestjs/common";
+import { ApiTags, ApiOperation, ApiBearerAuth } from "@nestjs/swagger";
+import { WalletService } from "./wallet.service";
+import { JwtGuard } from "../../common/jwt.guard";
 
-@ApiTags('Wallet')
-@Controller('wallet')
+@ApiTags("Wallet")
+@Controller("wallet")
 @UseGuards(JwtGuard)
-@ApiBearerAuth('JWT-auth')
-@Throttle({ strict: { limit: 20, ttl: 60_000 } })
+@ApiBearerAuth("JWT-auth")
+// @Throttle({ strict: { limit: 20, ttl: 60_000 } })
 export class WalletController {
   constructor(private service: WalletService) {}
-  @Get('accounts')              @SetMetadata('isPublic', true) @ApiOperation({ summary: 'List all wallet accounts' })      getAccounts(@Query() q: any) { return this.service.getAccounts(q); }
-  @Get(':passengerId')          @ApiOperation({ summary: 'Get wallet balance and ledger' })                                  getWallet(@Param('passengerId') id: string) { return this.service.getWallet(id); }
-  @Post(':passengerId/topup')   @ApiOperation({ summary: 'Top up wallet' })                                                  topUp(@Param('passengerId') id: string, @Body('amountMinor') amount: number) { return this.service.topUp(id, amount); }
-  @Delete('accounts/:id')       @SetMetadata('isPublic', true) @ApiOperation({ summary: 'Delete wallet account' })          deleteAccount(@Param('id') id: string) { return this.service.deleteAccount(id); }
+  @Get("accounts")
+  @SetMetadata("isPublic", true)
+  @ApiOperation({ summary: "List all wallet accounts" })
+  getAccounts(@Query() q: any) {
+    return this.service.getAccounts(q);
+  }
+  @Get(":passengerId")
+  @ApiOperation({ summary: "Get wallet balance and ledger" })
+  getWallet(@Param("passengerId") id: string) {
+    return this.service.getWallet(id);
+  }
+  @Post(":passengerId/topup") @ApiOperation({ summary: "Top up wallet" }) topUp(
+    @Param("passengerId") id: string,
+    @Body("amountMinor") amount: number,
+  ) {
+    return this.service.topUp(id, amount);
+  }
+  @Delete("accounts/:id")
+  @SetMetadata("isPublic", true)
+  @ApiOperation({ summary: "Delete wallet account" })
+  deleteAccount(@Param("id") id: string) {
+    return this.service.deleteAccount(id);
+  }
 }
diff --git a/apps/edr-passenger-web/portal/src/app/about/layout.tsx b/apps/edr-passenger-web/portal/src/app/about/layout.tsx
new file mode 100644
index 000000000..a7bb1b25d
--- /dev/null
+++ b/apps/edr-passenger-web/portal/src/app/about/layout.tsx
@@ -0,0 +1,21 @@
+import type { Metadata } from 'next';
+
+export const metadata: Metadata = {
+  title: 'About EDR – Connecting East Africa by Rail',
+  description:
+    'Learn about the Ethio-Djibouti Railway (EDR): our mission to connect Ethiopia and Djibouti with comfortable, affordable, and sustainable train travel.',
+  alternates: {
+    canonical: '/about',
+  },
+  openGraph: {
+    title: 'About EDR – Connecting East Africa by Rail',
+    description:
+      'Our mission is to provide reliable, affordable, and comfortable train travel connecting Ethiopia and Djibouti.',
+    url: '/about',
+    images: [{ url: '/edr-banner.jpg', width: 1200, height: 630, alt: 'EDR Railway – About Us' }],
+  },
+};
+
+export default function AboutLayout({ children }: { children: React.ReactNode }) {
+  return children;
+}
diff --git a/apps/edr-passenger-web/portal/src/app/booking/auth-check/page.tsx b/apps/edr-passenger-web/portal/src/app/booking/auth-check/page.tsx
index 43775b1c7..9e1cdc9c9 100644
--- a/apps/edr-passenger-web/portal/src/app/booking/auth-check/page.tsx
+++ b/apps/edr-passenger-web/portal/src/app/booking/auth-check/page.tsx
@@ -81,20 +81,6 @@ export default function AuthCheckPage() {
         </p>
 
         <div className="flex flex-col gap-3">
-          <Tooltip content={[
-            'Saved passenger details',
-            'View booking history',
-            'Faster future bookings',
-          ]}>
-            <button
-              onClick={() => router.push('/login?redirect=/booking/passengers')}
-              className="w-full flex items-center justify-center gap-2.5 px-5 py-3.5 bg-primary hover:bg-primary/90 active:scale-[0.98] text-white font-semibold rounded-xl transition-all shadow-md shadow-primary/20"
-            >
-              <LogIn className="w-5 h-5 flex-shrink-0" />
-              Sign in
-            </button>
-          </Tooltip>
-
           <Tooltip content={[
             'No account required',
             'Quick checkout',
@@ -102,12 +88,26 @@ export default function AuthCheckPage() {
           ]}>
             <button
               onClick={() => router.push('/booking/passengers')}
-              className="w-full flex items-center justify-center gap-2.5 px-5 py-3.5 bg-white dark:bg-gray-800 hover:bg-gray-50 dark:hover:bg-gray-700 active:scale-[0.98] text-gray-800 dark:text-gray-100 font-semibold rounded-xl border border-gray-200 dark:border-gray-700 transition-all shadow-sm"
+              className="w-full flex items-center justify-center gap-2.5 px-5 py-3.5 bg-primary hover:bg-primary/90 active:scale-[0.98] text-white font-semibold rounded-xl transition-all shadow-md shadow-primary/20"
             >
               <UserPlus className="w-5 h-5 flex-shrink-0" />
               Continue as guest
             </button>
           </Tooltip>
+
+          <Tooltip content={[
+            'Saved passenger details',
+            'View booking history',
+            'Faster future bookings',
+          ]}>
+            <button
+              onClick={() => router.push('/login?redirect=/booking/passengers')}
+              className="w-full flex items-center justify-center gap-2.5 px-5 py-3.5 bg-white dark:bg-gray-800 hover:bg-gray-50 dark:hover:bg-gray-700 active:scale-[0.98] text-gray-800 dark:text-gray-100 font-semibold rounded-xl border border-gray-200 dark:border-gray-700 transition-all shadow-sm"
+            >
+              <LogIn className="w-5 h-5 flex-shrink-0" />
+              SignIn or Register
+            </button>
+          </Tooltip>
         </div>
 
         <div className="mt-8 text-center">
diff --git a/apps/edr-passenger-web/portal/src/app/booking/detail/page.tsx b/apps/edr-passenger-web/portal/src/app/booking/detail/page.tsx
index 7aef411e6..6442fd0d6 100644
--- a/apps/edr-passenger-web/portal/src/app/booking/detail/page.tsx
+++ b/apps/edr-passenger-web/portal/src/app/booking/detail/page.tsx
@@ -39,6 +39,35 @@ const getIconForMethod = (methodType: string) => {
   return Smartphone;
 };
 
+function SeatDetailsGrid({
+  seat,
+}: {
+  seat?: { coach?: string; number?: string; seatClass?: string };
+}) {
+  return (
+    <div className="grid grid-cols-2 gap-3 text-sm">
+      <div>
+        <span className="text-gray-500 dark:text-gray-400">Coach:</span>
+        <div className="font-mono font-semibold text-gray-900 dark:text-white">
+          {seat?.coach || "N/A"}
+        </div>
+      </div>
+      <div>
+        <span className="text-gray-500 dark:text-gray-400">Seat Number:</span>
+        <div className="font-semibold text-gray-900 dark:text-white">
+          {seat?.number || "N/A"}
+        </div>
+      </div>
+      <div className="col-span-2">
+        <span className="text-gray-500 dark:text-gray-400">Class:</span>
+        <div className="font-medium text-gray-900 dark:text-white">
+          {seat?.seatClass || "N/A"}
+        </div>
+      </div>
+    </div>
+  );
+}
+
 function BookingDetailContent() {
   const router = useRouter();
   const searchParams = useSearchParams();
@@ -311,18 +340,22 @@ function BookingDetailContent() {
   };
 
   // /bookings/:ref returns one row per passenger PER LEG for round trips (leg 1 =
-  // outbound, leg 2 = return) — /booking/payment's fare breakdown, by contrast, shows one
-  // combined row per passenger with an Outbound/Return sub-split. Group leg rows back
-  // together here so both pages present the same per-passenger total, not a doubled list
-  // of half-fare rows.
+  // outbound, leg 2 = return), each carrying that leg's own seat assignment —
+  // /booking/payment's fare breakdown, by contrast, shows one combined row per
+  // passenger with an Outbound/Return sub-split. Group leg rows back together here —
+  // by identity, not by row — so every consumer (fare breakdown, passenger/seat list)
+  // sees one entry per real passenger with both legs' seats attached, not a doubled
+  // list of half-passenger rows.
   const isRoundTripBooking = booking.bookingType === "ROUND_TRIP";
-  const farePassengers = (() => {
+  const groupedPassengers = (() => {
     const rows: any[] = booking.passengers || [];
     if (!isRoundTripBooking) {
       return rows.map((p) => ({
         fullName: p.fullName,
         category: p.category,
         fareMinor: p.fareMinor ?? 0,
+        outboundSeat: p.seat,
+        returnSeat: undefined as any,
       }));
     }
     const grouped = new Map<
@@ -332,6 +365,8 @@ function BookingDetailContent() {
         category: string;
         outboundFareMinor: number;
         returnFareMinor: number;
+        outboundSeat?: any;
+        returnSeat?: any;
       }
     >();
     rows.forEach((p) => {
@@ -341,9 +376,16 @@ function BookingDetailContent() {
         category: p.category,
         outboundFareMinor: 0,
         returnFareMinor: 0,
+        outboundSeat: undefined,
+        returnSeat: undefined,
       };
-      if (p.leg === 2) entry.returnFareMinor = p.fareMinor ?? 0;
-      else entry.outboundFareMinor = p.fareMinor ?? 0;
+      if (p.leg === 2) {
+        entry.returnFareMinor = p.fareMinor ?? 0;
+        entry.returnSeat = p.seat;
+      } else {
+        entry.outboundFareMinor = p.fareMinor ?? 0;
+        entry.outboundSeat = p.seat;
+      }
       grouped.set(key, entry);
     });
     return Array.from(grouped.values()).map((p) => ({
@@ -352,6 +394,8 @@ function BookingDetailContent() {
       fareMinor: p.outboundFareMinor + p.returnFareMinor,
       outboundFareMinor: p.outboundFareMinor,
       returnFareMinor: p.returnFareMinor,
+      outboundSeat: p.outboundSeat,
+      returnSeat: p.returnSeat,
     }));
   })();
 
@@ -374,7 +418,7 @@ function BookingDetailContent() {
         <h3 className="text-sm font-bold text-gray-900 dark:text-gray-100">
           Fare breakdown
         </h3>
-        {farePassengers.map((passenger: any, idx: number) => {
+        {groupedPassengers.map((passenger: any, idx: number) => {
           const isChildPassenger = passenger.category === "CHILD";
           const isFreeChild =
             isChildPassenger && (passenger.fareMinor ?? 0) === 0;
@@ -1035,69 +1079,77 @@ function BookingDetailContent() {
 
             <div className="bg-white dark:bg-gray-800 rounded-2xl p-6 border border-gray-200 dark:border-gray-700">
               <h2 className="text-lg font-bold text-gray-900 dark:text-white mb-4">
-                Passenger Details ({booking.passengers?.length || 0})
+                Passenger Details ({groupedPassengers.length})
               </h2>
 
               <div className="space-y-4">
-                {booking.passengers?.map((passenger: any, idx: number) => (
+                {groupedPassengers.map((passenger: any, idx: number) => (
                   <div
                     key={idx}
-                    className="border border-gray-200 dark:border-gray-700 rounded-xl p-4"
+                    className="border border-gray-200 dark:border-gray-700 rounded-xl p-4 space-y-4"
                   >
-                    <div className="flex flex-col md:flex-row md:items-center gap-4">
-                      <div className="flex-1">
-                        <div className="flex items-center gap-2 mb-2">
-                          <span className="w-6 h-6 bg-primary text-white rounded-full flex items-center justify-center text-xs font-bold">
-                            {idx + 1}
-                          </span>
-                          <h3 className="font-bold text-gray-900 dark:text-white">
-                            {passenger.fullName}
-                          </h3>
-                          <span className="text-xs px-2 py-1 bg-gray-100 dark:bg-gray-700 text-gray-600 dark:text-gray-400 rounded-full">
-                            {passenger.category}
-                          </span>
-                        </div>
-
-                        <div className="grid grid-cols-2 gap-3 text-sm">
-                          <div>
-                            <span className="text-gray-500 dark:text-gray-400">
-                              Coach:
-                            </span>
-                            <div className="font-mono font-semibold text-gray-900 dark:text-white">
-                              {passenger.seat?.coach || "N/A"}
-                            </div>
-                          </div>
-                          <div>
-                            <span className="text-gray-500 dark:text-gray-400">
-                              Seat Number:
-                            </span>
-                            <div className="font-semibold text-gray-900 dark:text-white">
-                              {passenger.seat?.number || "N/A"}
-                            </div>
-                          </div>
-                          <div className="col-span-2">
-                            <span className="text-gray-500 dark:text-gray-400">
-                              Class:
-                            </span>
-                            <div className="font-medium text-gray-900 dark:text-white">
-                              {passenger.seat?.seatClass || "N/A"}
-                            </div>
-                          </div>
-                        </div>
-                      </div>
-
-                      {isConfirmed && (
-                        <div className="flex-shrink-0">
-                          <div className="bg-white p-3 rounded-lg border-2 border-gray-200">
-                            <QRCode
-                              value={`TICKET:${booking.bookingRef}-${passenger.seat?.id || idx}`}
-                              size={80}
-                              level="M"
-                            />
-                          </div>
-                        </div>
-                      )}
+                    <div className="flex items-center gap-2">
+                      <span className="w-6 h-6 bg-primary text-white rounded-full flex items-center justify-center text-xs font-bold">
+                        {idx + 1}
+                      </span>
+                      <h3 className="font-bold text-gray-900 dark:text-white">
+                        {passenger.fullName}
+                      </h3>
+                      <span className="text-xs px-2 py-1 bg-gray-100 dark:bg-gray-700 text-gray-600 dark:text-gray-400 rounded-full">
+                        {passenger.category}
+                      </span>
                     </div>
+
+                    {isRoundTripBooking ? (
+                      <div className="grid gap-4 md:grid-cols-2">
+                        {(
+                          [
+                            { legLabel: "Outbound", seat: passenger.outboundSeat },
+                            { legLabel: "Return", seat: passenger.returnSeat },
+                          ] as const
+                        ).map(({ legLabel, seat }) => (
+                          <div
+                            key={legLabel}
+                            className="flex items-center gap-4 pt-3 border-t border-gray-100 dark:border-gray-800 first:border-t-0 first:pt-0 md:border-t-0 md:pt-0"
+                          >
+                            <div className="flex-1">
+                              <span className="inline-block mb-2 text-xs font-semibold px-2 py-0.5 rounded-full bg-primary/10 text-primary">
+                                {legLabel}
+                              </span>
+                              <SeatDetailsGrid seat={seat} />
+                            </div>
+                            {isConfirmed && (
+                              <div className="flex-shrink-0">
+                                <div className="bg-white p-3 rounded-lg border-2 border-gray-200">
+                                  <QRCode
+                                    value={`TICKET:${booking.bookingRef}-${seat?.id || `${idx}-${legLabel}`}`}
+                                    size={72}
+                                    level="M"
+                                  />
+                                </div>
+                              </div>
+                            )}
+                          </div>
+                        ))}
+                      </div>
+                    ) : (
+                      <div className="flex flex-col md:flex-row md:items-center gap-4">
+                        <div className="flex-1">
+                          <SeatDetailsGrid seat={passenger.outboundSeat} />
+                        </div>
+                        {isConfirmed && (
+                          <div className="flex-shrink-0">
+                            <div className="bg-white p-3 rounded-lg border-2 border-gray-200">
+                              <QRCode
+                                value={`TICKET:${booking.bookingRef}-${passenger.outboundSeat?.id || idx}`}
+                                size={80}
+                                level="M"
+                              />
+                            </div>
+                          </div>
+                        )}
+                      </div>
+                    )}
                   </div>
                 ))}
               </div>
diff --git a/apps/edr-passenger-web/portal/src/app/booking/passengers/page.tsx b/apps/edr-passenger-web/portal/src/app/booking/passengers/page.tsx
index 4639bd196..7dccc7bdf 100644
--- a/apps/edr-passenger-web/portal/src/app/booking/passengers/page.tsx
+++ b/apps/edr-passenger-web/portal/src/app/booking/passengers/page.tsx
@@ -993,8 +993,21 @@ function PassengersForm() {
 
   const onInvalid = () => {
     // Sections still behind the Fayda verify screen stay collapsed here — they only expand
-    // when the user explicitly clicks "Skip for now" / "Enter details manually".
-    setSubmitError('Please fix the highlighted errors before continuing.');
+    // when the user explicitly clicks "Enter details manually" (shown only when Fayda is
+    // unavailable). Their name/DOB/gender fields are still empty at this point, which would
+    // otherwise surface as a generic "fix the highlighted errors" message that doesn't point
+    // at the actual cause — tell the user to verify with Fayda instead.
+    const needsFaydaVerification = passengers.some((p, i) => {
+      const isEthiopian = p?.nationality === 'ETHIOPIAN';
+      const isChildPassenger = i >= adultCount;
+      const isLoggedInAndVerified = i === 0 && isAuthenticated && user?.faydaVerified;
+      return isEthiopian && faydaEnabled && !p?.formExpanded && !isLoggedInAndVerified && !isChildPassenger;
+    });
+    setSubmitError(
+      needsFaydaVerification
+        ? 'Please verify your identity with Fayda before continuing — tap "Verify with Fayda" above to proceed.'
+        : 'Please fix the highlighted errors before continuing.'
+    );
   };
 
   const onSubmit = async (data: FormData) => {
@@ -1153,14 +1166,14 @@ function PassengersForm() {
                           Finish verifying Passenger {(verifyingIndex ?? 0) + 1} first
                         </p>
                       )}
-                      <button
+                      {/* <button
                         type="button"
                         onClick={() => toggleForm(index)}
                         disabled={isVerifyingThis}
                         className="text-sm text-gray-500 dark:text-gray-400 hover:underline mt-3 block mx-auto disabled:opacity-50 disabled:cursor-not-allowed"
                       >
                         Skip for now
-                      </button>
+                      </button> */}
                     </div>
                   ) : showManualEntryLink ? (
                     <div className="text-center py-8">
diff --git a/apps/edr-passenger-web/portal/src/app/contact/layout.tsx b/apps/edr-passenger-web/portal/src/app/contact/layout.tsx
new file mode 100644
index 000000000..3a5c61836
--- /dev/null
+++ b/apps/edr-passenger-web/portal/src/app/contact/layout.tsx
@@ -0,0 +1,21 @@
+import type { Metadata } from 'next';
+
+export const metadata: Metadata = {
+  title: 'Contact EDR – Get in Touch',
+  description:
+    'Contact the Ethio-Djibouti Railway (EDR) support team. We are available to assist with your train journey.',
+  alternates: {
+    canonical: '/contact',
+  },
+  openGraph: {
+    title: 'Contact EDR – Get in Touch',
+    description:
+      'Reach the EDR support team by phone, email, or in person. We are available to assist with your train journey.',
+    url: '/contact',
+    images: [{ url: '/edr-banner.jpg', width: 1200, height: 630, alt: 'EDR Railway – Contact Us' }],
+  },
+};
+
+export default function ContactLayout({ children }: { children: React.ReactNode }) {
+  return children;
+}
diff --git a/apps/edr-passenger-web/portal/src/app/guide/layout.tsx b/apps/edr-passenger-web/portal/src/app/guide/layout.tsx
new file mode 100644
index 000000000..417c46cf3
--- /dev/null
+++ b/apps/edr-passenger-web/portal/src/app/guide/layout.tsx
@@ -0,0 +1,28 @@
+import type { Metadata } from 'next';
+
+export const metadata: Metadata = {
+  title: 'How to Book a Train Ticket – EDR Step-by-Step Guide',
+  description:
+    'Step-by-step guide to booking an EDR train ticket online: search trains, select your seat class, enter passenger details, and complete payment.',
+  alternates: {
+    canonical: '/guide',
+  },
+  openGraph: {
+    title: 'How to Book a Train Ticket – EDR Step-by-Step Guide',
+    description:
+      'Follow our simple guide to book your EDR train journey in minutes.',
+    url: '/guide',
+    images: [
+      {
+        url: '/edr-banner.jpg',
+        width: 1200,
+        height: 630,
+        alt: 'EDR Railway – How to Book a Train Ticket',
+      },
+    ],
+  },
+};
+
+export default function GuideLayout({ children }: { children: React.ReactNode }) {
+  return children;
+}
diff --git a/apps/edr-passenger-web/portal/src/app/help/layout.tsx b/apps/edr-passenger-web/portal/src/app/help/layout.tsx
new file mode 100644
index 000000000..0211d6d23
--- /dev/null
+++ b/apps/edr-passenger-web/portal/src/app/help/layout.tsx
@@ -0,0 +1,23 @@
+import type { Metadata } from 'next';
+
+export const metadata: Metadata = {
+  title: 'Help & FAQs – EDR Train Booking',
+  description:
+    'Find answers to common questions about booking EDR train tickets: how to book, passenger pricing, identity verification, seat classes, payment methods, and more.',
+  alternates: {
+    canonical: '/help',
+  },
+  openGraph: {
+    title: 'Help & FAQs – EDR Train Booking',
+    description:
+      'Answers to your questions about booking EDR train tickets, payment methods, identity verification, and seat selection.',
+    url: '/help',
+    images: [
+      { url: '/edr-banner.jpg', width: 1200, height: 630, alt: 'EDR Railway – Help & FAQs' },
+    ],
+  },
+};
+
+export default function HelpLayout({ children }: { children: React.ReactNode }) {
+  return children;
+}
diff --git a/apps/edr-passenger-web/portal/src/app/layout.tsx b/apps/edr-passenger-web/portal/src/app/layout.tsx
index 7e6049956..7337c18d6 100644
--- a/apps/edr-passenger-web/portal/src/app/layout.tsx
+++ b/apps/edr-passenger-web/portal/src/app/layout.tsx
@@ -7,10 +7,61 @@ import MobileTopBar from '@/components/MobileTopBar';
 import BottomTabBar from '@/components/BottomTabBar';
 import { LoadingIndicator } from '@/components/LoadingIndicator';
 import SupportWidget from '@/features/support/SupportWidgetLazy';
+import { JsonLd } from '@/components/JsonLd';
+
+const siteUrl = process.env.NEXT_PUBLIC_SITE_URL ?? 'https://passenger.edrsc.com';
 
 export const metadata: Metadata = {
-  title: 'EDR Passenger Portal - Book your train journey',
-  description: 'Book train tickets on the Ethio-Djibouti Railway',
+  metadataBase: new URL(siteUrl),
+  title: {
+    default: 'EDR Passenger Portal – Book Train Tickets Online',
+    template: '%s | EDR Passenger Portal',
+  },
+  description:
+    'Book train tickets on the Ethio-Djibouti Railway. Travel between Ethiopia and Djibouti with easy online booking, seat selection, and multiple payment options.',
+  authors: [{ name: 'EDR – Ethio-Djibouti Railway' }],
+  creator: 'EDR – Ethio-Djibouti Railway',
+  publisher: 'EDR – Ethio-Djibouti Railway',
+  robots: {
+    index: true,
+    follow: true,
+    googleBot: {
+      index: true,
+      follow: true,
+      'max-snippet': -1,
+      'max-image-preview': 'large',
+      'max-video-preview': -1,
+    },
+  },
+  openGraph: {
+    type: 'website',
+    locale: 'en_US',
+    url: siteUrl,
+    siteName: 'EDR Passenger Portal',
+    title: 'EDR Passenger Portal – Book Train Tickets Online',
+    description:
+      'Book train tickets on the Ethio-Djibouti Railway. Comfortable seats, flexible payment options, and easy online booking.',
+    images: [
+      {
+        url: '/edr-banner.jpg',
+        width: 1200,
+        height: 630,
+        alt: 'EDR Ethio-Djibouti Railway – Book your train journey',
+      },
+    ],
+  },
+  twitter: {
+    card: 'summary_large_image',
+    title: 'EDR Passenger Portal – Book Train Tickets Online',
+    description:
+      'Book train tickets on the Ethio-Djibouti Railway. Comfortable seats, flexible payment options, and easy online booking.',
+    images: ['/edr-banner.jpg'],
+  },
+  icons: {
+    icon: '/edr-logo.png',
+    shortcut: '/edr-logo.png',
+    apple: '/edr-logo.png',
+  },
 };
 
 // viewportFit: 'cover' lets fixed bottom bars (e.g. the payment page's Pay
@@ -29,8 +80,48 @@ export default function RootLayout({
 }) {
   // Nonce set per-request by middleware; required for this inline script under the CSP.
   const nonce = headers().get('x-nonce') ?? undefined;
+
+  const organizationSchema = {
+    '@context': 'https://schema.org',
+    '@type': 'Organization',
+    name: 'Ethio-Djibouti Railway (EDR)',
+    url: siteUrl,
+    logo: `${siteUrl}/edr-logo.png`,
+    contactPoint: {
+      '@type': 'ContactPoint',
+      telephone: '9546',
+      contactType: 'customer service',
+      availableLanguage: ['English', 'Amharic'],
+    },
+    address: {
+      '@type': 'PostalAddress',
+      addressLocality: 'Addis Ababa',
+      addressCountry: 'ET',
+    },
+    sameAs: [],
+  };
+
+  const websiteSchema = {
+    '@context': 'https://schema.org',
+    '@type': 'WebSite',
+    name: 'EDR Passenger Portal',
+    url: siteUrl,
+    potentialAction: {
+      '@type': 'SearchAction',
+      target: {
+        '@type': 'EntryPoint',
+        urlTemplate: `${siteUrl}/booking/search?q={search_term_string}`,
+      },
+      'query-input': 'required name=search_term_string',
+    },
+  };
+
   return (
-    <html lang="en" suppressHydrationWarning>
+    <html lang="en" dir="ltr" suppressHydrationWarning>
+      <head>
+        <JsonLd data={organizationSchema} />
+        <JsonLd data={websiteSchema} />
+      </head>
       <body className="font-sans antialiased">
         <script
           nonce={nonce}
diff --git a/apps/edr-passenger-web/portal/src/app/packages/[id]/layout.tsx b/apps/edr-passenger-web/portal/src/app/packages/[id]/layout.tsx
new file mode 100644
index 000000000..0fc5b84e3
--- /dev/null
+++ b/apps/edr-passenger-web/portal/src/app/packages/[id]/layout.tsx
@@ -0,0 +1,80 @@
+import type { Metadata } from 'next';
+
+interface PackageSummary {
+  id: string;
+  name: string;
+  description?: string | null;
+  outboundSchedule?: {
+    originStation?: { name?: string };
+    destinationStation?: { name?: string };
+  };
+}
+
+/**
+ * Fetch a minimal package summary server-side so we can generate per-package
+ * metadata without requiring the page itself to be a Server Component.
+ * Errors are swallowed so the page still renders even if the API is unreachable
+ * at build/request time.
+ */
+async function fetchPackageSummary(id: string): Promise<PackageSummary | null> {
+  try {
+    const apiUrl = process.env.NEXT_PUBLIC_API_URL ?? 'http://localhost:4000';
+    const res = await fetch(`${apiUrl}/packages/${id}`, {
+      next: { revalidate: 3600 },
+    });
+    if (!res.ok) return null;
+    return await res.json();
+  } catch {
+    return null;
+  }
+}
+
+export async function generateMetadata({
+  params,
+}: {
+  params: { id: string };
+}): Promise<Metadata> {
+  const pkg = await fetchPackageSummary(params.id);
+
+  if (!pkg) {
+    return {
+      title: 'Train Package – EDR',
+      description:
+        'View details and book this Ethio-Djibouti Railway travel package with seat selection and flexible payment options.',
+      robots: { index: true, follow: true },
+    };
+  }
+
+  const origin = pkg.outboundSchedule?.originStation?.name?.trim();
+  const destination = pkg.outboundSchedule?.destinationStation?.name?.trim();
+  const routeLabel = origin && destination ? ` – ${origin} to ${destination}` : '';
+  const title = `${pkg.name}${routeLabel} | EDR`;
+  const description =
+    pkg.description?.trim() ||
+    `Book the "${pkg.name}" train package on the Ethio-Djibouti Railway${routeLabel ? ` (${origin} → ${destination})` : ''}. Choose your seat class and complete payment online.`;
+
+  return {
+    title,
+    description,
+    alternates: {
+      canonical: `/packages/${params.id}`,
+    },
+    openGraph: {
+      title,
+      description,
+      url: `/packages/${params.id}`,
+      images: [
+        {
+          url: '/edr-banner.jpg',
+          width: 1200,
+          height: 630,
+          alt: `EDR Railway – ${pkg.name}`,
+        },
+      ],
+    },
+  };
+}
+
+export default function PackageDetailLayout({ children }: { children: React.ReactNode }) {
+  return children;
+}
diff --git a/apps/edr-passenger-web/portal/src/app/packages/layout.tsx b/apps/edr-passenger-web/portal/src/app/packages/layout.tsx
new file mode 100644
index 000000000..ca307ed18
--- /dev/null
+++ b/apps/edr-passenger-web/portal/src/app/packages/layout.tsx
@@ -0,0 +1,23 @@
+import type { Metadata } from 'next';
+
+export const metadata: Metadata = {
+  title: 'Train Journey Packages – EDR',
+  description:
+    'Browse curated Ethio-Djibouti Railway travel packages. Choose from one-way and round-trip options with a range of seat classes at competitive fares.',
+  alternates: {
+    canonical: '/packages',
+  },
+  openGraph: {
+    title: 'Train Journey Packages – EDR',
+    description:
+      'Curated one-way and round-trip train packages on the Ethio-Djibouti Railway with multiple seat classes and flexible payment options.',
+    url: '/packages',
+    images: [
+      { url: '/edr-banner.jpg', width: 1200, height: 630, alt: 'EDR Railway – Travel Packages' },
+    ],
+  },
+};
+
+export default function PackagesLayout({ children }: { children: React.ReactNode }) {
+  return children;
+}
diff --git a/apps/edr-passenger-web/portal/src/app/page.tsx b/apps/edr-passenger-web/portal/src/app/page.tsx
index f77e7291d..4b6d470b2 100644
--- a/apps/edr-passenger-web/portal/src/app/page.tsx
+++ b/apps/edr-passenger-web/portal/src/app/page.tsx
@@ -1,8 +1,25 @@
 import { Suspense } from 'react';
+import type { Metadata } from 'next';
 import dynamic from 'next/dynamic';
 import { dehydrate, HydrationBoundary, QueryClient } from '@tanstack/react-query';
 import SearchPage from '@/app/booking/search/page';
 
+export const metadata: Metadata = {
+  title: 'EDR Passenger Portal – Book Train Tickets Online',
+  description:
+    'Book train tickets on the Ethio-Djibouti Railway. Search trains between Ethiopia and Djibouti with easy online booking, seat selection, and flexible payment options.',
+  alternates: {
+    canonical: '/',
+  },
+  openGraph: {
+    title: 'EDR Passenger Portal – Book Train Tickets Online',
+    description:
+      'Search and book train tickets across the Ethio-Djibouti Railway. Multiple seat classes available.',
+    url: '/',
+    type: 'website',
+  },
+};
+
 // Below-the-fold on the landing page — code-split out of the initial bundle
 // needed to render/hydrate the (above-the-fold) search form.
 const PackagesSection = dynamic(() => import('@/components/PackagesSection'));
diff --git a/apps/edr-passenger-web/portal/src/app/robots.ts b/apps/edr-passenger-web/portal/src/app/robots.ts
new file mode 100644
index 000000000..d72be41c1
--- /dev/null
+++ b/apps/edr-passenger-web/portal/src/app/robots.ts
@@ -0,0 +1,37 @@
+import type { MetadataRoute } from 'next';
+
+export default function robots(): MetadataRoute.Robots {
+  const baseUrl = process.env.NEXT_PUBLIC_SITE_URL ?? 'https://passenger.edrsc.com';
+
+  return {
+    rules: [
+      {
+        userAgent: '*',
+        allow: [
+          '/',
+          '/about',
+          '/contact',
+          '/services',
+          '/packages',
+          '/packages/',
+          '/help',
+          '/guide',
+        ],
+        disallow: [
+          '/booking/',
+          '/login',
+          '/register',
+          '/forgot-password',
+          '/reset-password',
+          '/set-password',
+          '/verify-account',
+          '/fayda-setup',
+          '/profile',
+          '/go/',
+          '/api/',
+        ],
+      },
+    ],
+    sitemap: `${baseUrl}/sitemap.xml`,
+  };
+}
diff --git a/apps/edr-passenger-web/portal/src/app/services/layout.tsx b/apps/edr-passenger-web/portal/src/app/services/layout.tsx
new file mode 100644
index 000000000..5d380781b
--- /dev/null
+++ b/apps/edr-passenger-web/portal/src/app/services/layout.tsx
@@ -0,0 +1,23 @@
+import type { Metadata } from 'next';
+
+export const metadata: Metadata = {
+  title: 'EDR Train Services – Booking, Seats, Payments & More',
+  description:
+    'Explore all services offered by the Ethio-Djibouti Railway: easy online booking, seat selection, flexible payment options, customer support, and live train tracking.',
+  alternates: {
+    canonical: '/services',
+  },
+  openGraph: {
+    title: 'EDR Train Services – Booking, Seats, Payments & More',
+    description:
+      'Book seats, pay with your preferred method, track your train live, and get support on the Ethio-Djibouti Railway.',
+    url: '/services',
+    images: [
+      { url: '/edr-banner.jpg', width: 1200, height: 630, alt: 'EDR Railway – Our Services' },
+    ],
+  },
+};
+
+export default function ServicesLayout({ children }: { children: React.ReactNode }) {
+  return children;
+}
diff --git a/apps/edr-passenger-web/portal/src/app/sitemap.ts b/apps/edr-passenger-web/portal/src/app/sitemap.ts
new file mode 100644
index 000000000..ffe163a48
--- /dev/null
+++ b/apps/edr-passenger-web/portal/src/app/sitemap.ts
@@ -0,0 +1,59 @@
+import type { MetadataRoute } from 'next';
+
+/**
+ * Static sitemap covering all publicly indexable pages.
+ * Dynamic package pages are omitted here because they are fetched at runtime;
+ * if you want to include them, replace this with an async function that calls
+ * the packages API and maps over the results.
+ */
+export default function sitemap(): MetadataRoute.Sitemap {
+  const baseUrl = process.env.NEXT_PUBLIC_SITE_URL ?? 'https://passenger.edrsc.com';
+  const now = new Date();
+
+  const staticPages: MetadataRoute.Sitemap = [
+    {
+      url: baseUrl,
+      lastModified: now,
+      changeFrequency: 'daily',
+      priority: 1.0,
+    },
+    {
+      url: `${baseUrl}/packages`,
+      lastModified: now,
+      changeFrequency: 'daily',
+      priority: 0.9,
+    },
+    {
+      url: `${baseUrl}/services`,
+      lastModified: now,
+      changeFrequency: 'monthly',
+      priority: 0.8,
+    },
+    {
+      url: `${baseUrl}/about`,
+      lastModified: now,
+      changeFrequency: 'monthly',
+      priority: 0.7,
+    },
+    {
+      url: `${baseUrl}/help`,
+      lastModified: now,
+      changeFrequency: 'weekly',
+      priority: 0.7,
+    },
+    {
+      url: `${baseUrl}/guide`,
+      lastModified: now,
+      changeFrequency: 'monthly',
+      priority: 0.6,
+    },
+    {
+      url: `${baseUrl}/contact`,
+      lastModified: now,
+      changeFrequency: 'yearly',
+      priority: 0.5,
+    },
+  ];
+
+  return staticPages;
+}
diff --git a/apps/edr-passenger-web/portal/src/components/JsonLd.tsx b/apps/edr-passenger-web/portal/src/components/JsonLd.tsx
new file mode 100644
index 000000000..a8a94104b
--- /dev/null
+++ b/apps/edr-passenger-web/portal/src/components/JsonLd.tsx
@@ -0,0 +1,12 @@
+/**
+ * Injects JSON-LD structured data into the page <head>.
+ * Usage: <JsonLd data={{ "@context": "https://schema.org", ... }} />
+ */
+export function JsonLd({ data }: { data: Record<string, unknown> }) {
+  return (
+    <script
+      type="application/ld+json"
+      dangerouslySetInnerHTML={{ __html: JSON.stringify(data) }}
+    />
+  );
+}
diff --git a/apps/edr-passenger-web/portal/src/lib/generate-voucher.ts b/apps/edr-passenger-web/portal/src/lib/generate-voucher.ts
index 4c8f25eec..a25679d75 100644
--- a/apps/edr-passenger-web/portal/src/lib/generate-voucher.ts
+++ b/apps/edr-passenger-web/portal/src/lib/generate-voucher.ts
@@ -218,15 +218,18 @@ function drawTicketHero(doc: jsPDF, bookingRef: string, ticketNumber: string, st
     doc.addImage(qrDataUrl, 'PNG', qrCardX + qrPad, cardY + qrPad, qrSize, qrSize);
   }
 
-  return y + cardH + 10;
+  return y + cardH + 8;
 }
 
 // ─── journey card ──────────────────────────────────────────────────────────
 
 function drawJourneyLeg(doc: jsPDF, schedule: ScheduleInfo, legLabel: string | null, y: number, margin: number, pageWidth: number): number {
   const cardW = pageWidth - margin * 2;
-  const routeH = 30;
-  const trainRowH = 9;
+  // Tall enough to clear the time+date block below (topY + 22, see below) with a margin
+  // before the train sub-row's hairline — previously 30, which the date line (topY + 25)
+  // overran by several mm, printing "Wed, Jul 15" directly on top of the TRAIN row.
+  const routeH = 35;
+  const trainRowH = 8;
   const cardH = routeH + trainRowH;
 
   doc.setDrawColor(...HAIRLINE);
@@ -241,37 +244,37 @@ function drawJourneyLeg(doc: jsPDF, schedule: ScheduleInfo, legLabel: string | n
   }
 
   const padX = 8;
-  const topY = y + (legLabel ? 12 : 8);
+  const topY = y + (legLabel ? 11 : 7);
 
   // Origin block
   label(doc, 'From', margin + padX, topY);
   doc.setTextColor(...INK); doc.setFontSize(16); doc.setFont('helvetica', 'bold');
-  doc.text(schedule.origin.code, margin + padX, topY + 8);
+  doc.text(schedule.origin.code, margin + padX, topY + 7);
   doc.setTextColor(...BODY); doc.setFontSize(8.5); doc.setFont('helvetica', 'normal');
-  doc.text(schedule.origin.city || schedule.origin.name, margin + padX, topY + 13);
+  doc.text(schedule.origin.city || schedule.origin.name, margin + padX, topY + 11.5);
 
   const dep = new Date(schedule.departureAt);
   doc.setTextColor(...BRAND); doc.setFontSize(11.5); doc.setFont('helvetica', 'bold');
-  doc.text(dep.toLocaleTimeString('en-US', { hour: 'numeric', minute: '2-digit', hour12: true }), margin + padX, topY + 20.5);
+  doc.text(dep.toLocaleTimeString('en-US', { hour: 'numeric', minute: '2-digit', hour12: true }), margin + padX, topY + 18);
   doc.setTextColor(...MUTED); doc.setFontSize(7); doc.setFont('helvetica', 'normal');
-  doc.text(dep.toLocaleDateString('en-US', { weekday: 'short', month: 'short', day: 'numeric' }), margin + padX, topY + 25);
+  doc.text(dep.toLocaleDateString('en-US', { weekday: 'short', month: 'short', day: 'numeric' }), margin + padX, topY + 22);
 
   // Destination block (right-aligned)
   const dx = pageWidth - margin - padX;
   label(doc, 'To', dx, topY, { align: 'right' });
   doc.setTextColor(...INK); doc.setFontSize(16); doc.setFont('helvetica', 'bold');
-  doc.text(schedule.destination.code, dx, topY + 8, { align: 'right' });
+  doc.text(schedule.destination.code, dx, topY + 7, { align: 'right' });
   doc.setTextColor(...BODY); doc.setFontSize(8.5); doc.setFont('helvetica', 'normal');
-  doc.text(schedule.destination.city || schedule.destination.name, dx, topY + 13, { align: 'right' });
+  doc.text(schedule.destination.city || schedule.destination.name, dx, topY + 11.5, { align: 'right' });
 
   const arr = new Date(schedule.arrivalAt);
   doc.setTextColor(...BRAND); doc.setFontSize(11.5); doc.setFont('helvetica', 'bold');
-  doc.text(arr.toLocaleTimeString('en-US', { hour: 'numeric', minute: '2-digit', hour12: true }), dx, topY + 20.5, { align: 'right' });
+  doc.text(arr.toLocaleTimeString('en-US', { hour: 'numeric', minute: '2-digit', hour12: true }), dx, topY + 18, { align: 'right' });
   doc.setTextColor(...MUTED); doc.setFontSize(7); doc.setFont('helvetica', 'normal');
-  doc.text(arr.toLocaleDateString('en-US', { weekday: 'short', month: 'short', day: 'numeric' }), dx, topY + 25, { align: 'right' });
+  doc.text(arr.toLocaleDateString('en-US', { weekday: 'short', month: 'short', day: 'numeric' }), dx, topY + 22, { align: 'right' });
 
   // Dashed route line with endpoint markers, connecting the two blocks
-  const lineY = topY + 8.5;
+  const lineY = topY + 7.5;
   const lineX1 = margin + padX + 24;
   const lineX2 = dx - 24;
   doc.setDrawColor(...HAIRLINE);
@@ -283,19 +286,20 @@ function drawJourneyLeg(doc: jsPDF, schedule: ScheduleInfo, legLabel: string | n
   doc.circle(lineX1, lineY, 0.9, 'F');
   doc.circle(lineX2, lineY, 0.9, 'F');
 
-  // Train info sub-row
+  // Train info sub-row — starts at routeH, comfortably below the date line above (topY +
+  // 22, i.e. y + 33 at most) so it never overlaps the journey block's text.
   const rowY = y + routeH;
   hairline(doc, margin, rowY, margin + cardW);
   doc.setFontSize(8); doc.setTextColor(...MUTED); doc.setFont('helvetica', 'normal');
-  doc.text('TRAIN', margin + padX, rowY + 6, { charSpace: 0.3 });
+  doc.text('TRAIN', margin + padX, rowY + 5.5, { charSpace: 0.3 });
   doc.setTextColor(...INK); doc.setFont('helvetica', 'bold');
-  doc.text(schedule.trainNumber + (schedule.trainName ? `  ·  ${schedule.trainName}` : ''), margin + padX + 15, rowY + 6);
+  doc.text(schedule.trainNumber + (schedule.trainName ? `  ·  ${schedule.trainName}` : ''), margin + padX + 15, rowY + 5.5);
   if (schedule.seatClass) {
     doc.setFont('helvetica', 'normal'); doc.setTextColor(...BODY);
-    doc.text(schedule.seatClass, pageWidth - margin - padX, rowY + 6, { align: 'right' });
+    doc.text(schedule.seatClass, pageWidth - margin - padX, rowY + 5.5, { align: 'right' });
   }
 
-  return y + cardH + 8;
+  return y + cardH + 6;
 }
 
 // ─── passenger details ─────────────────────────────────────────────────────
@@ -316,7 +320,7 @@ function drawPassengerDetails(doc: jsPDF, data: PassengerVoucherData, y: number,
     rows.push(['Seat', data.seatNumber || '—']);
   }
 
-  const rowH = 8;
+  const rowH = 7;
   rows.forEach(([k, v], i) => {
     const rowY = y + i * rowH;
     doc.setFontSize(8.5); doc.setTextColor(...MUTED); doc.setFont('helvetica', 'normal');
@@ -345,7 +349,7 @@ function drawFareSummary(doc: jsPDF, fareMinor: number, currency: string, y: num
   const displayAmount = fareIsMajorUnits ? fareMinor : fareMinor / 100;
   doc.text(`${currency} ${displayAmount.toFixed(2)}`, pageWidth - margin - padX, y + 13, { align: 'right' });
 
-  return y + cardH + 8;
+  return y + cardH + 6;
 }
 
 // ─── instructions ──────────────────────────────────────────────────────────
@@ -366,15 +370,18 @@ function drawInstructions(doc: jsPDF, y: number, margin: number, pageWidth: numb
   doc.text('Present this voucher (printed or on your phone) at the terminal for boarding.', margin + padX, y + 11);
   doc.text('Please arrive at least 30 minutes before scheduled departure.', margin + padX, y + 15);
 
-  return y + cardH + 6;
+  return y + cardH + 4;
 }
 
 // ─── footer ────────────────────────────────────────────────────────────────
 
-function drawFooter(doc: jsPDF, createdAt: string): void {
+function drawFooter(doc: jsPDF, createdAt: string, contentY: number): void {
   const pageWidth  = doc.internal.pageSize.getWidth();
   const pageHeight = doc.internal.pageSize.getHeight();
-  const footerY    = pageHeight - 20;
+  // Pinned near the bottom for short (one-way) content, same as before — but grows past
+  // that floor instead of staying fixed when a round trip's extra journey card pushes
+  // content lower, which previously made the footer overlap the instructions card.
+  const footerY = Math.max(contentY + 4, pageHeight - 20);
 
   hairline(doc, PAGE_MARGIN, footerY, pageWidth - PAGE_MARGIN);
   doc.setFontSize(7.5); doc.setTextColor(...MUTED); doc.setFont('helvetica', 'normal');
@@ -395,7 +402,7 @@ async function drawPassengerVoucherPage(doc: jsPDF, data: PassengerVoucherData):
   y = drawTicketHero(doc, data.bookingRef, data.ticketNumber, data.status, qrDataUrl, y, margin, pageW);
 
   label(doc, 'Journey details', margin, y);
-  y += 7;
+  y += 6;
   y = drawJourneyLeg(doc, data.outboundSchedule, data.isRoundTrip ? 'Outbound' : null, y, margin, pageW);
 
   if (data.isRoundTrip && data.inboundSchedule) {
@@ -404,8 +411,8 @@ async function drawPassengerVoucherPage(doc: jsPDF, data: PassengerVoucherData):
 
   y = drawPassengerDetails(doc, data, y, margin, pageW);
   y = drawFareSummary(doc, data.fareMinor, data.currency, y, margin, pageW, data.fareIsMajorUnits);
-  drawInstructions(doc, y, margin, pageW);
-  drawFooter(doc, data.createdAt);
+  y = drawInstructions(doc, y, margin, pageW);
+  drawFooter(doc, data.createdAt, y);
 }
 
 /** Generates and downloads one PDF voucher for a single passenger. */
@@ -419,56 +426,97 @@ export const generatePassengerVoucherPDF = async (data: PassengerVoucherData): P
 
 // ─── legacy combined voucher (kept for backward compat) ──────────────────────
 
+interface VoucherSchedule {
+  trainNumber: string;
+  trainName?: string;
+  origin: { name: string; code: string; city: string };
+  destination: { name: string; code: string; city: string };
+  departureAt: string;
+  arrivalAt: string;
+}
+
 interface VoucherData {
   bookingRef: string;
   status: string;
-  passengers: Array<{ fullName: string; category: string; seat?: { number: string; coach: string; seatClass: string } }>;
-  schedule: { trainNumber: string; trainName?: string; origin: { name: string; code: string; city: string }; destination: { name: string; code: string; city: string }; departureAt: string; arrivalAt: string };
+  // /bookings/:ref returns one row per passenger PER LEG for round trips (leg 1 =
+  // outbound, leg 2 = return), each with that leg's own seat — see bookings.service.ts's
+  // getByRef(). dateOfBirth is included purely to disambiguate same-name passengers when
+  // grouping leg rows back into one passenger below.
+  passengers: Array<{ fullName: string; dateOfBirth?: string; category: string; leg?: number; seat?: { number: string; coach: string; seatClass: string } }>;
+  schedule: VoucherSchedule;
+  returnSchedule?: VoucherSchedule | null;
   totalMinor: number;
   currency: string;
   bookingType: string;
   createdAt: string;
-  // One ticket per passenger, matched below by passengerName — see bookings.service.ts's
-  // getByRef(). Optional/absent falls back to a client-generated placeholder number.
-  tickets?: Array<{ passengerName?: string; barcodePayload?: string }>;
+  // One ticket per passenger per leg (round trips have a separate ticket/barcode for the
+  // return leg) — matched below by passengerName + leg. Optional/absent falls back to a
+  // client-generated placeholder number.
+  tickets?: Array<{ passengerName?: string; leg?: number; barcodePayload?: string }>;
   // The actual settled amount/currency for this booking's payment — preferred over the
   // ETB booking total once available, since it reflects what was really charged.
   payment?: { amountMinor?: number; currency?: string };
 }
 
 export const generateVoucherPDF = async (booking: VoucherData): Promise<void> => {
-  // The settled payment amount, when available, is shown exactly as returned by the API
-  // (no /100, no per-passenger split) on every passenger's voucher — see fareIsMajorUnits.
+  // The amount shown is always a single raw field straight from the API — the settled
+  // payment amount when available, otherwise the booking total — never a derived value
+  // (previously this fell back to Math.round(totalMinor / passengers.length), which
+  // doesn't correspond to any real field and could disagree with what was actually
+  // charged). Same value on every passenger's voucher; no /100, no per-passenger split.
   const settledAmountMinor = booking.payment?.amountMinor;
   const settledCurrency = booking.payment?.currency;
   const useSettledAmount = settledAmountMinor != null && !!settledCurrency;
   const voucherCurrency = useSettledAmount ? settledCurrency! : booking.currency;
 
+  const isRoundTrip = booking.bookingType === 'ROUND_TRIP' && !!booking.returnSchedule;
+
+  // Group leg rows back into one entry per real passenger — without this, a round trip
+  // produced two half-passenger vouchers (one per leg, each showing only its own leg's
+  // seat) instead of one voucher per passenger covering both legs.
+  const grouped = new Map<
+    string,
+    { fullName: string; category: string; outboundSeat?: VoucherData['passengers'][number]['seat']; returnSeat?: VoucherData['passengers'][number]['seat'] }
+  >();
+  booking.passengers.forEach((p) => {
+    const key = `${p.fullName}|${p.dateOfBirth}|${p.category}`;
+    const entry = grouped.get(key) || { fullName: p.fullName, category: p.category, outboundSeat: undefined, returnSeat: undefined };
+    if (p.leg === 2) entry.returnSeat = p.seat;
+    else entry.outboundSeat = p.seat;
+    grouped.set(key, entry);
+  });
+
   // Separate file per passenger, saved back-to-back with no macrotask (setTimeout) between
   // them — a setTimeout delay here would push later saves outside the click's synchronous
   // user-activation window and risk iOS Safari silently blocking them. The awaited work
   // inside generatePassengerVoucherPDF is itself just microtasks (cached logo, QR encode),
   // which doesn't have that effect.
-  for (let i = 0; i < booking.passengers.length; i++) {
-    const p = booking.passengers[i];
+  for (const p of grouped.values()) {
+    // The displayed ticket number is always the outbound leg's — matched by leg, not just
+    // name, so a round trip doesn't end up showing whichever ticket happens to sort first.
     const matchedTicket =
-      booking.tickets?.find((t) => t.passengerName === p.fullName) ?? booking.tickets?.[i] ?? null;
+      booking.tickets?.find((t) => t.passengerName === p.fullName && (t.leg ?? 1) === 1) ??
+      booking.tickets?.find((t) => t.passengerName === p.fullName) ??
+      null;
     // No fabricated placeholder — a made-up TKT-... number reads as real and is misleading
     // if it doesn't match what's actually on file.
     const ticketNumber = matchedTicket?.barcodePayload || 'Not yet issued';
 
     await generatePassengerVoucherPDF({
-      bookingRef:        booking.bookingRef,
+      bookingRef:          booking.bookingRef,
       ticketNumber,
-      passengerName:     p.fullName,
-      seatNumber:        p.seat?.number,
-      status:            booking.status,
-      outboundSchedule:  { ...booking.schedule, seatClass: p.seat?.seatClass },
-      isRoundTrip:       false,
-      fareMinor:         useSettledAmount ? settledAmountMinor! : Math.round(booking.totalMinor / booking.passengers.length),
-      currency:          voucherCurrency,
-      fareIsMajorUnits:  useSettledAmount,
-      createdAt:         booking.createdAt,
+      passengerName:       p.fullName,
+      status:              booking.status,
+      outboundSchedule:    { ...booking.schedule, seatClass: p.outboundSeat?.seatClass },
+      inboundSchedule:     isRoundTrip ? { ...booking.returnSchedule!, seatClass: p.returnSeat?.seatClass } : undefined,
+      isRoundTrip,
+      seatNumber:          isRoundTrip ? undefined : p.outboundSeat?.number,
+      outboundSeatNumber:  isRoundTrip ? p.outboundSeat?.number : undefined,
+      inboundSeatNumber:   isRoundTrip ? p.returnSeat?.number : undefined,
+      fareMinor:           useSettledAmount ? settledAmountMinor! : booking.totalMinor,
+      currency:            voucherCurrency,
+      fareIsMajorUnits:    useSettledAmount,
+      createdAt:           booking.createdAt,
     });
   }
 };
diff --git a/apps/edr-passenger-web/portal/src/middleware.ts b/apps/edr-passenger-web/portal/src/middleware.ts
index 9a73fdb85..9604317f7 100644
--- a/apps/edr-passenger-web/portal/src/middleware.ts
+++ b/apps/edr-passenger-web/portal/src/middleware.ts
@@ -16,6 +16,7 @@ const PRESERVED_ROUTES = [
   '/help',
   '/guide',
   '/services',
+  '/packages',
   '/go/',
   '/packages/',
 ];
@@ -99,10 +100,10 @@ export function middleware(request: NextRequest) {
     pathname.includes('.') ||
     pathname === '/'
   ) {
-    // Next.js internals, static files, API routes, and home: no redirect, just render.
+    // Next.js internals, static files, API routes, and home.
     response = render();
   } else if (PRESERVED_ROUTES.some((r) => pathname.startsWith(r))) {
-    // On hard refresh of a preserved route, let it through.
+    // Public and auth routes: let them through.
     response = render();
   } else {
     response = render();
@@ -112,6 +113,24 @@ export function middleware(request: NextRequest) {
   // Anti-clickjacking. `frame-ancestors 'none'` (in the CSP above) is the modern control;
   // X-Frame-Options: DENY is the legacy equivalent for older browsers and scanners.
   response.headers.set('X-Frame-Options', 'DENY');
+
+  // Tell crawlers not to index private/transactional routes.
+  const NOINDEX_PREFIXES = [
+    '/booking/',
+    '/login',
+    '/register',
+    '/forgot-password',
+    '/reset-password',
+    '/set-password',
+    '/verify-account',
+    '/fayda-setup',
+    '/profile',
+    '/go/',
+  ];
+  if (NOINDEX_PREFIXES.some((p) => pathname.startsWith(p))) {
+    response.headers.set('X-Robots-Tag', 'noindex, nofollow');
+  }
+
   return response;
 }
 
diff --git a/packages/types/src/freight/booking-window-ws.ts b/packages/types/src/freight/booking-window-ws.ts
index 6c48f2c4c..3fd3c4d7b 100644
--- a/packages/types/src/freight/booking-window-ws.ts
+++ b/packages/types/src/freight/booking-window-ws.ts
@@ -32,9 +32,22 @@ export interface BookingWindowPhaseEvent {
   scheduledDepartureDate: string | null;
 }
 
+/**
+ * Payload pushed whenever server-side state behind a schedule's batch board
+ * changes outside a phase transition (payment settled, allocation run, batch
+ * fill, reservation expiry, doc review, …). Carries no board data — clients
+ * refetch the views they hold; `reason` exists for debugging/telemetry only.
+ */
+export interface BatchBoardChangedEvent {
+  scheduleId: string;
+  reason: string;
+  at: string;
+}
+
 /** Socket.io event names pushed server → client on the booking-windows namespace. */
 export const BOOKING_WINDOW_WS_EVENTS = {
   PHASE: "booking-window:phase",
+  BATCH_CHANGED: "batch-board:changed",
 } as const;
 
 /** Socket.io namespace the booking-window gateway listens on. */
diff --git a/packages/types/src/freight/index.ts b/packages/types/src/freight/index.ts
index 9e72cb365..7e874ee0f 100644
--- a/packages/types/src/freight/index.ts
+++ b/packages/types/src/freight/index.ts
@@ -237,6 +237,42 @@ export enum WagonReadiness {
   ExportReady = "EXPORT_READY",
 }
 
+/**
+ * Frozen record of one wagon slot's allocation at the moment a schedule leaves
+ * DRAFT/SCHEDULED (dispatch / arrive / cancel). Captured once into
+ * `train_schedules.wagon_allocation_snapshot` so the historical wagon plan
+ * survives later re-pinning of the same physical wagons onto other trains.
+ */
+export interface WagonAllocationSnapshotSlot {
+  sequenceNo: number;
+  trainSetWagonId: string;
+  physicalWagonId: string | null;
+  physicalWagonNumber: string | null;
+  wagonTypeId: string | null;
+  wagonTypeCode: string | null;
+  /** Wagon slot status (RESERVED/LOADED/…) at capture time. */
+  slotStatus: string | null;
+  boardYardId: string | null;
+  alightYardId: string | null;
+  allocations: WagonAllocationSnapshotAllocation[];
+}
+
+export interface WagonAllocationSnapshotAllocation {
+  bookingId: string;
+  bookingReference: string | null;
+  allocatedWeightTons: number;
+  loadType: string | null;
+  containerNumbers: string[];
+}
+
+/** Whole-schedule frozen wagon plan written at a terminal/transit transition. */
+export interface WagonAllocationSnapshot {
+  /** Schedule status the snapshot was captured at (DISPATCHED/ARRIVED/CANCELLED). */
+  capturedStatus: string;
+  capturedAt: string;
+  slots: WagonAllocationSnapshotSlot[];
+}
+
 export type ScheduleTradeDirection = "IMPORT" | "EXPORT" | "DOMESTIC";
 
 /**
@@ -497,6 +533,12 @@ export interface IBooking extends BaseEntity {
   trainScheduleStatus?: TrainScheduleStatus | string | null;
   /** ONE_TIME for normal bookings; GENERAL_CONTRACT for umbrella contracts. */
   bookingType?: BookingType;
+  /**
+   * Denormalized kind of the parent contract (ONE_TIME | GENERAL). Drawdown
+   * bookings under a GENERAL contract keep bookingType = ONE_TIME, so this is
+   * the field UIs must read to label a booking "General".
+   */
+  contractKind?: `${import("./contracts").ContractKind}` | null;
   /** General contracts only: when ordering closes (null until active / for one-time). */
   expiresAt?: string | null;
   /** Null for general contracts at creation — the date is chosen per order. */
@@ -604,6 +646,16 @@ export interface IBooking extends BaseEntity {
   latestChangeRequestNote?: string | null;
   contractSummary?: string | null;
   pricingBreakdown?: PricingBreakdown | null;
+
+  /**
+   * The customer paid a partial batch offer and this booking was reduced to
+   * the offered part. On a ONE_TIME contract this frees the single-booking
+   * slot for the remainder: the next booking must take the whole leftover
+   * quantity (the contract kind itself never changes).
+   */
+  isSplit?: boolean;
+  /** What this booking carried before it was reduced by a split (bulk tons / units per size). */
+  preSplitQuantities?: { bulkTons?: number; bySize?: Record<string, number> } | null;
 }
 
 export interface PricingBreakdownLineItem {
diff --git a/scripts/deploy/sync-env-from-server-jenkins.sh b/scripts/deploy/sync-env-from-server-jenkins.sh
index 74b9a3f13..e444996d6 100644
--- a/scripts/deploy/sync-env-from-server-jenkins.sh
+++ b/scripts/deploy/sync-env-from-server-jenkins.sh
@@ -12,24 +12,23 @@
 # Server layout (one file per service):
 #   /home/user/environmen/<project>/<branch-slug>/freight-api.env
 #   /home/user/environmen/<project>/<branch-slug>/freight-portal.env
-
 set -euo pipefail
-
 DEPLOY_USER="${DEPLOY_USER:-tria}"
 BRANCH="${BRANCH:?BRANCH is required}"
 BRANCH_SLUG="${BRANCH_SLUG:-$(echo "${BRANCH}" | tr "[:upper:]" "[:lower:]" | sed -E "s/[^a-z0-9]+/-/g; s/^-+//; s/-+$//")}"
 ENV_ROOT="${ENV_ROOT:-/home/${DEPLOY_USER}/environment/edr/${BRANCH_SLUG}/${PROJECT:?PROJECT is required}}"
 CI_ENV_FILE="${CI_ENV_FILE:?CI_ENV_FILE is required (e.g. \${WORKSPACE}/.ci-env/<service>.env)}"
-
 if [[ ! -d "${ENV_ROOT}" ]]; then
   echo "Environment directory not found: ${ENV_ROOT}" >&2
   exit 1
 fi
 echo "Using environment directory: ${ENV_ROOT}"
-
 mkdir -p "$(dirname "${CI_ENV_FILE}")"
+if [[ -d "${CI_ENV_FILE}" ]]; then
+  echo "Removing stale directory at ${CI_ENV_FILE}" >&2
+  rm -rf "${CI_ENV_FILE}"
+fi
 : > "${CI_ENV_FILE}"
-
 declare -A SERVICE_ENV_TARGET=(
   ["freight-api"]="apps/edr-freight-api/.env"
   ["freight-portal"]="apps/edr-freight-web/portal/.env"
@@ -39,36 +38,29 @@ declare -A SERVICE_ENV_TARGET=(
   ["passenger-backoffice"]="apps/edr-passenger-web/backoffice/.env"
   ["payment-api"]="apps/edr-payment-api/.env"
 )
-
 for service in "$@"; do
   src="${ENV_ROOT}/${service}.env"
   dest="${SERVICE_ENV_TARGET[${service}]:-}"
-
   if [[ -z "${dest}" ]]; then
     echo "Unknown service: ${service}" >&2
     exit 1
   fi
-
   if [[ ! -f "${src}" ]]; then
     echo "Missing env file: ${src}" >&2
     exit 1
   fi
-
   mkdir -p "$(dirname "${dest}")"
   cp "${src}" "${dest}"
   echo "Synced ${src} -> ${dest}"
-
   port_value=$(sed -n -E 's/^[[:space:]]*PORT[[:space:]]*=[[:space:]]*"?([^"#]+)"?[[:space:]]*(#.*)?$/\1/p' "${src}" | head -n1 | tr -d '[:space:]')
   if [[ -z "${port_value}" ]]; then
     echo "Missing required PORT in env file: ${src}" >&2
     exit 1
   fi
-
   service_var=$(echo "${service}" | tr '[:lower:]-' '[:upper:]_')
   echo "${service_var}_PORT=${port_value}" >> "${CI_ENV_FILE}"
   echo "Exported ${service_var}_PORT from ${src}"
-
   # Forward NEXT_PUBLIC_* and VITE_* vars so docker compose build can inject them as build args.
   grep -E '^[[:space:]]*(NEXT_PUBLIC_|VITE_)[A-Za-z0-9_]+=' "${src}" \
     | sed -E 's/^[[:space:]]*//' >> "${CI_ENV_FILE}" || true
-done
\ No newline at end of file
+done